Chinaunix首页 | 论坛 | 博客
  • 博客访问: 755665
  • 博文数量: 699
  • 博客积分: 0
  • 博客等级: 民兵
  • 技术积分: 4045
  • 用 户 组: 普通用户
  • 注册时间: 2013-11-20 21:22
文章分类

全部博文(699)

文章存档

2018年(18)

2017年(74)

2016年(170)

2015年(103)

2014年(279)

2013年(55)

分类: Java

2017-03-01 13:14:16

转自:
http://m.blog.csdn.net/article/details?id=50525335


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

点击(此处)折叠或打开

  1. package com.effective.singleton;

  2. public class Elvis
  3. {
  4.     private static boolean flag = false;

  5.     private Elvis(){
  6.     }

  7.     private static class SingletonHolder{
  8.         private static final Elvis INSTANCE = new Elvis();
  9.     }

  10.     public static Elvis getInstance()
  11.     {
  12.         return SingletonHolder.INSTANCE;
  13.     }

  14.     public void doSomethingElse()
  15.     {

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

点击(此处)折叠或打开

  1. package com.effective.singleton;

  2. import java.lang.reflect.Constructor;
  3. import java.lang.reflect.InvocationTargetException;

  4. public class ElvisReflectAttack
  5. {

  6.     public static void main(String[] args) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException
  7.     {
  8.         Class<?> classType = Elvis.class;

  9.         Constructor<?> c = classType.getDeclaredConstructor(null);
  10.         c.setAccessible(true);
  11.         Elvis e1 = (Elvis)c.newInstance();
  12.         Elvis e2 = Elvis.getInstance();
  13.         System.out.println(e1==e2);
  14.     }

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

点击(此处)折叠或打开

  1. private ElvisModified(){
  2.         synchronized(ElvisModified.class)
  3.         {
  4.             if(flag == false)
  5.             {
  6.                 flag = !flag;
  7.             }
  8.             else
  9.             {
  10.                 throw new RuntimeException("单例模式被侵犯!");
  11.             }
  12.         }
  13.     }

  14.     private static class SingletonHolder{
  15.         private static final ElvisModified INSTANCE = new ElvisModified();
  16.     }

  17.     public static ElvisModified getInstance()
  18.     {
  19.         return SingletonHolder.INSTANCE;
  20.     }

  21.     public void doSomethingElse()
  22.     {

  23.     }
  24. }
测试代码:

点击(此处)折叠或打开

  1. package com.effective.singleton;

  2. import java.lang.reflect.Constructor;

  3. public class ElvisModifiedReflectAttack
  4. {

  5.     public static void main(String[] args)
  6.     {
  7.         try
  8.         {
  9.             Class<ElvisModified> classType = ElvisModified.class;

  10.             Constructor<ElvisModified> c = classType.getDeclaredConstructor(null);
  11.             c.setAccessible(true);
  12.             ElvisModified e1 = (ElvisModified)c.newInstance();
  13.             ElvisModified e2 = ElvisModified.getInstance();
  14.             System.out.println(e1==e2);
  15.         }
  16.         catch (Exception e)
  17.         {
  18.             e.printStackTrace();
  19.         }
  20.     }
  21. }
结果:

点击(此处)折叠或打开

  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还有新的写法,只需编写一个包含单个元素的枚举类型。推荐写法:

点击(此处)折叠或打开

  1. package com.effective.singleton;

  2. public enum SingletonClass
  3. {
  4.     INSTANCE;

  5.     public void test()
  6.     {
  7.         System.out.println("The Test!");
  8.     }
  9. }
测试代码:

点击(此处)折叠或打开

  1. package com.effective;

  2. import java.lang.reflect.Constructor;
  3. import java.lang.reflect.InvocationTargetException;

  4. import com.effective.singleton.SingletonClass;

  5. public class TestMain
  6. {

  7.     public static void main(String[] args) throws NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException
  8.     {
  9.         Class<SingletonClass> classType = SingletonClass.class;
  10.         Constructor<SingletonClass> c = (Constructor<SingletonClass>) classType.getDeclaredConstructor();
  11.         c.setAccessible(true);
  12.         c.newInstance();
  13.     }
  14. }
运行结果:

点击(此处)折叠或打开

  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模式的最佳方法。










阅读(1231) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
评论热议
请登录后评论。

登录 注册