单例模式下防止攻击(反射攻击)

这几天看了几篇java的单例模式，以前也看过很多java单例的创建什么的，也知道怎么创建这些单例，比如懒汉啊、饿汉啊、枚举啊什么的，但是一直就是不明白为什么单例就是安全的，为什么懒汉和饿汉就没有枚举安全？

直到这几天看点儿多线程的东西才发现，多线程里面要求全局变量是固定的，不可变得（为什么？）。举个例子：买票的时候，有三个窗口，同时去卖票。这三个窗口的售票员都要从统一的地方去取票，这统一的地方其实就是对应了我们的全局变量（比如有个静态变量10，有一个方法取这个变量数子，然后做了减一的操作以后再放回到静态变量里面，结果静态变量就变成了9，其他的方法以此类推，一个方法一个方法的取，直到最后取完，很安心）。

为什么要举一个多线程的例子呢？因为我们单例模式的情况下会用到这玩意，单例模式为什么安全，因为单例模式只有一个入口，我们通常写一个类，然后用其他的类调用的时候会在内存里面新建一块内存，也就是new，这个内存也就对应一个地址；相应的我们再new一个名字不一样的相同的类，它会在内存里面再开辟一个新的内存，也就对应了一个新的地址。然后我们看代码：

        TestClass testing = new TestClass();
 
        TestClass tesing = new TestClass();
        
        System.out.println(":"+testing);
        System.out.println(":"+tesing);

下面是输出的结果：

:enumtest.TestClass@117f31e
:enumtest.TestClass@15a6029

看到没有，这是两个地址了，那我要是想用这个类整个全局变量的话(那肯定不行啊，一个人取这个地址，其他人取的是其他的地址了，取的都不知道是啥，这个还整个毛线啊)，所以现在就出现了转机：单例模式，单例的出现拯救了这个类，让它可以被大家所用，具体是怎么用的嘞，请看下面的代码：

public class TestSingleton { 

//这个是先定一个全局的初始化
    public static TestSingleton test = null;   
    private TestSingleton(){}

//实现单例的创建，如果为空就创建
    public static TestSingleton getInstance(){
        if(test == null) {
            test = new TestSingleton();
        }
        return test;
    }
}

上面创建了一个单例，然后我们调用一下这个单例，看一下它有什么优点：

public class SingleTonTest {

    public static void main(String args[]) throws NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException{
        TestSingleton t = TestSingleton.getInstance();
        
        TestSingleton tee = TestSingleton.getInstance();
        
        System.out.println("輸出來的地址是："+t);
        System.out.println("輸出來的地址是: "+ tee);
        System.out.println("看一下對比："+(t == tee));
       
    }
    
}

看一下结果：

輸出來的地址是：enumtest.TestSingleton@1d7fbfb
輸出來的地址是: enumtest.TestSingleton@1d7fbfb
看一下對比：true

通过对比发现，从单例模式new出来的地址都是一样样的，这就是单例的好处了，用它做静态变量就比较让人放心了。

但是！！！ java有个反射模式，我们看一下这个模式的定义：

反射是Java的特征之一，是一种间接操作目标对象的机制，核心是JVM在运行的时候才动态加载类，并且对于任意一个类，都能够知道这个类的所有属性和方法，调用方法/访问属性，不需要提前在编译期知道运行的对象是谁，他允许运行中的Java程序获取类的信息，并且可以操作类或对象内部属性。程序中对象的类型一般都是在编译期就确定下来的，而当我们的程序在运行时，可能需要动态的加载一些类，这些类因为之前用不到，所以没有加载到jvm，这时，使用Java反射机制可以在运行期动态的创建对象并调用其属性，它是在运行时根据需要才加载。

可以看到这个反射就是一个暴力破解器啊，可以强制的获取其他的类的所有的信息，私有类也不放过，太过分了，不过没办法，反射也有反射的好处，这里就不讲了。下面贴一个通过反射获取单例的代码：

public class SingleTonTest {

    public static void main(String args[]) throws NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException{

   
        Constructor<TestSingleton> construcetor = TestSingleton.class.getDeclaredConstructor();
        
        construcetor.setAccessible(true);
        
        TestSingleton test = construcetor.newInstance();
        
        TestSingleton te = construcetor.newInstance();
        
        System.out.println("輸出來的地址是："+test);
        System.out.println("輸出來的地址是："+te);
        System.out.println("new出來的一樣不:"+(test==te));
    } 
}

看一下结果：

輸出來的地址是：enumtest.TestSingleton@1d7fbfb
輸出來的地址是：enumtest.TestSingleton@e020c9
new出來的一樣不:false

咋样，看出来了吧，看不出来就上去再看几遍。结果是不一样的，说明反射暴力破解了单例模式，new出了新天地，这种单例不安全啊。所以就出了枚举单例模式，贴代码：

public enum TestEnum {
    
    INSTANCE;
    
    public void test(){
        System.out.println("這個枚舉單例模式");
    }

}

上面是典型的枚举单例模式，看一下调用代码：

public class SingleTonTest {
    public static void main(String args[]) throws NoSuchMethodException, SecurityException, InstantiationException, IegalAccessException, IllegalArgumentException, InvocationTargetException{
       Constructor<TestEnum> construcetor = TestEnum.class.getDeclaredConstructor();
      
       construcetor.setAccessible(true);
      
       construcetor.newInstance();   
   }  
}

看一下结果：

Exception in thread "main" java.lang.NoSuchMethodException: enumtest.TestEnum.<init>()
    at java.lang.Class.getConstructor0(Unknown Source)
    at java.lang.Class.getDeclaredConstructor(Unknown Source)
    at enumtest.SingleTonTest.main(SingleTonTest.java:36)

报错了，，，所以说枚举是安全的单例，java反射没法暴力破解枚举的单例模式。

还有一种安全的单例模式的写法，就是在单例模式里面加一个判断实例是否为空，这样就可以避免反射的暴力，贴代码：

public class TestSingleton {
    private TestSingleton(){
        if(null != InnerClass.instance) {
            throw new RuntimeException("有了就不要創建了");
        }
    }
    
    private static class InnerClass{
        private static TestSingleton instance=new TestSingleton();
    }
    
    public static TestSingleton getInstance(){
        return InnerClass.instance;
    }
    
    private Object readResolve()
    {
        return InnerClass.instance;
    }
}

看一下调用代码：

public class SingleTonTest {

    public static void main(String args[]) throws NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException{
        Constructor<TestSingleton> construcetor = TestSingleton.class.getDeclaredConstructor();
        
        construcetor.setAccessible(true);
        
        TestSingleton test = construcetor.newInstance();
        
        TestSingleton te = TestSingleton.getInstance();
        
        System.out.println("輸出來的地址是："+test);
        System.out.println("輸出來的地址是："+te);
        System.out.println("new出來的一樣不:"+(test==te));
    }
}

看一下结果：

Exception in thread "main" java.lang.reflect.InvocationTargetException
    at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
    at sun.reflect.NativeConstructorAccessorImpl.newInstance(Unknown Source)
    at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(Unknown Source)
    at java.lang.reflect.Constructor.newInstance(Unknown Source)
    at enumtest.SingleTonTest.main(SingleTonTest.java:28)
Caused by: java.lang.RuntimeException: 有了就不要創建了
    at enumtest.TestSingleton.<init>(TestSingleton.java:8)
    ... 5 more

报错了，反射是没法进去创建新的实例的。