【设计模式】创建型：单例模式（三）序列化坏单例问题及解决方案

Myth丶恋晨 2023-01-15 08:11 130阅读 0赞

当我们将一个单例对象创建好，有时候需要将对象序列化然后写入到磁盘，下次使用时再从磁盘中读取到对象，反序列化转化为内存对象。

> PS：关于序列化可以参考[这篇文章][Link 1]，这里简单说一下
> 
>  *  序列化，就是说把内存中的状态通过转换成字节码的形式，从而转换一个 IO 流，写入到其他地方(可以是磁盘、网络 IO)，即内存中状态给永久保存下来了
>  *  反序列化，是将已经持久化的字节码内容，转换为 IO 流，通过 IO 流的读取，进而将读取的内容转换为 Java 对象，在转换过程中会重新创建对象 new。

那么问题来了，反序列化时，大多数情况下（有空参构造器），默认会创建创建一个新对象，而不是将原有的对象返回。而单例模式基本都是私有的空参构造器，所以，那如果序列化的目标的对象为单例对象，就会出现问题。

### 1.问题复现 ###

来看一段代码：

// 反序列化时导致单例破坏
    public class SeriableSingleton implements Serializable {
        
    
        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 s1 = null;
            SeriableSingleton s2 = SeriableSingleton.getInstance();
            FileOutputStream fos = null;
            try {
        
                fos = new FileOutputStream("SeriableSingleton.obj");
                ObjectOutputStream oos = new ObjectOutputStream(fos); // 通过OOS进行序列化
                // 将创建的单例对象序列化到文件保存
                oos.writeObject(s2);
                oos.flush();
                oos.close();
                
                FileInputStream fis = new FileInputStream("SeriableSingleton.obj");
                ObjectInputStream ois = new ObjectInputStream(fis); // 通过OIS进行反序列化
                // 从文件中将保存的对象反序列化读出
                s1 = (SeriableSingleton)ois.readObject();
                ois.close();
                
                System.out.println(s1);
                System.out.println(s2);
                // 比较 S1 S2
                System.out.println(s1 == s2);
            } catch (Exception e) {
        
            	e.printStackTrace();
            }
        }
    }

运行结果如下：

![在这里插入图片描述][20210421233042643.png_pic_center]

可以看出，反序列化后的对象和手动创建的对象是不一致的，实例化了两次，违背了单例的设计初衷。那么，我们如何保证序列化的情况下也能够实现单例？

### 2.解决方案 ###

解决方案其实很简单，只需要增加 readResolve() 方法即可。

来看优化代码：

// 反序列化时导致单例破坏
    public class SeriableSingleton implements Serializable {
        
    
        public final static SeriableSingleton INSTANCE = new SeriableSingleton();
        
        private SeriableSingleton(){
        }
        
        public static SeriableSingleton getInstance(){
        
        	return INSTANCE;
        }
        
        private Object readResolve(){
        
        	return INSTANCE;
        }
    }

再看运行结果：

![在这里插入图片描述][20210421233341243.png_pic_center]  
大家一定会关心这是什么原因呢？为什么要这样写？看上去很神奇的样子，所以，我们下面就一起看看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 {
        
            // readObject0()
            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 {
        
           	// isInstantiable() 判断当前类构造方法是否为空，如果为空，则返回true
            // 这意味着，只要有无参构造方法就会实例化一个新对象
            // 这正是反序列化会破坏单例的原因所在！！！
            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 &&
            	// hasReadResolveMethod() 判断 readResolveMethod 是否为空，不为空就返回 true
            	// 而 readResolveMethod 是一个 Method 类型的变量，
            	// 保存的就是当前类的 readResolve() 方法（通过反射获取）
                desc.hasReadResolveMethod())
            {
        
            	// 如果 readResolve() 方法存在，则调用 invokeReadResolve() 方法
    	        // invokeReadResolve() 根据名字就可以知道，它通过反射执行了 readResolve() 方法
            	// 并把结果赋给 rep
                Object rep = desc.invokeReadResolve(obj);
                if (unshared && rep.getClass().isArray()) {
        
                    rep = cloneArray(rep);
                }
            	// 如果上面 obj 实例化新对象了，则使 obj=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;
    }

通过 JDK 源码分析我们可以看到，如果在代码中增加 readResolve() 方法，则可以返回原有的实例，而不是新的空参构造的那个对象，即解决了单例被破坏的问题。

> 但是，通过上面源码也可以看到，obj 实际上实例化了两次，只不过新创建的对象没有被返回而已。那如果，创建对象的动作发生频率增大，就意味着内存分配开销也就随之增大，难道真的就没办法从根本上解决问题吗？当然有办法，就是使用使用注册式单例，比如[枚举单例][Link 2]…

[Link 1]: https://yzhyaa.blog.csdn.net/article/details/109002466
[20210421233042643.png_pic_center]: /images/20221022/43238971cc84442db6feb733fae0433e.png
[20210421233341243.png_pic_center]: /images/20221022/b9035ebc52a04d39b551baf6fa81d000.png
[Link 2]: https://yzhyaa.blog.csdn.net/article/details/115985319