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