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

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

posted @ 2020-05-26 11:45  homeSicker  阅读(684)  评论(0编辑  收藏  举报