| 为什么说Enum实现单例模式是最佳实践 | 您所在的位置：网站首页 › enum实现单例 › 为什么说Enum实现单例模式是最佳实践 |
|
目录 内容概要 实现单例模式的几个关键点 利用Enum实现单例模式 实现代码 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.) * * 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 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 valueOf(Class 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 enumConstantDirectory = null; 也就是说，Enum中定义的Enum成员值都被缓存在了这个Map中，Key是成员名称（比如“INSTANCE”），Value就是Enum的成员对象。这样的机制天然保证了取到的Enum对象是唯一的。即使是反序列化，也是一样的。 结论经过上面的分析，枚举的实现天然地支持了单例模式的特点，大大降低了单例的开发难度。 |
| CopyRight 2018-2019 实验室设备网 版权所有 |