java——破坏单例模式和解决措施以及源码解析和扩展

破坏方式

所谓破坏单例模式，就是使定义的单例类（Singleton）可以创建多个对象。有两种方式，分别是序列化反序列化和反射。

以下做举例

序列化反序列化方式

Singleton类：

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

Test类：

public class Test {
    public static void main(String[] args) throws Exception {
        //往文件中写对象
        //writeObject2File();
        //从文件中读取对象
        Singleton s1 = readObjectFromFile();
        Singleton s2 = readObjectFromFile();

        //判断两个反序列化后的对象是否是同一个对象
        System.out.println(s1 == s2);
    }

    private static Singleton readObjectFromFile() throws Exception {
        //创建对象输入流对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("C:\\Users\\Think\\Desktop\\a.txt"));
        //第一个读取Singleton对象
        Singleton instance = (Singleton) ois.readObject();

        return instance;
    }

    public static void writeObject2File() throws Exception {
        //获取Singleton类的对象
        Singleton instance = Singleton.getInstance();
        //创建对象输出流
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("C:\\Users\\Think\\Desktop\\a.txt"));
        //将instance对象写出到文件中
        oos.writeObject(instance);
    }
}

上面代码运行结果是false，表明序列化和反序列化已经破坏了单例设计模式。

解决措施

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

Singleton类：

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

源码解析：
ObjectInputStream类

public final Object readObject() throws IOException, ClassNotFoundException{
    ...
    // if nested read, passHandle contains handle of enclosing object
    int outerHandle = passHandle;
    try {
        Object obj = readObject0(false);//重点查看readObject0方法
    .....
}
    
private Object readObject0(boolean unshared) throws IOException {
	...
    try {
		switch (tc) {
			...
			case TC_OBJECT:
				return checkResolve(readOrdinaryObject(unshared));//重点查看readOrdinaryObject方法
			...
        }
    } finally {
        depth--;
        bin.setBlockDataMode(oldMode);
    }    
}
    
private Object readOrdinaryObject(boolean unshared) throws IOException {
	...
	//isInstantiable 返回true，执行 desc.newInstance()，通过反射创建新的单例类，
    obj = desc.isInstantiable() ? desc.newInstance() : null; 
    ...
    // 在Singleton类中添加 readResolve 方法后 desc.hasReadResolveMethod() 方法执行结果为true
    if (obj != null && handles.lookupException(passHandle) == null && desc.hasReadResolveMethod()) {
    	// 通过反射调用 Singleton 类中的 readResolve 方法，将返回值赋值给rep变量
    	// 这样多次调用ObjectInputStream类中的readObject方法，继而就会调用我们定义的readResolve方法，所以返回的是同一个对象。
    	Object rep = desc.invokeReadResolve(obj);
     	...
    }
    return obj;
}

反射方式

Singleton类：

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

Test类：

public class Test {
    public static void main(String[] args) throws Exception {
        //获取Singleton类的字节码对象
        Class clazz = Singleton.class;
        //获取Singleton类的私有无参构造方法对象
        Constructor constructor = clazz.getDeclaredConstructor();
        //取消访问检查
        constructor.setAccessible(true);

        //创建Singleton类的对象s1
        Singleton s1 = (Singleton) constructor.newInstance();
        //创建Singleton类的对象s2
        Singleton s2 = (Singleton) constructor.newInstance();

        //判断通过反射创建的两个Singleton对象是否是同一个对象
        System.out.println(s1 == s2);
    }
}

上面代码运行结果是false，表明序列化和反序列化已经破坏了单例设计模式

注意:这里仅展示了一种反射破坏单例的方式，往下继续解决

解决措施

public class Singleton {

    //私有构造方法
    private Singleton() {
        /*
           反射破解单例模式需要添加的代码
        */
        if(instance != null) {
            throw new RuntimeException();
        }
    }
    
    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.序列化反序列化为什么能够破坏单例模式？

答：细心看源码发现，它实际上也只是在反序列化过程中使用了反射调用了构造函数的newInstance()方法，从而避免了单例。第二个问题也可以同样得到解释。

源码浅析，欢迎访问该博主的博文：JAVA对象流序列化时的readObject，writeObject，readResolve是怎么被调用的：（他的图解析的很好）https://blog.csdn.net/u014653197/article/details/78114041

我在这里做一些补充：（可以跳过）




此处不再深入

总之就是从源码上证明了这家伙返回的就是序列化对象的构造函数，在第三个问题里也印证了我们的测试结果（往下）！

2.为什么在单例类中提供了readResolve()方法就能够避免反序列化破坏单例问题？

答：其实注释已经写的很清楚了，就是ObjectInputStream给我们提供了一个方法，只要序列化对象中实现了该方法，就通过反射调用 Singleton 类中的 readResolve 方法，将返回值赋值给rep变量，这样多次调用ObjectInputStream类中的readObject方法，继而就会调用我们定义的readResolve方法，所以返回的是同一个对象。

细心的小伙伴到这里应该已经发现了，单例模式的破坏实质都源于反射 导致未使用我们提前准备好的实现单例的方式去获取对象，而使用的类本身的私有构造方法创建了对象。

但这样我们又产生了一个疑问：既然都是通过反射调用私有构造方法创建的对象，那么我们是否可以通过我们上述所说的直接阻止反射破坏单例的方式来阻止序列化反序列化带来的单例破坏呢？

3.是否可以通过直接抛异常的方式阻止反射破坏单例从而阻止序列化反序列化带来的单例破坏？
答：不允许。

一起来做个测试吧！

Singleton类：

public class Singleton implements Serializable{

    //私有构造方法
    private Singleton() {
        /*
           反射破解单例模式需要添加的代码
        */
        System.out.println("=========经过了私有构造方法===========");
        if(instance != null) {
            throw new RuntimeException();
        }
    }

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

/*    private Object readResolve() {
        return instance;
    }*/
}

public class Test {
    public static void main(String[] args) throws Exception {
        //往文件中写对象
        writeObject2File();
        //从文件中读取对象
        Singleton s1 = readObjectFromFile();
        Singleton s2 = readObjectFromFile();

        //判断两个反序列化后的对象是否是同一个对象
        System.out.println("序列化反序列化 经过私有无参构造方法创建对象："+(s1 == s2));

        System.out.println("|||||||||||||||||||||||||||||||");

        //获取Singleton类的字节码对象
        Class clazz = Singleton.class;
        //获取Singleton类的私有无参构造方法对象
        Constructor constructor = clazz.getDeclaredConstructor();
        //取消访问检查
        constructor.setAccessible(true);

        //创建Singleton类的对象s1
        Singleton s11 = (Singleton) constructor.newInstance();
        //创建Singleton类的对象s2
        Singleton s22 = (Singleton) constructor.newInstance();

        //判断通过反射创建的两个Singleton对象是否是同一个对象
        System.out.println("反射 经过私有无参构造方法创建对象："+(s11 == s22));
    }

    private static Singleton readObjectFromFile() throws Exception {
        //创建对象输入流对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("G:\\a.txt"));
        //第一个读取Singleton对象
        Singleton instance = (Singleton) ois.readObject();

        return instance;
    }

    public static void writeObject2File() throws Exception {
        //获取Singleton类的对象
        Singleton instance = Singleton.getInstance();
        //创建对象输出流
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("G:\\a.txt"));
        //将instance对象写出到文件中
        oos.writeObject(instance);
    }
}

控制台：

=========经过了私有构造方法===========
序列化反序列化 经过私有无参构造方法创建对象：false
|||||||||||||||||||||||||||||||
=========经过了私有构造方法===========
Exception in thread "main" java.lang.reflect.InvocationTargetException
   ...
Caused by: java.lang.RuntimeException
   ...
	... 5 more

也就是说，反序列化时所调用对象的私有无参构造方法时，对instance的判断不会空，那么为什么不是跟我们所使用的反射一个结果呢？
看这里：

        // 我们可以看到，s1,s2 都是反序列化得到的
        Singleton s1 = readObjectFromFile();
        Singleton s2 = readObjectFromFile();

我们反序列化使用的是newInstance()方法，那使用的newInstance()方法是通过谁调用的？构造方法。
那这个构造方法哪来的？

我们可以猜想：通过类，也就是Class类。我们通过获取序列化对象的类获取其构造方法从而调用newInstance()方法创建实例。
并且问题的来源肯定是：要么获取的类对象不一样，要么获取的构造函数对象不一样

为什么这么去猜测？我们知道创建类对象的方式只有三种 : forName("")、类.Class、对象.getClass()
第一种显然不是，通过对象去获取类更不可能（我都有对象了我还创建类干啥）

当然，也确实是这么去做的

那么一起来测试一下吧！

测试类：

        // 弄俩类对象
        Class<Singleton> singletonClass = Singleton.class;
        Class<Singleton> singletonClass1 = Singleton.class;
        // 弄俩构造函数
        Constructor<Singleton> declaredConstructor = singletonClass.getDeclaredConstructor();
        declaredConstructor.setAccessible(true);
        Constructor<Singleton> declaredConstructor1 = singletonClass1.getDeclaredConstructor();
        declaredConstructor1.setAccessible(true);
        // 弄俩实例
        Singleton singleton = declaredConstructor.newInstance();
        Singleton singleton1 = declaredConstructor1.newInstance();
        System.out.println("类对象是否一样："+ (singletonClass==singletonClass1));
        System.out.println("获取构造函数是否一样："+(declaredConstructor1 == declaredConstructor));
        System.out.println("获取实例是否一样："+(singleton == singleton1));

控制台：

=========经过了私有构造方法===========
=========经过了私有构造方法===========
类对象是否一样：true
获取构造函数是否一样：false
获取实例是否一样：false

结果：不同的构造函数对象得到了不同的实例对象，略过了 instance 的判空
结论：经过反序列化获取的构造函数与其他从同一个序列化对象反序列化过来的类生成的构造函数不是同一个构造函数

这里再把上面所用到的反射例子做补充，也就是说，通过这种方式（多构造函数创建多实例）也是反射破坏单例的一种方式

这又产生了一个新问题：这不还是反射所造成的单例破坏吗？那这种破坏又该怎么阻止？能否通过这种防范方式同时阻止反射破坏和反序列化破坏？

答案是：没错，就是反射。有阻止方法。

解决：使用枚举

简述单例破坏

1.不同 declaredConstructor 对象new不同实例破坏单例

        Constructor<Singleton> declaredConstructor = singletonClass.getDeclaredConstructor();
        declaredConstructor.setAccessible(true);
        Constructor<Singleton> declaredConstructor1 = singletonClass1.getDeclaredConstructor();
        declaredConstructor1.setAccessible(true);
        Singleton singleton = declaredConstructor.newInstance();
        Singleton singleton1 = declaredConstructor1.newInstance();
        System.out.println("获取实例是否一样："+(singleton == singleton1)); // false

对此，可以通过静态标识位判断阻止 不同 declaredConstructor 对象new不同实例 的单例破坏

	// 在类加载时就已经初始化的标识位
    private static boolean flag = false;

    private Singleton() {
        
        System.out.println("=========经过了私有构造方法===========");
        synchronized (this) {
            if (flag == false) {
                flag = true;
            } else {
                throw new RuntimeException("不要试图挑衅我的底线");
            }
        }
    }

2.获取标识位属性进行破坏（即使是加密的属性，反射破坏者也可以通过反编译等手段获取属性名）

        Field flag= LazyMan.class.getDeclaredField("flag");
        flag.setAccessible(true);
        Constructor<LazyMan> declaredConstructor =
                LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        LazyMan instance = declaredConstructor.newInstance();
        flag.set(instance,false);

所以

• 无论如何反射都一定可以破坏单例（除枚举），因为不同维度上的防御是不可阻止的

文章说明

1.其中有部分代码直接拷贝自黑马程序员设计模式文档
2.这篇博文是我边思考边写的，所以编写的逻辑是按我的思路走的
3.如有错误，请及时联系我纠正
3.如有侵权，请及时联系我删除