什么是序列化，为什么要序列化

￡神魔★判官ぃ 2022-05-27 03:07 250阅读 0赞

总结就是：为了解决用流方式读写对象的时候数据不一致问题，实现Serializable接口即可实现序列化解决问题。

简单来说序列化就是一种用来处理对象流的机制。所谓对象流也就是将对象的

内容进行流化，流的概念这里不用多说(就是I/O)。我们可以对流化后的对象进行读写

操作，也可将流化后的对象传输于网络之间(注：要想将对象传输于网络必须进行流化)！

在对对象流进行读写操作时会引发一些问题，而序列化机制正是用来解决这些问题的！

—————————————————————————————–小分割线  
问题的引出：  
如上所述，读写对象会有什么问题呢？比如：我要将对象写入一个磁盘文件而后再将

其读出来会有什么问题吗？别急，其中一个最大的问题就是对象引用！

举个例子来说：假如我有两个类，分别是A和B，B类中含有一个指向A类对象的引用，

现在我们对两个类进行实例化\{ A a = new A(); B b = new B(); \}。这时在内存中实际上分配

了两个空间，一个存储对象a，一个存储对象b。接下来我们想将它们写入到磁盘的一个文件

中去，就在写入文件时出现了问题！因为对象b包含对对象a的引用，所以系统会自动的将a

的数据复制一份到b中，这样的话当我们从文件中恢复对象时(也就是重新加载到内存中)时，

内存分配了三个空间，而对象a同时在内存中存在两份，想一想后果吧，如果我想修改对象a

的数据的话，那不是还要搜索它的每一份拷贝来达到对象数据的一致性，这不是我们所希望的！

—————————————————————————————–小分割线  
以下序列化机制的解决方案：  
1.保存到磁盘的所有对象都获得一个序列号(1, 2, 3等等)

2.当要保存一个对象时，先检查该对象是否被保存了

3.如果以前保存过，只需写入”与已经保存的具有序列号x的对象相同”的标记，否则，保存该对象

通过以上的步骤序列化机制解决了对象引用的问题！

—————————————————————————————–小分割线  
序列化的实现  
将需要被序列化的类实现Serializable接口，该接口没有需要实现的方法，implements Serializable

只是为了标注该对象是可被序列化的。然后使用一个输出流(如：FileOutputStream)来构造一个

ObjectOutputStream(对象流)对象。接着，使用ObjectOutputStream对象的writeObject(Object obj)方法

就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。

在序列化的过程中，有些数据字段我们不想将其序列化，对于此类字段我们只需要在定义

时给它加上transient关键字即可，对于transient字段序列化机制会跳过不会将其写入文件，当然

也不可被恢复。但有时我们想将某一字段序列化，但它在SDK中的定义却是不可序列化的类型，

这样的话我们也必须把他标注为transient，可是不能写入又怎么恢复呢？好在序列化机制为包含

这种特殊问题的类提供了如下的方法定义：

private void readObject(ObjectInputStream in) throws  
IOException, ClassNotFoundException;  
private void writeObject(ObjectOutputStream out) throws  
IOException;  
(注：这些方法定义时必须是私有的，因为不需要你显示调用，序列化机制会自动调用的)

使用以上方法我们可以手动对那些你又想序列化又不可以被序列化的数据字段进行写出和读入操作。

======================================================================分割线

下面是一个典型的例子，java.awt.geom包中的Point2D.Double类就是不可序列化的，因为该类

没有实现Serializable接口，在我的例子中将把它当作LabeledPoint类中的一个数据字段，并演示

如何将其序列化！

**\[java\]** view plain copy

print ?

1.  import java.io.\*;  
2.  import java.awt.geom.\*;  
3.    
4.  public class TransientTest  
5.  \{  
6.           public static void main(String\[\] args)  
7.           \{  
8.    
9.                   LabeledPoint label = new LabeledPoint(“Book”, 5.00, 5.00);  
10.   
11.                  try  
12.                  \{  
13.                          System.out.println(label); // 写入前  
14.                          ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(“Label.txt”));  
15.                          out.writeObject(label);    //通过对象输出流，将label写入流中  
16.                          out.close();  
17.                          System.out.println(label);// 写入后  
18.                          ObjectInputStream in = new ObjectInputStream(new FileInputStream(“Label.txt”));  
19.                          LabeledPoint label1 = (LabeledPoint) in.readObject();  
20.                          in.close();  
21.                          System.out.println(label1);// 读出并加1.0后  
22.                  \}  
23.                  catch (Exception e)  
24.                  \{  
25.                          e.printStackTrace();  
26.                  \}  
27.          \}  
28. \}  
29.   
30. class LabeledPoint implements Serializable  
31. \{  
32.          private String label;  
33.          transient private Point2D.Double point;    //因为不可被序列化，所以需要加transient关键字  
34.   
35.          public LabeledPoint(String str, double x, double y)//构造方法  
36.          \{  
37.                  label = str;  
38.                  point = new Point2D.Double(x, y);  //此类Point2D.Double不可被序列化  
39.          \}  
40.   
41.     //因为Point2D.Double不可被序列化，所以需要实现下面两个方法  
42.          private void writeObject(ObjectOutputStream out) throws IOException  
43.          \{  
44.                   
45.                  out.defaultWriteObject();  
46.                  out.writeDouble(point.getX());  
47.                  out.writeDouble(point.getY());  
48.          \}  
49.          private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException  
50.          \{  
51.                   
52.                  in.defaultReadObject();  
53.                  double x = in.readDouble() + 1.0;  
54.                  double y = in.readDouble() + 1.0;  
55.                  point = new Point2D.Double(x, y);  
56.          \}  
57.   
58.     //重写toString方法  
59.          public String toString()  
60.          \{  
61.                  return getClass().getName()+ “\[label = ” + label+ “, point.getX() = ” + point.getX()+ “, point.getY() = ” +   
62.   
63. point.getY()+ ”\]”;  
64.          \}  
65.   
66. \}

import java.io.*;
    import java.awt.geom.*;
    
    public class TransientTest
    {
             public static void main(String[] args)
             {
    
                     LabeledPoint label = new LabeledPoint("Book", 5.00, 5.00);
    
                     try
                     {
                             System.out.println(label); // 写入前
                             ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("Label.txt"));
                             out.writeObject(label);    //通过对象输出流，将label写入流中
                             out.close();
                             System.out.println(label);// 写入后
                             ObjectInputStream in = new ObjectInputStream(new FileInputStream("Label.txt"));
                             LabeledPoint label1 = (LabeledPoint) in.readObject();
                             in.close();
                             System.out.println(label1);// 读出并加1.0后
                     }
                     catch (Exception e)
                     {
                             e.printStackTrace();
                     }
             }
    }
    
    class LabeledPoint implements Serializable
    {
             private String label;
             transient private Point2D.Double point;    //因为不可被序列化，所以需要加transient关键字
    
             public LabeledPoint(String str, double x, double y)//构造方法
             {
                     label = str;
                     point = new Point2D.Double(x, y);  //此类Point2D.Double不可被序列化
             }
    
        //因为Point2D.Double不可被序列化，所以需要实现下面两个方法
             private void writeObject(ObjectOutputStream out) throws IOException
             {
    
                     out.defaultWriteObject();
                     out.writeDouble(point.getX());
                     out.writeDouble(point.getY());
             }
             private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
             {
    
                     in.defaultReadObject();
                     double x = in.readDouble() + 1.0;
                     double y = in.readDouble() + 1.0;
                     point = new Point2D.Double(x, y);
             }
    
        //重写toString方法
             public String toString()
             {
                     return getClass().getName()+ "[label = " + label+ ", point.getX() = " + point.getX()+ ", point.getY() = " + 
    
    point.getY()+ "]";
             }
    
    }