如何防止单例模式被JAVA反射攻击

 单例模式相信大家都知道，用过的人不在少数。之前写过一篇博文《singleton模式四种线程安全的实现》（参见：http://blog.csdn.net/u013256816/article/details/50427061），讲诉了单例模式的四种写法，并指出占位符模式的写法比较ok，详见如下：

[java]  view plain  copy

1. package com.effective.singleton;  
2.   
3. public class Elvis  
4. {  
5.     private static boolean flag = false;  
6.   
7.     private Elvis(){  
8.     }  
9.   
10.     private  static class SingletonHolder{  
11.         private static final Elvis INSTANCE = new Elvis();  
12.     }  
13.   
14.     public static Elvis getInstance()  
15.     {  
16.         return SingletonHolder.INSTANCE;  
17.     }  
18.   
19.     public void doSomethingElse()  
20.     {  
21.   
22.     }  
23. }  

    但这都是基于一个条件：确保不会通过反射机制调用私有的构造器。
    这里举个例子，通过JAVA的反射机制来“攻击”单例模式：

[java]  view plain  copy

1. package com.effective.singleton;  
2.   
3. import java.lang.reflect.Constructor;  
4. import java.lang.reflect.InvocationTargetException;  
5.   
6. public class ElvisReflectAttack  
7. {  
8.   
9.     public static void main(String[] args) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException  
10.     {  
11.         Class<?> classType = Elvis.class;  
12.   
13.         Constructor<?> c = classType.getDeclaredConstructor(null);  
14.         c.setAccessible(true);  
15.         Elvis e1 = (Elvis)c.newInstance();  
16.         Elvis e2 = Elvis.getInstance();  
17.         System.out.println(e1==e2);  
18.     }  
19.   
20. }  

   运行结果：false
   可以看到，通过反射获取构造函数，然后调用setAccessible(true)就可以调用私有的构造函数，所有e1和e2是两个不同的对象。
   如果要抵御这种攻击，可以修改构造器，让它在被要求创建第二个实例的时候抛出异常。
   经修改后：

[java]  view plain  copy

1. package com.effective.singleton;  
2.   
3. public class ElvisModified  
4. {  
5.     private static boolean flag = false;  
6.   
7.     private ElvisModified(){  
8.         synchronized(ElvisModified.class)  
9.         {  
10.             if(flag == false)  
11.             {  
12.                 flag = !flag;  
13.             }  
14.             else  
15.             {  
16.                 throw new RuntimeException("单例模式被侵犯！");  
17.             }  
18.         }  
19.     }  
20.   
21.     private  static class SingletonHolder{  
22.         private static final ElvisModified INSTANCE = new ElvisModified();  
23.     }  
24.   
25.     public static ElvisModified getInstance()  
26.     {  
27.         return SingletonHolder.INSTANCE;  
28.     }  
29.   
30.     public void doSomethingElse()  
31.     {  
32.   
33.     }  
34. }  

    测试代码：

[java]  view plain  copy

1. package com.effective.singleton;  
2.   
3. import java.lang.reflect.Constructor;  
4.   
5. public class ElvisModifiedReflectAttack  
6. {  
7.   
8.     public static void main(String[] args)  
9.     {  
10.         try  
11.         {  
12.             Class<ElvisModified> classType = ElvisModified.class;  
13.   
14.             Constructor<ElvisModified> c = classType.getDeclaredConstructor(null);  
15.             c.setAccessible(true);  
16.             ElvisModified e1 = (ElvisModified)c.newInstance();  
17.             ElvisModified e2 = ElvisModified.getInstance();  
18.             System.out.println(e1==e2);  
19.         }  
20.         catch (Exception e)  
21.         {  
22.             e.printStackTrace();  
23.         }  
24.     }  
25. }  

    运行结果：

[plain]  view plain  copy

1. Exception in thread "main" java.lang.ExceptionInInitializerError  
2.     at com.effective.singleton.ElvisModified.getInstance(ElvisModified.java:27)  
3.     at com.effective.singleton.ElvisModifiedReflectAttack.main(ElvisModifiedReflectAttack.java:17)  
4. Caused by: java.lang.RuntimeException: 单例模式被侵犯！  
5.     at com.effective.singleton.ElvisModified.<init>(ElvisModified.java:16)  
6.     at com.effective.singleton.ElvisModified.<init>(ElvisModified.java:7)  
7.     at com.effective.singleton.ElvisModified$SingletonHolder.<clinit>(ElvisModified.java:22)  
8.     ... 2 more  

    可以看到，成功的阻止了单例模式被破坏。
    从JDK1.5开始，实现Singleton还有新的写法，只需编写一个包含单个元素的枚举类型。推荐写法：

[java]  view plain  copy

1. package com.effective.singleton;  
2.   
3. public enum SingletonClass  
4. {  
5.     INSTANCE;  
6.   
7.     public void test()  
8.     {  
9.         System.out.println("The Test!");  
10.     }  
11. }  

    测试代码：

[java]  view plain  copy

1. package com.effective;  
2.   
3. import java.lang.reflect.Constructor;  
4. import java.lang.reflect.InvocationTargetException;  
5.   
6. import com.effective.singleton.SingletonClass;  
7.   
8. public class TestMain  
9. {  
10.   
11.     public static void main(String[] args) throws NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException  
12.     {  
13.         Class<SingletonClass> classType = SingletonClass.class;  
14.         Constructor<SingletonClass> c = (Constructor<SingletonClass>) classType.getDeclaredConstructor();  
15.         c.setAccessible(true);  
16.         c.newInstance();  
17.     }  
18. }  

    运行结果：

[plain]  view plain  copy

1. Exception in thread "main" java.lang.NoSuchMethodException: com.effective.singleton.SingletonClass.<init>()  
2.     at java.lang.Class.getConstructor0(Unknown Source)  
3.     at java.lang.Class.getDeclaredConstructor(Unknown Source)  
4.     at com.effective.TestMain.main(TestMain.java:22)  

    由此可见这种写法也可以防止单例模式被“攻击”。
    而且这种写法也可以防止序列化破坏单例模式，具体不在举例了，有关序列化以及单例模式被序列化破坏可以参考博文《JAVA序列化》（链接：http://blog.csdn.net/u013256816/article/details/50474678）。
    单元素的枚举类型已经成为实现Singleton模式的最佳方法。