Java 知识点：序列化

首先明确一点：默认的序列化方法速度很慢，因为需要对整个对象和他的类都进行保存，因此我们建议自定义序列化格式。

ObjectInputStream和ObjectOutputStream

用途	ObjectInputStream	ObjectOutputStream
整数	readInt()	writeInt(int)
浮点数	readDouble()	writeDouble(double)
字符串	readUTF()	writeUTF(String)
字节数组	read(byte[] buf, int off,int length)	write(byte[])
对象	readObject()	writeObject(Object)

哪些数据不会被序列化

1. 被标记为 transient 的域。
2. 静态变量。

查看某个类的SerialVersionUID

如果类A实现了Serializable接口，则可以使用Java 提供的serialver命令： serialver  A 。

SerialVersionUID变量的作用

场景：你在公司开发一个类（记为LogManager，用来管理日志，拥有变量Date date,String description，我们使用序列化保存日志信息），并且已经上线使用（已经积累了一些数据），随着时间的推移，你发现你这个类设计的不够完善，因此你需要添加一个实例变量 int errorID，那么你如果按照一般反序列化方法（readObject），则会抛出：InvalidClassException。那么怎么能够成功将原始的数据转换成新版本的LogManager对象呢？

解决：

1. 使用 Java 提供的serialver命令： serialver  LogManager 计算出原始LogManager的 serialVersionUID（比如为123L）。
2. 在新版本的LogManager中添加：  static final long serialVersionUID = 123L；

目的：保持不同版本类的序列化的兼容性。

序列化类A（类A继承自类B），但是类B不可序列化，怎么办？

默认情况：

1. 先将类A的实例变量全部还原。
2. 因为类A继承类B，因此类A的对象也会有类B的实例变量，对于类B的实例变量，调用类B的默认无参构造函数初始化类B的实例变量。（一定要定义超类无参构造函数，不然会抛 no valid constructor）

解决：自定义readObject和writeObject。

对序列化的数据加密

问题：我们知道，序列化主要用于数据传输，但是序列化的数据是可以反序列化的，因此黑客可以直接把你的数据截下来（比如你的序列化文件为data.txt，用WinHeX打开后，基本就能看到所涉及的类和你传输的数据）。那么怎么样能够加密序列化的数据呢？
解决：通过自定义的序列化方法（在要序列化的对象中实现readObject和writeObject方法）。

• private void writeObject(ObjectOutputStream os)throws IOException    // 你如果重写时必须是private的。
• private void readObject(ObjectInputStream is)throws IOException,ClassNotFoundException   //你如果重写时必须是private的

 import java.io.*;
 public class Serialize05
 {
     public static void main(String[] args) throws Exception{
         ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("object.txt"));
         out.writeObject(new Person("admin","abc123"));
         out.close();
         ObjectInputStream in = new ObjectInputStream(new FileInputStream("object.txt"));
         Person person = (Person)in.readObject();
         System.out.println(person);
     }
 }
 class Person implements Serializable
 {
     String name;
     String password;
     public Person(String name,String password)
     {
         this.name = name;
         this.password = password;
     }
     private void writeObject(ObjectOutputStream os)throws IOException
     {
         os.writeUTF(name);
         byte[] pass = password.getBytes("UTF-8");
         for(int i=0;i<pass.length;i++)
         {
             pass[i] = (byte)(pass[i] ^ 32);        //对密码加密
         }
         os.write(pass);
     }
     private void readObject(ObjectInputStream is)throws IOException,ClassNotFoundException
     {
         name = is.readUTF();
         byte[] pass = new byte[1024];
         int size = is.read(pass,0,1024);
         for(int i=0;i<pass.length;i++)
         {
             pass[i] = (byte)(pass[i] ^ 32);        //对密码解密
         }
         String password = new String(pass,0,size,"UTF-8");
         this.password = password;
     }
     public String toString()
     {
         return "name="+name+",password="+password;
     }
 }

利用序列化实现深层复制

 /*
     用序列化实现深层复制
 */
 import java.io.*;
 public class Serialize09
 {
     public static void main(String[] args) throws Exception{
         ByteArrayOutputStream bout = new ByteArrayOutputStream();
         ObjectOutputStream out = new ObjectOutputStream(bout);
         Person f1 = new Person("f1",null);
         Person p1 = new Person("u1",f1);
         out.writeObject(p1);
         byte[] b = bout.toByteArray();
         ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(b));
         Person p2 = (Person)in.readObject();
         p2.friend.name = "f2";
         System.out.println(p1.friend.name);    //输出：f1.虽然p2的朋友名字改变了，但是p1的朋友没改。

     }
 }
 class Person implements Serializable
 {
     String name;
     Person friend;
     public Person(String name,Person friend)
     {
         this.name = name;
         this.friend = friend;
     }
 }

序列化包含别人开发过的不可序列化的类

问题：如果你想要开发一个 House 类，此时别人已经开发好的 Furniture 类（Furniture 类中有实例变量int size，没有类Furniture的源代码，只有class文件，且类Furniture不是可序列化的）。因为House HAS-A Furniture，因此需要组合，因此在House类中需要声明一个Furniture的实例变量，但是Furniture并不能实例化，如果按照一般的方法，则会抛“NoSerializableException”。

解决：

1. 将Furniture实例变量设为transient。
2. 在House类中实现readObject和writeObject方法。

实现方法：

• private void writeObject(ObjectOutputStream os)throws IOException
• private void readObject(ObjectInputStream is)throws IOException,ClassNotFoundException

 import java.io.*;
 public class Serialize03
 {
     public static void main(String[] args) throws Exception {
         ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("object.txt"));
         out.writeObject(new A(new B(10),100));
         out.close();
         ObjectInputStream in = new ObjectInputStream(new FileInputStream("object.txt"));
         A a = (A)in.readObject();
         System.out.println(a);        //输出：b=10,a=100
     }
 }
 class B       //别人已经开发好的类，且假设看不到B的源代码
 {
     int bb;
     public B(int bb)
     {
         this.bb = bb;
     }
 }
 class A implements Serializable
 {
     transient B b;
     int a;
     public A(B b,int a)
     {
         this.b = b;
         this.a = a;
     }
     public String toString()
     {
         return "b="+b.bb+",a="+a;
     }
     private void writeObject(ObjectOutputStream os)throws IOException    //手工序列化B b
     {
         os.defaultWriteObject();
         os.writeInt(b.bb);
     }
     private void readObject(ObjectInputStream is)throws IOException,ClassNotFoundException
     {
         is.defaultReadObject();
         b = new B(is.readInt());
     }
 }

writeReplace和readResolve方法

如果有一个类A、类AProxy，如果想要实现以下任务：当 writeObject(A a) 时，实际写入的是AProxy对象（代理类），则可以使用readResolve和writeReplace。

• 在类A中实现writeReplace方法（当ObjectOutputStream.writeObject(A)时调用该方法）
• Object writeReplace() throws ObjectStreamException。
• 在类AProxy中实现 readResolve 方法（当ObjectInputStream.readObject(A)时调用该方法）
• Object readResolve() throws ObjectStreamException。

 import java.io.*;
 public class Serialize07
 {
     public static void main(String[] args) throws Exception{
         ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("object.txt"));
         out.writeObject(new Person("admin",20));
         out.close();
         ObjectInputStream in = new ObjectInputStream(new FileInputStream("object.txt"));
         Person person = (Person)in.readObject();
         System.out.println(person);
     }
 }

 class PersonProxy implements Serializable
 {
     String data;
     public PersonProxy(Person person)
     {
         data = person.name+","+person.age;
     }
     private Object readResolve() throws ObjectStreamException
     {
         System.out.println("调用了readResolve方法");
         String name = data.split(",")[0];
         int age = Integer.parseInt(data.split(",")[1]);
         Person person = new Person(name,age);
         return person;
     }
 }
 class Person implements Serializable
 {
     String name;
     int age;
     public Person(String name,int age)
     {
         this.name = name;
         this.age = age;
     }
     private Object writeReplace() throws ObjectStreamException
     {
         System.out.println("调用了writeReplace方法");
         return new PersonProxy(this);
     }
     public String toString()
     {
         return "name=" + name + ",age=" + age;
     }
 }

Externalizable接口

用途：自定义流格式，比如类A没有实现序列化，而类B继承类A，而类B需要负责包括超类数据的保存和恢复。

实现方法：

• void writeExternal(ObjectOutput out) throws IOException
• void readExternal(ObjectInput in) throws IOException,ClassNotFoundException

从API中可以看出，Externalizable接口实现了Serializable接口。
如果一个类A实现了Externalizable接口，则

• ObjectInputStream.readObject()时会调用readExternal()，而不是readObject()
• ObjectOutputStream.writeObject()时会调用writeExternal()，而不是writeObject()

当ObjectInputStream.readObject()时，过程如下：

1. 假设读取类A的对象，则首先调用类A的无参构造函数(只有在实现Externalizable接口时才会调用无参构造函数)，因此我们必须要实现这个构造函数。
2. 因为类A实现了Externalizable接口，则调用readExternal()。

 import java.io.*;
 public class Serialize06
 {
     public static void main(String[] args) throws Exception{
         ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("object.txt"));
         out.writeObject(new Employee("admin",20,1000));
         out.close();
         ObjectInputStream in = new ObjectInputStream(new FileInputStream("object.txt"));
         Employee person = (Employee)in.readObject();
         System.out.println(person);
     }
 }

 class Person
 {
     String name;
     int age;
     public Person()
     {
     }
 }
 class Employee extends Person implements Externalizable
 {
     transient double salary;
     public Person()
     {
     }
     public Employee(String name,int age,double salary)
     {
         this.name = name;
         this.age = age;
         this.salary = salary;
     }
     public void readExternal(ObjectInput in) throws IOException,ClassNotFoundException
     {
         name = in.readUTF();
         age = in.readInt();
         salary = in.readDouble();
     }
     public void writeExternal(ObjectOutput out)throws IOException
     {
         out.writeUTF(name);
         out.writeInt(age);
         out.writeDouble(salary);
     }
     public String toString()
     {
         return "name=" + name + ",age=" + age + ",salary=" + salary;
     }
 }

Reference

[1]http://www.ibm.com/developerworks/cn/java/j-5things1/
[2]Java核心技术(第7版) P617~637