Java与设计模式之单例模式（下）安全的单例模式

关于单例设计模式，《Java与设计模式之单例模式（上）六种实现方式》介绍了6种不同的单例模式，线程安全，本文介绍该如何保证单例模式最核心的作用——“实现该模式的类有且只有一个实例对象”。

我们知道，Java中有四种方式创建对象：new、克隆、序列化、反射。下面逐一分析哪个方式存在风险。

new，无风险。由于单例模式提供的构造函数都是私有的，所以不能在外部使用new的方式创建对象。
克隆，无风险。因为对象必须实现一个Cloneable 接口才可以直接调用clone()，而单例模式并未实现Cloneable 接口，所以，无风险。
序列化机制，有风险。对象序列化成一个字节流后，若要被反序列化恢复时，会生成一个新的对象，此对象和原来的对象具有一模一样的行为，但归根结底是两个对象。
反射机制，有风险。有句老话“反射可以打破一切封装！”，说明了任何类在反射机制面前都是透明的，通过反射机制可以获得类的各种属性，当然也可以获得类的构造函数（包括私有的），从而构造一个新的对象。但是，枚举类除外，下文会提到。

通过上述分析，若要实现一个完美的单例模式必须考虑序列化和反射问题。本文就序列化机制和反射是如何破坏单例模式，以及枚举类型是如何完美解决这个问题加以解析讨论。

通过反射破坏单例

原理很简单，通过反射获取其构造方法，然后重新生成一个实例。

     private static void reflectMethod() {
        try {
            EagerSingleton instance1 = EagerSingleton.getInstance();
            // 通过反射得到其构造方法，修改其构造方法的访问权限，并用这个构造方法构造一个对象
            Constructor constructor = EagerSingleton.class.getDeclaredConstructor();
            // 把私有访问域的访问级别设置为public，否则，会抛异常
            constructor.setAccessible(true);
            EagerSingleton instance2 = (EagerSingleton) constructor.newInstance();
 
            System.out.println( "反射是否破坏了单例 : " + !(instance1 == instance2)); // true
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

显然，说好的单例已经变成了多例。防止反射破坏单例可以使用枚举式单例模式。

   private static void reflectEnumMethod() {
        try {
            EnumSingleton instance1 = EnumSingleton.INSTANCE;
            Constructor constructor = EnumSingleton.class.getDeclaredConstructor();
            constructor.setAccessible(true);
            EnumSingleton instance2 = (EnumSingleton) constructor.newInstance(); 
            System.out.println( "反射是否破坏了单例 : " + !(instance1 == instance2)); // true
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

执行改方法时抛出如下异常：

       java.lang.NoSuchMethodException: com.east7.singleton.EnumSingleton.<init>()
       at java.lang.Class.getConstructor0(Class.java:3082)
       at java.lang.Class.getDeclaredConstructor(Class.java:2178)
       at com.east7.controller.SingletonController.reflectEnumMethod(SingletonController.java:42)
       at com.east7.controller.SingletonController.main(SingletonController.java:22)

不言而喻，我们在代码中无法通过反射获取 enum 类的构造方法。对于枚举，JVM 会自动进行实例的创建，其构造方法由 JVM 在创建实例的时候进行调用。

通过序列化机制破坏

下面，我们再说说另一种破解方法：序列化、反序列化。我们知道，序列化是将 java 对象转换为字节流，反序列化是从字节流转换为 java 对象。下面以饿汉式单例为例，验证反序列化会生成新的单例实例。

   private static void serialMethod() {
        try {
            EagerSingleton instance1 = EagerSingleton.getInstance();
 
            // instance3 将从 instance1 序列化后，反序列化而来
            EagerSingleton instance3 = null;
            ByteArrayOutputStream bout = null;
            ObjectOutputStream out = null;
            try {
                bout = new ByteArrayOutputStream();
                out = new ObjectOutputStream(bout);
                out.writeObject(instance1);
 
                ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
                ObjectInputStream in = new ObjectInputStream(bin);
                instance3 = (EagerSingleton) in.readObject();
            } catch (Exception e) {
                System.out.println(" -------------- " + e);
            } finally {
                // close bout&out
            }
            System.out.println( "序列化是否破坏了单例 : " + (instance1 == instance3));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

执行结果打印为false，说明生成了不同的实例。序列化饿汉式单例：

import java.io.ObjectStreamException;
import java.io.Serializable;
 
/**
 * 序列化的饿汉式单例，线程安全
 */
public class EagerSingletonPlus implements Serializable {
 
    private static final EagerSingletonPlus instance = new EagerSingletonPlus();
    // 私有化构造方法
 
    private EagerSingletonPlus() {
    }
    public static EagerSingletonPlus getInstance() {
        return instance;
    }
    /**
     * 看这里，新增
     */
    public Object readResolve() throws ObjectStreamException {
        return instance;
    }
 
    // 序列化，新增
    private static final long serialVersionUID = -3006063981632376005L;
}

把serialEnumMethod中的EagerSingleton类替换成EagerSingletonPlus，再次执行，结果变成了false，说明反序列化生成的实例instance3和instance1对应同一个实例。因为在反序列化的时候，JVM 会自动调用 readResolve() 这个方法，我们可以在这个方法中替换掉从流中反序列化回来的对象。关于readResolve()的更详细信息，请参考3.7 The readResolve Method 。下面验证基于枚举创建的单例类是不会被序列化破坏的，代码结构和serialMethod()类似。

   private static void serialEnumMethod() {
        try {
            EnumSingleton instance1 = EnumSingleton.INSTANCE; 
            // instance3 将从 instance1 序列化后，反序列化而来
            EnumSingleton instance3 = null;
            ByteArrayOutputStream bout = null;
            ObjectOutputStream out = null;
            try {
                bout = new ByteArrayOutputStream();
                out = new ObjectOutputStream(bout);
                out.writeObject(instance1);
 
                ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
                ObjectInputStream in = new ObjectInputStream(bin);
                instance3 = (EnumSingleton) in.readObject();
            } catch (Exception e) {
                System.out.println(" - EagerSingletonPlus ------------- " + e);
            } finally {
                // close bout&out
            }
            System.out.println( "枚举自带光环，反序列化未破坏单例 : " + (instance1 == instance3)); // true
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

由此可见，enum 类自带特殊光环，不用写 readResolve() 方法就可以自动防止反序列化方式对单例的破坏，而前四种写法的单例模式则需要特殊处理。原因是在枚举类型的序列化和反序列化上，Java做了特殊的规定在枚举类型的序列化和反序列化上，Java做了特殊的规定。原文如下：

Enum constants are serialized differently than ordinary serializable or externalizable objects. The serialized form of an enum constant consists solely of its name; field values of the constant are not present in the form. To serialize an enum constant, ObjectOutputStream writes the value returned by the enum constant’s name method. To deserialize an enum constant, ObjectInputStream reads the constant name from the stream; the deserialized constant is then obtained by calling the java.lang.Enum.valueOf method, passing the constant’s enum type along with the received constant name as arguments. Like other serializable or externalizable objects, enum constants can function as the targets of back references appearing subsequently in the serialization stream. The process by which enum constants are serialized cannot be customized: any class-specific writeObject, readObject, readObjectNoData, writeReplace, and readResolve methods defined by enum types are ignored during serialization and deserialization. Similarly, any serialPersistentFields or serialVersionUID field declarations are also ignored–all enum types have a fixed serialVersionUID of 0L. Documenting serializable fields and data for enum types is unnecessary, since there is no variation in the type of data sent.

大概意思就是说，在序列化的时候Java仅仅是将枚举对象的name属性输出到结果中，反序列化的时候则是通过java.lang.Enum的valueOf方法根据名字查找枚举对象。同时，编译器是不允许任何对这种序列化机制的定制的，因此禁用了writeObject、readObject、readObjectNoData、writeReplace和readResolve等方法。

   public static <T extends Enum<T>> T valueOf(Class<T> enumType,String name) { 
       T result = enumType.enumConstantDirectory().get(name); 
       if (result != null) 
              return result; 
       if (name == null) 
              throw new NullPointerException("Name is null"); 
       throw new IllegalArgumentException( 
              "No enum const " + enumType +"." + name); 
  }

从代码中可以看到，代码会尝试从调用enumType这个Class对象的enumConstantDirectory()方法返回的map中获取名字为name的枚举对象，如果不存在就会抛出异常。再进一步跟到enumConstantDirectory()方法，就会发现到最后会以反射的方式调用enumType这个类型的values()静态方法，也就是上面我们看到的编译器为我们创建的那个方法，然后用返回结果填充enumType这个Class对象中的enumConstantDirectory属性。所以，JVM对序列化有保证。