【如何破坏单例模式(详解)】

在这里插入图片描述

✅如何破坏单例模式

  • 典型解析
  • ✅拓展知识仓
    • ✅反射破坏单例
    • ✅反序列化破坏单例
    • ✅ObjectlnputStream
  • ✅总结
    • ✅如何避免单例被破坏
      • ✅ 避免反射破坏单例
      • ✅ 避免反序列化破坏单例

典型解析


单例模式主要是通过把一个类的构造方法私有化,来避免重复创建多个对象的。那么,想要破坏单例,只要想办注能够执行到这个私有的构造方法就行了。


✅拓展知识仓


一般来说做法有使用反射及使用反序列化都可以破坏单例。


我们先通过双重校验锁的方式创建一个单例,后文会通过反射及反序列化的方式尝试破坏这个单例。


package com.yangxiaoyuan;

import java.io.Serializable;

/**
 * Created by yangxiaoyuan on 23/12/24
 * 使用双重校验锁方式实现单例
*/

public class Singleton implements Serializable {
	private volatile static Singleton singleton;
	private Singleton () {
		
	}

	public static Singleton getsingleton()  {
		if (singleton == null) {
			synchronized (Singleton.class)  {
				if (singleton == null) {
					singleton = new Singleton();
				}
			}
		}

		return singleton;
	}	
}

✅反射破坏单例


我们尝试通过反射技术,来破坏单例:


Singleton singleton1 = Singleton.getSingleton();

//通过反射获取到构造函数
Constructor<Singleton> constructor = Singleton.class.getDeclaredConstructor();
//将构造函数设置为可访问类型
constructor.setAccessible(true);
//调用构造函数的newInstance创建一个对象
Singleton singleton2 = constructor.newInstance();
//判断反射创建的对象和之前的对象是不是同一个对象
System.out.println(s1 == s2);

以上代码,输出结果为false,也就是说通过反射技术,我们给单例对象创建出来了一个 "兄弟” 。


setAccessible(true),使得反射对象在使用时应该取消Java 语言访检查,使得私有的构造函数能够被访问。


✅反序列化破坏单例


我们尝试通过序列化+反序列化来破坏一下单例:


package com.yangxiaoyuan;

import java.io.*;

public class SerializableDemo1 {
	//为了便于理解,忽略关闭流操作及删除文件操作。真正编码时千万不要忘记
	//Exception直接抛出


	public static void main(String  args) throws IOException, ClassNotFoundException {
		
		//Write Obj to file
		ObjectOutputStream oos = new ObjectOutputStream(new File0utputStream("tempFile"));
		oos.writeObject(Singleton.getsingleton());
		//Read Obi from file
		File file = new File("tempFile");
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
		Singleton newInstance = (Singleton) ois.readObject();
		//判断是否是同一个对象
		System.out.println(newInstance == Singleton.getSingleton());
	}
}

//false


输出结构为false,说明:


通过对Singleton的序列化与反序列化得到的对象是一个新的对象,这就破坏了Singleton的单例性。


这里,在介绍如何解决这个问题之前,我们先来深入分析一下,为什么会这样?在反序列化的过程中到底发生了什么。


✅ObjectlnputStream


对象的序列化过程通过ObjectOutputStream和ObiectlnputStream来实现的,那么带着刚刚的问题,分析一下ObjectlnputStream 的 readobject 方法执行情况到底是怎样的。


为了节省篇幅,这里给出ObiectlnputStream的 readobject 的调用栈:


【如何破坏单例模式(详解)】_第1张图片

这里看一下重点代码,readOrdinaryObject 万法的代码片段: code 3


private Object readOrdinaryObject(boolean unshared) throws IOException {
	//此处省略部分代码

	Object obj;
	try {
		obj = desc.isInstantiable() ? desc.newInstance() : null;
	} catch (Exception ex)  {
		throw (IOException) new InvalidClassException(desc .forClass().getName(),
"unable to create instance").initCause(ex);
	}

	//此处省略部分代码

	if (obj != null && handles.lookupException(passHandle) == null && desc.hasReadResolveMethod()) {
		Object rep = desc.invokeReadResolve(obj);
		if (unshared && rep.getClass().isArray()) {
			rep = cloneArray(rep);
		}
		if (rep != obj) {
			handles.setObject(passHandle, obj = rep);
		}
	}
	return obj;
}

code 3 中主要贴出两部分代码。先分析第一部分:


code3.1


Object obj;
	try {
		obj = desc.isInstantiable() ? desc.newInstance() : null;
	} catch (Exception ex)  {
		throw (IOException) new InvalidClassException(desc .forClass().getName(),
"unable to create instance").initCause(ex);
	}

这里创建的这个obj对象,就是本方法要返回的对象,也可以暂时理解为是ObjectlnputStream的 readobject 返回的对象。


![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/d9179a634e2a462dafeaf5c696d1a6f7.png#pic_center【如何破坏单例模式(详解)】_第2张图片


isInstantiable: 如果一个serializable/externalizable的类可以在运行时被实例化,那么该方法就返回true。针对serializable和externalizable我会在其他文章中介绍。




desc.newInstance:该方法通过反射的方式新建一个对象。


然后看一下 newInstance 的源码:


public T newInstance(Object ... initargs) throws InstantiationExceptionIllegalAccessException,
IllegalArgumentExceptionInvocationTargetException {
	if (!override) {
		if (!Reflection.quickCheckMemberAccess(clazz,modifiers)) {
			Class<?> caller = Reflection.getCallerClass();
			checkAccess(caller, clazz, nul1, modifiers);
		}
	}
	if ((clazz.getModifiers() & Modifier.ENUM) != 0) {
		throw new IllegalArgumentException("Cannot reflectively create enum objects");
		
	}
	ConstructorAccessor ca = constructorAccessor;         // read volatile
	if (ca == null) {
		ca = acquireConstructorAccessor();
	}
	@Suppresslarnings("unchecked")
	T inst = (T) ca.newInstance(initargs];
	return inst;
}

其中关键的就是 T inst = (T) ca.newInstance(initargs);这一步,这里实现的话在BootstrapConstructorAccessorlmpl中,实现如下:


public Object newInstance(Object[] args)
throws IllegalArgumentExceptionInvocationTargetException {
	try {
		return UnsafeFieldAccessorImpl.unsafe.allocateInstance(constructor.getDeclaringClass());
	} catch (InstantiationException e)  {
		throw new InvocationTargetException(e);
	}
}

可以看到,这里通过Java 的 Unsafe 机制来创建对象的,而不是通过调用构造函数。这意味着即使类的构造函数是私有的,反序列化仍然可以创建该类的实例,因为它不依赖于常规的构造过程。


So,到目前为止,也就可以解释,为什么序列化可以破坏单例?

答:序列化会通过Unsafe直接分配的方式来创建一个新的对象。

✅总结


在涉及到序列化的场景时,要格外注意他对单例的破坏。


✅如何避免单例被破坏


✅ 避免反射破坏单例


反射是调用默认的构造函数创建出来的,只需要我们改造下构造函数,使其在反射调用的时候识别出来对象是不是被创建过就行了:


private Singleton() {
	if (singleton != null) {
		throw new RuntimeException("单例对象只能创建一次...");
	}
}

✅ 避免反序列化破坏单例


解决反序列化的破坏单例,只需要我们自定义反序列化的策略就行了,就是说我们不要让他走默认逻辑一直调用至Unsafe创建对象,而是我们干预他的这个过程,干预方式就是在Singleton类中定义 readResolve ,这样就可以解决该问题:


package com.yangxiaoyuan;


import java.io.Serializable;

// 使用双重校验锁方式实现单例

public class Singleton implements Serializable {
	private volatile static Singleton singleton;
	private Singleton (){}
	public static Singleton getSingleton()  {
		if (singleton == null) {
			synchronized (Singleton.class)  {
				if (singleton == null) {
					singleton = new Singleton();
				}
			}
		}
		return singleton;
	}
	private Object readResolve() {
		return singleton;
	}
}

还是运行以下测试类


package com.yangxiaoyuan;

import java.io.*;

public class SerializableDemo1 {
	//为了便于理解,忽略关闭流操作及删除文件操作。真正编码时千万不要忘记
	//Exception直接抛出

	public static void main(Stringl] args) throws IOException, ClassNotFoundException {
		//Write Obj to file
		ObjectOutputStream oos = new ObiectOutputStream(new File0utputstream("tempFile")):
		oos.writeObject(Singleton.getSingleton());
		//Read Obj from file
		File file = new File("tempFile");
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
		Singleton newInstance = (Singleton) ois.readObject();
		//判断是否是同一个对象
		System.out.println(newInstance == Singleton.getSingleton());
	}
}

//true

本次输出结果为true。具体原理,我们回过头继续分析code 3中的第二段代码:


if (obj != null &&

handles.lookupException(passHandle) == null && desc.hasReadResolveMethod()) {
	Object rep = desc.invokeReadResolve(obj);
	if (unshared && rep.getClass().isArray()) {
		rep = cloneArray(rep);
	}
	if (rep != obj) {
		handles .setObject(passHandle, obj = rep);
	}
}

hasReadResolveMethod :如果实现了serializable 或者 externalizable接口的类中包含 readResolve 则返回true。


invokeReadResolve :通过反射的方式调用要被反序列化的类的readResolve方法。


所以,原理也就清楚了,只要在Singleton中定义readResolve方法,并在该方法中指定要返回的对象的生成策略,就可可以防止单例被破坏。

你可能感兴趣的:(Java基础,单例模式,java,开发语言)