JAVA八股文-序列化和反序列化

一、什么是序列化和反序列化

序列化：将对象转换为字节流的过程被称为序列化。

反序列化：将字节流重新转换回对象的过程。

二、为什么要序列化

序列化一个对象的目的是为了将这个对象反序列化回来。

应用场景有:

1、对象存储：当我们关闭应用程序后，想要保存某些对象的状态，以备下次启动时恢复使用。通过序列化对象，我们可以将它们保存到磁盘或数据库中，实现对象的长期保存。

2、缓存和缓存数据库：在使用缓存技术存储对象时，一些缓存系统（redis、memcache）要求存储的对象必须是可序列化的，读取的时候再反序列化回来。

3、远程方法调用rpc:在远程方法调用中，客户端和服务端之间需要传递方法参数和返回值，数据需要在网络间传输就必须要进行学历恶化和反序列化。

4、分布式应用：在分布式系统中，不同节点可能需要共享对象或者将对象传输给其它节点，为了实现对象的跨节点传递和共享，我们可以对对象进行序列化和反序列化操作。

通过序列化和反序列化，我们可以在不同的环境中传递、存储对象，这些过程允许我们以字节流的新形势操作对象，实现对象的跨平台、跨网络和跨存储媒介的传递和使用。

三、序列化步骤

1、要序列化的类需要实现Serializable接口

注意：serialVersionUID用来标识类的版本，反序列化时如果二进制流中的serialVersionUID和要反序列化的对象的serialVersionUID不匹配会反序列化失败。

如果不显示指定serialVersionUID，系统会基于类的属性和方法生成一个默认值，后续如果类有变动，这个默认值也会跟着变动。

transient：用来修饰类的属性可以不被序列化和反序列化。

public class Singleton implements Serializable {
    private volatile static Singleton uniqueInstance;

    private Singleton() {
    }

    public static Singleton getInstance() {
        if (uniqueInstance == null) {
            synchronized (Singleton.class) {
                if (uniqueInstance == null) {//进入区域后，再检查一次，如果仍是null,才创建实例
                    uniqueInstance = new Singleton();

                }

            }

        }
        return uniqueInstance;
    }

    private static final long serialVersionUID = 1L;

    private String name;

    private transient int age;

    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;
    }

    @Override
    public String toString() {
        return String.format("{name:%s,age:%d}", name, age);
    }
}

2、序列化和反序列化

    public static void main(String[] args) throws Exception {
        //1、要进行序列化的对象
        Singleton s = Singleton.getInstance();
        s.setName("单例序列化");
        s.setAge(16);
        System.out.println("序列化前读取其中的内容：" + s.toString());
        //2、序列化文件地址：
        String path = s.getClass().getResource("/").getPath();
        String outPutPath = path + File.separator + "1.txt";
        System.out.println(outPutPath);
        //3、序列化：将对象写入文件
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(outPutPath));
        oos.writeObject(s);
        oos.flush();
        oos.close();
        //4、反序列化：将对象从文件中读取出来
        FileInputStream fis = new FileInputStream(outPutPath);
        ObjectInputStream ois = new ObjectInputStream(fis);
        Singleton s1 = (Singleton) ois.readObject();
        ois.close();

       // System.out.println(s + "\n" + s1);

        System.out.println("序列化后读取其中的内容：" + s1.toString());
        System.out.println("序列化前后两个是否同一个：" + (s == s1));

    }

3、执行 输出结果：

序列化前读取其中的内容：{name:单例序列化,age:16}
/E:/IntelliJidea/study_1/target/classes/\1.txt
{name:单例序列化,age:16}
{name:单例序列化,age:0}
序列化后读取其中的内容：{name:单例序列化,age:0}
序列化前后两个是否同一个：false

4、readResolve

作用：在目标类中定义一个私有的readResolve方法，然后再反序列化的时候会被调用到。

readResolve方法会在readObject之后调用，所以反序列化的时候readResolve方法会覆盖掉readObject方法的修改。

 private Object readResolve() {
        System.out.println("readResolve");
        return new Singleton();
}

应用场景：单例模式中可以避免通过序列化方式创建对象。

在本章第三节的输出内容最后一行可以看到，反序列生成的新对象跟序列化的对象不是同一个：

在Singleton对象中如果支持readResolve方法，return Singleton的唯一实例：getInstance()，就可以避免被创建出两个对象。下面是加上readResolve方法后的输出结果：

 private Object readResolve() {
        System.out.println("readResolve");
        return getInstance();
 }

序列化前读取其中的内容：{name:单例序列化,age:16}
/E:/IntelliJidea/study_1/target/classes/\1.txt
readResolve
序列化后读取其中的内容：{name:单例序列化,age:16}
序列化前后两个是否同一个：true