之前写过几篇单例的文章：
Java单例—双重锁校验详解
Java单例—序列化破坏单例模式原理解析
Java单例—静态内部类
在静态内部类中引出了反射攻击的问题，本篇就来说一下反射攻击，废话不多少说上代码：
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
可以看到还是破坏了单例。
先写到这里，后面看有补充的继续补充
个人浅薄理解，欢迎补充
