JAVA基础知识之IO——对象序列化

对象序列化

Java对象序列化(Serialize)是指将Java对象写入IO流，反序列化（Deserilize)则是从IO流中恢复该Java对象。

对象序列化将程序运行时内存中的对象以字节码的方式保存在磁盘中，或直接通过网络进行传输(例如web中的HttpSession，或者J2EE中的RMI参数及返回值)，以便通过反序列化的方式将字节码恢复成对象来使用。

所有可能在网络上传输对象的类都应该可序列化，通常分布式应用需要跨平台，跨网络，所以要求所有传递的参数及返回值都可序列化。

通常让需要被序列化和的类实现Serializable接口，调用序列化流对象(ObjectOutputStream/ObjectInputStream)的writeObject和readObject就可以实现序列化，

另外，通过实现Externlizable接口也可以实现序列化，但是必须要重写writeObject和readObject这两个方法才行。

使用Serializable序列化

只需要目标类实现了Serializable接口即可，不需要重写任何方法，直接调用序列化流对象(ObjectOutputStream/ObjectInputStream)的writeObject和readObject。

假如现在有一个Person类需要序列化，

class Person implements java.io.Serializable{
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    private String name;
    private int age;
    
    public Person(String name, int age) {
        System.out.println("有参数构造器");
        this.name = name;
        this.age = age;
    }
}

在测试类中，使用流对象(ObjectOutputStream)的writeObject就可以将对象序列化到具体文件，

使用流对象(ObjectInputStream)的readObject就可以从指定文件反序列化对象

public class ObjectIO {
    public static void writeObject() {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("obj.txt"))) {
            Person per = new Person ("孙悟空",500);
            oos.writeObject(per);
        } catch (IOException e) {
            e.printStackTrace();
        }    
    }
    
    public static void readObject() throws FileNotFoundException, IOException, ClassNotFoundException {
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.txt"))) {
             Person p = (Person)ois.readObject();
             System.out.println("name: "+p.getName()+", age: "+p.getAge());
        }
    }
    
    public static void main(String[] args) throws FileNotFoundException, ClassNotFoundException, IOException {
        writeObject();
        //不会调用构造器
        readObject();
    }
}
    

执行结果，

有参数构造器
name: 孙悟空, age: 500

对象引用的序列化

如果某个类的成员变量不是基本类型，而是另一个类的引用类型(例如 Teacher 类中有个成员变量 private Person student)，那么这个引用类(Person)必须是可序列化的，当前类(Teacher)才可以序列化，否则会抛出java.io.NotSerializableException异常。

对象不会被重复序列化

序列化对象将会产生一个序列号，每次序列化对象时会先检查是否已经序列化过该对象，只有未被序列化的对象才序列化，已被序列化的对象则直接输出序列号，而不会重新序列化该对象。

即：对象只有第一次序列化才生效。

例如下面的例子，

package io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;


class Person  {
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    private String name;
    private int age;
    
    public Person(String name, int age) {
        System.out.println("有参数构造器");
        this.name = name;
        this.age = age;
    }
}

class Teacher implements java.io.Serializable {
    public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}
public Person getStudent() {
    return student;
}


public class ObjectIO {
    
    public static void writeTeacher() throws FileNotFoundException, IOException, ClassNotFoundException {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("teacher.txt"))) {
            Person per = new Person("孙悟空" , 500 );
            Teacher t1 = new Teacher("唐僧" , per);
            Teacher t2 = new Teacher("菩提祖师" , per);
            
            //下面四行只会序列化三个对象，其中t1, t2 将引用同一个对象
            oos.writeObject(t1);
            oos.writeObject(t2);
            oos.writeObject(per);
            oos.writeObject(t2);
        } catch (IOException e) {
            e.printStackTrace();
        }
        
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("teacher.txt"))) {
            //反序列化需要按照序列化的顺序取对象
            Teacher t1 = (Teacher)ois.readObject();
            Teacher t2 = (Teacher)ois.readObject();
            Person p = (Person)ois.readObject();
            Teacher t3 = (Teacher)ois.readObject();
            System.out.println("t1的student引用和p是否相同: "+ (t1.getStudent() == p));
            System.out.println("t2的student引用和p是否相同: "+ (t2.getStudent() == p));
            System.out.println("t2和t3是否是同一个对象: "+ (t2 == t3));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    
    public static void main(String[] args) throws FileNotFoundException, ClassNotFoundException, IOException {
        writeTeacher();
    }
}

上面的例子中，Teacher 类中有个成员变量 private Person student， 虽然实例化了两个Teacher对象t1 t2, 连同Person类一起都进行了序列化，但是从反序列化结果中看到这三个Person对象完全相同。

执行结果，

有参数构造器
t1的student引用和p是否相同: true
t2的student引用和p是否相同: true
t2和t3是否是同一个对象: true

可变对象序列化

由于Java对象只会序列化一次，当可变对象在序列化之后发生了变化，即使再进行一次序列化，也不能改变序列化对象的值，反序列化之后依然是第一次序列化的值，例如下面的例子，

    public static void mutable() throws FileNotFoundException, IOException, ClassNotFoundException {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("mutable.txt"));
                ObjectInputStream ois = new ObjectInputStream(new FileInputStream("mutable.txt"))) {
            Person per = new Person("孙悟空" , 500);
            oos.writeObject(per);
            per.setName("猪八戒");
            //per在前面已经序列化过，这里再序列化不会生效
            oos.writeObject(per);
            Person p1 = (Person)ois.readObject();
            Person p2 = (Person)ois.readObject();
            System.out.println(p1==p2);
            System.out.println(p2.getName());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    public static void main(String[] args) throws FileNotFoundException, ClassNotFoundException, IOException {
        mutable();
    }

上面程序在第5行序列化之后，在第6行修改了对象的值，然后又在第8行序列化一次。但是通过反序列化之后发现，name的值依然是第一次序列化的值，执行结果，

有参数构造器
true
孙悟空

以上完整代码，

package io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;


class Person implements java.io.Serializable {
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    private String name;
    private int age;
    
    public Person(String name, int age) {
        System.out.println("有参数构造器");
        this.name = name;
        this.age = age;
    }
}

class Teacher implements java.io.Serializable {
    public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}
public Person getStudent() {
    return student;
}
public void setStudent(Person student) {
    this.student = student;
}
    private String name;
    private Person student;
    public Teacher(String name, Person student) {
        this.name = name;
        this.student = student;
    }
}

public class ObjectIO {
    public static void writeObject() {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("obj.txt"))) {
            Person per = new Person ("孙悟空",500);
            oos.writeObject(per);
        } catch (IOException e) {
            e.printStackTrace();
        }    
    }
    
    public static void readObject() throws FileNotFoundException, IOException, ClassNotFoundException {
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.txt"))) {
             Person p = (Person)ois.readObject();
             System.out.println("name: "+p.getName()+", age: "+p.getAge());
        }
    }
    
    public static void writeTeacher() throws FileNotFoundException, IOException, ClassNotFoundException {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("teacher.txt"))) {
            Person per = new Person("孙悟空" , 500 );
            Teacher t1 = new Teacher("唐僧" , per);
            Teacher t2 = new Teacher("菩提祖师" , per);
            
            //下面四行只会序列化三个对象，其中t1, t2 将引用同一个对象
            oos.writeObject(t1);
            oos.writeObject(t2);
            oos.writeObject(per);
            oos.writeObject(t2);
        } catch (IOException e) {
            e.printStackTrace();
        }
        
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("teacher.txt"))) {
            //反序列化需要按照序列化的顺序取对象
            Teacher t1 = (Teacher)ois.readObject();
            Teacher t2 = (Teacher)ois.readObject();
            Person p = (Person)ois.readObject();
            Teacher t3 = (Teacher)ois.readObject();
            System.out.println("t1的student引用和p是否相同: "+ (t1.getStudent() == p));
            System.out.println("t2的student引用和p是否相同: "+ (t2.getStudent() == p));
            System.out.println("t2和t3是否是同一个对象: "+ (t2 == t3));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    public static void mutable() throws FileNotFoundException, IOException, ClassNotFoundException {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("mutable.txt"));
                ObjectInputStream ois = new ObjectInputStream(new FileInputStream("mutable.txt"))) {
            Person per = new Person("孙悟空" , 500);
            oos.writeObject(per);
            per.setName("猪八戒");
            //per在前面已经序列化过，这里再序列化不会生效
            oos.writeObject(per);
            Person p1 = (Person)ois.readObject();
            Person p2 = (Person)ois.readObject();
            System.out.println(p1==p2);
            System.out.println(p2.getName());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    public static void main(String[] args) throws FileNotFoundException, ClassNotFoundException, IOException {
        //writeObject();
        //不会调用构造器
        //readObject();
        //writeTeacher();
        mutable();
    }
}

自定义序列化

• transient关键字

如果不希望序列化某个变量（例如银行账户信息等敏感信息），又或者某个实例变量类型不可序列化（例如某个成员变量是引用了一个不可序列化的类型），

我们不希望程序递归地去序列化这些对象，则可以通过transient关键字来修饰变量，程序就不会序列化这个变量，例如下面这样。

class Person implements java.io.Serializable {
...
    private String name;
    private transient int age;
...

如果用上面的例子序列化这个类，再执行程序将会得到下面的结果，可以看到aga并没有取序列化之前的结果，而是被初始化成0了

有参数构造器
name: 孙悟空, age: 0

• 通过重写writeObject/readObject自定义序列化

transient可以对某些变量进行屏蔽序列化效果，但是过于死板。Java还提供了一种方法来自定义序列化，就是在目标类中重写流对象的writeObject/readObject方法。

上面的序列化方式都使用的是流对象的默认序列化方法，oos.defaultWriteObject/ois.defaultReadObject，包括transient关键字，默认就是不做序列化。

而通过重写这两个方法，可以很具体地对目标类的指定变量做特殊操作，transient关键字修饰的变量不再是直接屏蔽，而是和其他变量一样可以自定义序列化的方式。

还有一个可重写的方法是readObjectNoData()，当序列化不完整（例如序列化版本不同，或者序列化流被篡改）时使用这个方法可以正确地初始化反序列化的对象。

重写的writeObject跟重写readObject总是成对出现，在序列化中做了什么操作（例如加密），在反序列化中需要做相反操作，且各个变量序列化和反序列化的顺序需要一样。

例如下面这样，

class Person implements java.io.Serializable {

    private String name;
    private transient int age;
    
    public Person(String name, int age) {
        System.out.println("有参数构造器");
        this.name = name;
        this.age = age;
    }
    
    private void writeObject(java.io.ObjectOutputStream oos) throws IOException {
        oos.writeObject(new StringBuilder(name).reverse());
        oos.writeInt(age);
    }
    
    private void readObject(java.io.ObjectInputStream ois) throws IOException, ClassNotFoundException {
        this.name = ((StringBuilder)ois.readObject()).reverse().toString();
        this.age = ois.readInt();
    }
...
}

执行下面测试类，

public class ObjectIO {
    public static void writeObject() {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("obj.txt"))) {
            Person per = new Person ("孙悟空",500);
            oos.writeObject(per);
        } catch (IOException e) {
            e.printStackTrace();
        }    
    }
    
    public static void readObject() throws FileNotFoundException, IOException, ClassNotFoundException {
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.txt"))) {
             Person p = (Person)ois.readObject();
             System.out.println("name: "+p.getName()+", age: "+p.getAge());
        }
    }
    
    
    public static void main(String[] args) throws FileNotFoundException, ClassNotFoundException, IOException {
        writeObject();
        //不会调用构造器
        readObject();
    }
}

测试类中，序列化时对name进行了反转，相当于加密，即使在传输过程中被截获，也是加密的结果。 在反序列化过程中，对name进行了相反操作。

而对于age，虽然有transient关键字修饰，但是执行了通过重写writeObject方法，依然可以自定义这个变量的序列化方式；在反序列化中依然取得了结果。

执行结果，

有参数构造器
name: 孙悟空, age: 500

•  通过重写writeReplace自定义序列化

Java在序列化某个对象之前，将先调用writeReplace(), writeReplace()方法的返回值将用来替换实际将被序列化的对象，例如下面，

package io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.ObjectStreamException;
import java.util.ArrayList;


class Person implements java.io.Serializable {
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    private String name;
    private transient int age;
    
    public Person(String name, int age) {
        System.out.println("有参数构造器");
        this.name = name;
        this.age = age;
    }
    
    private void writeObject(java.io.ObjectOutputStream oos) throws IOException {
        oos.writeObject(new StringBuilder(name).reverse());
        oos.writeInt(age);
    }
    
    private void readObject(java.io.ObjectInputStream ois) throws IOException, ClassNotFoundException {
        this.name = ((StringBuilder)ois.readObject()).reverse().toString();
        this.age = ois.readInt();
    }
    
    private Object writeReplace() throws ObjectStreamException {
        ArrayList<Object> list = new ArrayList<Object>();
        list.add(name);
        list.add(age);
        return list;
    }
}



public class ObjectIO {
    
    public static void writeReplaceTest() throws FileNotFoundException, IOException {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("writeReplace.txt"));
                ObjectInputStream ois = new ObjectInputStream(new FileInputStream("writeReplace.txt"))) {
            Person per = new Person("孙悟空", 500);
            oos.writeObject(per);
            ArrayList list = (ArrayList)ois.readObject();
            System.out.println(list);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    public static void main(String[] args) throws FileNotFoundException, ClassNotFoundException, IOException {
        writeReplaceTest();
    }
}

可以看到，我们序列化的是Person对象，但是我们取出的是list对象；

我们同时重写了writeObject和writeReplace，最后反序列化的结果由writeReplace返回的对象替代了。执行结果如下，

有参数构造器
[孙悟空, 500]

•  通过重写readResolve自定义序列化

与writeReplace对应的是readResolve方法，它将紧接着readObject调用，readObject的结果将被直接丢弃，readResolve的返回值将替代readObject的返回值。

对象序列化会破坏单例设计，因为在反序列化过程中，将会生成一个新的对象并用原来序列化时候的值来初始化，也就是反序列化和序列化两个对象不是同一个对象。

但是对于单例类，例如枚举类，如果反序列化得到的对象不是序列化之前的对象，这将违背单例类的原则，因此我们需要用一个特殊的反序列方法readResolve().

值得注意的是，readResolve()跟writeReplace()一样可以使用任意访问控制符，这样子类就有可能继承父类的readResolve()方法。这将会有一个问题，如果父类包含

一个protected或public的readResolve()方法时，如果子类不重写该方法，在反序列化时将会得到一个父类对象，这显然不是程序想要的结果，而且不易发现。

但是总是在子类中重写这个方法也挺麻烦，无疑增加了不必要的工作量，而且还容易忽视这前面的潜在问题。

因此如果一个类将成为父类的话，要么这个类是final类，则可以用任意访问权限修饰它的readResolve()方法； 要么将它的readResolve()方法最好是定义为private的。

readResolve()的作用就是在单例类的反序列化时，取代反序列化的结果， 例如下面的场景。

package io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

class Orientation implements java.io.Serializable {
    public static final Orientation HORIZONTAL = new Orientation(1);
    public static final Orientation VERTICAL = new Orientation(2);
    private int value;
    private Orientation(int value) {
        this.value = value;
    }
}

public class ReadResolveTest {
    public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("readResolve.txt"));
                ObjectInputStream ois = new ObjectInputStream(new FileInputStream("readResolve.txt"))) {
            oos.writeObject(Orientation.HORIZONTAL);
            Orientation ori = (Orientation)ois.readObject();
            System.out.println(ori == Orientation.HORIZONTAL);
        }
    }
}

执行结果发现ori与Orientation.HORIZONTAL不相等，因为反序列化是生成新对象的过程（其实是一个拷贝对象的过程，因为这里的类初始化方法是private的）。

为了解决这个问题，我们在目标类中重写readResolve()方法，

package io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.ObjectStreamException;

class Orientation implements java.io.Serializable {
    public static final Orientation HORIZONTAL = new Orientation(1);
    public static final Orientation VERTICAL = new Orientation(2);
    private int value;
    public Orientation(int value) {
        this.setValue(value);
    }
    public int getValue() {
        return value;
    }
    public void setValue(int value) {
        this.value = value;
    }
    private Object readResolve() throws ObjectStreamException {
        if (value==1) {
            return HORIZONTAL;
        }
        
        if (value==2) {
            return VERTICAL;
        }
        
        return null;
    }
}

public class ReadResolveTest {
    public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("readResolve.txt"));
                ObjectInputStream ois = new ObjectInputStream(new FileInputStream("readResolve.txt"))) {
            
            oos.writeObject(Orientation.HORIZONTAL);

            //紧接着readObject()，将会调用重写的readResolve()，并取代readObject
            //我们在readResolve()中返回的是单例，这就解决对象序列化破坏单例设计模型的问题了
            Orientation ori = (Orientation)ois.readObject();
            System.out.println(ori==Orientation.HORIZONTAL);
        }
    }
}

再来执行，发现反序列化就可以得到序列化的同一个对象了。执行结果为true.

使用Externalizable接口实现序列化

这种方式与实现Serializable接口方式基本相同，但是Externalizable必须要在目标类中手工实现两个方法：writeExternal 用来实现序列化，用来实现反序列化。 且目标类必须包含一个默认构造函数(无参).

下面是一个例子，注意在writeExternal和readExternal使用的是ObjectOutput和ObjectInput而不是ObjectInputStream和ObjectOutputStream.

package io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;

class People implements java.io.Externalizable {
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    private String name;
    private transient int age;
    
    public People(String name, int age) {
        System.out.println("有参数构造器");
        this.name = name;
        this.age = age;
    }
    
    public People() {
        System.out.println("无参数构造器");
    }
    
    @Override
    public void writeExternal(java.io.ObjectOutput out) throws IOException {
        out.writeObject(new StringBuffer(name).reverse());
        out.writeInt(age);
    }
    
    @Override
    public void readExternal(java.io.ObjectInput in) throws IOException, ClassNotFoundException {
        this.name = ((StringBuffer)in.readObject()).reverse().toString();
        this.age = in.readInt();
    }
}

public class ExternalizableTest {
    public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("external.txt"));
                ObjectInputStream ois = new ObjectInputStream(new FileInputStream("external.txt"))) {
            People peo = new People("孙悟空" , 500);
            oos.writeObject(peo);
            
            People p = (People)ois.readObject();
            System.out.println(p.getName()+" : "+p.getAge());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 执行结果， 可以看到在反序列化过程中调用了默认构造函数

有参数构造器
无参数构造器
孙悟空 : 500

反序列化兼容—— class版本

在反序列化时必须提供class文件，但class文件随着程序升级也会有不同的版本，但很多情况下需要保证两个class版本序列化能兼容，该如何做到呢？

Java的序列化机制允许定义一个version值，只要升级前后两个class的version值一样，就看作同一个版本，序列化前后能兼容。

定义如下，

public class Test {
...
    private static final long serialVersionUID = 512L;
...
}

通常建议在每个类中都加入这个变量，这样在在反序列化时，即使提供的class文件版本已经跟序列化时的class文件有所改动，但只要这个version变量不变，就可以反序列化。

如果不显式定义version变量，JVM会根据类信息计算出一个（通常会变化），从而导致反序列化因为类版本不同而失败。

通过JDK下的serialver.exe 可以获取该类的serverUID

命令： serialver Person

输出结果： Person: static final long serialVersionUID = -2595800114629327570L;