本文探讨了单例模式在反射调用和序列化过程中的脆弱性，通过具体代码示例展示了如何破坏单例模式，并提供了防止破坏的解决方案。
反射破坏单例
大家有没有发现，《设计模式2.0-单例模式-四种常用的单例模式》一文中介绍的单例模式的构造方法除了加上 private 以外，没有做任何处理。如果我们使用反射来调用其构造方法，然后，再调用 getInstance()方法，应该就会两个不同的实例。现在来看一段测试代码，以 LazyInnerClassSingleton 为例：
public class LazyInnerClassSingletonTest {
public static void main(String[] args) {
try{
//很无聊的情况下，进行破坏
Class<?> clazz = LazyInnerClassSingleton.class;
//通过反射拿到私有的构造方法
Constructor c = clazz.getDeclaredConstructor(null);
//强制访问，强吻，不愿意也要吻
c.setAccessible(true);
//暴力初始化
Object o1 = c.newInstance();
//调用了两次构造方法，相当于 new 了两次
//犯了原则性问题，
Object o2 = c.newInstance();
System.out.println(o1 == o2);
// Object o2 = c.newInstance();
}catch (Exception e){
e.printStackTrace();
}
}
}
运行的结果为：false
显然，是创建了两个不同的实例。现在，我们在其构造方法中做一些限制，一旦出现多次重复创建，则直接抛出异常。来看优化后的代码：
//史上最牛 B 的单例模式的实现方式
public class LazyInnerClassSingleton {
//默认使用 LazyInnerClassGeneral 的时候，会先初始化内部类
//如果没使用的话，内部类是不加载的
private LazyInnerClassSingleton(){
if(LazyHolder.LAZY != null){
throw new RuntimeException("不允许创建多个实例");
}
}
//每一个关键字都不是多余的
//static 是为了使单例的空间共享
//保证这个方法不会被重写，重载
public static final LazyInnerClassSingleton getInstance(){
//在返回结果以前，一定会先加载内部类
return LazyHolder.LAZY;
}
//默认不加载
private static class LazyHolder{
private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton();
}
}
再运行测试代码，会得到以下结果：
序列化破坏单例
当我们将一个单例对象创建好，有时候需要将对象序列化然后写入到磁盘，下次使用时再从磁盘中读取到对象，反序列化转化为内存对象。反序列化后的对象会重新分配内存，即重新创建。那如果序列化的目标的对象为单例对象，就违背了单例模式的初衷，相当于破坏了单例，来看一段代码：
/**
* 使用序列化破坏单例
*/
public class SeriableSingleton implements Serializable {
//序列化就是说把内存中的状态通过转换成字节码的形式
//从而转换一个 IO 流，写入到其他地方(可以是磁盘、网络 IO)
//内存中状态给永久保存下来了
//反序列化
//讲已经持久化的字节码内容，转换为 IO 流
//通过 IO 流的读取，进而将读取的内容转换为 Java 对象
//在转换过程中会重新创建对象 new
public final static SeriableSingleton instance = new SeriableSingleton();
private SeriableSingleton(){}
public static SeriableSingleton getInstance(){
return instance;
}
}
编写测试代码：
public class SeriableSingletonTest {
public static void main(String[] args) {
SeriableSingleton seriableSingleton1 = null;
SeriableSingleton seriableSingleton2 = SeriableSingleton.getInstance();
FileOutputStream fos = null;
try {
fos = new FileOutputStream("SeriableSingleton.obj");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(seriableSingleton2);
oos.flush();
oos.close();
FileInputStream fis = new FileInputStream("SeriableSingleton.obj");
ObjectInputStream ois = new ObjectInputStream(fis);
seriableSingleton1 = (SeriableSingleton)ois.readObject();
ois.close();
System.out.println(seriableSingleton1);
System.out.println(seriableSingleton2);
System.out.println(seriableSingleton1 == seriableSingleton2);
} catch (Exception e) {
e.printStackTrace();
}
}
}
运行结果：
运行结果中，可以看出，反序列化后的对象和手动创建的对象是不一致的，实例化了两次，违背了单例的设计初衷。那么，我们如何保证序列化的情况下也能够实现单例？其实很简单，只需要增加 readResolve()方法即可。来看优化代码：
/**
* 使用序列化破坏单例
*/
public class SeriableSingleton implements Serializable {
//序列化就是说把内存中的状态通过转换成字节码的形式
//从而转换一个 IO 流，写入到其他地方(可以是磁盘、网络 IO)
//内存中状态给永久保存下来了
//反序列化
//讲已经持久化的字节码内容，转换为 IO 流
//通过 IO 流的读取，进而将读取的内容转换为 Java 对象
//在转换过程中会重新创建对象 new
public final static SeriableSingleton instance = new SeriableSingleton();
private SeriableSingleton(){}
public static SeriableSingleton getInstance(){
return instance;
}
/**
* 填加该方法，防止序列化破坏
* @return
*/
private Object readResolve(){
return instance;
}
}
大家一定会关心这是什么原因呢？为什么要这样写？看上去很神奇的样子，也让人有些费 解 。 不 如 ， 我 们 一 起 来 看 看 JDK 的 源 码 实 现 以 一 清 二 楚 了 。 我 们 进 入ObjectInputStream 类的 readObject()方法，代码如下：
public final Object readObject()
throws IOException, ClassNotFoundException
{
if (enableOverride) {
return readObjectOverride();
}
// if nested read, passHandle contains handle of enclosing object
int outerHandle = passHandle;
try {
Object obj = readObject0(false);
handles.markDependency(outerHandle, passHandle);
ClassNotFoundException ex = handles.lookupException(passHandle);
if (ex != null) {
throw ex;
}
if (depth == 0) {
vlist.doCallbacks();
}
return obj;
} finally {
passHandle = outerHandle;
if (closed && depth == 0) {
clear();
}
}
}
我们发现在readObject中又调用了我们重写的readObject0()方法。进入readObject0() 方法，代码如下：
private Object readObject0(boolean unshared) throws IOException {
...
case TC_OBJECT:
return checkResolve(readOrdinaryObject(unshared));
...
}
我们看到 TC_OBJECTD 中判断，调用了 ObjectInputStream 的 readOrdinaryObject()方法，我们继续进入看源码：
private Object readOrdinaryObject(boolean unshared)
throws IOException
{
if (bin.readByte() != TC_OBJECT) {
throw new InternalError();
}
ObjectStreamClass desc = readClassDesc(false);
desc.checkDeserialize();
Class<?> cl = desc.forClass();
if (cl == String.class || cl == Class.class
|| cl == ObjectStreamClass.class) {
throw new InvalidClassException("invalid class descriptor");
}
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);
}
...
return obj;
}
发现调用了 ObjectStreamClass 的 isInstantiable()方法，而 isInstantiable()里面的代码 如下：
boolean isInstantiable() {
requireInitialized();
return (cons != null);
}
代码非常简单，就是判断一下构造方法是否为空，构造方法不为空就返回 true。意味着，只要有无参构造方法就会实例化。这时候，其实还没有找到为什么加上 readResolve()方法就避免了单例被破坏的真正原因。我再回到 ObjectInputStream 的 readOrdinaryObject()方法继续往下看：
private Object readOrdinaryObject(boolean unshared)
throws IOException
{
if (bin.readByte() != TC_OBJECT) {
throw new InternalError();
}
ObjectStreamClass desc = readClassDesc(false);
desc.checkDeserialize();
Class<?> cl = desc.forClass();
if (cl == String.class || cl == Class.class
|| cl == ObjectStreamClass.class) {
throw new InvalidClassException("invalid class descriptor");
}
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) {
// Filter the replacement object
if (rep != null) {
if (rep.getClass().isArray()) {
filterCheck(rep.getClass(), Array.getLength(rep));
} else {
filterCheck(rep.getClass(), -1);
}
}
handles.setObject(passHandle, obj = rep);
}
}
return obj;
}
判断无参构造方法是否存在之后，又调用了 hasReadResolveMethod()方法，来看代码：
boolean hasReadResolveMethod() {
requireInitialized();
return (readResolveMethod != null);
}
逻辑非常简单，就是判断 readResolveMethod 是否为空，不为空就返回 true。那么readResolveMethod 是在哪里赋值的呢？通过全局查找找到了赋值代码在私有方法ObjectStreamClass()方法中给 readResolveMethod 进行赋值，来看代码：
readResolveMethod = getInheritableMethod(
cl, "readResolve", null, Object.class);
上面的逻辑其实就是通过反射找到一个无参的 readResolve()方法，并且保存下来。现在再 回 ObjectInputStream 的 readOrdinaryObject() 方 法 继 续 往 下 看 ， 如 果readResolve()存在则调用 invokeReadResolve()方法，来看代码：
Object invokeReadResolve(Object obj)
throws IOException, UnsupportedOperationException
{
requireInitialized();
if (readResolveMethod != null) {
try {
return readResolveMethod.invoke(obj, (Object[]) null);
} catch (InvocationTargetException ex) {
Throwable th = ex.getTargetException();
if (th instanceof ObjectStreamException) {
throw (ObjectStreamException) th;
} else {
throwMiscException(th);
throw new InternalError(th); // never reached
}
} catch (IllegalAccessException ex) {
// should not occur, as access checks have been suppressed
throw new InternalError(ex);
}
} else {
throw new UnsupportedOperationException();
}
}
我们可以看到在 invokeReadResolve()方法中用反射调用了 readResolveMethod 方法。通过 JDK 源码分析我们可以看出，虽然，增加 readResolve()方法返回实例，解决了单例被破坏的问题。但是，我们通过分析源码以及调试，我们可以看到实际上实例化了两次，只不过新创建的对象没有被返回而已。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
