通过枚举实现单例模式

枚举类实现单例模式的优点

对于饿汉式单例模式和懒汉式单例模式了解的同学，使用以上两种单例模式，我们均可以通过反射的方式破坏单例模式的特性。那么，如何才能避免程序开发中使用反射的方式破坏单例的这种行为呢？接下来用过枚举的方式来创建的单例模式就可以避免上述的问题。

直接上代码:

public enum EnumSingleton {
    INSTANCE;
    //枚举类可以自定义一些属性
    private Object data;

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }
}

获取EnumSingleton 单例对象

   public static void main(String[] args) {
       // instance为单例
        EnumSingleton instance = EnumSingleton.INSTANCE;  
}

尝试通过反射破坏单例

我们尝试使用反射的方式创建实例，看是否能够创建成功:

public class EnumSingletonTest {
    public static void main(String[] args) {
        EnumSingleton enumSingleton=EnumSingleton.getInstance();
        enumSingleton.setData(new Object());
        System.out.println("创建单例模式:"+enumSingleton);
        try{
            Class clazz= EnumSingleton.class;
            Constructor c=clazz.getDeclaredConstructor(String.class,int.class);
            c.setAccessible(true);
            Object object=c.newInstance();
            System.out.println(object);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

会出现以下报错:

java.lang.IllegalArgumentException: Cannot reflectively create enum objects
    at java.lang.reflect.Constructor.newInstance(Constructor.java:417)
    at com.example.singleton.EnumSingletonTest.main(EnumSingletonTest.java:16)

我们直接定位到报错源码的位置(Constructor.java:417)发现如下内容：

    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");

也就是说，在通过反射调用方法newInstance()创建实例时，源码会对class的修饰符做一个判断(clazz.getModifiers() & Modifier.ENUM) != 0)。如果创建实例的类是用enum修饰的，那么不能通过反射创建实例（Cannot reflectively create enum objects）
————————————————

版权声明：本文为CSDN博主「沐谦」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/jl19960421/article/details/115036490

---

深入了解 enum

首先给出文章的结论：

• 枚举是类类型
• 每个枚举常量都是所属枚举类的对象
• 枚举类在加载完成后，无法再进行实例化操作
• 枚举是线程安全的

java 中的枚举在实现上非常简单，以下就是一个枚举的例子：

public enum FruitEnum {
    APPLE
}

但是如果反编译 FruitEnum.class，会发现编译器在背后默默的做了大量的工作，以下是反编译结果：

public final class FruitEnum extends Enum {
    public  static final FruitEnum APPLE;
    private static final FruitEnum $VALUES[];

    private FruitEnum(String s, int i) {
        super(s, i);
    }
  
    public static FruitEnum[] values() {
        return (FruitEnum[])$VALUES.clone();
    }

    public static FruitEnum valueOf(String name) {
        return (FruitEnum)Enum.valueOf(FruitEnum, name);
    }
  
    static {
        APPLE = new FruitEnum("APPLE", 0);
        $VALUES = (new FruitEnum[] {
            APPLE
        });
    }
}

下面根据反编译结果说明枚举的几个特性。

• 枚举的实际类型

public final class FruitEnum extends Enum

说明枚举是类，并且是用 final 修饰的类，意味着枚举不能再被继承扩展。而我们声明枚举类时使用的 enum 只是一个关键字。

其次，所有的枚举都继承了一个基类 Enum ，该基类为枚举提供了一些通用方法。

• 枚举的构造函数

在 FruitEnum 中，我们并没有定义构造函数，但在反编译的代码中，我们发现编译器自动帮我们添加了以下私有构造函数：

private FruitEnum(String s, int i) {
    super(s, i);
}

该私有构造函数只是简单调用了父类 Enum 的构造函数：

protected Enum(String name, int ordinal) {
    this.name = name;       // 枚举常量的名称
    this.ordinal = ordinal; // 枚举常量在枚举类的位置，从0开始
}

实际上，编译器只允许私有的枚举类构造函数，并且显示定义的枚举构造函数经编译器后，都会被添加 name 和 ordinal 2个参数，用以调用父类 Enum 的构造函数。

• 枚举常量

再看反编译后的 FruitEnum 中的成员变量：

public  static final FruitEnum APPLE;
private static final FruitEnum $VALUES[];

其中 FruitEnum APPLE 对应我们定义的枚举常量 APPLE，而 FruitEnum $VALUES[] 则是容纳所有枚举常量的数组。

这两个变量初始化操作如下：

static {
    APPLE = new FruitEnum("APPLE", 0);
    $VALUES = (new FruitEnum[] { APPLE });
}

可知，每个枚举常量都是定义它的类的对象，各枚举对象都是用 public static final 修饰的，这也是枚举对象被称为枚举常量的原因。

其次，FruitEnum APPLE 和 FruitEnum $VALUES[] 都是在静态代码块中进行初始化，因此在 JVM 记载完成枚举类后，各枚举常量都已被

创建完毕。由于枚举类中只允许出现私有构造函数，固无法再实例化新的枚举对象。

枚举类实例化

无法通过构造函数这种一般手段实例化枚举类，那么通过反射呢？

先尝试以下形式：

Class<FruitEnum> fruitEnumClazz = FruitEnum.class;
FruitEnum fruitDemo1 = fruitEnumClazz.newInstance();

抛出了以下错误：

因为 Class.newInstance 内部是通过目标Class的 无参构造函数 创建实例的，而上文已经说了 FruitEnum 的实构造函数是：

private FruitEnum(String s, int i) {
    super(s, i);
}

固会找不到对应的构造函数，抛出异常。

换种反射方式，先获取正确的构造函数：

// 获取 FruitEnum 的构造函数
Constructor<FruitEnum> fruitEnumConstructor = fruitEnumClazz.getDeclaredConstructor(String.class, int.class);
// 获取访问权限
fruitEnumConstructor.setAccessible(true);
// 实例化
FruitEnum fruitDemo2 = fruitEnumConstructor.newInstance();

成功获取了 FruitEnum 的构造函数，然而还是抛出了异常：

在 JVM 层面禁止了通过反射构造枚举实例的行为。

然而除了反射外，还可以通过 Object.clone() 方法克隆一个已存在的对象。但是这种方式也是不行的，看 Enum 类中的 clone() 方法：

protected final Object clone() throws CloneNotSupportedException {
    throw new CloneNotSupportedException();
}

Enum 类重写了 Obejct 的 clone()方法，只要尝试通过 clone() 方法构造枚举对象，都会抛出异常，并且该方法被设置为不能再重写。

• 单例

从编译器、JVM，再到 java 内部设计，层层把关，封死了实例化枚举类的这一企图。因此有一种作法是通过枚举的形式实现单例，下面给个示例：

public class EnumSingleton{
    private EnumSingleton() {
      
    }
  
    public static EnumSingleton getInstance(){
        return Singleton.INSTANCE.getInstance();
    }
    
    private static enum Singleton {
        INSTANCE;
        
        private EnumSingleton singleton;
        
        // JVM 保证了此方法绝对只调用一次
        private Singleton(){
            singleton = new EnumSingleton();
        }
        
        public EnumSingleton getInstance(){
            return singleton;
        }
    }
}

• 线程安全

枚举常量都是 static 类型的，在枚举类加载完成后，会进行枚举常量的初始化，之后枚举类无法再实例化和修改。java 的类加载、初始化过程是线程安全的，因此创建一个 enum 是线程安全的。

作者：EricAlpha
链接：https://www.jianshu.com/p/ec811fc70b08
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。