在我的上篇随笔中，我们知道了创建单例类有以下几种方式：
(1).饿汉式;
(2).懒汉式(、加同步锁的懒汉式、加双重校验锁的懒汉式、防止指令重排优化的懒汉式);
(3).登记式单例模式;
(4).静态内部类单例模式;
(5).枚举类型的单例模式。
在上面的5种实现方式中，除了枚举类型外，其他的实现方式是可以被JAVA的反射机制给攻击的，即使他的构造方法是私有化的，我们也可以做一下处理，从外部得到它的实例。
下面，我将会举例来说明：
说明：
Singleton.java 没有经过处理的饿汉式单例模式实现方式
Singleton6.java 枚举类型的单例模式
SingletonNotAttackByReflect.java 经过处理的饿汉式单例模式实现方式
SingletonReflectAttack.java 具体反射类
SingletonReflectAttackMain.java JUnit测试类
举例1：不经过处理的单例类被JAVA反射机制攻击
Singleton.java 代码清单【1.1】
public class Singleton
{
private static boolean flag = true;
private static final Singleton INSTANCE = new Singleton(); private Singleton()
{
} public static Singleton newInstance()
{
return INSTANCE;
} }
SingletonReflectAttack.java 代码清单【1.2】
/**
* 单例模式被java反射攻击
* @throws IllegalArgumentException
* @throws InstantiationException
* @throws IllegalAccessException
* @throws InvocationTargetException
* @throws SecurityException
* @throws NoSuchMethodException
*/ public static void attack() throws IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException, SecurityException, NoSuchMethodException
{
Class<?> classType = Singleton.class;
Constructor<?> constructor = classType.getDeclaredConstructor(null);
constructor.setAccessible(true);
Singleton singleton = (Singleton) constructor.newInstance();
Singleton singleton2 = Singleton.newInstance();
System.out.println(singleton == singleton2); //false
}
测试结果：SingletonReflectAttackMain.java 代码清单【1.3】
/**
* 1.测试单例模式被java反射攻击
* @throws NoSuchMethodException
* @throws InvocationTargetException
* @throws IllegalAccessException
* @throws InstantiationException
* @throws SecurityException
* @throws IllegalArgumentException
*/
@Test
public void testSingletonReflectAttack() throws IllegalArgumentException, SecurityException, InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchMethodException
{
System.out.println("-------------单例模式被java反射攻击测试--------------");
SingletonReflectAttack.attack();
System.out.println("--------------------------------------------------");
}
运行结果：
返回结果为false，说明创建了两个不同的实例。通过反射获取构造函数，然后调用setAccessible(true)就可以调用私有的构造函数；所以创建出来的两个实例时不同的对象。
如果要抵御这种攻击，就要修改构造器，让他在被要求创建第二个实例的时候抛出异常。
下面，我们对饿汉式单例模式做修改。
举例2.经过处理的单例类，JAVA反射机制攻击测试
SingletonNotAttackByReflect.java 代码清单【2.1】
package com.lxf.singleton; import javax.management.RuntimeErrorException; public class SingletonNotAttackByReflect
{
private static boolean flag = false;
private static final SingletonNotAttackByReflect INSTANCE = new SingletonNotAttackByReflect(); //保证其不被java反射攻击
private SingletonNotAttackByReflect()
{
synchronized (SingletonNotAttackByReflect.class)
{
if(false == flag)
{
flag = !flag;
}
else
{
throw new RuntimeException("单例模式正在被攻击");
} }
} public static SingletonNotAttackByReflect getInstance()
{
return INSTANCE;
} }
SingletonReflectAttack.java 代码清单【2.2】
public static void modifiedByAttack()
{
try
{
Class<SingletonNotAttackByReflect> classType = SingletonNotAttackByReflect.class;
Constructor<SingletonNotAttackByReflect> constructor = classType.getDeclaredConstructor(null);
constructor.setAccessible(true);
SingletonNotAttackByReflect singleton = (SingletonNotAttackByReflect) constructor.newInstance();
SingletonNotAttackByReflect singleton2 = SingletonNotAttackByReflect.getInstance(); System.out.println(singleton == singleton2);
}
catch (Exception e)
{
e.printStackTrace();
} }
SingletonReflectAttackMain.java 代码清单【2.3】
/**
* 2.修改后的单例模式被java反射攻击测试.
* 攻击失败
* @throws IllegalArgumentException
* @throws SecurityException
* @throws InstantiationException
* @throws IllegalAccessException
* @throws InvocationTargetException
* @throws NoSuchMethodException
*/ @Test
public void testModifiedByattack() throws IllegalArgumentException, SecurityException, InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchMethodException
{
System.out.println("-------------修改后的单例模式被java反射攻击测试--------------");
SingletonReflectAttack.modifiedByAttack();
System.out.println("----------------------------------------------------------");
}
运行结果：
在之前，我们也介绍过，枚举类型的单例模式也可以防止被JAVA反射攻击，这里我们简单测试一下。
举例3：枚举类型的单例模式被JAVA反射机制攻击测试
Singleton6.java 代码清单【3.1】
public enum Singleton6
{
INSTANCE; private Resource instance; Singleton6()
{
instance = new Resource();
} public Resource getInstance()
{
return instance;
} }
SingletonReflectAttack.java 代码清单【3.2】
public static void enumAttack() throws SecurityException, NoSuchMethodException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException
{
try
{
Class<Singleton6> classType = Singleton6.class;
Constructor<Singleton6> constructor =(Constructor<Singleton6>) classType.getDeclaredConstructor();
constructor.setAccessible(true);
constructor.newInstance(); }
catch (Exception e)
{
e.printStackTrace();
}
SingletonReflectAttackMain.java 代码清单【3.3】
/**
* 枚举类型的单例模式被java反射攻击测试
* 攻击失败
*
* @throws IllegalArgumentException
* @throws SecurityException
* @throws InstantiationException
* @throws IllegalAccessException
* @throws InvocationTargetException
* @throws NoSuchMethodException
*/ @Test
public void testenumAttack() throws IllegalArgumentException, SecurityException, InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchMethodException
{
System.out.println("-------------枚举类型的单例模式被java反射攻击测试--------------");
SingletonReflectAttack.enumAttack();
System.out.println("----------------------------------------------------------");
}
运行结果：
4.总结与拓展
所以，在项目开发中，我们要根据实际情况，选择最安全的单例模式实现方式。