最近在閱讀《Effective Java 》這本書，第3個條款專門提到了單例屬性，并給出了使用單例的最佳實踐建議。讓我對這個單例模式（原本我以為是設計模式中最簡單的一種）有了更深的認識。

單例模式

單例模式（Singleton Pattern）是 Java 中最簡單的設計模式之一。這種類型的設計模式屬于創(chuàng)建型模式，它提供了一種創(chuàng)建對象的最佳方式。

在應用這個模式時，單例對象的類必須保證只有一個實例存在。許多時候整個系統(tǒng)只需要擁有一個的全局對象，這樣有利于我們協(xié)調(diào)系統(tǒng)整體的行為。

單例的特點

1. 單例類只能有一個實例。
2. 單例類必須自己創(chuàng)建自己的唯一實例。
3. 單例類必須給所有其他對象提供這一實例。

單例模式的7種寫法

單例模式的寫法很多，涉及到了線程安全和性能問題。在這里我不重復介紹。這篇《單例模式的七種寫法》寫得很詳細，博主也給出了每一種寫法的優(yōu)缺點。

但是，單例模式真的能夠?qū)崿F(xiàn)實例的唯一性嗎？答案是否定的。

如何破壞單例

反射

有兩種常見的方式來實現(xiàn)單例。他們的做法都是將構(gòu)造方法設為私有，并導出一個公有的靜態(tài)成員來提供對唯一實例的訪問。在第1種方式中，成員是個final字段：

// Singleton with public final field
public class Elvis {
    public static final Elvis INSTANCE = new Elvis();
    private Elvis() { ... }
    public void leaveTheBuilding() { ... }
}

只調(diào)用私有構(gòu)造函數(shù)一次，以初始化公共靜態(tài)final字段elvi.instance。不提供公有的或者受保護的構(gòu)造函數(shù)保證了全局唯一性：當Elvis類初始化的時候，僅僅只會有一個Elvis實例存在——不多也不少 。無論客戶端怎么做都無法改變這一點，只不過我還是要警告一下 ：授權(quán)的客戶端可以通過反射來調(diào)用私有構(gòu)造方法，借助于AccessibleObject.setAccessible方法即可做到 。如果需要防范這種攻擊，請修改構(gòu)造函數(shù)，使其在被要求創(chuàng)建第二個實例時拋出異常。

測試代碼：

public class TestSingleton {

    /**
     * 通過反射破壞單例
     */
    @Test
    public void testReflection() throws Exception {
        /**
         * 驗證單例有效性
         */
        Elvis elvis1 = Elvis.INSTANCE;
        Elvis elvis2 = Elvis.INSTANCE;

        System.out.println("elvis1 == elvis2 ? ===>" + (elvis1 == elvis2));
        System.err.println("-----------------");

        /**
         * 反射調(diào)用構(gòu)造方法
         */
        Class clazz = Elvis.class;
        Constructor cons = clazz.getDeclaredConstructor(null); 
        cons.setAccessible(true);

        Elvis elvis3 = (Elvis) cons.newInstance(null);

        System.out.println("elvis1 == elvis3 ? ===> "
            + (elvis1 == elvis3));
    }
}

運行結(jié)果：

Elvis Constructor is invoked!
elvis1 == elvis2 ? ===> true
elvis1 == elvis3 ? ===> false
-----------------
Elvis Constructor is invoked!

結(jié)論：

反射是可以破壞單例屬性的。因為我們通過反射把它的構(gòu)造函數(shù)設成可訪問的，然后去生成一個新的對象。

改進版的單例寫法：

public class Elvis {
    public static final Elvis INSTANCE = new Elvis();

    private Elvis() { 
        System.err.println("Elvis Constructor is invoked!");
        if (INSTANCE != null) {
            System.err.println("實例已存在，無法初始化！");
            throw new UnsupportedOperationException("實例已存在，無法初始化！");
        }
    }

}

結(jié)果：

Elvis Constructor is invoked!
elvis1 == elvis2 ? ===> true
-----------------
Elvis Constructor is invoked!
實例已存在，無法初始化！

第2種實現(xiàn)單例模式的方法是，提供一個公有的靜態(tài)工廠方法：

// Singleton with static factory
public class Elvis {
    private static final Elvis INSTANCE = new Elvis();
    private Elvis() { ... }
    public static Elvis getInstance() { return INSTANCE; }
    public void leaveTheBuilding() { ... }
}

所有調(diào)用Elvis類的getInstance方法，返回相同的對象引用，并且不會有其它的Elvis對象被創(chuàng)建。但同樣有上面第1個方法提到的反射破壞單例屬性的問題存在。

序列化和反序列化

如果對上述2種方式實現(xiàn)的單例類進行序列化，反序列化得到的對象是否是同一個對象呢？答案是否定的。
看下面的測試代碼：
單例類：

public class Elvis implements Serializable {
    public static final Elvis INSTANCE = new Elvis();

    private Elvis() { 
        System.err.println("Elvis Constructor is invoked!");
    }

}

測試代碼：

    /**
     * 序列化對單例屬性的影響
     * @throws Exception 
     */
    @Test
    public void testSerialization() throws Exception {
        Elvis elvis1 = Elvis.INSTANCE;
        FileOutputStream fos = new FileOutputStream("a.txt");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(elvis1);
        oos.flush();
        oos.close();

        Elvis elvis2 = null;
        FileInputStream fis = new FileInputStream("a.txt");
        ObjectInputStream ois = new ObjectInputStream(fis);
        elvis2 = (Elvis) ois.readObject();

        System.out.println("elvis1 == elvis2 ? ===>" + (elvis1 == elvis2));
    }

結(jié)果是：

Elvis Constructor is invoked! 
elvis1 == elvis2 ? ===>false

說明：

通過對序列化后的Elvis 進行反序列化得到的對象是一個新的對象，這就破壞了Elvis 的單例性。

標簽： 安全 代碼

版權(quán)申明：本站文章部分自網(wǎng)絡，如有侵權(quán)，請聯(lián)系：west999com@outlook.com
特別注意：本站所有轉(zhuǎn)載文章言論不代表本站觀點！
本站所提供的圖片等素材，版權(quán)歸原作者所有，如需使用，請與原作者聯(lián)系。