设计模式 创建者模式 -- 单例模式存在的问题和解决办法（序列化反序列化破坏单例模式 & 反射破坏单例模式）

1. 单例模式存在的问题和解决办法

破坏单例模式：
上诉单例模式定义的单例类（Singleton）可以创建多个对象，枚举方式除外。有两种方式，分别是序列化和反射。

---

1.1 序列化反序列化破坏单例模式

---

1.1.1 单例类

Singleton.java

package singleton.demo1;

import java.io.Serializable;

/**
 * @Description: 静态内部类方式实现单例模式
 */
public class Singleton implements Serializable {
    //私有构造方法
    private Singleton() {
    }

    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    //提供公共的访问方式
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

---

1.1.2 测试类

package singleton.demo1;


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

/**
 * @Description: 测试使用序列化破坏单例模式
 */
public class Client {
    public static void main(String[] args) throws Exception {
        // 1. 对象写入文件(序列化)
        writeObject2File();
        // 2. 从文件读取对象(反序列化)
        Singleton singleton1 = readObjectFromFile();
        // 3. 再次从文件读取对象(反序列化)
        Singleton singleton2 = readObjectFromFile();
        System.out.println(singleton1 == singleton2 ? "是同一个对象" : "不是同一个对象");
    }

    //从文件读取数据（对象）
    public static Singleton readObjectFromFile() throws Exception {
        //1,创建对象输入流对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("E:\\IDEACode\\workspace\\heima-design-patterns\\src\\main\\resources\\object.txt"));
        //2,读取对象(反序列化)
        Singleton instance = (Singleton) ois.readObject();
        //释放资源
        ois.close();
        return instance;
    }

    //向文件中写数据（对象）
    public static void writeObject2File() throws Exception {
        //1,获取Singleton对象
        Singleton instance = Singleton.getInstance();
        //2,创建对象输出流对象
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("E:\\IDEACode\\workspace\\heima-design-patterns\\src\\main\\resources\\object.txt"));
        //3,写对象(序列化)
        oos.writeObject(instance);
        //4,释放资源
        oos.close();
    }
}

1.1.3 运行结果

---

1.2 反射破坏单例模式

1.1.1 单例类

package singleton.demo2;

public class Singleton {
    //私有构造方法
    private Singleton() {
    }

    private static volatile Singleton instance;

    //对外提供静态方法获取该对象
    public static Singleton getInstance() {
        if (instance != null) {
            return instance;
        }
        synchronized (Singleton.class) {
            if (instance != null) {
                return instance;
            }
            instance = new Singleton();
            return instance;
        }
    }
}

---

1.1.2 测试类

package singleton.demo2;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class Client {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //1,获取Singleton的字节码对象
        Class clazz = Singleton.class;
        //2,获取无参构造方法对象
        Constructor cons = clazz.getDeclaredConstructor();
        //3,取消访问检查
        cons.setAccessible(true);
        //4,创建Singleton对象
        Singleton s1 = (Singleton) cons.newInstance();
        Singleton s2 = (Singleton) cons.newInstance();
        System.out.println("s1: " + s1);
        System.out.println("s2: " + s2);
        System.out.println(s1 == s2 ? "是同一个对象" : "不是同一个对象"); //如果返回的是true，说明并没有破坏单例模式，如果是false，说明破坏了单例模式
    }
}

---

1.1.3 运行结果

---

1.3 序列化反序列化破坏单例模式解决方案

在Singleton类中添加 readResolve() 方法，在反序列化时被反射调用，如果定义了这个方法，就返回这个方法的值，如果没有定义，则返回新new出来的对象。

Singleton类：

package singleton.demo1;

import java.io.Serializable;

/**
 * @Description: 静态内部类方式实现单例模式
 */
public class Singleton implements Serializable {
    //私有构造方法
    private Singleton() {
    }

    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    //提供公共的访问方式
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }

    /**
     * 下面是为了解决序列化反序列化破解单例模式
     */
    private Object readResolve() {
        return SingletonHolder.INSTANCE;
    }
}

测试代码不变 测试结果:

---

1.4 反射方式破解单例的解决方法

当通过反射方式调用构造方法进行创建创建时，直接抛异常。不运行此中操作。

package singleton.demo2;

public class Singleton {
    private static boolean flag = false;

    //私有构造方法
    private Singleton() {
        synchronized (Singleton.class) {
            if (flag) {
            /* 反射破解单例模式
        需要添加的代码 */
                throw new RuntimeException("不可以创建多个对象");
            }
            flag = true;
        }
    }

    private static volatile Singleton instance;

    //对外提供静态方法获取该对象
    public static Singleton getInstance() {
        if (instance != null) {
            return instance;
        }
        synchronized (Singleton.class) {
            if (instance != null) {
                return instance;
            }
            instance = new Singleton();
            return instance;
        }
    }
}

测试代码不变，运行结果：

---

---