Java Serializable系列化与反系列化

【引言】

将 Java 对象序列化为二进制文件的 Java 序列化技术是 Java
系列技术中一个较为重要的技术点，在大部分情况下，开发人员只需要了解被序列化的类需要实现 Serializable 接口，使用
ObjectInputStream 和 ObjectOutputStream
进行对象的读写。然而在有些情况下，光知道这些还远远不够，文章列举了笔者遇到的一些真实情境，它们与 Java
序列化相关，通过分析情境出现的原因，使读者轻松牢记 Java 序列化中的一些高级认识。

【系列化serialVersionUID问题】

在Java系列化与反系列化中，虚拟机是否允许反序列化，不仅取决于类路径和功能代码是否一致，一个非常重要的一点是两个类的序列化 ID
是否一致（就是 private static final long serialVersionUID =
1L），如果serialVersionUID不同，你将得到一个java.io.InvalidClassException，看如下代码：

1. package wen.hui.test.serializable;
2. import java.io.Serializable;
3. /**
4. * serializable测试
5. *
6. * @author whwang
7. * 2011-12-1 下午09:50:07
8. */
9. public class A implements Serializable {
10. private static final long serialVersionUID = 2L;
11. public A() {
12. }
13. public void print() {
14. System.err.println("test serializable");
15. }
16. public static void main(String[] args) throws Exception {
17. }
18. }

1. package wen.hui.test.serializable;
2. import java.io.FileInputStream;
3. import java.io.FileOutputStream;
4. import java.io.ObjectInputStream;
5. import java.io.ObjectOutputStream;
6. /**
7. *
8. * @author whwang
9. * 2011-12-1 下午09:54:36
10. */
11. public class Test1 {
12. public static void main(String[] args) throws Exception {
13. // write object
14. String fileName = "obj";
15. toWrite(fileName);
16. // read object
17. toRead(fileName);
18. }
19. public static void toWrite(String fileName) throws Exception {
20. ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(
21. fileName));
22. oos.writeObject(new A());
23. oos.close();
24. }
25. public static void toRead(String fileName) throws Exception {
26. ObjectInputStream ois = new ObjectInputStream(
27. new FileInputStream("obj"));
28. A t = (A) ois.readObject();
29. t.print();
30. ois.close();
31. }
32. }

1、直接运行Test1的main方法，运行正确；
2、先将Test1的main方法中的toRead(fileName)注释，把类A中的serialVersionUID
值改为1，运行Test1；然后在代开toRead(fileName)，将toWrite(fileName)注释，同时将类A中的serialVersionUID
值改为2；运行Test1，发现抛出异常，表明如果serialVersionUID不同，即使两个“完全”相同的类也无法反序列化。

1. Exception in thread "main" java.io.InvalidClassException: wen.hui.test.serializable.A; local class incompatible: stream classdesc serialVersionUID = 1, local class serialVersionUID = 2

序列化 ID 在 Eclipse 下提供了两种生成策略，一个是固定的 1L，一个是随机生成一个不重复的 long 类型数据（实际上是使用 JDK
工具生成），在这里有一个建议，如果没有特殊需求，就是用默认的 1L 就可以，这样可以确保代码一致时反序列化成功。那么随机生成的序列化 ID
有什么作用呢，有些时候，通过改变序列化 ID 可以用来限制某些用户的使用。如Facade模式中，Client 端通过 Façade Object
才可以与业务逻辑对象进行交互。而客户端的 Façade Object 不能直接由
Client 生成，而是需要 Server 端生成，然后序列化后通过网络将二进制对象数据传给 Client，Client 负责反序列化得到
Façade 对象。该模式可以使得 Client 端程序的使用需要服务器端的许可，同时 Client 端和服务器端的 Façade Object
类需要保持一致。当服务器端想要进行版本更新时，只要将服务器端的 Façade Object 类的序列化 ID 再次生成，当 Client
端反序列化 Façade Object 就会失败，也就是强制 Client 端从服务器端获取最新程序。

【静态变量序列】

直接看代码：

1. package wen.hui.test.serializable;
2. import java.io.Serializable;
3. /**
4. * serializable测试
5. *
6. * @author whwang
7. * 2011-12-1 下午09:50:07
8. */
9. public class A implements Serializable {
10. private static final long serialVersionUID = 1L;
11. public static int staticVar = 10;
12. public A() {
13. }
14. public void print() {
15. System.err.println("test serializable");
16. }
17. public static void main(String[] args) throws Exception {
18. }
19. }

1. package wen.hui.test.serializable;
2. import java.io.FileInputStream;
3. import java.io.FileNotFoundException;
4. import java.io.FileOutputStream;
5. import java.io.IOException;
6. import java.io.ObjectInputStream;
7. import java.io.ObjectOutputStream;
8. /**
9. * 序列化保存的是对象的状态，静态变量属于类的状态，不会被序列化
10. * @author whwang
11. * 2011-12-1 下午10:12:06
12. */
13. public class Test2 {
14. public static void main(String[] args) {
15. try {
16. // 初始时staticVar为10
17. ObjectOutputStream out = new ObjectOutputStream(
18. new FileOutputStream("obj"));
19. out.writeObject(new A());
20. out.close();
21. // 序列化后修改为100
22. A.staticVar = 100;
23. ObjectInputStream oin = new ObjectInputStream(new FileInputStream(
24. "obj"));
25. A t = (A) oin.readObject();
26. oin.close();
27. // 再读取，通过t.staticVar打印新的值
28. System.err.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. }

A类的静态字段staticVar初始化值为10，在Teste2的main方法中，将A类的一个实例系列化到硬盘，然后修改静态字段staticVar
= 100，接着反系列化刚系列化的对象，输出”该对象的“staticVar的值。输出的是 100 还是 10 呢？
结果输出是100，之所以打印 100 的原因在于序列化时，并不保存静态变量，这其实比较容易理解，序列化保存的是对象的状态，静态变量属于类的状态，因此 序列化并不保存静态变量。

【父类的序列化与 Transient 关键字】

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

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

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

1. package wen.hui.test.serializable;
2. /**
3. *
4. * @author whwang
5. * 2011-12-1 下午10:23:10
6. */
7. public class B {
8. public int b1;
9. public int b2;
10. public B() {
11. this.b2 = 100;
12. }
13. }

1. package wen.hui.test.serializable;
2. import java.io.Serializable;
3. /**
4. *
5. * @author whwang
6. * 2011-12-1 下午09:49:51
7. */
8. public class C extends B implements Serializable {
9. private static final long serialVersionUID = 1L;
10. public int c1;
11. public int c2;
12. public C() {
13. // 给b1,b2赋值
14. this.b1 = 1;
15. this.b2 = 2;
16. this.c2 = -100;
17. }
18. }

1. package wen.hui.test.serializable;
2. import java.io.FileInputStream;
3. import java.io.FileNotFoundException;
4. import java.io.FileOutputStream;
5. import java.io.IOException;
6. import java.io.ObjectInputStream;
7. import java.io.ObjectOutputStream;
8. /**
9. * 如果父类没有实现Serializable，那么父类不会被系列化，当反系列化子类时
10. * 会调用父类无参的构造方法。
11. * @author whwang
12. * 2011-12-1 下午10:23:51
13. */
14. public class Test3 {
15. public static void main(String[] args) {
16. try {
17. ObjectOutputStream out = new ObjectOutputStream(
18. new FileOutputStream("obj"));
19. out.writeObject(new C());
20. out.close();
21. ObjectInputStream oin = new ObjectInputStream(new FileInputStream(
22. "obj"));
23. C t = (C) oin.readObject();
24. oin.close();
25. System.err.println(t.b1 + ", " + t.b2 + ", " + t.c1 + ", " + t.c2);
26. } catch (FileNotFoundException e) {
27. e.printStackTrace();
28. } catch (IOException e) {
29. e.printStackTrace();
30. } catch (ClassNotFoundException e) {
31. e.printStackTrace();
32. }
33. }
34. }

运行Test3的main方法，结果输出0, 100, 0, -100；即在子类的构造方法中对父类的成员变量的初始化没有被系列化；而反系列化时，则是调用父类的无参构造方法实例化父类。

【对敏感字段加密】

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

解决：在序列化过程中，虚拟机会试图调用对象类里的 writeObject(ObjectOutputStread out) 和
readObject(ObjectInputStread in)
方法（通过反射机制），进行用户自定义的序列化和反序列化，如果没有这样的方法，则默认调用是 ObjectOutputStream 的
defaultWriteObject 方法以及 ObjectInputStream 的 defaultReadObject 方法。用户自定义的
writeObject 和 readObject

方法可以允许用户控制序列化的过程，比如可以在序列化的过程中动态改变序列化的数值。基于这个原理，可以在实际应用中得到使用，用于敏感字段的加密工作，如：

1. package wen.hui.test.serializable;
2. import java.io.IOException;
3. import java.io.ObjectInputStream;
4. import java.io.ObjectInputStream.GetField;
5. import java.io.Serializable;
6. /**
7. * @author whwang 2011-12-1 下午10:29:54
8. */
9. public class D implements Serializable {
10. private static final long serialVersionUID = 1L;
11. private String password;
12. public D() {
13. }
14. public String getPassword() {
15. return password;
16. }
17. public void setPassword(String password) {
18. this.password = password;
19. }
20. //    private void writeObject(ObjectOutputStream out) {
21. //
22. //    }
23. private void readObject(ObjectInputStream in) {
24. try {
25. GetField readFields = in.readFields();
26. Object object = readFields.get("password", "");
27. System.err.println("要解密的字符串:" + object.toString());
28. password = "password";// 模拟解密,需要获得本地的密钥
29. } catch (IOException e) {
30. e.printStackTrace();
31. } catch (ClassNotFoundException e) {
32. e.printStackTrace();
33. }
34. }
35. }

1. package wen.hui.test.serializable;
2. import java.io.FileInputStream;
3. import java.io.FileNotFoundException;
4. import java.io.FileOutputStream;
5. import java.io.IOException;
6. import java.io.ObjectInputStream;
7. import java.io.ObjectOutputStream;
8. /**
9. * @ClassName: Test4
10. * @Description: 加密测试。
11. * @author whwang
12. * @date 2011-12-1 下午05:01:34
13. *
14. */
15. public class Test4 {
16. public static void main(String[] args) {
17. try {
18. ObjectOutputStream out = new ObjectOutputStream(
19. new FileOutputStream("obj"));
20. D t1 = new D();
21. t1.setPassword("encryption");// 加密后的（模拟）
22. out.writeObject(t1);
23. out.close();
24. ObjectInputStream oin = new ObjectInputStream(new FileInputStream(
25. "obj"));
26. D t = (D) oin.readObject();
27. oin.close();
28. System.err.println("解密后的字符串:" + t.getPassword());
29. } catch (FileNotFoundException e) {
30. e.printStackTrace();
31. } catch (IOException e) {
32. e.printStackTrace();
33. } catch (ClassNotFoundException e) {
34. e.printStackTrace();
35. }
36. }
37. }

在系列化之前，将密码字段加密，然后系列化到硬盘，在反系列化时，通过类D中的readObject(ObjectInputStream in)做解密操作，确保了数据的安全。

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

【序列化存储规则】

请看如下代码：

1. package wen.hui.test.serializable;
2. import java.io.File;
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. /**
10. *
11. * @author whwang 2011-12-1 下午11:00:35
12. */
13. public class Test5 {
14. public static void main(String[] args) {
15. ObjectOutputStream out;
16. try {
17. out = new ObjectOutputStream(new FileOutputStream(
18. "obj"));
19. A t = new A();
20. // 试图将对象两次写入文件
21. out.writeObject(t);
22. out.flush();
23. System.err.println("加入第一个类：" + new File("obj").length());
24. //t.a = 10;
25. out.writeObject(t);
26. out.close();
27. System.err.println("加入第二个类：" + new File("obj").length());
28. ObjectInputStream oin = new ObjectInputStream(new FileInputStream(
29. "obj"));
30. // 从文件依次读出两个文件
31. A t1 = (A) oin.readObject();
32. A t2 = (A) oin.readObject();
33. oin.close();
34. // 判断两个引用是否指向同一个对象
35. System.err.println(t1 == t2);
36. } catch (FileNotFoundException e) {
37. e.printStackTrace();
38. } catch (IOException e) {
39. e.printStackTrace();
40. } catch (ClassNotFoundException e) {
41. e.printStackTrace();
42. }
43. }
44. }

对同一对象两次写入文件，打印出写入一次对象后的存储大小和写入两次后的存储大小，然后从文件中反序列化出两个对象，比较这两个对象是否为同一对象。一般的思维是，两次写入对象，文件大小会变为两倍的大小，反序列化时，由于从文件读取，生成了两个对象，判断相等时应该是输入
false 才对。但实际结果是：第二次写入对象时文件只增加了 5 字节，并且两个对象是相等的，这是为什么呢？
解答：Java
序列化机制为了节省磁盘空间，具有特定的存储规则，当写入文件的为同一对象时（根据包名+类名），并不会再将对象的内容进行存储，而只是再次存储一份引用，上面增加的
5 字节的存储空间就是新增引用和一些控制信息的空间。反序列化时，恢复引用关系，使得程序 中的 t1 和 t2 指向唯一的对象，二者相等，输出
true，该存储规则极大的节省了存储空间。

但需要注意，在上面程序中将//t.a = 10注释打开，执行的结果也一样。 原因就是第一次写入对象以后，第二次再试图写的时候，虚拟机根据引用关系知道已经有一个相同对象已经写入文件，因此只保存第二次写的引用，所以读取时，都是第一次保存的对象。