序列化对单例的破坏

太过爱你忘了你带给我的痛 2021-09-28 23:34 304阅读 0赞

## 序列化对单例的破坏 ##

# 前言 #

大家知道单例模式中，对对象序列化不恰当，会导致单例失效。

## 单例在序列化被破败案例 ##

package com.yunfeng;
        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;
            }
        }

写一个序列化的测试类：

package com.yunfeng;
        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 FileOutputStream("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());
            }
        }
        //false

输出结构为false，说明：  
通过对Singleton的序列化与反序列化得到的对象是一个新的对象，这就破坏了Singleton的单例性。

## 序列化破坏单例的过程 ##

在反序列化的过程中

## ObjectInputStream ##

对象的序列化过程通过ObjectOutputStream和ObjectInputputStream来实现的。为了节省篇幅，这里给出ObjectInputStream的`readObject`的调用栈：

重点代码，`readOrdinaryObject`方法的代码片段：

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

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对象，就是本方法要返回的对象，也可以暂时理解为是ObjectInputStream的`readObject`返回的对象。

> `isInstantiable`：如果一个serializable/externalizable的类可以在运行时被实例化，那么该方法就返回true。针对serializable和externalizable我会在其他文章中介绍。
> 
> `desc.newInstance`：该方法通过反射的方式调用无参构造方法新建一个对象。

这就解释了原因，为什么序列化会破坏单例?：序列化会通过反射调用无参数的构造方法创建一个新的对象。

## 防止序列化破坏单例模式 ##

先给出解决方案，然后再具体分析原理：

只要在Singleton类中定义`readResolve`就可以解决该问题：

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

还是运行以下测试类：

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 FileOutputStream("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。具体原理，我们回过头继续分析以下ObjectInputStream的`readObject`的调用代码:

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方法，并在该方法中指定要返回的对象的生成策略，就可以防止单例被破坏。