ObjectOutputStream和ObjectInputStream对对象进行序列化和反序列化

1 Java序列化和反序列化简介

Java序列化是指把对象转换为字节序列的过程，而Java反序列化是指把字节序列恢复为java对象的过程。

我们把对象序列化成有序字节流，保存到本地磁盘或者Redis等媒介中，或者直接通过网络传输进行远程方法调用（RMI）来使用，在使用的时候再进行反序列化来得到该对象

2 通过Serializable实现序列化

在Java中，只要一个类实现了了java.io.Serializable接口，那么这个类就可以被序列化。

查看Serializable接口，会发现该接口中并没有任何代码，这个实现Serializable接口仅仅作为一个标志。

2.1 ObjectOutputStream和ObjectInputStream对对象进行序列化和反序列化

通过ObjectOutputStream和ObjectInputStream对对象进行序列化及反序列化。调用ObjectOutputStream对象的writeObject输出可序列化对象，调用ObjectInputStream对象的readObject()得到序列化的对象。

public class Person implements Serializable {

    //序列化并不保存静态变量
    static String a = "hello";
    static int  b = 200;

    int id;
    String name;

    //只定义有参构造器
    public Person(int id, String name) {
        System.out.println("反序列化会调用构造器吗？");
        this.id = id;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{" + "id=" + id + ", name='" + name + '\'' + '}';
    }
}

在Person中，只定义了有参构造器。

public class SerializableTest {
    public static void main(String[] args) throws Exception {
       dome1();
       dome2();
    }

    private static void dome1() throws Exception{
        File f = new File("test.txt");
        if(!f.exists())
            f.createNewFile();
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(f));
        objectOutputStream.writeObject(new Person(1, "Tom"));
        objectOutputStream.close();
    }
   private static void dome2() throws Exception{
        File f = new File("test.txt");
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(f));
        Object object = objectInputStream.readObject();
        System.out.println(object.toString());
        objectInputStream.close();
    }
}

执行结果：

反序列化会调用构造器吗？
Person{id=1, name='Tom'}

可以看到只会打印一次“反序列化会调用构造器吗？”，说明反序列化并不会使用构造器来生成对象，跟踪反序列化代码，最终执行到：

obj = desc.isInstantiable() ? desc.newInstance() : null;

desc.newInstance()方法原理是利用反射创建了一个对象，本质是调用非序列化父类的无参构造器。

如果该类是Serializable类型的，则调用该类的第一个非Serializable类型的父类的无参构造方法。这里最终会调用Object类的无参构造器，在JDK1.8中，Object中没有构造器，系统会自动生成一个无参构造器。

我们添加一个Parent类,Parent没有实现Serializable，再让Person类继承它，执行dome1和dome2方法：

public class Parent {
    public Parent(){
        System.out.println("父类构造器");
    }
}

执行结果：

父类构造器
反序列化会调用构造器吗？
父类构造器
Person{id=1, name='Tom'}

可以看到反序列化调用了没有实现Serializable的Parent类的构造器，我们再将Parent 实现Serializable，执行dome1和dome2方法：

父类构造器
反序列化会调用构造器吗？
Person{id=1, name='Tom'}

发现并没有调用Parent类的构造器了，这里会继续向上找到Object类，并调用构造方法创建对象，并逐层向下去通过反射设置可以被反序列化的属性。

我们不去继承Parent类，重新执行dome1和dome2方法：

找到test.txt文本，打开可以看出静态变量并不会被序列化。

2.2 serialVersionUID

这里我们在Person在增加两个属性如下,其中email使用**transient **修饰：

public class Person implements Serializable {

    //序列化并不保存静态变量
    static String a = "hello";
    static int  b = 200;

    int id;
    String name;
    int age;
    transient String email;

    //只定义有参构造器
    public Person(int id, String name, int age, String email) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.email = email;
    }

    @Override
    public String toString() {
        return "Person[" + "id=" + id + ", name='" + name + '\'' + ", age=" + age + ", email='" + email + '\'' + ']';
    }
}

然后只运行dome2()，测试能否可以从上次保存的文本内容中反序列化成功？

从异常信息中可以明显看出问题：本地保存和读取的流中 serialVersionUID不匹配。

serialVersionUID是记录class文件的版本信息的，这个数字是JVM通过一个类的类名、成员、包名、工程名算出的一个数字。

而这时候序列化文件中记录的serialVersionUID与项目中的不一致，即找不到对应的类来反序列化。从而抛出InvalidClassException，InvalidClassException是一个IOException。

解决方法：给需要序列化的类指定一个serialVersionUID，在序列化与反序列化的时候，JVM都不会再自己算这个class的serialVersionUID了

我们给Person类加上serialVersionUID，来重新序列化，然后再添加两个属性，再进行反序列可以得到执行结果：

Person[id=1, name='Tom', age=0, email='null']

可以看到反序列成功了，所以如果在类中指定了serialVersionUID，后期可以修改这个类，还是可以成功的反序列化，若我们保存数据在Redis中，后期添加了类属性，在没删除缓存的情况下，还是可以从Redis中获取对象。

我们改造dome1,然后运行dome1（）：

 private static void dome1() throws Exception{
        File f = new File("test.txt");
        if(!f.exists())
            f.createNewFile();
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(f));
        objectOutputStream.writeObject(new Person(1, "Tom", 25, "78451248788@qq.com"));
        objectOutputStream.close();
    }

找到test.txt文本，可以看到age属性，但是email属性没有，这是因为transient修饰的原因，transient修饰的属性，是不会被序列化的。

所以反序列化出的对象，被transient修饰的属性是默认值。对于引用类型，值是null；基本类型，值是0；boolean类型，值是false。

这里提一点，从 email='null' 可以看出String类型是被当成引用类型的。

再添加dome3和dome4方法，并运行：

  private static void dome3() throws Exception{
        File f = new File("test.txt");
        if(!f.exists())
            f.createNewFile();
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(f));
        Person person = new Person(1, "Tom", 25, "78451248788@qq.com");
        //写入两次
        objectOutputStream.writeObject(person);
        objectOutputStream.writeObject(person);
        objectOutputStream.close();
    }
    private static void dome4() throws Exception{
        File f = new File("test.txt");
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(f));
        //读取两次
        Object object1 = objectInputStream.readObject();
        Object object2 = objectInputStream.readObject();
        Person p1 = (Person) object1;
        Person p2 = (Person) object2;
        System.out.println(p1 == p2);
        objectInputStream.close();
    }

执行结果：

true

可以看出Java序列化同一对象，并不会将此对象序列化多次得到多个对象。

2.3 自定义序列化，写入时替换对象writeReplace

在序列化时，会先调用此方法，再调用writeObject方法。此方法可将任意对象代替目标序列化对象，在我们需要改变序列化对象时使用。

在person中添加writeReplace方法：

private Object writeReplace(){
        List<Object> list = new ArrayList<>();
        list.add(id);
        list.add(name);
        list.add(age);
        list.add(email);
        return list;
    }

这里将对象替换成一个List，在序列化的时候会调用writeReplace将对象换成List再存入文本中，反序列的时候获得的不再是person对象，而是List对象。

2.4 自定义反序列化，恢复对象时替换readResolve

反序列化时替换反序列化出的对象，反序列化出来的对象被立即丢弃。readResolve在readeObject后调用。

我们注释上面的writeReplace方法，添加readResolve方法,执行方法：

 private Object readResolve()throws ObjectStreamException {
        return "恢复对象时直接替换结果";
    }

执行结果：

恢复对象时直接替换结果

可以看到结果已经被替换了。writeObject与readObject需成对实现，而writeReplace与readResolve则不需要成对出现，一般单独使用。

2.5 readResolve保护单例和枚举类型

定义单例对象：

public class Singleton implements Serializable {

    private Singleton(){}

    private static Singleton instance = new Singleton();

    public static Singleton getInstance(){
        return instance;
    }
}

添加dome5方法，并执行：

  private static void dome5() throws Exception{
        File f = new File("test.txt");
        if(!f.exists())
            f.createNewFile();
        Singleton singleton = Singleton.getInstance();
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(f));
        objectOutputStream.writeObject(singleton);
        objectOutputStream.close();

        //反序列化一次
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(f));
        Singleton s1 = (Singleton) objectInputStream.readObject();
        objectInputStream.close();

        //反序列化两次
        ObjectInputStream objectInputStream2 = new ObjectInputStream(new FileInputStream(f));
        Singleton s2 = (Singleton) objectInputStream2.readObject();
        objectInputStream.close();

        System.out.println(singleton == s1);
        System.out.println(s1 == s2);
    }

执行结果：

false
false

在单例方法中添加readResolve方法，直接返回原单例对象,再执行dome5方法：

public class Singleton implements Serializable {

    private Singleton(){}

    private static Singleton instance = new Singleton();

    public static Singleton getInstance(){
        return instance;
    }
        private Object readResolve(){
        return instance;
    }
}

执行结果：

true
true

可以看到反序列出来还是原来的单例对象，保护了单例。