如何防止單例模式被JAVA反射攻擊

單例模式相信你們都知道，用過的人不在少數。以前寫過一篇博文《singleton模式四種線程安全的實現》（參見：http://blog.csdn.NET/u013256816/article/details/50427061），講訴了單例模式的四種寫法，並指出佔位符模式的寫法比較ok，詳見以下：

package com.effective.singleton;  
 
public class Elvis  
{  
    private static boolean flag = false;  
 
    private Elvis(){  
    }  
 
    private  static class SingletonHolder{  
        private static final Elvis INSTANCE = new Elvis();  
    }  
 
    public static Elvis getInstance()  
    {  
        return SingletonHolder.INSTANCE;  
    }  
 
    public void doSomethingElse()  
    {  
 
    }  
}

但這都是基於一個條件：確保不會經過反射機制調用私有的構造器。
這裏舉個例子，經過JAVA的反射機制來「攻擊」單例模式：

package com.effective.singleton;  
 
import java.lang.reflect.Constructor;  
import java.lang.reflect.InvocationTargetException;  
 
public class ElvisReflectAttack  
{  
 
    public static void main(String[] args) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException  
    {  
        Class<?> classType = Elvis.class;  
 
        Constructor<?> c = classType.getDeclaredConstructor(null);  
        c.setAccessible(true);  
        Elvis e1 = (Elvis)c.newInstance();  
        Elvis e2 = Elvis.getInstance();  
        System.out.println(e1==e2);  
    }  
 
}

運行結果：false
能夠看到，經過反射獲取構造函數，而後調用setAccessible(true)就能夠調用私有的構造函數，全部e1和e2是兩個不一樣的對象。
若是要抵禦這種攻擊，能夠修改構造器，讓它在被要求建立第二個實例的時候拋出異常。
經修改後：

package com.effective.singleton;  
 
public class ElvisModified  
{  
    private static boolean flag = false;  
 
    private ElvisModified(){  
        synchronized(ElvisModified.class)  
        {  
            if(flag == false)  
            {  
                flag = !flag;  
            }  
            else 
            {  
                throw new RuntimeException("單例模式被侵犯！");  
            }  
        }  
    }  
 
    private  static class SingletonHolder{  
        private static final ElvisModified INSTANCE = new ElvisModified();  
    }  
 
    public static ElvisModified getInstance()  
    {  
        return SingletonHolder.INSTANCE;  
    }  
 
    public void doSomethingElse()  
    {  
 
    }  
}

測試代碼：

package com.effective.singleton;  
 
import java.lang.reflect.Constructor;  
 
public class ElvisModifiedReflectAttack  
{  
 
    public static void main(String[] args)  
    {  
        try 
        {  
            Class<ElvisModified> classType = ElvisModified.class;  
 
            Constructor<ElvisModified> c = classType.getDeclaredConstructor(null);  
            c.setAccessible(true);  
            ElvisModified e1 = (ElvisModified)c.newInstance();  
            ElvisModified e2 = ElvisModified.getInstance();  
            System.out.println(e1==e2);  
        }  
        catch (Exception e)  
        {  
            e.printStackTrace();  
        }  
    }  
}

運行結果：

Exception in thread "main" java.lang.ExceptionInInitializerError  
    at com.effective.singleton.ElvisModified.getInstance(ElvisModified.java:27)  
    at com.effective.singleton.ElvisModifiedReflectAttack.main(ElvisModifiedReflectAttack.java:17)  
Caused by: java.lang.RuntimeException: 單例模式被侵犯！  
    at com.effective.singleton.ElvisModified.<init>(ElvisModified.java:16)  
    at com.effective.singleton.ElvisModified.<init>(ElvisModified.java:7)  
    at com.effective.singleton.ElvisModified$SingletonHolder.<clinit>(ElvisModified.java:22)  
    ... 2 more

 

能夠看到，成功的阻止了單例模式被破壞。
從JDK1.5開始，實現Singleton還有新的寫法，只需編寫一個包含單個元素的枚舉類型。推薦寫法：

package com.effective.singleton;  
 
public enum SingletonClass  
{  
    INSTANCE;  
 
    public void test()  
    {  
        System.out.println("The Test!");  
    }  
}

測試代碼：

package com.effective;  
 
import java.lang.reflect.Constructor;  
import java.lang.reflect.InvocationTargetException;  
 
import com.effective.singleton.SingletonClass;  
 
public class TestMain  
{  
 
    public static void main(String[] args) throws NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException  
    {  
        Class<SingletonClass> classType = SingletonClass.class;  
        Constructor<SingletonClass> c = (Constructor<SingletonClass>) classType.getDeclaredConstructor();  
        c.setAccessible(true);  
        c.newInstance();  
    }  
}

運行結果：

Exception in thread "main" java.lang.NoSuchMethodException: com.effective.singleton.SingletonClass.<init>()  
    at java.lang.Class.getConstructor0(Unknown Source)  
    at java.lang.Class.getDeclaredConstructor(Unknown Source)  
    at com.effective.TestMain.main(TestMain.java:22)

因而可知這種寫法也能夠防止單例模式被「攻擊」。
並且這種寫法也能夠防止序列化破壞單例模式，具體不在舉例了，有關序列化以及單例模式被序列化破壞能夠參考博文《JAVA序列化》（連接：http://blog.csdn.net/u013256816/article/details/50474678）。
單元素的枚舉類型已經成爲實現Singleton模式的最佳方法