之前写过几篇单例的文章：
在静态内部类中引出了反射攻击的问题，本篇就来说一下反射攻击，废话不多少说上代码：
import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; public class Test1 { public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException { Class objClass = StaticInnerClass.class; //获取类的构造器 Constructor constructor = objClass.getDeclaredConstructor(); //把构造器私有权限放开 constructor.setAccessible(true); //正常的获取实例方式 StaticInnerClass staticInnerClass = StaticInnerClass.getInstance(); //反射创建实例 StaticInnerClass newStaticInnerClass = (StaticInnerClass) constructor.newInstance(); System.out.println(staticInnerClass); System.out.println(newStaticInnerClass); System.out.println(staticInnerClass == newStaticInnerClass); } }
上面这个代码的运行结果:
com.ygz.designpatterns.singleton.StaticInnerClass@4d7e1886
com.ygz.designpatterns.singleton.StaticInnerClass@3cd1a2f1
false
出现了两个不同的实例，这就违反了我们使用单例原则，不能保证只有一个实例，那么如何解决呢？还是直接上代码：
public class StaticInnerClass { private static class InnerClass{ private static StaticInnerClass staticInnerClass = new StaticInnerClass(); } public static StaticInnerClass getInstance(){ return InnerClass.staticInnerClass; } private StaticInnerClass(){ //构造器判断，防止反射攻击，大家可以在下面这行if判断打断点来测试一下这个方法的过程，很好理解的 if(InnerClass.staticInnerClass != null){ throw new IllegalStateException(); } } }
这样写就可以防止反射攻击啦，这种方式同样适用于其他的饿汉模式防御反射攻击。但是如果不是在类加载的时候创建对象实例的这种单例，是没有办法防止反射攻击的，比如之前写过的那个双重锁校验，使用这种在构造器判断方式是无效的，来段代码证明一下，先上双重锁校验的构造器判断方式代码：
import java.io.Serializable; /** * 双重锁校验的单例 */ public class DoubleLock implements Serializable { public static volatile DoubleLock doubleLock = null;//volatile防止指令重排序，内存可见(缓存中的变化及时刷到主存，并且其他的内存失效，必须从主存获取) private DoubleLock(){ //构造器必须私有 不然直接new就可以创建 //构造器判断，防止反射攻击 if(doubleLock != null){ throw new IllegalStateException(); } } public static DoubleLock getInstance(){ if(doubleLock == null){ synchronized (DoubleLock.class){ if(doubleLock == null){ doubleLock = new DoubleLock(); } } } return doubleLock; } private Object readResolve(){ return doubleLock; } }
这段代码其他注释就不写了，感兴趣的可以直接去看文章开头的几篇博客。从这段代码可以看到我们采用同样的方式防止反射攻击，接下来我们测试一下他是不是可以防止反射攻击：
public class Test1 { public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException { Class objClass = DoubleLock.class; //获取类的构造器 Constructor constructor = objClass.getDeclaredConstructor(); //把构造器私有权限放开 constructor.setAccessible(true); //反射创建实例 注意反射创建要放在前面，才会攻击成功，因为如果反射攻击在后面，先使用正常的方式创建实例的话，在构造器中判断是可以防止反射攻击、抛出异常的， //因为先使用正常的方式已经创建了实例，会进入if DoubleLock o1= (DoubleLock) constructor.newInstance(); //正常的获取实例方式 正常的方式放在反射创建实例后面，这样当反射创建成功后，单例对象中的引用其实还是空的，反射攻击才能成功 DoubleLock o2= DoubleLock.getInstance(); System.out.println(o2); System.out.println(o1); System.out.println(o1 == o2); } }
上面是测试代码，注意这段代码中要先进行反射创建实例，再进行正常的getInstance()创建实例，才能攻击成功，如果先getInstance()再反射创建，构造器中的判断是可以防止的，原因注释里面也有写，就不重复了。
还有一种尝试解决这种反射攻击的是：在单例里面加标识属性，如果实例化之后，标识改变，在构造器里面判断标识改变就抛异常，和上面这种气势差不多，但是没用的，反射可以把构造器的权限放开，同样可以把属性的权限放开，并且修改属性值，所以这种方式也是不行的，我还是写一下这个代码吧，方便大家理解，首先上加了标识属性的单例：
import java.io.Serializable; /** * 双重锁校验的单例 */ public class DoubleLock implements Serializable { public static volatile DoubleLock doubleLock = null;//volatile防止指令重排序，内存可见(缓存中的变化及时刷到主存，并且其他的内存失效，必须从主存获取) private static boolean flag = true; //设置标识属性 private DoubleLock(){ if(flag){ //初始为true，进入构造器正常创建对象，然后把flag的值改成false，后面的就会抛异常 flag = false; }else{ throw new IllegalStateException(); } } public static DoubleLock getInstance(){ if(doubleLock == null){ synchronized (DoubleLock.class){ if(doubleLock == null){ doubleLock = new DoubleLock(); } } } return doubleLock; } private Object readResolve(){ return doubleLock; } }
这段代码中加了一个flag属性用来标识是否已经创建了实例，接下来我们来通过反射破坏这个单例：
import java.lang.reflect.Constructor; import java.lang.reflect.Field; public class Test1 { public static void main(String[] args) throws Exception { Class objClass = DoubleLock.class; Constructor constructor = objClass.getDeclaredConstructor(); //构造器权限 constructor.setAccessible(true); //正常获取实例 DoubleLock o1 = DoubleLock.getInstance(); //获取到这个实例的flag属性 Field flag = o1.getClass().getDeclaredField("flag"); //属性权限放开 flag.setAccessible(true); //属性值改为true flag.set(o1, true); DoubleLock o2 = (DoubleLock) constructor.newInstance(); System.out.println(o1); System.out.println(o2); System.out.println(o1 == o2); } }
这段代码运行结果：
com.ygz.designpatterns.singleton.DoubleLock@2f0e140b
com.ygz.designpatterns.singleton.DoubleLock@7440e464
false
可以看到还是破坏了单例。
先写到这里，后面看有补充的继续补充
个人浅薄理解，欢迎补充
