单例模式详解与序列化破坏防范-优快云博客

本文链接：https://blog.youkuaiyun.com/zhll3377/article/details/50662974

单例模式简要总结：
1.饿汉模式


import java.io.Serializable;

/**
 * 饿汉式(线程安全，调用效率高，不能延迟加载)
 * @author Administrator
 *
 */
public class SinglePatternDemo1 implements Serializable {
    //私用构造方法
    private SinglePatternDemo1(){
        //防止通过以反射的方式违反单例创建多个对象，采取抛出异常的方式
        if(null!=instance){
            throw new RuntimeException("对象已存在");
        }
    }

    private static SinglePatternDemo1 instance=new SinglePatternDemo1();

    public static SinglePatternDemo1 getInstance(){
        return instance;
    }
    //序列化会通过反射调用无参数的构造方法创建一个新对象，以此来破坏单例,添加如下方法，会在反序列化时通过反射的方式调用如下的方法
    private Object readResolve(){
        return instance;
    }
}

2.懒汉模式

/**
 * @author Administrator
 * 懒汉式(线程安全，调用效率不高，可以延迟加载)
 */
public class SinglePatternDemo2 {
    //私有构造方法
    private SinglePatternDemo2(){

    }
    private static SinglePatternDemo2 instance;
    //添加synchorinzed的同步方法
    public synchronized static SinglePatternDemo2 getInstance(){
        if(null==instance){
            instance=new SinglePatternDemo2();
        }
        return instance;
    }
}

3.双重锁检测模式

/**
 * 双重锁检测机制()
 * @author Administrator
 *
 */
public class SinglePatternDemo5 {
    private volatile static SinglePatternDemo5 instance;
    //私有构造方法
    private SinglePatternDemo5(){}

    public static SinglePatternDemo5 getInstance(){
        if(null==instance){
            synchronized (SinglePatternDemo5.class) {
                if(null==instance){
                    instance=new SinglePatternDemo5();
                }
            }
        }
        return instance;
    }
}

4.静态内部类模式

/**
 * @author Administrator
 * 静态内部类式（线程安全，调用效率高，可以延迟加载）
 */
public class SinglePatternDemo3 {
    //静态内部类
    private static class SingleInstance{
        public final static SinglePatternDemo3 instance=new SinglePatternDemo3();
    }
    //私有构造方法
    private SinglePatternDemo3(){
    }
    public static SinglePatternDemo3 getInstance(){
        return SingleInstance.instance;
    }
}

5.枚举模式

/**
 * 枚举式(线程安全，调用效率高，但不能延迟加载,可以天然的防止反射和反序列化)
 * @author Administrator
 *
 */
public enum SinglePatternDemo4 {
    INSTANCE;
    public void operation(){

    }
}
序列化和反序列化破坏单例的原因及解决办法(转载自http://www.hollischuang.com/archives/1144)
首先来写一个单例的类：

code 1

package com.hollis;
import java.io.Serializable;
/**
 * Created by hollis on 16/2/5.
 * 使用双重校验锁方式实现单例
 */
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;
    }
}
接下来是一个测试类：

code 2

package com.hollis;
import java.io.*;
/**
 * Created by hollis on 16/2/5.
 */
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来实现的，那么带着刚刚的问题，分析一下ObjectInputputStream 的readObject 方法执行情况到底是怎样的。

为了节省篇幅，这里给出ObjectInputStream的readObject的调用栈：

readObject--->readObject0--->readOrdinaryObject--->checkResolve

这里看一下重点代码，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 中主要贴出两部分代码。先分析第一部分：

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

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

desc.newInstance：该方法通过反射的方式调用无参构造方法新建一个对象。

所以。到目前为止，也就可以解释，为什么序列化可以破坏单例了？

答：序列化会通过反射调用无参数的构造方法创建一个新的对象。

那么，接下来我们再看刚开始留下的问题，如何防止序列化/反序列化破坏单例模式。

防止序列化破坏单例模式

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

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

code 4

package com.hollis;
import java.io.Serializable;
/**
 * Created by hollis on 16/2/5.
 * 使用双重校验锁方式实现单例
 */
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;
    }
}
具体原理，我们回过头继续分析code 3中的第二段代码:

code 3.2

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

总结

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

设计模式-单例