JAVA序列化机制的深入研究

1、java序列化简介

序列化就是指对象通过写出描述自己状态的数值来记录自己的过程,即将对象表示成一系列有序字节,java提供了将对象写入流和从流中恢复对象的方法。对象能包含其它的对象,而其它的对象又可以包含另外的对象。JAVA序列化能够自动的处理嵌套的对象。对于一个对象的简单域,writeObject()直接将其值写入流中。当遇到一个对象域时,writeObject()被再次调用,如果这个对象内嵌另一个对象,那么,writeObject()又被调用,直到对象能被直接写入流为止。程序员所需要做的是将对象传入ObjectOutputStreamwriteObject()方法,剩下的将有系统自动完成。

要实现序列化的类必须实现的java.io.Serializablejava.io.Externalizable接口,否则将产生一个NotSerializableException。该接口内部并没有任何方法,它只是一个"tagging interface",仅仅"tags"它自己的对象是一个特殊的类型。类通过实现 java.io.Serializable接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。可序列化类的所有子类型本身都是可序列化的。序列化接口没有方法或字段,仅用于标识可序列化的语义。Java"对象序列化"能让你将一个实现了Serializable接口的对象转换成一组byte,这样日后要用这个对象时候,你就能把这些byte数据恢复出来,并据此重新构建那个对象了。

序列化图示


反序列化图示


在序列化的时候,writeObjectreadObject之间是有先后顺序的。readObject将最先writeobject read出来。用数据结构的术语来讲就称之为先进先出!

2、序列化的必要性及目的

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

Java序列化支持的两种主要特性:

  • Java RMI使本来存在于其他机器的对象可以表现出就象本地机器上的行为。
  • 将消息发给远程对象时,需要通过对象序列化来传输参数和返回值.

Java序列化的目的:

  • 支持运行在不同虚拟机上不同版本类之间的双向通讯;
  • 定义允许JAVA类读取用相同类较老版本写入的数据流的机制;
  • 定义允许JAVA类写用相同类较老版本读取的数据流的机制;
  • 提供对持久性和RMI的序列化;
  • 产生压缩流且运行良好以使RMI能序列化;
  • 辨别写入的是否是本地流;
  • 保持非版本化类的低负载;

3、序列化异常

    序列化对象期间可能抛出6种异常:

  •  InvalidClassException 通常在重序列化流无法确定类型时或返回的类无法在取得对象的系统中表示时抛出此异常。异常也在恢复的类不声明为public时或没有public缺省(无变元)构造器时抛出。
  •  NotSerializableException 通常由具体化对象(负责自身的重序列化)探测到输入流错误时抛出。错误通常由意外不变量值指示,或者表示要序列化的对象不可序列化。
  • StreamCorruptedException 在存放对象的头或控制数据无效时抛出。
  • OptionalDataException 流中应包含对象但实际只包含原型数据时抛出。
  • ClassNotFoundException 流的读取端找不到反序列化对象的类时抛出。
  • IOException  要读取或写入的对象发生与流有关的错误时抛出。

4、序列化一个对象

序列化一个对象,以及对序列化后的对象进行操作,需要遵循以下3点:

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

2、 写个程序将对象序列化并输出。ObjectOutputStream能把Object输出成Byte流。

3、 要从持久的文件中读取Bytes重建对象,我们可以使用ObjectInputStream。 

在序列化时,有几点要注意的:

  •  当一个对象被序列化时,只序列化对象的非静态成员变量,不能序列化任何成员方法和静态成员变量。
  •  如果一个对象的成员变量是一个对象,那么这个对象的数据成员也会被保存。
  • 如果一个可序列化的对象包含对某个不可序列化的对象的引用,那么整个序列化操作将会失败,并且会抛出一个NotSerializableException。可以通过将这个引用标记为transient,那么对象仍然可以序列化。对于一些比较敏感的不想序列化的数据,也可以采用该标识进行修饰。

5、对象的序列化格式

5.1 简单对象的序列化介绍

  1. package com.asc.alibaba.base;  
  2.   
  3. import java.io.FileInputStream;  
  4. import java.io.FileOutputStream;  
  5. import java.io.IOException;  
  6. import java.io.ObjectOutputStream;  
  7. import java.io.Serializable;  
  8. publicclassTestSerialimplements Serializable{  
  9.     publicbyteversion = 100;  
  10.     publicbytecount = 0;  
  11.     publicstaticvoid main(String[] args)throws IOException, ClassNotFoundException {  
  12.         FileOutputStream fos = new FileOutputStream("temp.out");  
  13.         ObjectOutputStream oos =new ObjectOutputStream(fos);  
  14.         TestSerialize testSerialize =new TestSerialize();  
  15.         oos.writeObject(testSerialize);  
  16.         oos.flush();  
  17.         oos.close();  
  18.         }  
  19.     }  
  20. }  

将一个对象序列化后是什么样子呢?打开刚才将对象序列化输出的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,也就是说除了数据以外,还包括了对序列化对象的其他描述。

开头部分,见颜色

²  AC ED: STREAM_MAGIC. 声明使用了序列化协议.

²  00 05: STREAM_VERSION. 序列化协议版本.

²  0x73: TC_OBJECT. 声明这是一个新的对象.  

输出TestSerial类的描述。见颜色:

²  0x72: TC_CLASSDESC. 声明这里开始一个新Class。

²  00 0A: Class名字的长度.

²  53 65 72 69 61 6c 54 65 73 74: TestSerial,Class类名.

²  05 52 81 5A AC 66 02 F6: SerialVersionUID, 序列化ID,如果没有指定,
则会由算法随机生成一个8byte的ID.

²  0x02: 标记号. 该值声明该对象支持序列化。

²  00 02: 该类所包含的域个数。

输出域的信息,见颜色

²  0x42: 域类型. 42 代表"B", 也就是byte;

²  00 05: 域名字的长度;

²  636F 75 6E 74: count,域名字描述count;

²  0x42: 域类型. 42 代表"B", 也就是byte;

²  00 07: 域名字的长度;

²  76 65 72 73 69 6F 6E 78 70: version,域名字描述version;
块的结束标记:见颜色
0x78: TC_ENDBLOCKDATA,对象块结束的标志。

0x70:TC_NULL,没有超类了。

输出域的值信息,见颜色:
²  00: 域值为00;
²  64: 域值为100;

5.2 复杂对象的序列化介绍

  1. package com.asc.alibaba.base;  
  2.   
  3. import java.io.FileInputStream;  
  4. import java.io.FileOutputStream;  
  5. import java.io.IOException;  
  6. import java.io.ObjectOutputStream;  
  7. import java.io.Serializable;  
  8.   
  9. classContain implements Serializable {  
  10.     publicintcontainVersion = 11;  
  11. }  
  12.   
  13. classParent implements Serializable {  
  14.     publicintparentVersion = 10;  
  15. }  
  16.   
  17. publicclassSerialTest extends Parent implements Serializable {  
  18.     publicint      version   = 66;  
  19.     public Containcon = new Contain();  
  20.   
  21.     publicint getVersion() {  
  22.         returnversion;  
  23.     }  
  24.   
  25.     publicstaticvoid main(String[] args)throws IOException {  
  26.         FileOutputStream fos = new FileOutputStream("temp1.out");  
  27.         ObjectOutputStream oos =new ObjectOutputStream(fos);  
  28.         SerialTest testSerialize =new SerialTest();  
  29.         oos.writeObject(testSerialize);  
  30.         oos.flush();  
  31.         oos.close();  
  32.         FileInputStream fis = new FileInputStream("temp1.out");  
  33.         byte[] bb =newbyte[200];  
  34.         while (fis.read(bb) != -1) {  
  35.             for (byte b : bb) {               System.out.print(Integer.toHexString(b));  
  36.                 System.out.print(" ");  
  37.             }  
  38.         }  
  39.     }  
  40. }  

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 7000 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

开头部分,见颜色

²  ACED: STREAM_MAGIC. 声明使用了序列化协议;

²  0005: STREAM_VERSION. 序列化协议版本;

²  0x73: TC_OBJECT. 声明这是一个新的对象;

输出TestSerial类的描述。见颜色:

²  0x72: TC_CLASSDESC. 声明这里开始一个新Class;

²  000A: Class名字的长度;

²  5365 72 69 61 6c 54 65 73 74: SerialTest,Class类名;

²  0552 81 5A AC 66 02 F6: SerialVersionUID, 序列化ID,如果没有指定,则会由算法随机生成一个8byte的ID;

²  0x02: 标记号. 该值声明该对象支持序列化;

²  0002: 该类所包含的域个数;

输出域的信息,见颜色

²  0x49: 域类型. 49 代表"I", 也就是Int.

²  00 07: 域名字的长度.

²  76 65 72 73 69 6F 6E: version,域名字描述.

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

²  0x4C: 域的类型;

²  0003: 域名字长度;

²  636F 6E: 域名字描述,con;

²  0x74: TC_STRING. 代表一个new String.用String来引用对象;

²  0009: 该String长度;

²  4C63 6F 6E 74 61 69 6E 3B: Lcontain;,JVM的标准对象签名表示法;

²  0x78: TC_ENDBLOCKDATA,对象数据块结束的标志;

算法就会输出超类也就是Parent类描述了,见颜色

²  0x72: TC_CLASSDESC. 声明这个是个新类;

²  00 06: 类名长度;

²  70 6172 65 6E 74: parent,类名描述;

²  0E DBD2 BD 85 EE 63 7A: SerialVersionUID, 序列化ID;

²  0x02: 标记号. 该值声明该对象支持序列化;

²  00 01: 类中域的个数;

输出parent类的域描述,int parentVersion=100;见颜色

²  0x49: 域类型. 49 代表"I", 也就是Int;

²  00 0D: 域名字长度;

²  70 6172 65 6E 74 56 65 72 73 69 6F 6E: parentVersion,域名字描述;

²  0x78: TC_ENDBLOCKDATA,对象块结束的标志;

²  0x70: TC_NULL, 说明没有其他超类的标志;

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

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

²  还有SerialTest类的域:

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

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

²  0x73: TC_OBJECT, 声明这是一个新的对象;

²  0x72: TC_CLASSDESC声明这里开始一个新Class;

²  0007: 类名的长度;

²  636F 6E 74 61 69 6E:contain,类名描述;

²  FCBB E6 0E FB CB 60 C7: SerialVersionUID, 序列化ID;

²  0x02: Various flags. 标记号. 该值声明该对象支持序列化;

²  0001: 类内的域个数;

输出contain的唯一的域描述,int containVersion=11:

²  0x49: 域类型. 49 代表"I", 也就是Int;

²  000E: 域名字长度;

²  636F 6E 74 61 69 6E 56 65 72 73 69 6F 6E: containVersion, 域名字描述;

²  0x78: TC_ENDBLOCKDATA对象块结束的标志;

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

²  0x70:TC_NULL,没有超类了;

最后,将contain类实际域值输出:

²  00 00 00 0B: 11, containVersion的值。

6、Java的序列化算法

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

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

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

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

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

7、序列化实例介绍

7.1 定制数据格式的序列化

验证怎样用writeObjectreadObject方法编码一个定制数据格式。当有大量持久性数据时,数据应该以简洁、精简的格式存放。此例子用一个矩形对称阵列,只对其一半数据序列化,即只写/读一半数据再恢复成完整阵列。

  1. package com.asc.alibaba.base;  
  2.   
  3. import java.io.*;  
  4.   
  5. public class CustomDataExample implements Serializable {  
  6.   
  7.     transient int dimension;  
  8.     transient int thearray[][];  
  9.   
  10.     CustomDataExample(int dim){  
  11.         dimension = dim;  
  12.         thearray = new int[dim][dim];  
  13.         arrayInit();  
  14.     }  
  15.   
  16.     public static void main(String args[]) {  
  17.         CustomDataExample corg = new CustomDataExample(4);  
  18.         CustomDataExample cnew = null;  
  19.         try {  
  20.             FileOutputStream fo = new FileOutputStream("cde.tmp");  
  21.             ObjectOutputStream so = new ObjectOutputStream(fo);  
  22.             so.writeObject(corg);  
  23.             so.flush();  
  24.             so.close();  
  25.         } catch (Exception e) {  
  26.             e.printStackTrace();  
  27.             System.exit(1);  
  28.         }  
  29.         try {  
  30.             FileInputStream fi = new FileInputStream("cde.tmp");  
  31.             ObjectInputStream si = new ObjectInputStream(fi);  
  32.             cnew = (CustomDataExample) si.readObject();  
  33.             si.close();  
  34.         } catch (Exception e) {  
  35.             e.printStackTrace();  
  36.             System.exit(1);  
  37.         }  
  38.         System.out.println();  
  39.         System.out.println("Printing the original array...");  
  40.         System.out.println(corg);  
  41.         System.out.println();  
  42.         System.out.println("Printing the new array...");  
  43.         System.out.println();  
  44.         System.out.println(cnew);  
  45.         System.out.println();  
  46.         System.out.println("The original and new arrays should be the same!");  
  47.         System.out.println();  
  48.     }  
  49.   
  50.     private void writeObject(ObjectOutputStream s) throws IOException {  
  51.         /* 先调用缺省的defaultWriteObject()方法保存非临时变元(若有) */  
  52.         s.defaultWriteObject();  
  53.         /* 对临时变元明确调用原型数据writeInt()方法以保存其 */  
  54.         s.writeInt(dimension);  
  55.         for (int i = 0; i < dimension; i++) {  
  56.             for (int j = 0; j <= i; j++) {  
  57.                 /* 对临时变元明确调用原型数据writeInt()方法以保存其阵列的一半数据 */  
  58.                 s.writeInt(thearray[i][j]);  
  59.             }  
  60.         }  
  61.   
  62.     }  
  63.   
  64.     private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException {  
  65.         /* 先调用缺省的defaultReadObject()方法恢复非临时数据,再显式调用原型数据readInt()方法恢复临时数据,写入和恢复数据的顺序要求一致 */  
  66.         s.defaultReadObject();  
  67.         dimension = s.readInt();  
  68.         thearray = new int[dimension][dimension];  
  69.         for (int i = 0; i < dimension; i++) {  
  70.             for (int j = 0; j <= i; j++) {  
  71.                 thearray[i][j] = s.readInt();  
  72.             }  
  73.         }  
  74.         for (int i = 0; i < dimension; i++) {  
  75.             for (int j = dimension - 1; j > i; j--) {  
  76.                 thearray[i][j] = thearray[j][i];  
  77.             }  
  78.         }  
  79.     }  
  80.   
  81.     /* 此方法的功能是将阵列作成对角阵 */  
  82.     void arrayInit() {  
  83.         int x = 0;  
  84.         for (int i = 0; i < dimension; i++) {  
  85.             for (int j = 0; j <= i; j++) {  
  86.                 thearray[i][j] = x;  
  87.                 thearray[j][i] = x;  
  88.                 x++;  
  89.             }  
  90.         }  
  91.     }  
  92.   
  93.     public String toString() {  
  94.   
  95.         StringBuffer sb = new StringBuffer();  
  96.         for (int i = 0; i < dimension; i++) {  
  97.             for (int j = 0; j < dimension; j++) {  
  98.   
  99.                 sb.append(Integer.toString(thearray[i][j]) + " ");  
  100.             }  
  101.             sb.append("\n");  
  102.         }  
  103.         return (sb.toString());  
  104.     }  
  105. }  
  106. 结果如下:  
  107.   Printing the original array...  
  108. 0 1 3 6  
  109. 1 2 4 7  
  110. 3 4 5 8  
  111. 6 7 8 9  
  112. Printing the new array...  
  113. 0 1 3 6  
  114. 1 2 4 7  
  115. 3 4 5 8  
  116. 6 7 8 9  
  117. The original and new arrays should be the same!  

7.2 非序列化超类的序列化

当一个已序列化的子类的超类没有序列化时,子类必须显式存储超类的状态。

  1. /* NonSerialSuperExample */  
  2. package com.asc.alibaba.base;  
  3.   
  4. import java.io.FileInputStream;  
  5. import java.io.FileOutputStream;  
  6. import java.io.ObjectInputStream;  
  7. import java.io.ObjectOutputStream;  
  8.   
  9. public class NonSerialSuperExample {  
  10.   
  11.     public static void main(String args[]) {  
  12.         Book bookorg = new Book(100"How to Serialize"true"R.R""Serialization"97);  
  13.         Book booknew = null;  
  14.         try {  
  15.             FileOutputStream fo = new FileOutputStream("tmp");  
  16.             ObjectOutputStream so = new ObjectOutputStream(fo);  
  17.             so.writeObject(bookorg);  
  18.             so.flush();  
  19.         } catch (Exception e) {  
  20.             System.out.println(e);  
  21.             System.exit(1);  
  22.         }  
  23.         try {  
  24.             FileInputStream fi = new FileInputStream("tmp");  
  25.             ObjectInputStream si = new ObjectInputStream(fi);  
  26.             booknew = (Book) si.readObject();  
  27.         } catch (Exception e) {  
  28.             System.out.println(e);  
  29.             System.exit(1);  
  30.         }  
  31.         System.out.println();  
  32.         System.out.println("Printing original book..");  
  33.         System.out.println(bookorg);  
  34.         System.out.println("Printing new book..");  
  35.         System.out.println(booknew);  
  36.         System.out.println("Both original and new should be the same");  
  37.         System.out.println();  
  38.     }  
  39. }  
  40. /* Book.java */  
  41. package com.asc.alibaba.base;  
  42.   
  43. import java.io.IOException;  
  44. import java.io.ObjectInputStream;  
  45. import java.io.ObjectOutputStream;  
  46. import java.io.Serializable;  
  47.   
  48. class Book extends ReadingMaterial implements Serializable {  
  49.   
  50.     int     numpages;  
  51.     String  name;  
  52.     boolean ishardcover;  
  53.   
  54.     public Book(){  
  55.         super();  
  56.     }  
  57.   
  58.     public Book(int pages, String n, boolean hardcover, String author, String subject, int yearwritten){  
  59.         super(author, subject, yearwritten);  
  60.         numpages = pages;  
  61.         name = n;  
  62.         ishardcover = hardcover;  
  63.     }  
  64.   
  65.     private void writeObject(ObjectOutputStream out) throws IOException {  
  66.         out.defaultWriteObject();  
  67.         out.writeObject(author);  
  68.         out.writeObject(subject);  
  69.         out.writeInt(yearwritten);  
  70.     }  
  71.   
  72.     private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {  
  73.   
  74.         in.defaultReadObject();  
  75.   
  76.         author = (String) in.readObject();  
  77.         subject = (String) in.readObject();  
  78.         yearwritten = in.readInt();  
  79.     }  
  80.   
  81.     public String toString() {  
  82.         return ("Name:" + name + "\n" + "Author:" + author + "\n" + "Pages:" + numpages + "\n" + "Subject:" + subject  
  83.                 + "\n" + "Year:" + yearwritten + "\n");  
  84.     }  
  85. }/* ReadingMaterial.java */  
  86.  package com.asc.alibaba.base;  
  87.   
  88. class ReadingMaterial {  
  89.   
  90.     protected String author;  
  91.     protected String subject;  
  92.     protected int    yearwritten;  
  93.   
  94.     public ReadingMaterial(){  
  95.     }  
  96.   
  97.     public ReadingMaterial(String auth, String sub, int year){  
  98.         author = auth;  
  99.         subject = sub;  
  100.         yearwritten = year;  
  101.     }  
  102. }  
  103. 结果如下:   
  104. Printing original book..  
  105. Name:How to Serialize  
  106. Author:R.R  
  107. Pages:100  
  108. Subject:Serialization  
  109. Year:97  
  110. Printing new book..  
  111. Name:How to Serialize  
  112. Author:R.R  
  113. Pages:100  
  114. Subject:Serialization  
  115. Year:97  
  116. Both original and new should be the same  

7.3 超类具体化的具体化

当用具体化接口时,一个具体化对象必须运行writeExternal()方法存储对象的状态,用readExternal方法读取对象的状态。此例子验证了一个怎样存储和恢复它可具体化超类对象的状态。当一个可具体化对象的超类也具体化,子类要在它自己的writeExternal()readExternal()方法中调用其超类的writeExternal()readExternal()方法。

  1. /*SaveSuper*/  
  2. package com.asc.alibaba.base;  
  3.   
  4. import java.io.FileInputStream;  
  5. import java.io.FileOutputStream;  
  6. import java.io.ObjectInputStream;  
  7. import java.io.ObjectOutputStream;  
  8.   
  9. public class SaveSuper {  
  10.   
  11.     public static void main(String args[]) {  
  12.         Book1 bookorg = new Book1(100"How to Serialize"true"R.R""Serialization"97);  
  13.         Book1 booknew = null;  
  14.         try {  
  15.             FileOutputStream fo = new FileOutputStream("tmp");  
  16.             ObjectOutputStream so = new ObjectOutputStream(fo);  
  17.             so.writeObject(bookorg);  
  18.             so.flush();  
  19.         } catch (Exception e) {  
  20.             System.out.println(e);  
  21.             System.exit(1);  
  22.         }  
  23.         try {  
  24.             FileInputStream fi = new FileInputStream("tmp");  
  25.             ObjectInputStream si = new ObjectInputStream(fi);  
  26.             booknew = (Book1) si.readObject();  
  27.         } catch (Exception e) {  
  28.             System.out.println(e);  
  29.             System.exit(1);  
  30.         }  
  31.         System.out.println();  
  32.         System.out.println("Printing original book..");  
  33.         System.out.println(bookorg);  
  34.         System.out.println("Printing new book..");  
  35.         System.out.println(booknew);  
  36.         System.out.println("Both original and new should be the same");  
  37.         System.out.println();  
  38.     }  
  39. }  
  40. /*Book1*/  
  41. package com.asc.alibaba.base;  
  42.   
  43. import java.io.Externalizable;  
  44. import java.io.IOException;  
  45. import java.io.ObjectInput;  
  46. import java.io.ObjectOutput;  
  47.   
  48. class Book1 extends ReadingMaterial1 implements Externalizable {  
  49.   
  50.     private int     numpages;  
  51.     private String  name;  
  52.     private boolean ishardcover;  
  53.   
  54.     public Book1(){  
  55.         super();  
  56.     }  
  57.   
  58.     public Book1(int pages, String n, boolean hardcover, String author, String subject, int yearwritten){  
  59.         super(author, subject, yearwritten);  
  60.         numpages = pages;  
  61.         name = n;  
  62.         ishardcover = hardcover;  
  63.     }  
  64.   
  65.     public void witeExternal(ObjectOutput out) throws IOException {  
  66.         super.writeExternal(out);  
  67.     }  
  68.   
  69.     public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {  
  70.         super.readExternal(in);  
  71.         numpages = in.readInt();  
  72.         name = (String) in.readObject();  
  73.         ishardcover = in.readBoolean();  
  74.     }  
  75.   
  76.     public String toString() {  
  77.         return ("Name:" + name + "\n" + "Author:" + super.getAuthor() + "\n" + "Pages:" + numpages + "\n" + "Subject:"  
  78.                 + super.getSubject() + "\n" + "Year:" + super.getYearwritten() + "\n");  
  79.     }  
  80. }  
  81.   
  82. /*ReadingMaterial1*/  
  83. package com.asc.alibaba.base;  
  84.   
  85. import java.io.Externalizable;  
  86. import java.io.IOException;  
  87. import java.io.ObjectInput;  
  88. import java.io.ObjectOutput;  
  89.   
  90. class ReadingMaterial1 implements Externalizable {  
  91.   
  92.     private String author;  
  93.     private String subject;  
  94.     private int    yearwritten;  
  95.   
  96.     public ReadingMaterial1(){  
  97.     }  
  98.   
  99.     public ReadingMaterial1(String auth, String sub, int year){  
  100.         author = auth;  
  101.         subject = sub;  
  102.         yearwritten = year;  
  103.     }  
  104.   
  105.     public String getAuthor() {  
  106.         return author;  
  107.     }  
  108.   
  109.     public String getSubject() {  
  110.         return subject;  
  111.     }  
  112.   
  113.     public int getYearwritten() {  
  114.         return yearwritten;  
  115.     }  
  116.   
  117.     public void writeExternal(ObjectOutput out) throws IOException {  
  118.         out.writeObject(author);  
  119.         out.writeObject(subject);  
  120.         out.writeInt(yearwritten);  
  121.     }  
  122.   
  123.     public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {  
  124.         author = (String) in.readObject();  
  125.         subject = (String) in.readObject();  
  126.         yearwritten = in.readInt();  
  127.     }  
  128. }  
  129. 结果如下:  
  130. Printing original book..  
  131. Name:How to Serialize  
  132. Author:R.R  
  133. Pages:100  
  134. Subject:Serialization  
  135. Year:97  
  136.   
  137. Printing new book..  
  138. Name:null  
  139. Author:R.R  
  140. Pages:0  
  141. Subject:Serialization  
  142. Year:97  
  143. Both original and new should be the same  

7.4 超类非具体化的具体化

当用具体化接口时,一个具体化对象必须运行writeExternal()方法存储对象的状态,用readExternal()方法读取对象的状态。此例子验证了一个对象怎样存储和恢复它非具体化超类的状态。当一个可具体化对象的超类没有具体化,子类必须用它自己的writeExternal()readExternal()方法明确存储和恢复其超类的可具体化对象状态。

  1. /*Nonexternsuper1*/  
  2. package com.asc.alibaba.base;  
  3.   
  4. import java.io.FileInputStream;  
  5. import java.io.FileOutputStream;  
  6. import java.io.ObjectInputStream;  
  7. import java.io.ObjectOutputStream;  
  8.   
  9. public class Nonexternsuper1 {  
  10.   
  11.     public static void main(String args[]) {  
  12.         Book2 bookorg = new Book2(100"How to Serialize"true"R.R""Serialization"97);  
  13.         Book2 booknew = null;  
  14.         try {  
  15.             FileOutputStream fo = new FileOutputStream("tmp");  
  16.             ObjectOutputStream so = new ObjectOutputStream(fo);  
  17.             so.writeObject(bookorg);  
  18.             so.flush();  
  19.         } catch (Exception e) {  
  20.             System.out.println(e);  
  21.             System.exit(1);  
  22.         }  
  23.         try {  
  24.             FileInputStream fi = new FileInputStream("tmp");  
  25.             ObjectInputStream si = new ObjectInputStream(fi);  
  26.             booknew = (Book2) si.readObject();  
  27.         } catch (Exception e) {  
  28.             System.out.println(e);  
  29.             System.exit(1);  
  30.         }  
  31.         System.out.println();  
  32.         System.out.println("Printing original book..");  
  33.         System.out.println(bookorg);  
  34.         System.out.println("Printing new book..");  
  35.         System.out.println(booknew);  
  36.         System.out.println("Both original and new should be the same");  
  37.         System.out.println();  
  38.     }  
  39. }  
  40. /*Book2*/  
  41. package com.asc.alibaba.base;  
  42.   
  43. import java.io.Externalizable;  
  44. import java.io.IOException;  
  45. import java.io.ObjectInput;  
  46. import java.io.ObjectOutput;  
  47.   
  48. class Book2 extends ReadingMaterial2 implements Externalizable {  
  49.   
  50.     int     numpages;  
  51.     String  name;  
  52.     boolean ishardcover;  
  53.   
  54.     public Book2(){  
  55.         super();  
  56.     }  
  57.   
  58.     Book2(int pages, String n, boolean hardcover, String author, String subject, int yearwritten){  
  59.         super(author, subject, yearwritten);  
  60.         numpages = pages;  
  61.         name = n;  
  62.         ishardcover = hardcover;  
  63.     }  
  64.   
  65.     public void writeExternal(ObjectOutput out) throws IOException {  
  66.         out.writeObject(author);  
  67.         out.writeObject(subject);  
  68.         out.writeInt(yearwritten);  
  69.         out.writeInt(numpages);  
  70.         out.writeObject(name);  
  71.         out.writeBoolean(ishardcover);  
  72.     }  
  73.   
  74.     public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {  
  75.         author = (String) in.readObject();  
  76.         subject = (String) in.readObject();  
  77.         yearwritten = in.readInt();  
  78.         numpages = in.readInt();  
  79.         name = (String) in.readObject();  
  80.         ishardcover = in.readBoolean();  
  81.     }  
  82.   
  83.     public String toString() {  
  84.         return ("Name:" + name + "\n" + "Author:" + author + "\n" + "Pages:" + numpages + "\n" + "Subject:" + subject  
  85.                 + "\n" + "Year:" + yearwritten + "\n");  
  86.     }  
  87. }  
  88. /*ReadingMaterial2*/  
  89. package com.asc.alibaba.base;  
  90.   
  91. public class ReadingMaterial2 {  
  92.   
  93.     String author;  
  94.     String subject;  
  95.     int    yearwritten;  
  96.   
  97.     public ReadingMaterial2(){  
  98.     }  
  99.   
  100.     ReadingMaterial2(String auth, String sub, int year){  
  101.         author = auth;  
  102.         subject = sub;  
  103.         yearwritten = year;  
  104.     }  
  105. }  
  106. 结果:  
  107. Printing original book..  
  108. Name:How to Serialize  
  109. Author:R.R  
  110. Pages:100  
  111. Subject:Serialization  
  112. Year:97  
  113.   
  114. Printing new book..  
  115. Name:How to Serialize  
  116. Author:R.R  
  117. Pages:100  
  118. Subject:Serialization  
  119. Year:97  
  120.   
  121. Both original and new should be the same  

7.5 演进类的序列化

  1. /* EvolutionExampleOriginalClass3*/  
  2. package com.asc.alibaba.base;  
  3.   
  4. import java.io.FileInputStream;  
  5. import java.io.FileOutputStream;  
  6. import java.io.IOException;  
  7. import java.io.ObjectInputStream;  
  8. import java.io.ObjectOutputStream;  
  9. import java.io.Serializable;  
  10.   
  11. public class EvolutionExampleOriginalClass3 {  
  12.   
  13.     public static void main(String args[]) {  
  14.         boolean serialize = false;  
  15.         boolean deserialize = false;  
  16.         if (args.length == 1) {  
  17.             if (args[0].equals("-d")) {  
  18.                 deserialize = true;  
  19.             } else if (args[0].equals("-s")) {  
  20.                 serialize = true;  
  21.             } else {  
  22.                 usage();  
  23.                 System.exit(0);  
  24.             }  
  25.         } else {  
  26.             usage();  
  27.             System.exit(0);  
  28.         }  
  29.         AClass serializeclass = new AClass(10"serializedByOriginalClass");  
  30.         AClass deserializeclass = null;  
  31.         if (serialize) {  
  32.             try {  
  33.                 FileOutputStream fo = new FileOutputStream("evolve.tmp");  
  34.                 ObjectOutputStream so = new ObjectOutputStream(fo);  
  35.                 so.writeObject(serializeclass);  
  36.                 so.flush();  
  37.             } catch (Exception e) {  
  38.                 System.out.println(e);  
  39.                 System.exit(1);  
  40.             }  
  41.         }  
  42.         if (deserialize) {  
  43.             try {  
  44.                 FileInputStream fi = new FileInputStream("evolve.tmp");  
  45.                 ObjectInputStream si = new ObjectInputStream(fi);  
  46.                 deserializeclass = (AClass) si.readObject();  
  47.             } catch (Exception e) {  
  48.                 System.out.println(e);  
  49.                 System.exit(1);  
  50.             }  
  51.             System.out.println("Now printing deserialzed object's name:");  
  52.             System.out.println();  
  53.             System.out.println(deserializeclass);  
  54.             System.out.println();  
  55.         }  
  56.     }  
  57.   
  58.     static void usage() {  
  59.         System.out.println("Usage:");  
  60.         System.out.println("    -s(in order to serialize)");  
  61.         System.out.println("    -d(in order to deserialize)");  
  62.     }  
  63. }  
  64.   
  65. class AClass implements Serializable {  
  66.   
  67.     private int num;  
  68.     String      name;  
  69.   
  70.     AClass(int n, String s){  
  71.         num = n;  
  72.         name = s;  
  73.     }  
  74.   
  75.     private void writeObject(ObjectOutputStream s) throws IOException {  
  76.         s.defaultWriteObject();  
  77.     }  
  78.   
  79.     private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException {  
  80.         s.defaultReadObject();  
  81.     }  
  82.   
  83.     public String toString() {  
  84.         return ("Name:" + name + "\n" + "Num:" + num + "\n");  
  85.     }  
  86. }  
  87. 结果:  
  88. Now printing deserialzed object's name:  
  89.   
  90. Name:serializedByOriginalClass  
  91. Num:10  

8、Java序列化的高级认识

8.1 序列化 ID 问题

情境:两个客户端 AB试图通过网络传递对象数据,A端将对象C序列化为二进制数据再传给BB反序列化得到C

问题C对象的全类路径假设为 com.alibaba.Test,在AB端都有这么一个类文件,功能代码完全一致。也都实现了Serializable接口,但是反序列化时总是提示不成功。

解决虚拟机是否允许反序列化,不仅取决于类路径和功能代码是否一致,一个非常重要的一点是两个类的序列化ID是否一致(就是 privatestatic final long serialVersionUID = 1L。清单 1中,虽然两个类的功能代码完全一致,但是序列化ID不同,他们无法相互序列化和反序列化。

  1. package com.asc.alibaba.base;  
  2.   
  3. import java.io.Serializable;  
  4.   
  5. public class AA implements Serializable {  
  6.   
  7.     private static final long serialVersionUID = 1L;  
  8.     private String            name;  
  9.   
  10.     public String getName() {  
  11.         return name;  
  12.     }  
  13.   
  14.     public void setName(String name) {  
  15.         this.name = name;  
  16.     }  
  17. }  
  18.   
  19. package com.asc.alibaba.base;  
  20.   
  21. import java.io.Serializable;  
  22.   
  23. public class AA implements Serializable {  
  24.   
  25.     private static final long serialVersionUID = 2L;  
  26.     private String            name;  
  27.   
  28.     public String getName() {  
  29.         return name;  
  30.     }  
  31.   
  32.     public void setName(String name) {  
  33.         this.name = name;  
  34.     }  
  35. }  

序列化IDEclipse下提供了两种生成策略,一个是固定的1L,一个是随机生成一个不重复的long类型数据(实际上是使用JDK工具生成),在这里有一个建议,如果没有特殊需求,就是用默认的1L就可以,这样可以确保代码一致时反序列化成功。

8.2静态变量的序列化

情境:两个客户端A B试图通过网络传递对象数据,A端将对象C序列化为二进制数据再传给B,对C中的静态变量进行修改,B在反序列化出C对象后,重新访问该静态变量,将会发现该变量已经被修改。代码清单如下:

  1. package com.asc.alibaba.base;  
  2.   
  3. import java.io.FileInputStream;  
  4. import java.io.FileNotFoundException;  
  5. import java.io.FileOutputStream;  
  6. import java.io.IOException;  
  7. import java.io.ObjectInputStream;  
  8. import java.io.ObjectOutputStream;  
  9. import java.io.Serializable;  
  10.   
  11. public class StaticTest implements Serializable {  
  12.   
  13.     private static final long serialVersionUID = 1L;  
  14.     public static int         staticVar        = 5;  
  15.   
  16.     public static void main(String[] args) {  
  17.         try {  
  18.             // 初始时staticVar为5  
  19.             ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("result.obj"));  
  20.             out.writeObject(new StaticTest());  
  21.             out.close();  
  22.             // 序列化后修改为10  
  23.             StaticTest.staticVar = 10;  
  24.             ObjectInputStream oin = new ObjectInputStream(new FileInputStream("result.obj"));  
  25.             StaticTest t = (StaticTest) oin.readObject();  
  26.             oin.close();  
  27.             // 再读取,通过t.staticVar打印新的值  
  28.             System.out.println(t.staticVar);  
  29.         } catch (FileNotFoundException e) {  
  30.             e.printStackTrace();  
  31.         } catch (IOException e) {  
  32.             e.printStackTrace();  
  33.         } catch (ClassNotFoundException e) {  
  34.             e.printStackTrace();  
  35.         }  
  36.     }  
  37. }  

将对象序列化后,修改静态变量的数值,再将序列化对象读取出来,然后通过读取出来的对象获得静态变量的数值并打印出来。依照清单2,这个System.out.println(t.staticVar)语句输出的是 10 还是 5 呢?

最后的输出是 10,对于无法理解的读者认为,打印的 staticVar是从读取的对象里获得的,应该是保存时的状态才对。之所以打印10的原因在于序列化时,并不保存静态变量,这其实比较容易理解,序列化保存的是对象的状态,静态变量属于类的状态,因此 序列化并不保存静态变量

8.3 父类的序列化与 Transient 关键字

情境:一个子类实现了Serializable接口,它的父类都没有实现Serializable接口,序列化该子类对象,然后反序列化后输出父类定义的某变量的数值,该变量数值与序列化时的数值不同。

解决要想将父类对象也序列化,就需要让父类也实现Serializable接口。如果父类没有实现的话,就需要有默认的无参的构造函数。在父类没有实现Serializable接口时,虚拟机是不会序列化父对象的,而一个Java对象的构造必须先有父对象,才有子对象,反序列化也不例外。所以反序列化时,为了构造父对象,只能调用父类的无参构造函数作为默认的父对象。因此当我们取父对象的变量值时,它的值是调用父类无参构造函数后的值。如果你考虑到这种序列化的情况,在父类无参构造函数中对变量进行初始化,否则的话,父类变量值都是默认声明的值,如int型的默认是0,string型的默认是 null。

Transient关键字的作用是控制变量的序列化,在变量声明前加上该关键字,可以阻止该变量被序列化到文件中,在被反序列化后,transient变量的值被设为初始值,如int型的是0,对象型的是 null。

8.4 对敏感字段加密

情境:服务器端给客户端发送序列化对象数据,对象中有一些数据是敏感的,比如密码字符串等,希望对该密码字段在序列化时,进行加密,而客户端如果拥有解密的密钥,只有在客户端进行反序列化时,才可以对密码进行读取,这样可以一定程度保证序列化对象的数据安全。

解决:在序列化过程中,虚拟机会试图调用对象类里的writeObject和readObject方法,进行用户自定义的序列化和反序列化,如果没有这样的方法,则默认调用是ObjectOutputStream的defaultWriteObject方法以及ObjectInputStream的defaultReadObject方法。用户自定义的writeObject和readObject方法可以允许用户控制序列化的过程,比如可以在序列化的过程中动态改变序列化的数值。基于这个原理,可以在实际应用中得到使用,用于敏感字段的加密工作。

  1. package com.asc.alibaba.base;  
  2.   
  3. import java.io.FileInputStream;  
  4. import java.io.FileNotFoundException;  
  5. import java.io.FileOutputStream;  
  6. import java.io.IOException;  
  7. import java.io.ObjectInputStream;  
  8. import java.io.ObjectOutputStream;  
  9. import java.io.Serializable;  
  10. import java.io.ObjectInputStream.GetField;  
  11. import java.io.ObjectOutputStream.PutField;  
  12.   
  13. public class EncryptTest implements Serializable {  
  14.   
  15.     private static final long serialVersionUID = 1L;  
  16.     private String            password         = "password1";  
  17.   
  18.     public String getPassword() {  
  19.         return password;  
  20.     }  
  21.   
  22.     public void setPassword(String password) {  
  23.         this.password = password;  
  24.     }  
  25.   
  26.     private void writeObject(ObjectOutputStream out) {  
  27.         try {  
  28.             PutField putFields = out.putFields();  
  29.             System.out.println("原密码:" + password);  
  30.             password = "password2";// 模拟加密  
  31.             putFields.put("password", password);  
  32.             System.out.println("加密后的密码" + password);  
  33.             out.writeFields();  
  34.         } catch (IOException e) {  
  35.             e.printStackTrace();  
  36.         }  
  37.     }  
  38.   
  39.     private void readObject(ObjectInputStream in) {  
  40.         try {  
  41.             GetField readFields = in.readFields();  
  42.             Object object = readFields.get("password""");  
  43.             System.out.println("解密的字符串:" + object.toString());  
  44.             password = "password1";// 模拟解密,需要获得本地的密钥  
  45.         } catch (IOException e) {  
  46.             e.printStackTrace();  
  47.         } catch (ClassNotFoundException e) {  
  48.             e.printStackTrace();  
  49.         }  
  50.     }  
  51.   
  52.     public static void main(String[] args) {  
  53.         try {  
  54.             ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("result.obj"));  
  55.             out.writeObject(new EncryptTest());  
  56.             out.close();  
  57.   
  58.             ObjectInputStream oin = new ObjectInputStream(new FileInputStream("result.obj"));  
  59.             EncryptTest t = (EncryptTest) oin.readObject();  
  60.             System.out.println("解密后的字符串:" + t.getPassword());  
  61.             oin.close();  
  62.         } catch (FileNotFoundException e) {  
  63.             e.printStackTrace();  
  64.         } catch (IOException e) {  
  65.             e.printStackTrace();  
  66.         } catch (ClassNotFoundException e) {  
  67.             e.printStackTrace();  
  68.         }  
  69.     }  
  70. }  

RMI 技术是完全基于 Java序列化技术的,服务器端接口调用所需要的参数对象来自于客户端,它们通过网络相互传输。这就涉及 RMI的安全传输的问题。一些敏感的字段,如用户名密码(用户登录时需要对密码进行传输),我们希望对其进行加密,这时,就可以采用本节介绍的方法在客户端对密码进行加密,服务器端进行解密,确保数据传输的安全性。

8.5 序列化的存储规则

情境:当将一个对象连续两次进行序列化时,它并不能够使文件翻倍,而且在反序列化出来的两个对象完全一致。

解答:Java序列化机制为了节省磁盘空间,具有特定的存储规则,当写入文件的为同一对象时,并不会再将对象的内容进行存储,而只是再次存储一份引用,上面增加的 5字节的存储空间就是新增引用和一些控制信息的空间。反序列化时,恢复引用关系,使得清单中的 t1和 t2 指向唯一的对象,二者相等,输出 true。该存储规则极大的节省了存储空间。

  1. package com.asc.alibaba.base;  
  2.   
  3. import java.io.File;  
  4. import java.io.FileInputStream;  
  5. import java.io.FileNotFoundException;  
  6. import java.io.FileOutputStream;  
  7. import java.io.IOException;  
  8. import java.io.ObjectInputStream;  
  9. import java.io.ObjectOutputStream;  
  10. import java.io.Serializable;  
  11.   
  12. public class StoreTest implements Serializable {  
  13.   
  14.     private static final long serialVersionUID = 1L;  
  15.   
  16.     public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {  
  17.         ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("result.obj"));  
  18.         StoreTest test = new StoreTest();  
  19.         // 试图将对象两次写入文件  
  20.         out.writeObject(test);  
  21.         out.flush();  
  22.         System.out.println(new File("result.obj").length());  
  23.         out.writeObject(test);  
  24.         out.close();  
  25.         System.out.println(new File("result.obj").length());  
  26.         ObjectInputStream oin = new ObjectInputStream(new FileInputStream("result.obj"));  
  27.         // 从文件依次读出两个文件  
  28.         StoreTest t1 = (StoreTest) oin.readObject();  
  29.         StoreTest t2 = (StoreTest) oin.readObject();  
  30.         oin.close();  
  31.         // 判断两个引用是否指向同一个对象  
  32.         System.out.println(t1 == t2);  
  33.     }  
  34. }  
转载:http://blog.csdn.net/zhaozheng7758/article/details/7820018
阅读更多
想对作者说点什么?

博主推荐

换一批

没有更多推荐了,返回首页