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);

    }

}

上面這個程式碼的執行結果:
[email protected]
[email protected]
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);

    }

}

這段程式碼執行結果：
[email protected]
[email protected]
false

可以看到還是破壞了單例。
先寫到這裡，後面看有補充的繼續補充
國際慣例加上群連結：個人淺薄理解，歡迎補充
點選連結加入群聊【Java技術學習閒聊群】：https://jq.qq.com/?_wv=1027&k=59emCBA