为什么说Enum实现单例模式是最佳实践
众所周知，单例的实现有很多方式。从单例加载的时机区分，有懒汉模式、饿汉模式。而从实现方式区分有双重检查模式，内部类模式、Enum模式、Map模式等。在《Effective Java》中，作者提出利用Enum是实现单例模式的最佳实践。研究了下Enum反编译源码，就一切都清楚了。本文针对此问题做些总结。
内容概要
- 实现单例模式的几个关键点
- 利用Enum实现单例模式
- 结论
实现单例模式的几个关键点
为了实现单例模式，其核心就是确保单例对象的唯一性。需要重点关注几个关键点。
- 无法通过new来随意创建对象，构造函数为private
- 提供获取唯一实例对象的方法，通常是getInstance
- 多线程并发的情况下保证唯一
- 避免反射创建单例对象（反射攻击）
- 避免通过序列化创建单例对象（如果单例类实现了Serializable）（序列化攻击）
利用Enum实现单例模式
利用Enum的天然属性，可以有效的保证上面的几个关键点。它属于饿汉模式的单例实现。下面先看看实现代码及其反编译代码。
实现代码
下面列出Java实现代码及其反编译代码，从中找出单例模式的几个关键点。看看Enum是如何保证的。
Java代码
/**
* 使用枚举实现单例。
*/
public enum EnumSingleton {
INSTANCE; // 唯一的实例对象
public static EnumSingleton getInstance() {
return INSTANCE;
}
// 单例对象的属性对象
private Object obj = new Object();
public Object getObj() {
return obj;
}
/**
* 单例提供的对外服务。
*/
public Object getFactoryService() {
return new Object();
}
}
反编译代码
// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.kpdus.com/jad.html
// Decompiler options: packimports(3)
// Source File Name: EnumSingleton.java
package com.ws.pattern.singleton;
public final class EnumSingleton extends Enum
{
public static EnumSingleton[] values()
{
return (EnumSingleton[])$VALUES.clone();
}
public static EnumSingleton valueOf(String name)
{
return (EnumSingleton)Enum.valueOf(com/ws/pattern/singleton/EnumSingleton, name);
}
// 无法通过new来随意创建对象，构造函数为private.
private EnumSingleton(String s, int i)
{
super(s, i);
obj = new Object();
}
// 提供获取唯一实例对象的方法，通常是getInstance
public static EnumSingleton getInstance()
{
return INSTANCE;
}
public Object getObj()
{
return obj;
}
public Object getFactoryService()
{
return new Object();
}
// 提供获取唯一实例对象的方法，通常是getInstance
// 也可以直接获取到INSTANCE，但是获取到的都是一个对象
public static final EnumSingleton INSTANCE;
private Object obj;
private static final EnumSingleton $VALUES[];
// 静态代码中实例化对象，多线程并发的情况下保证唯一，属于饿汉模式
static
{
INSTANCE = new EnumSingleton("INSTANCE", 0);
$VALUES = (new EnumSingleton[] {
INSTANCE
});
}
}
从反编译代码中我们可以看到Enum的本质：
- 枚举本质上是个final类
- 定义的枚举值实际上就是一个枚举类的不可变对象（比如这里的INSTANCE）
- 在Enum类加载的时候，就已经实例化了这个对象
- 无法通过new来创建枚举对象
Enum实现单例模式的几个关键点验证
在反编译代码中，对前三个关键点已经做了明确的保证，下面看看后面两个序列化攻击和反射攻击是如何保证的。
1.避免反射创建单例对象（反射攻击）
从反编译代码中，我们可以看到，枚举的私有构造函数如下所示：
private EnumSingleton(String s, int i)
那我们来尝试利用反射创建对象。
/**
* 反射攻击。
* 由于Enum天然的不允许反射创建实例，所以可以完美的防范反射攻击。
*/
private static void reflectionAttack() {
System.out.println("反射攻击单例对象-----------开始");
try {
Constructor con = EnumSingleton.class.getDeclaredConstructor(String.class, int.class);
con.setAccessible(true);
Object obj = con.newInstance("INSTANCE", 0); // 反射新建对象以破坏单例
System.out.println(obj);
System.out.println(EnumSingleton.getInstance());
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("反射攻击单例对象-----------结束");
}
上看的代码运行后，会抛出异常”java.lang.IllegalArgumentException: Cannot reflectively create enum objects”。如下所示：
Exception in thread "main" java.lang.IllegalArgumentException: Cannot reflectively create enum objects
at java.lang.reflect.Constructor.newInstance(Constructor.java:416)
at com.ws.pattern.singleton.EnumSingletonAppMain.reflectionAttack(EnumSingletonAppMain.java:43)
at com.ws.pattern.singleton.EnumSingletonAppMain.main(EnumSingletonAppMain.java:9)
从异常可以看出来，newInstance抛出了异常。推测Java反射是不允许创建Enum对象的，看看源码Constructor.java中的newInstance方法，存在处理Enum类型实例化的一行判断代码if ((clazz.getModifiers() & Modifier.ENUM) != 0)，满足这个条件就抛出异常。newInstance的JDK代码如下：
public T newInstance(Object ... initargs)
throws InstantiationException, IllegalAccessException,
IllegalArgumentException, InvocationTargetException
{
if (!override) {
if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
Class<?> caller = Reflection.getCallerClass();
checkAccess(caller, clazz, null, modifiers);
}
}
if ((clazz.getModifiers() & Modifier.ENUM) != 0)
throw new IllegalArgumentException("Cannot reflectively create enum objects");
ConstructorAccessor ca = constructorAccessor; // read volatile
if (ca == null) {
ca = acquireConstructorAccessor();
}
@SuppressWarnings("unchecked")
T inst = (T) ca.newInstance(initargs);
return inst;
}
原来反射机制不允许实例化Enum类型的对象，自然挡住了反射攻击。
2.避免通过序列化创建单例对象（如果单例类实现了Serializable）（序列化攻击）
序列化对象后，如果执行反序列化，也可以创建一个对象。利用此机制来尝试创建一个新的Enum对象。
/**
* 序列化攻击
* 需要在单例类中增加read
*/
private static void serializableAttack() {
System.out.println("序列化攻击单例对象-----------开始");
EnumSingleton singleton = EnumSingleton.getInstance();
System.out.println(singleton);
try {
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("./EnumSingleton.out"));
oos.writeObject(singleton);
ObjectInputStream ois = new ObjectInputStream((new FileInputStream("./EnumSingleton.out")));
Object obj = ois.readObject(); // 这里利用反序列化创建对象
System.out.println(obj);
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
System.out.println("序列化攻击单例对象-----------结束");
}
从执行结果来看，拿到了相同的对象。执行结果如下：
序列化攻击单例对象-----------开始
INSTANCE
INSTANCE
序列化攻击单例对象-----------结束
来撸代码吧，跟踪进入ois.readObject()，会进入ObjectInputStream.readObject0方法。其中会解析class的二进制，根据class的文件定义，分别解析不同类型的字段。重点关注case TC_ENUM:如下所示：
switch (tc) {
case TC_NULL:
return readNull();
case TC_REFERENCE:
return readHandle(unshared);
case TC_CLASS:
return readClass(unshared);
case TC_CLASSDESC:
case TC_PROXYCLASSDESC:
return readClassDesc(unshared);
case TC_STRING:
case TC_LONGSTRING:
return checkResolve(readString(unshared));
case TC_ARRAY:
return checkResolve(readArray(unshared));
case TC_ENUM:
return checkResolve(readEnum(unshared));
case TC_OBJECT:
return checkResolve(readOrdinaryObject(unshared));
case TC_EXCEPTION:
IOException ex = readFatalException();
throw new WriteAbortedException("writing aborted", ex);
case TC_BLOCKDATA:
case TC_BLOCKDATALONG:
if (oldMode) {
bin.setBlockDataMode(true);
bin.peek(); // force header read
throw new OptionalDataException(
bin.currentBlockRemaining());
} else {
throw new StreamCorruptedException(
"unexpected block data");
}
case TC_ENDBLOCKDATA:
if (oldMode) {
throw new OptionalDataException(true);
} else {
throw new StreamCorruptedException(
"unexpected end of block data");
}
default:
throw new StreamCorruptedException(
String.format("invalid type code: %02X", tc));
}
进入readEnum方法，重点关注Enum.valueOf方法。如下所示：
/**
* Reads in and returns enum constant, or null if enum type is
* unresolvable. Sets passHandle to enum constant's assigned handle.
*/
private Enum<?> readEnum(boolean unshared) throws IOException {
if (bin.readByte() != TC_ENUM) {
throw new InternalError();
}
ObjectStreamClass desc = readClassDesc(false);
if (!desc.isEnum()) {
throw new InvalidClassException("non-enum class: " + desc);
}
int enumHandle = handles.assign(unshared ? unsharedMarker : null);
ClassNotFoundException resolveEx = desc.getResolveException();
if (resolveEx != null) {
handles.markException(enumHandle, resolveEx);
}
String name = readString(false);
Enum<?> result = null;
Class<?> cl = desc.forClass();
if (cl != null) {
try {
@SuppressWarnings("unchecked")
Enum<?> en = Enum.valueOf((Class)cl, name); // 这里根据name和class拿到Enum实例。这里的name="INSTANCE"
result = en;
} catch (IllegalArgumentException ex) {
throw (IOException) new InvalidObjectException(
"enum constant " + name + " does not exist in " +
cl).initCause(ex);
}
if (!unshared) {
handles.setObject(enumHandle, result);
}
}
handles.finish(enumHandle);
passHandle = enumHandle;
return result;
}
再跟进Enum.valueOf方法。代码如下：
/**
* Returns the enum constant of the specified enum type with the
* specified name. The name must match exactly an identifier used
* to declare an enum constant in this type. (Extraneous whitespace
* characters are not permitted.)
*
* <p>Note that for a particular enum type {@code T}, the
* implicitly declared {@code public static T valueOf(String)}
* method on that enum may be used instead of this method to map
* from a name to the corresponding enum constant. All the
* constants of an enum type can be obtained by calling the
* implicit {@code public static T[] values()} method of that
* type.
*
* @param <T> The enum type whose constant is to be returned
* @param enumType the {@code Class} object of the enum type from which
* to return a constant
* @param name the name of the constant to return
* @return the enum constant of the specified enum type with the
* specified name
* @throws IllegalArgumentException if the specified enum type has
* no constant with the specified name, or the specified
* class object does not represent an enum type
* @throws NullPointerException if {@code enumType} or {@code name}
* is null
* @since 1.5
*/
public static <T extends Enum<T>> T valueOf(Class<T> enumType,
String name) {
// 从enumConstantDirectory()中根据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 constant " + enumType.getCanonicalName() + "." + name);
}
enumConstantDirectory()是Class的方法，其本质是从Class.java的enumConstantDirectory属性中获取。代码如下：
private volatile transient Map<String, T> enumConstantDirectory = null;
也就是说，Enum中定义的Enum成员值都被缓存在了这个Map中，Key是成员名称（比如“INSTANCE”），Value就是Enum的成员对象。这样的机制天然保证了取到的Enum对象是唯一的。即使是反序列化，也是一样的。
结论
经过上面的分析，枚举的实现天然地支持了单例模式的特点，大大降低了单例的开发难度。
