java设计模式——单例模式之序列化会破坏单例模式及解决方案

一、序列化会破坏单例模式的示例

1、定义一个饿汉式单例模式并实现序列化接口

package com.rf.designPatterns.singleton.serializeHungrySingleton;
import java.io.Serializable;
/**
 * @description: 饿汉式单例模式实现序列化接口
 * @author: xiaozhi
 * @create: 2020-05-24 15:24
 */
public class SerializeHungrySingleton implements Serializable {
    //直接声明一个需要被单例的对象，在静态块中初始化对象
    private final static SerializeHungrySingleton serializeHungrySingleton;

    static {
        System.out.println("执行静态块。。。。。");
        serializeHungrySingleton=new SerializeHungrySingleton();
    }
    //私有的构造器，不被外部所访问
    private SerializeHungrySingleton(){
        System.out.println("构造方法。。。。");
    }
    //提供一个外部获取HungrySingleton对象的静态方法
    public static SerializeHungrySingleton getInstance(){
        return serializeHungrySingleton;
    }
}

2、定义一个测试类，序列化饿汉式单例模式，并反序列化，查看是否是同一对象

package com.rf.designPatterns.singleton.serializeHungrySingleton;
import java.io.*;
/**
 * @description:测试类，序列化饿汉式单例模式，并反序列化，查看是否是同一对象
 * @author: xiaozhi
 * @create: 2020-05-24 15:26
 */
public class Test {
    public static void main(String[] args) {
        //调用饿汉式对外提供的方法，获取到SerializeHungrySingleton对象
        SerializeHungrySingleton instance = SerializeHungrySingleton.getInstance();
        //序列化获取到的SerializeHungrySingleton对象
        try {
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("singleton_file"));
            oos.writeObject(instance);
        } catch (IOException e) {
            e.printStackTrace();
        }

        //反序列化
        File file = new File("singleton_file");
        SerializeHungrySingleton newInstance=null;
        try {
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
            newInstance = (SerializeHungrySingleton) ois.readObject();
        } catch (IOException e) {
            e.printStackTrace();
        }catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        System.out.println("序列化之前的对象："+instance);
        System.out.println("反序列化后的对象："+newInstance);
        System.out.println(instance==newInstance);
    }
}

3、运行结果如下：

结论：序列化之前的对象和反序列化后的对象不是同一对象

二、序列化会破坏单例模式的解决方式

1、在饿汉式单例模式中添加一个readResolve目标方法，代码如下： 2、定义一个测试类，序列化饿汉式单例模式，并反序列化，查看是否是同一对象

package com.rf.designPatterns.singleton.serializeHungrySingleton;
import java.io.*;
/**
 * @description:测试类，序列化饿汉式单例模式，并反序列化，查看是否是同一对象
 * @author: xiaozhi
 * @create: 2020-05-24 15:26
 */
public class Test {
    public static void main(String[] args) {
        //调用饿汉式对外提供的方法，获取到SerializeHungrySingleton对象
        SerializeHungrySingleton instance = SerializeHungrySingleton.getInstance();
        //序列化获取到的SerializeHungrySingleton对象
        try {
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("singleton_file"));
            oos.writeObject(instance);
        } catch (IOException e) {
            e.printStackTrace();
        }

        //反序列化
        File file = new File("singleton_file");
        SerializeHungrySingleton newInstance=null;
        try {
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
            newInstance = (SerializeHungrySingleton) ois.readObject();
        } catch (IOException e) {
            e.printStackTrace();
        }catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        System.out.println("序列化之前的对象："+instance);
        System.out.println("反序列化后的对象："+newInstance);
        System.out.println(instance==newInstance);
    }
}

3、在进行测试，结果如下图：

结论：序列化之前的对象和反序列化后的对象是同一对象

三、序列化之前的对象和反序列化后的对象不是同一对象的原因

如下图为源码解析步骤