Java序列化的机制和原理，以及自定义序列化问题

 

一. Java序列化的机制和原理

有关Java对象的序列化和反序列化也算是Java基础的一部分，下面对Java序列化的机制和原理进行一些介绍。

Java序列化算法透析

Serialization（序列化）是一种将对象以一连串的字节描述的过程；反序列化deserialization是一种将这些字节重建成一个对象的过程。Java序列化API提供一种处理对象序列化的标准机制。在这里你能学到如何序列化一个对象，什么时候需要序列化以及Java序列化的算法，我们用一个实例来示范序列化以后的字节是如何描述一个对象的信息的。

序列化的必要性

Java中，一切都是对象，在分布式环境中经常需要将Object从这一端网络或设备传递到另一端。这就需要有一种可以在两端传输数据的协议。Java序列化机制就是为了解决这个问题而产生。

如何序列化一个对象

一个对象能够序列化的前提是实现Serializable接口，Serializable接口没有方法，更像是个标记。有了这个标记的Class就能被序列化机制处理。

1. import java.io.Serializable;  
2.  
3. class TestSerial implements Serializable {  
4.  
5.        public byte version = 100;  
6.  
7.        public byte count = 0;  
8.  
9. } 

然后我们写个程序将对象序列化并输出。ObjectOutputStream能把Object输出成Byte流。我们将Byte流暂时存储到temp.out文件里。

1. public static void main(String args[]) throws IOException {  
2.  
3.        FileOutputStream fos = new FileOutputStream("temp.out");  
4.  
5.        ObjectOutputStream oos = new ObjectOutputStream(fos);  
6.  
7.        TestSerial ts = new TestSerial();  
8.  
9.        oos.writeObject(ts);  
10.  
11.        oos.flush();  
12.  
13.        oos.close();  
14.  
15. } 

如果要从持久的文件中读取Bytes重建对象，我们可以使用ObjectInputStream。  

1. public static void main(String args[]) throws IOException {  
2.  
3.        FileInputStream fis = new FileInputStream("temp.out");  
4.  
5.        ObjectInputStream oin = new ObjectInputStream(fis);  
6.  
7.        TestSerial ts = (TestSerial) oin.readObject();  
8.  
9.        System.out.println("version="+ts.version);  
10.  
11. } 

执行结果为

100.

对象的序列化格式

将一个对象序列化后是什么样子呢？打开刚才我们将对象序列化输出的temp.out文件，以16进制方式显示。内容应该如下：

AC ED 00 05 73 72 00 0A 53 65 72 69 61 6C 54 65

73 74 A0 0C 34 00 FE B1 DD F9 02 00 02 42 00 05

63 6F 75 6E 74 42 00 07 76 65 72 73 69 6F 6E 78

70 00 64

这一坨字节就是用来描述序列化以后的

TestSerial对象的，我们注意到TestSerial类中只有两个域：

public byte version = 100;

public byte count = 0;

且都是byte型，理论上存储这两个域只需要2个byte，但是实际上temp.out占据空间为51bytes，也就是说除了数据以外，还包括了对序列化对象的其他描述。

Java的序列化算法

序列化算法一般会按步骤做如下事情：

◆将对象实例相关的类元数据输出。

◆递归地输出类的超类描述直到不再有超类。

◆类元数据完了以后，开始从最顶层的超类开始输出对象实例的实际数据值。

◆从上至下递归输出实例的数据

我们用另一个更完整覆盖所有可能出现的情况的例子来说明：

1. class parent implements Serializable {  
2.  
3.        int parentVersion = 10;  
4.  
5. }  
6.  
7.    
8.  
9. class contain implements Serializable{  
10.  
11.        int containVersion = 11;  
12.  
13. }  
14.  
15. public class SerialTest extends parent implements Serializable {  
16.  
17.        int version = 66;  
18.  
19.        contain con = new contain();  
20.  
21.    
22.  
23.        public int getVersion() {  
24.  
25.               return version;  
26.  
27.        }  
28.  
29.        public static void main(String args[]) throws IOException {  
30.  
31.               FileOutputStream fos = new FileOutputStream("temp.out");  
32.  
33.               ObjectOutputStream oos = new ObjectOutputStream(fos);  
34.  
35.               SerialTest st = new SerialTest();  
36.  
37.               oos.writeObject(st);  
38.  
39.               oos.flush();  
40.  
41.               oos.close();  
42.  
43.        }  
44.  
45. } 

这个例子是相当的直白啦。SerialTest类实现了Parent超类，内部还持有一个Container对象。

序列化后的格式如下：

AC ED 00 05 73 72 00 0A 53 65 72 69 61 6C 54 65

73 74 05 52 81 5A AC 66 02 F6 02 00 02 49 00 07

76 65 72 73 69 6F 6E 4C 00 03 63 6F 6E 74 00 09

4C 63 6F 6E 74 61 69 6E 3B 78 72 00 06 70 61 72

65 6E 74 0E DB D2 BD 85 EE 63 7A 02 00 01 49 00

0D 70 61 72 65 6E 74 56 65 72 73 69 6F 6E 78 70

00 00 00 0A 00 00 00 42 73 72 00 07 63 6F 6E 74

61 69 6E FC BB E6 0E FB CB 60 C7 02 00 01 49 00

0E 63 6F 6E 74 61 69 6E 56 65 72 73 69 6F 6E 78

70 00 00 00 0B

我们来仔细看看这些字节都代表了啥。开头部分，见颜色：

1. AC ED: STREAM_MAGIC.  声明使用了序列化协议 .
2. 00 05: STREAM_VERSION.  序列化协议版本 .
3. 0x73: TC_OBJECT.   声明这是一个新的对象 .   

序列化算法的第一步就是输出对象相关类的描述。例子所示对象为SerialTest类实例，因此接下来输出SerialTest类的描述。见颜色：

1. 0x72: TC_CLASSDESC.  声明这里开始一个新 Class 。
2. 00 0A: Class 名字的长度 .
3. 53 65 72 69 61 6c 54 65 73 74: SerialTest,Class 类名 .
4. 05 52 81 5A AC 66 02 F6: SerialVersionUID,  序列化 ID ，如果没有指定，则会由算法随机生成一个 8byte 的 ID.
5. 0x02:  标记号 .  该值声明该对象支持序列化。
6. 00 02:  该类所包含的域个数。

接下来，算法输出其中的一个域，int version=66；见颜色：

1. 0x49:  域类型 . 49  代表 "I",  也就是 Int.
2. 00 07:  域名字的长度 .
3. 76 65 72 73 69 6F 6E: version, 域名字描述 .

然后，算法输出下一个域，contain con = new contain();这个有点特殊，是个对象。描述对象类型引用时需要使用JVM的标准对象签名表示法，见颜色：

1. 0x4C:  域的类型 .
2. 00 03:  域名字长度 .
3. 63 6F 6E:  域名字描述， con
4. 0x74: TC_STRING.  代表一个 new String. 用 String 来引用对象。
5. 00 09:  该 String 长度 .
6. 4C 63 6F 6E 74 61 69 6E 3B: Lcontain;, JVM 的标准对象签名表示法 .
7. 0x78: TC_ENDBLOCKDATA, 对象数据块结束的标志

.接下来算法就会输出超类也就是Parent类描述了，见颜色：

1. 0x72: TC_CLASSDESC.  声明这个是个新类 .
2. 00 06:  类名长度 .
3. 70 61 72 65 6E 74: parent, 类名描述。
4. 0E DB D2 BD 85 EE 63 7A: SerialVersionUID,  序列化 ID.
5. 0x02:  标记号 .  该值声明该对象支持序列化 .
6. 00 01:  类中域的个数 .

下一步，输出parent类的域描述，int parentVersion=100;同见颜色：

1. 0x49:  域类型 . 49  代表 "I",  也就是 Int.
2. 00 0D:  域名字长度 .
3. 70 61 72 65 6E 74 56 65 72 73 69 6F 6E: parentVersion ，域名字描述。
4. 0x78: TC_ENDBLOCKDATA, 对象块结束的标志。
5. 0x70: TC_NULL,  说明没有其他超类的标志。 .

到此为止，算法已经对所有的类的描述都做了输出。下一步就是把实例对象的实际值输出了。这时候是从parent Class的域开始的，见颜色：

1. 00 00  00  0A: 10, parentVersion 域的值 .

还有SerialTest类的域：

1. 00 00  00  42: 66, version 域的值 .

再往后的bytes比较有意思，算法需要描述contain类的信息，要记住，现在还没有对contain类进行过描述，见颜色：

1. 0x73: TC_OBJECT,  声明这是一个新的对象 .
2. 0x72: TC_CLASSDESC 声明这里开始一个新 Class.
3. 00 07:  类名的长度 .
4. 63 6F 6E 74 61 69 6E: contain, 类名描述 .
5. FC BB E6 0E FB CB 60 C7: SerialVersionUID,  序列化 ID.
6. 0x02: Various flags.  标记号 .  该值声明该对象支持序列化
7. 00 01:  类内的域个数。

.输出contain的唯一的域描述，int containVersion=11；

1. 0x49:  域类型 . 49  代表 "I",  也就是 Int..
2. 00 0E:  域名字长度 .
3. 63 6F 6E 74 61 69 6E 56 65 72 73 69 6F 6E: containVersion,  域名字描述 .
4. 0x78: TC_ENDBLOCKDATA 对象块结束的标志 .

这时，序列化算法会检查contain是否有超类，如果有的话会接着输出。

1. 0x70:TC_NULL ，没有超类了。

最后，将contain类实际域值输出。

1. 00 00  00  0B: 11, containVersion 的值 .

二. Java自定义序列化反序列化问题

正常情况下，一个类实现java序列化很简单，只需要implements Serializable接口即可，之后该类在跨jvm的传输过程中会遵照默认java序列化规则序列化和反序列化;不同jvm版本之间序列化方式稍有不同，但基本上都是兼容的。

在某些特殊情况下，可能需要自定义序列化和反序列化的行为，看下面例子：

Java代码

1. class AbstractSerializeDemo {     
2.     private int x, y;     
3.     
4.     public void init(int x, int y) {     
5.         this.x = x;     
6.         this.y = y;     
7.     }     
8.     
9.     public int getX() {     
10.         return x;     
11.     }     
12.     
13.     public int getY() {     
14.         return y;     
15.     }     
16.     
17.     public void printXY() {     
18.         System.out.println("x:" + x + ";y:" + y);     
19.     }     
20. }     
21.     
22. public class SerializeDemo extends AbstractSerializeDemo implements Serializable {     
23.     private int z;     
24.     
25.     public SerializeDemo() {     
26.         super.init(10, 50);     
27.         z = 100;     
28.     }     
29.     
30.     public void printZ() {     
31.         super.printXY();     
32.         System.out.println("z:" + z);     
33.     }     
34.     
35.     public static void main(String[] args) throws IOException, ClassNotFoundException {     
36.         ByteArrayOutputStream bos = new ByteArrayOutputStream();     
37.         ObjectOutputStream out = new ObjectOutputStream(bos);     
38.         SerializeDemo sd = new SerializeDemo();     
39.         sd.printZ();     
40.         out.writeObject(sd);     
41.         ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(bos.toByteArray()));     
42.         SerializeDemo sd2 = (SerializeDemo) in.readObject();     
43.         sd2.printZ();     
44.     }     
45. }  

这段程序表示了一个可序列化的类继承自一个非序列化的有状态超类，期望的结果是，子类序列化以后传输并反序列化回来，原先的值域包括超类的值域都保持不变。

但是输出是：

Java代码

1. x:10;y:50    
2. z:100    
3. x:0;y:0    
4. z:100    

结果和期望不符，子类的值域保留下来了，但是超类的值域丢失了，这对jvm来说是正常的，因为超类不可序列化;

为了解决这个问题，只能自定义序列化行为，具体做法是在SerializeDemo里加入以下代码：

Java代码

1. private void writeObject(ObjectOutputStream os) throws IOException {     
2.       os.defaultWriteObject();//java对象序列化默认操作     
3.       os.writeInt(getX());     
4.       os.writeInt(getY());     
5.   }     
6.     
7.   private void readObject(ObjectInputStream is) throws IOException, ClassNotFoundException {     
8.       is.defaultReadObject();//java对象反序列化默认操作     
9.       int x=is.readInt();     
10.       int y=is.readInt();     
11.       super.init(x,y);     
12.   }   

writeObject和readObject方法为JVM会在序列化和反序列化java对象时会分别调用的两个方法，修饰符都是private，没错。

我们在序列化的默认动作之后将超类里的两个值域x和y也写入object流;与之对应在反序列化的默认操作之后读入x和y两个值，然后调用超类的初始化方法。

再次执行程序之后的输出为：

Java代码

1. x:10;y:50    
2. z:100    
3. x:10;y:50    
4. z:100   

另外还有两个自定义序列化方法writeReplace和readResolve，分别用来在序列化之前替换序列化对象 和 在反序列化之后的对返回对象的处理。一般可以用来避免singleTon对象跨jvm序列化和反序列化时产生多个对象实例，事实上singleTon的对象一旦可序列化，它就不能保证singleTon了。JVM的Enum实现里就是重写了readResolve方法，由JVM保证Enum的值都是singleTon的，所以建议多使用Enum代替使用writeReplace和readResolve方法。

Java代码

1. private Object readResolve()     
2.     {     
3.         return INSTANCE;     
4.     }     
5.         
6.     private Object writeReplace(){     
7.         return INSTANCE;     
8.     }    

注：writeReplace调用在writeObject前;readResolve调用在readObject之后。

 

这篇是对7天Java学习的一个补充，主要是针对自定义序列化的学习，感谢CSDN会员wangtenndsc 让我又多学了一点关于序列化的知识。

序列化学习共有三个贴:

7天Java学习---Java的对象序列化以及文件IO处理

java serializable