既然調(diào)用的是objectInputStream.readObject()來(lái)反序列化，那么我們看看里面的源碼,里面調(diào)用了readObject()方法。

    public final Object readObject()
        throws IOException, ClassNotFoundException {
        return readObject(Object.class);
    }

readObject()方法，里面調(diào)用了readObject0()方法：

    private final Object readObject(Class<?> type)
        throws IOException, ClassNotFoundException
    {
        if (enableOverride) {
            return readObjectOverride();
        }

        if (! (type == Object.class || type == String.class))
            throw new AssertionError("internal error");

        // if nested read, passHandle contains handle of enclosing object
        int outerHandle = passHandle;
        try {
            // 序列化對(duì)象
            Object obj = readObject0(type, false);
            handles.markDependency(outerHandle, passHandle);
            ClassNotFoundException ex = handles.lookupException(passHandle);
            if (ex != null) {
                throw ex;
            }
            if (depth == 0) {
                vlist.doCallbacks();
            }
            return obj;
        } finally {
            passHandle = outerHandle;
            if (closed && depth == 0) {
                clear();
            }
        }
    }

readObject0()內(nèi)部如下，其實(shí)是針對(duì)不同的類(lèi)型分別處理：

    private Object readObject0(Class<?> type, boolean unshared) throws IOException {
        boolean oldMode = bin.getBlockDataMode();
        if (oldMode) {
            int remain = bin.currentBlockRemaining();
            if (remain > 0) {
                throw new OptionalDataException(remain);
            } else if (defaultDataEnd) {
                /*
                 * Fix for 4360508: stream is currently at the end of a field
                 * value block written via default serialization; since there
                 * is no terminating TC_ENDBLOCKDATA tag, simulate
                 * end-of-custom-data behavior explicitly.
                 */
                throw new OptionalDataException(true);
            }
            bin.setBlockDataMode(false);
        }

        byte tc;
        while ((tc = bin.peekByte()) == TC_RESET) {
            bin.readByte();
            handleReset();
        }

        depth++;
        totalObjectRefs++;
        try {
            switch (tc) {
                // null
                case TC_NULL:
                    return readNull();
                // 引用類(lèi)型
                case TC_REFERENCE:
                    // check the type of the existing object
                    return type.cast(readHandle(unshared));
                // 類(lèi)
                case TC_CLASS:
                    if (type == String.class) {
                        throw new ClassCastException("Cannot cast a class to java.lang.String");
                    }
                    return readClass(unshared);

                // 代理
                case TC_CLASSDESC:
                case TC_PROXYCLASSDESC:
                    if (type == String.class) {
                        throw new ClassCastException("Cannot cast a class to java.lang.String");
                    }
                    return readClassDesc(unshared);

                case TC_STRING:
                case TC_LONGSTRING:
                    return checkResolve(readString(unshared));

                // 數(shù)組
                case TC_ARRAY:
                    if (type == String.class) {
                        throw new ClassCastException("Cannot cast an array to java.lang.String");
                    }
                    return checkResolve(readArray(unshared));

                // 枚舉
                case TC_ENUM:
                    if (type == String.class) {
                        throw new ClassCastException("Cannot cast an enum to java.lang.String");
                    }
                    return checkResolve(readEnum(unshared));

                // 對(duì)象
                case TC_OBJECT:
                    if (type == String.class) {
                        throw new ClassCastException("Cannot cast an object to java.lang.String");
                    }
                    return checkResolve(readOrdinaryObject(unshared));

                // 異常
                case TC_EXCEPTION:
                    if (type == String.class) {
                        throw new ClassCastException("Cannot cast an exception to java.lang.String");
                    }
                    IOException ex = readFatalException();
                    throw new WriteAbortedException("writing aborted", ex);

                case TC_BLOCKDATA:
                case TC_BLOCKDATALONG:
                    if (oldMode) {
                        bin.setBlockDataMode(true);
                        bin.peek();             // force header read
                        throw new OptionalDataException(
                            bin.currentBlockRemaining());
                    } else {
                        throw new StreamCorruptedException(
                            "unexpected block data");
                    }

                case TC_ENDBLOCKDATA:
                    if (oldMode) {
                        throw new OptionalDataException(true);
                    } else {
                        throw new StreamCorruptedException(
                            "unexpected end of block data");
                    }

                default:
                    throw new StreamCorruptedException(
                        String.format("invalid type code: %02X", tc));
            }
        } finally {
            depth--;
            bin.setBlockDataMode(oldMode);
        }
    }

可以看到處理對(duì)象的時(shí)候，調(diào)用了readOrdinaryObject()方法,好家伙來(lái)了：

    private Object readOrdinaryObject(boolean unshared)
        throws IOException
    {
        if (bin.readByte() != TC_OBJECT) {
            throw new InternalError();
        }

        ObjectStreamClass desc = readClassDesc(false);
        desc.checkDeserialize();

        Class<?> cl = desc.forClass();
        if (cl == String.class || cl == Class.class
                || cl == ObjectStreamClass.class) {
            throw new InvalidClassException("invalid class descriptor");
        }

        Object obj;
        try {
            // 反射
            obj = desc.isInstantiable() ? desc.newInstance() : null;
        } catch (Exception ex) {
            throw (IOException) new InvalidClassException(
                desc.forClass().getName(),
                "unable to create instance").initCause(ex);
        }

        passHandle = handles.assign(unshared ? unsharedMarker : obj);
        ClassNotFoundException resolveEx = desc.getResolveException();
        if (resolveEx != null) {
            handles.markException(passHandle, resolveEx);
        }

        if (desc.isExternalizable()) {
            readExternalData((Externalizable) obj, desc);
        } else {
            readSerialData(obj, desc);
        }

        handles.finish(passHandle);

        // 如果實(shí)現(xiàn)了hasReadResolveMethod（）方法
        if (obj != null &&
            handles.lookupException(passHandle) == null &&
            desc.hasReadResolveMethod())
        {
            // 執(zhí)行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;
    }

從上面的diamante可以看出，底層是通過(guò)反射來(lái)實(shí)現(xiàn)序列化的，那我們?nèi)绻幌ＭM(jìn)行反射怎么辦？然后可以看到反射之后，其實(shí)有一個(gè)查找readResolveMethod()方法有關(guān)，如果有實(shí)現(xiàn)readResolveMethod()，那就直接調(diào)用該方法返回結(jié)果，而不是返回反射調(diào)用之后的結(jié)果。這樣雖然反射了，但是不起作用。

那要是我們重寫(xiě)readResolveMethod()方法，就可以直接返回我們的對(duì)象，而不是返回反射之后的對(duì)象了。

試試？

image

我們將單例模式改造成為這樣：

import java.io.Serializable;

public class Singleton implements Serializable,Cloneable {
    private static int num = 0;

    private volatile static Singleton singleton;

    private Singleton() {
        synchronized (Singleton.class) {
            if (num == 0) {
                num++;
            } else {
                throw new RuntimeException("Don't use this method");
            }
        }
    }

    public static Singleton getSingleton() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
    // 阻止反序列反射生成對(duì)象
    private Object readResolve() {
        return singleton;
    }
}

測(cè)試代碼不變，結(jié)果如下，事實(shí)證明確實(shí)是這樣，反序列化不會(huì)重新反射對(duì)象了，一直是同一個(gè)對(duì)象，問(wèn)題完美解決了。

2055281021
2055281021

3. 小結(jié)

一個(gè)稍微完美的單例，是不會(huì)讓別人調(diào)用構(gòu)造器的，但是private的構(gòu)造器，并不能完全阻止對(duì)單例的破壞，如果使用反射還是可以非法調(diào)用到構(gòu)造器，因?yàn)槲覀冃枰粋€(gè)次數(shù)，構(gòu)造器如果調(diào)用次數(shù)過(guò)多，那么就直接報(bào)錯(cuò)。

但是有時(shí)候我們希望留個(gè)小后門(mén)，所以我們大部分時(shí)候不可以破壞單例模式。通過(guò)實(shí)現(xiàn)cloneable的方式，重寫(xiě)了clone()方法，就可以做到，生成不同的對(duì)象。

序列化和clone()，有點(diǎn)像，都是主動(dòng)提供破壞的方法，但是很多時(shí)候不得已提供序列化接口，卻不想被破壞，這個(gè)時(shí)候可以通過(guò)重寫(xiě)readResolve()方法，直接返回對(duì)象，不返回反射生成的對(duì)象，保護(hù)了單例模式不被破壞。

【作者簡(jiǎn)介】：
秦懷，公眾號(hào)【秦懷雜貨店】作者，技術(shù)之路不在一時(shí)，山高水長(zhǎng)，縱使緩慢，馳而不息。寫(xiě)好每一篇文章，期待和你們一起交流。

開(kāi)源編程文檔：https://damaer.github.io/Coding/#/。