快捷導(dǎo)航

詳解Java序列化如何破壞單例模式

更新時間：2023年12月15日 08:15:55 作者：大明哥_

這篇文章主要為大家詳細(xì)介紹了Java序列化是如何破壞單例模式的,文中的示例代碼講解詳細(xì),具有一定的借鑒價值,感興趣的小伙伴可以學(xué)習(xí)一下

先看代碼：

public class Singleton {
    private Singleton(){}

    private static class SingletonInstance{
        private static final Singleton instance = new Singleton();
    }

    public static Singleton getInstance(){
        return SingletonInstance.instance;
    }
}

我想應(yīng)該沒有不知道這行個類是干嘛的小伙伴了吧，這是單例模式的一種寫法。

單例模式是每一個 Java boy 必須要掌握的設(shè)計模式，它所描述的是在某個進(jìn)程內(nèi)，某個類有且僅有一個實例。我們知道要破壞單例模式就必須讓它創(chuàng)建多個對象。創(chuàng)建對象的方式無非就幾種：

new
clone
反射
反序列化

首先單例模式的構(gòu)造器一定是 private 的，所以 new 這種方式是無法破壞單例模式的。而 clone 需要實現(xiàn) Cloneable 接口，單例模式誰如果實現(xiàn)了這個接口，請打死它。所以就剩下反射和反序列化了。本篇文章只討論反序列化。

反序列化破壞單例模式

與 clone 方式一樣，反序列化需要實現(xiàn) Serializable 接口，但是有小伙伴可能會說，誰會在單例模式中實現(xiàn) Serializable 接口咯，除非他瘋了，確實是這種情況，但是在實際情況中它并不是一定會避免的，有些類它就是一定要序列化。比如單例對象在不同環(huán)境或應(yīng)用實例之間的共享、持久化或狀態(tài)恢復(fù)，當(dāng)然這些場景都屬于比較特殊的場景。

繼續(xù)用上面例子：

public class SerializableSingleton implements Serializable {
    // 省略部分代碼
}

然后在對該類進(jìn)行序列化和反序列化

public class Test {
    public static void main(String[] args) throws Exception {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("Singleton.txt"));
        SerializableSingleton singleton = SerializableSingleton.getInstance();
        oos.writeObject(singleton);

        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("Singleton.txt"));
        SerializableSingleton singleton1 = (SerializableSingleton) ois.readObject();

        System.out.println("singleton = singleton1：" + (singleton == singleton1));
    }
}

運(yùn)行結(jié)果

singleton = singleton1：false

通過對 Singleton 進(jìn)行反序列化得到了一個全新的對象，這就破壞了 Singleton 的單例性了。我們看 readObject() 源碼就知道了。

    public final Object readObject() throws IOException, ClassNotFoundException {
        //...
        int outerHandle = passHandle;
        try {
            Object obj = readObject0(false);
            //...
            return obj;
        } finally {
            //...
        }
    }

調(diào)用 readObject0() ：

    private Object readObject0(boolean unshared) throws IOException {
        // ...
        try {
            switch (tc) {
                // ...

                case TC_OBJECT:
                    // readObject0()
                    return checkResolve(readOrdinaryObject(unshared));
                // ...
            }
        } finally {
            depth--;
            bin.setBlockDataMode(oldMode);
        }
    }

readObject0() 是根據(jù)反序列化對象的不同執(zhí)行不同的方法來反序列化一個實例對象。我們這里是 Object，所以進(jìn)一步看 readOrdinaryObject()。

    private Object readOrdinaryObject(boolean unshared) throws IOException {
        // ...

        Object obj;
        try {
            // 核心代碼
            // 反射創(chuàng)建一個新對象
            obj = desc.isInstantiable() ? desc.newInstance() : null;
        } catch (Exception ex) {
            throw (IOException) new InvalidClassException(
                desc.forClass().getName(),
                "unable to create instance").initCause(ex);
        }
        
        // ...

        if (obj != null &&
            handles.lookupException(passHandle) == null &&
            desc.hasReadResolveMethod()) {
            Object rep = desc.invokeReadResolve(obj);
            if (unshared && rep.getClass().isArray()) {
                rep = cloneArray(rep);
            }
            if (rep != obj) {
                // Filter the replacement object
                if (rep != null) {
                    if (rep.getClass().isArray()) {
                        filterCheck(rep.getClass(), Array.getLength(rep));
                    } else {
                        filterCheck(rep.getClass(), -1);
                    }
                }
                handles.setObject(passHandle, obj = rep);
            }
        }

        return obj;
    }

這段代碼最核心的地方就是：

obj = desc.isInstantiable() ? desc.newInstance() : null;

底層依然是利用反射的方式來創(chuàng)建一個新對象。

那么對于這種方式有什么保護(hù)措施沒？在 readOrdinaryObject() 最后面一段就已經(jīng)告知了：

if (obj != null && handles.lookupException(passHandle) == null &&
      desc.hasReadResolveMethod()) {
     //....
 }

判斷反序列化的類是否已實現(xiàn)了 readResolve() ，如果有則會調(diào)用該方法，我們只需要在該方法里面返回原對象就可以了。驗證下。

public class SerializableSingleton implements Serializable {
    // ...
    private Object readResolve() {
        return SingletonInstance.instance;
    }
}

執(zhí)行結(jié)果：