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

Posted Z && Y

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了设计模式 创建者模式 -- 单例模式存在的问题和解决办法(序列化反序列化破坏单例模式 & 反射破坏单例模式)相关的知识,希望对你有一定的参考价值。

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

测试代码不变,运行结果:



以上是关于设计模式 创建者模式 -- 单例模式存在的问题和解决办法(序列化反序列化破坏单例模式 & 反射破坏单例模式)的主要内容,如果未能解决你的问题,请参考以下文章

设计模式---单例模式

设计模式:创建型单例模式

3创建型模式之单例模式

设计模式——单例模式

设计模式之单例模式

Python版设计模式: 创建型模式:单例模式和工厂模式家族