上一篇讲了类的序列化，今天要讲类的反序列化，ObjectInputStream。

从内部变量中我们可以看出，内部包含一个块输入流，因为有handle机制所以也有一个内部缓存表但不是hash表

/** 处理数据块转换的过滤流 */    private final BlockDataInputStream bin;    /** 确认调用返回列表 */    private final ValidationList vlist;    /** 递归深度 */    private long depth;    /** 对任何种类的对象、类、枚举、代理的引用总数 */    private long totalObjectRefs;    /** 流是否关闭 */    private boolean closed;    /** 线柄->obj/exception映射 */    private final HandleTable handles;    /** 传递句柄值上下调用栈的草稿区 */    private int passHandle = NULL_HANDLE;    /** 当在字段值末尾因没有TC_ENDBLOCKDATA阻塞时设置的标志 */    private boolean defaultDataEnd = false;    /** b读取原始字段值的缓冲区 */    private byte[] primVals;    /** 如果为true，调用readObjectOverride()来替代readObject() */    private final boolean enableOverride;    /** if true, invoke resolveObject()如果为true调用resolveObject() */    private boolean enableResolve;    /**     * 向上调用类定义的readObject方法期间的上下文，保持当前在被反序列化的对象和当前类的描述符。非readObject向上调用期间为null。     */    private SerialCallbackContext curContext;    /**     * 类描述符过滤器和从流中读取的类，可能是null     */    private ObjectInputFilter serialFilter;

从构造函数中可以看出，同样需要验证类的安全性，同时在初始化时会自动读取Java序列化头部信息。跟输出流一样，预留了一个生成全空的类输入流初始化方法，用于继承ObjectInputStream的子类进行重写。安全验证和输出流中是相同的，而读取头部信息需要读取魔数和版本号并验证与当前JDK中的是否一致。当然，如果两端使用的JDK中这个类版本号不一致就会出现异常。

/**     * 创建一个ObjectInputStream从指定的InputStream中读取。一个序列化流头部从这个流读取和验证。这个构造器会阻塞直到对应的ObjectOutputStream已经写并刷新了头部。     * 如果安装了安全管理器，这个构造器会在被重写了ObjectInputStream.readFields或ObjectInputStream.readUnshared的子类构造器     * 直接或间接调用的时候检查enableSubclassImplementation序列化许可     *     * @param   in input stream to read from     * @throws  StreamCorruptedException 如果流头部错误     * @throws  IOException 在读取流头部是发生了IO错误     * @throws  SecurityException 如果不被信任的子类非法重写了安全敏感方法     * @throws  NullPointerException 如果in是null     */    public ObjectInputStream(InputStream in) throws IOException {        verifySubclass();        bin = new BlockDataInputStream(in);        handles = new HandleTable(10);        vlist = new ValidationList();        serialFilter = ObjectInputFilter.Config.getSerialFilter();        enableOverride = false;        readStreamHeader();        bin.setBlockDataMode(true);    }    protected ObjectInputStream() throws IOException, SecurityException {        SecurityManager sm = System.getSecurityManager();        if (sm != null) {            sm.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);        }        bin = null;        handles = null;        vlist = null;        serialFilter = ObjectInputFilter.Config.getSerialFilter();        enableOverride = true;    }    protected void readStreamHeader()        throws IOException, StreamCorruptedException    {        short s0 = bin.readShort();        short s1 = bin.readShort();        if (s0 != STREAM_MAGIC || s1 != STREAM_VERSION) {            throw new StreamCorruptedException(                String.format("invalid stream header: %04X%04X", s0, s1));        }    }

下面直接切入正题，来看一下readObject，读和写一样也是final方法，所以子类要重写必须通过readObjectOverride方法来完成。如果类里面定义了非基本数据类型变量，需要进行嵌套读取，outerHandle用来存储上一层读取对象的句柄，然后调用readObject0读取生成对象。完成之后要记录句柄依赖，并检查有无异常产生。最上层读取完成之后要发起回调。

public final Object readObject()        throws IOException, ClassNotFoundException    {        if (enableOverride) {            return readObjectOverride();//因为是final方法，子类要重写只能通过这里        }        // 如果是嵌套读取，passHandle包含封闭对象的句柄        int outerHandle = passHandle;        try {            Object obj = readObject0(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必须在块输入流内为空也就是上一次反序列化完全结束后才能开始，否则会抛出异常。首先，从流中读取一个标志位，判断当前下一个内容是什么类型，上次我们讲到过，输出的时候都会先输出TC_OBJECT，所以在默认情况下也是先读取到TC_OBJECT，也就是先执行readOrdinaryObject

private Object readObject0(boolean unshared) throws IOException {        boolean oldMode = bin.getBlockDataMode();        if (oldMode) {//之前是块输入模式且有未消费的数据会抛出异常            int remain = bin.currentBlockRemaining();            if (remain > 0) {                throw new OptionalDataException(remain);            } else if (defaultDataEnd) {                /*                 * 流当前在字段值通过默认序列化块写的末尾，因为没有终止TC_ENDBLOCKDATA标记，模拟通常数据结尾的行为                 */                throw new OptionalDataException(true);            }            bin.setBlockDataMode(false);        }        byte tc;        while ((tc = bin.peekByte()) == TC_RESET) {//读到流reset标志            bin.readByte();//消耗缓存的字节            handleReset();//depth为0时执行clear方法，否则抛出异常        }        depth++;//增加递归深度        totalObjectRefs++;//增加引用对象数        try {            switch (tc) {                case TC_NULL:                    return readNull();                case TC_REFERENCE:                    return readHandle(unshared);                case TC_CLASS:                    return readClass(unshared);                case TC_CLASSDESC:                case TC_PROXYCLASSDESC:                    return readClassDesc(unshared);                case TC_STRING:                case TC_LONGSTRING:                    return checkResolve(readString(unshared));                case TC_ARRAY:                    return checkResolve(readArray(unshared));                case TC_ENUM:                    return checkResolve(readEnum(unshared));                case TC_OBJECT:                    return checkResolve(readOrdinaryObject(unshared));//一般会先进入这里                case TC_EXCEPTION:                    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);        }    }

readOrdinaryObject是读取一个自定义类最上层直接调用的方法。几个关键的点，首先是要读取类的描述信息，然后根据类描述符创建一个实例，将对象实例存储到句柄缓存中并将句柄存储到passHandle，然后读取内部变量数据，最后检查有没有替换对象

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);//标记句柄对应的对象读取完成        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;    }

那么先来看下怎么读取类的描述信息readClassDesc，从上面方法的case中不能分析出，在没有发生异常使用的情况下，此时的case只会进入TC_PROXYCLASSDESC或者TC_CLASSDESC也就是动态代理类的描述符合普通类的描述符。对于readProxyDesc读取并返回一个动态代理类的类描述符，而readNonProxyDesc则是返回一个普通类的描述符，两个方法都会设置passHandle到动态类描述符的设置句柄。如果类描述符不能被解析为本地虚拟机中的一个类，一个ClassNotFoundException会被关联到描述符的句柄中。关于动态代理和反射的部分下次要再仔细看一下。不过这里又是读取类描述，又是安全检查还有类合法性检查，跟直接在读取端指定类相比额外多出很多开销。

private ObjectStreamClass readClassDesc(boolean unshared)        throws IOException    {        byte tc = bin.peekByte();        ObjectStreamClass descriptor;        switch (tc) {            case TC_NULL:                descriptor = (ObjectStreamClass) readNull();                break;            case TC_REFERENCE:                descriptor = (ObjectStreamClass) readHandle(unshared);                break;            case TC_PROXYCLASSDESC:                descriptor = readProxyDesc(unshared);                break;            case TC_CLASSDESC:                descriptor = readNonProxyDesc(unshared);                break;            default:                throw new StreamCorruptedException(                    String.format("invalid type code: %02X", tc));        }        if (descriptor != null) {            validateDescriptor(descriptor);        }        return descriptor;    }        private ObjectStreamClass readProxyDesc(boolean unshared)        throws IOException    {        if (bin.readByte() != TC_PROXYCLASSDESC) {            throw new InternalError();        }        ObjectStreamClass desc = new ObjectStreamClass();        int descHandle = handles.assign(unshared ? unsharedMarker : desc);//添加描述符到句柄缓存中        passHandle = NULL_HANDLE;        int numIfaces = bin.readInt();//接口实现类数量        if (numIfaces > 65535) {            throw new InvalidObjectException("interface limit exceeded: "                    + numIfaces);        }        String[] ifaces = new String[numIfaces];        for (int i = 0; i < numIfaces; i++) {            ifaces[i] = bin.readUTF();//读取接口名        }        Class
     cl = null;        ClassNotFoundException resolveEx = null;        bin.setBlockDataMode(true);        try {            if ((cl = resolveProxyClass(ifaces)) == null) {                resolveEx = new ClassNotFoundException("null class");            } else if (!Proxy.isProxyClass(cl)) {                throw new InvalidClassException("Not a proxy");            } else {                //这个检查等价于isCustomSubclass                ReflectUtil.checkProxyPackageAccess(                        getClass().getClassLoader(),                        cl.getInterfaces());                // Filter the interfaces过滤接口                for (Class
     clazz : cl.getInterfaces()) {                    filterCheck(clazz, -1);                }            }        } catch (ClassNotFoundException ex) {            resolveEx = ex;        }        // Call filterCheck on the class before reading anything else        filterCheck(cl, -1);        skipCustomData();        try {            totalObjectRefs++;            depth++;            desc.initProxy(cl, resolveEx, readClassDesc(false));//初始化类描述符        } finally {            depth--;        }        handles.finish(descHandle);        passHandle = descHandle;        return desc;    }        private ObjectStreamClass readNonProxyDesc(boolean unshared)        throws IOException    {        if (bin.readByte() != TC_CLASSDESC) {            throw new InternalError();        }        ObjectStreamClass desc = new ObjectStreamClass();        int descHandle = handles.assign(unshared ? unsharedMarker : desc);//将描述符存储到句柄缓存中，返回句柄值        passHandle = NULL_HANDLE;        ObjectStreamClass readDesc = null;        try {            readDesc = readClassDescriptor();        } catch (ClassNotFoundException ex) {            throw (IOException) new InvalidClassException(                "failed to read class descriptor").initCause(ex);        }        Class
     cl = null;        ClassNotFoundException resolveEx = null;        bin.setBlockDataMode(true);        final boolean checksRequired = isCustomSubclass();        try {            if ((cl = resolveClass(readDesc)) == null) {//通过类描述解析类                resolveEx = new ClassNotFoundException("null class");            } else if (checksRequired) {                ReflectUtil.checkPackageAccess(cl);            }        } catch (ClassNotFoundException ex) {            resolveEx = ex;        }        // Call filterCheck on the class before reading anything else        filterCheck(cl, -1);        skipCustomData();        try {            totalObjectRefs++;            depth++;            desc.initNonProxy(readDesc, cl, resolveEx, readClassDesc(false));//初始化类描述符        } finally {            depth--;        }        handles.finish(descHandle);        passHandle = descHandle;        return desc;    }

接下来是读取序列化内部变量数据，由于readExternalData除了一些安全性的判断外，直接调用了类中的方法，所以就不看了，直接看readSerialData中默认的读取数据部分defaultReadFields。注意到基本数据类型可以直接通过字节输入流来进行读取，而非基本数据类型则需要递归调用readObject0来读取。

private void defaultReadFields(Object obj, ObjectStreamClass desc)        throws IOException    {        Class
     cl = desc.forClass();        if (cl != null && obj != null && !cl.isInstance(obj)) {            throw new ClassCastException();        }        int primDataSize = desc.getPrimDataSize();        if (primVals == null || primVals.length < primDataSize) {            primVals = new byte[primDataSize];//第一次进行需要初始化缓冲区，缓冲区不足时需要新建一个更大的缓冲区        }            bin.readFully(primVals, 0, primDataSize, false);//将字节流读取到缓冲区        if (obj != null) {//从readSerialData进入这个方法时obj为null            desc.setPrimFieldValues(obj, primVals);        }        int objHandle = passHandle;        ObjectStreamField[] fields = desc.getFields(false);        Object[] objVals = new Object[desc.getNumObjFields()];        int numPrimFields = fields.length - objVals.length;        for (int i = 0; i < objVals.length; i++) {            ObjectStreamField f = fields[numPrimFields + i];            objVals[i] = readObject0(f.isUnshared());//递归读取非基本数据类型类            if (f.getField() != null) {                handles.markDependency(objHandle, passHandle);//记录依赖            }        }        if (obj != null) {            desc.setObjFieldValues(obj, objVals);        }        passHandle = objHandle;    }

然后看一下其他非基本数据类的读取。readNull读取null代码并将句柄设置为NULL_HANDLE，readString读取UTF编码，readArray需要先读取数组长度，然后根据类的类型进行读取。

private Object readNull() throws IOException {        if (bin.readByte() != TC_NULL) {            throw new InternalError();        }        passHandle = NULL_HANDLE;        return null;    }    private String readString(boolean unshared) throws IOException {        String str;        byte tc = bin.readByte();        switch (tc) {            case TC_STRING:                str = bin.readUTF();                break;            case TC_LONGSTRING:                str = bin.readLongUTF();                break;            default:                throw new StreamCorruptedException(                    String.format("invalid type code: %02X", tc));        }        passHandle = handles.assign(unshared ? unsharedMarker : str);        handles.finish(passHandle);        return str;    }    private Object readArray(boolean unshared) throws IOException {        if (bin.readByte() != TC_ARRAY) {            throw new InternalError();        }        ObjectStreamClass desc = readClassDesc(false);        int len = bin.readInt();        filterCheck(desc.forClass(), len);        Object array = null;        Class
     cl, ccl = null;        if ((cl = desc.forClass()) != null) {            ccl = cl.getComponentType();            array = Array.newInstance(ccl, len);        }        int arrayHandle = handles.assign(unshared ? unsharedMarker : array);        ClassNotFoundException resolveEx = desc.getResolveException();        if (resolveEx != null) {            handles.markException(arrayHandle, resolveEx);        }        if (ccl == null) {            for (int i = 0; i < len; i++) {                readObject0(false);            }        } else if (ccl.isPrimitive()) {            if (ccl == Integer.TYPE) {                bin.readInts((int[]) array, 0, len);            } else if (ccl == Byte.TYPE) {                bin.readFully((byte[]) array, 0, len, true);            } else if (ccl == Long.TYPE) {                bin.readLongs((long[]) array, 0, len);            } else if (ccl == Float.TYPE) {                bin.readFloats((float[]) array, 0, len);            } else if (ccl == Double.TYPE) {                bin.readDoubles((double[]) array, 0, len);            } else if (ccl == Short.TYPE) {                bin.readShorts((short[]) array, 0, len);            } else if (ccl == Character.TYPE) {                bin.readChars((char[]) array, 0, len);            } else if (ccl == Boolean.TYPE) {                bin.readBooleans((boolean[]) array, 0, len);            } else {                throw new InternalError();            }        } else {            Object[] oa = (Object[]) array;            for (int i = 0; i < len; i++) {                oa[i] = readObject0(false);                handles.markDependency(arrayHandle, passHandle);            }        }        handles.finish(arrayHandle);        passHandle = arrayHandle;        return array;    }

readHandle方法从缓存中寻找该对象

private Object readHandle(boolean unshared) throws IOException {        if (bin.readByte() != TC_REFERENCE) {            throw new InternalError();        }        passHandle = bin.readInt() - baseWireHandle;//因为写的时候handle值加上了baseWireHandle        if (passHandle < 0 || passHandle >= handles.size()) {            throw new StreamCorruptedException(                String.format("invalid handle value: %08X", passHandle +                baseWireHandle));        }        if (unshared) {            // REMIND: what type of exception to throw here?            throw new InvalidObjectException(                "cannot read back reference as unshared");        }        Object obj = handles.lookupObject(passHandle);//缓存中寻找该对象        if (obj == unsharedMarker) {            // REMIND: what type of exception to throw here?            throw new InvalidObjectException(                "cannot read back reference to unshared object");        }        filterCheck(null, -1);       // just a check for number of references, depth, no class检查引用数量，递归深度，是否有这个类        return obj;    }

BlockDataInputStream

跟输出时相同，对象输入流也使用的是块输入流，输入流有两个模式：默认模式下，输入数据写入的格式和DataOutputStream相同；在块数据模式，输入的数据被块数据标记归为一类。逻辑上来说，读和写应该是相对应的，主要是要判断读取到的头部信息，然后根据不同的信息来读取实际信息。有些跟输出部分非常重复的就跳过了

内部变量主要需要注意两个不同的输入流，din是块输入流，in是取数输入流，in中的下层输入流是最初在构造ObjectInputStream中传入的变量，所以通常是FileInputStream。

/** maximum data block length最大数据块长度1K */        private static final int MAX_BLOCK_SIZE = 1024;        /** maximum data block header length最大数据块头部长度 */        private static final int MAX_HEADER_SIZE = 5;        /** (tunable) length of char buffer (for reading strings)可调节的字符缓冲的长度作为供读取的字符串 */        private static final int CHAR_BUF_SIZE = 256;        /** readBlockHeader() return value indicating header read may block readBlockHeader()返回的值指示头部可能阻塞 */        private static final int HEADER_BLOCKED = -2;        /** buffer for reading general/block data读取一般/块数据的缓冲区 */        private final byte[] buf = new byte[MAX_BLOCK_SIZE];        /** buffer for reading block data headers读取块数据头部的缓冲区 */        private final byte[] hbuf = new byte[MAX_HEADER_SIZE];        /** char buffer for fast string reads快速字符串读取的字符缓冲区 */        private final char[] cbuf = new char[CHAR_BUF_SIZE];        /** block data mode块数据模式 */        private boolean blkmode = false;        // block data state fields; values meaningful only when blkmode true块数据状态字段，这些值仅在blkmode为true时有意义        /** current offset into buf当前进入buf的偏移 */        private int pos = 0;        /** end offset of valid data in buf, or -1 if no more block data buf中有效值的结束偏移，没有更多块数据buf时为-1 */        private int end = -1;        /** number of bytes in current block yet to be read from stream 在当前block中还没有从流中读取的字节数 */        private int unread = 0;        /** underlying stream (wrapped in peekable filter stream) 下层流包装在可见过滤流中 */        private final PeekInputStream in;        /** loopback stream (for data reads that span data blocks) 回路流用于扩展数据块的数据读取 */        private final DataInputStream din;

构造函数就是初始化两个流变量

BlockDataInputStream(InputStream in) {            this.in = new PeekInputStream(in);            din = new DataInputStream(this);        }

setBlockDataMode将块数据模式设为给定的模式，true是打开，off是关闭，并返回之前的模式值。如果新的模式和旧模式一样，什么都不做。如果块数据模式从打开被改为关闭时有未消费的块数据还留在流中，会抛出IllegalStateException

boolean setBlockDataMode(boolean newmode) throws IOException {            if (blkmode == newmode) {                return blkmode;            }            if (newmode) {//从关闭到打开，重置块数据参数状态                pos = 0;                end = 0;                unread = 0;            } else if (pos < end) {//从打开到关闭且有未消费的块数据                throw new IllegalStateException("unread block data");            }            blkmode = newmode;            return !blkmode;        }

skipBlockData如果在块数据模式，跳跃到数据块的当前组的末尾但不会取消块数据模式。如果不在块数据模式，抛出IllegalStateException。这个方法调用了refill，refill用块数据再装满内部缓冲区。任何buf中的数据在调用这个方法时被认为是已经被消费了。设置pos、end、unread字段值来反映有效块数据的数量。如果流中的下一个元素不是一个数据块，设置pos=0和unread=0，end=-1

void skipBlockData() throws IOException {            if (!blkmode) {                throw new IllegalStateException("not in block data mode");            }            while (end >= 0) {                refill();            }        }        private void refill() throws IOException {            try {                do {                    pos = 0;                    if (unread > 0) {//当前block中还有未读取的字节                        int n =                            in.read(buf, 0, Math.min(unread, MAX_BLOCK_SIZE));//读取unread和最大数据块长度中的较小值的数据到buf中                        if (n >= 0) {                            end = n;//end为读取到的字节数                            unread -= n;//当前block中还没读取的字节减少n                        } else {                            throw new StreamCorruptedException(                                "unexpected EOF in middle of data block");                        }                    } else {                        int n = readBlockHeader(true);                        if (n >= 0) {                            end = 0;                            unread = n;                        } else {                            end = -1;                            unread = 0;                        }                    }                } while (pos == end);//成功读取到数据就会退出循环            } catch (IOException ex) {//出现异常说明下一个元素不是数据块                pos = 0;                end = -1;                unread = 0;                throw ex;            }        }

readBlockHeader尝试读取下一个块数据头部。如果canBlock是false并且一个完整的头部没有阻塞时不能被读取，返回HEADER_BLOCKED。否则如果流中下一个元素是一个块数据头部，返回头部标识的这个块数据的长度，否则返回-1

private int readBlockHeader(boolean canBlock) throws IOException {            if (defaultDataEnd) {                /*                 * 流当前在一个字段值块通过默认序列化写入的末尾。因为没有终点TC_ENDBLOCKDATA标志，                 * 明确地模仿常规数据结束行为。                 */                return -1;            }            try {                for (;;) {                    int avail = canBlock ? Integer.MAX_VALUE : in.available();//可以阻塞时avail是最大整数，不能阻塞时是流中能读取的字节数                    if (avail == 0) {                        return HEADER_BLOCKED;//没有可读取的字节数时返回HEADER_BLOCKED                    }                    int tc = in.peek();//从流中取数                    switch (tc) {                        case TC_BLOCKDATA://第二个字节是块数据长度                            if (avail < 2) {                                return HEADER_BLOCKED;                            }                            in.readFully(hbuf, 0, 2);                            return hbuf[1] & 0xFF;                        case TC_BLOCKDATALONG://块字节长度需要4个字节来表示                            if (avail < 5) {                                return HEADER_BLOCKED;                            }                            in.readFully(hbuf, 0, 5);                            int len = Bits.getInt(hbuf, 1);//位运算获取后4位的整数值                            if (len < 0) {                                throw new StreamCorruptedException(                                    "illegal block data header length: " +                                    len);                            }                            return len;                        /*                         * TC_RESET可能发生在数据块之间。不幸的是，这个状况必须在比其他类型标志更低的级别被解析，                         * 因为原始数据读取可能跨越被TC_RESET分割的数据块                         */                        case TC_RESET:                            in.read();//跳过这个头部                            handleReset();//重置                            break;                        default:                            if (tc >= 0 && (tc < TC_BASE || tc > TC_MAX)) {                                throw new StreamCorruptedException(                                    String.format("invalid type code: %02X",                                    tc));                            }                            return -1;                    }                }            } catch (EOFException ex) {                throw new StreamCorruptedException(                    "unexpected EOF while reading block data header");            }        }

单个字节的read和peek都是基于refill来完成的，而read多字节时，最大不能超过缓冲区内剩余的字节，如果copy为true，需要先将字节读取到一个内部缓冲区再复制到目标数组，又增加开销。

int read(byte[] b, int off, int len, boolean copy) throws IOException {            if (len == 0) {                return 0;            } else if (blkmode) {                if (pos == end) {                    refill();                }                if (end < 0) {                    return -1;                }                int nread = Math.min(len, end - pos);//最大不超过缓冲区内剩余的字节                System.arraycopy(buf, pos, b, off, nread);                pos += nread;                return nread;            } else if (copy) {//copy模式先将数据读取到一个缓冲区，再从缓冲区复制到目标数组                int nread = in.read(buf, 0, Math.min(len, MAX_BLOCK_SIZE));                if (nread > 0) {                    System.arraycopy(buf, 0, b, off, nread);                }                return nread;            } else {                return in.read(b, off, len);            }        }

readFully循环调用read直到达到要读取的字节数，如果不足会抛出EOFException

public void readFully(byte[] b, int off, int len, boolean copy)            throws IOException        {            while (len > 0) {                int n = read(b, off, len, copy);                if (n < 0) {                    throw new EOFException();                }                off += n;                len -= n;            }        }

HandleTable

比起输入流来，输入流的缓存表多了一个HandleList[] deps用来存储依赖，HandleList可以理解为一个简易版的ArrayList，当数组被填满再次增加元素的时候，自动分配一个新的2倍大小的数组，把旧的元素复制过去再插入新的。另外两个数组，Object[] entries存储对象或异常，byte[] status存储对象的状态。并且这个缓存表并没有使用hash，它是依靠ObjectInputStream中的passHandle来获取位置的。

/** array mapping handle -> object status 句柄->对象状态的数组映射*/        byte[] status;        /** array mapping handle -> object/exception (depending on status) */        Object[] entries;        /** array mapping handle -> list of dependent handles (if any) */        HandleList[] deps;        /** lowest unresolved dependency 最低的未解决依赖*/        int lowDep = -1;        /** number of handles in table */        int size = 0;

从assign我们可以看到，对象和它的状态（默认为UNKNOWN）被顺序存储到了数组中，并返回下标值

int assign(Object obj) {            if (size >= entries.length) {                grow();            }            status[size] = STATUS_UNKNOWN;            entries[size] = obj;            return size++;        }

关于deps这个数组到底是干什么的，我们可以一步步来分析。首先，寻找deps在HandleTable中被修改的地方，除了构造时初始化以外，finish中deps对应状态为UNKNOWN状态的全部被设为NULL，clear当中deps全部为设为null，grow当中新建了一个大小是原本2倍加1的deps数组并复制了原有内容来取代之前的数组，这些都不足以分析它的用途，关键在markDependency和markException两个方法中。首先markException我们可以看到所有调用都是发生在出现ClassNotFoundException的时候，传入的参数是这个类的handle值和异常。markDependency关联一个ClassNotFoundException和当前活动句柄并传播它到其他合适的引用对象。这个特定的句柄必须是打开的。简单的来说，如果一个类解析失败，那么添加到entries缓存里的对象会是一个异常，它对应的status为STATUS_EXCEPTION

void markException(int handle, ClassNotFoundException ex) {            switch (status[handle]) {                case STATUS_UNKNOWN:                    status[handle] = STATUS_EXCEPTION;//标记当前对象状态为异常                    entries[handle] = ex;//修改缓存中的对象为异常                    // propagate exception to dependents传播异常给依赖                    HandleList dlist = deps[handle];                    if (dlist != null) {                        int ndeps = dlist.size();                        for (int i = 0; i < ndeps; i++) {                            markException(dlist.get(i), ex);//递归传播依赖列表内的所有对象                        }                        deps[handle] = null;//清除依赖表中的对象，因为只要再有对象关联到相同类它必然是会从缓存中获取异常，不再需要依赖表项                    }                    break;                case STATUS_EXCEPTION:                    break;                default:                    throw new InternalError();            }        }

再来看一下markDependency的调用，一处是在readObject调用readObject0之后，传入参数是上一层对象的句柄和本层对象的句柄；一处是在readArray中读取非基本数据类型调用readObject0之后，传入参数也是上一层对象的句柄和本层对象的句柄；一处是在defaultReadFields中递归读取非基本数据类中，传入参数也是上一层对象的句柄和本层对象的句柄。总之，根据上面这几个例子再结合方法的注释，我们可以推测出这里deps的作用是在一层层读取对象时，比如自定义类中又又自定义类，记录下一层指向上一层的关系，用来传递异常状态。很明显，从代码中可以看出，在存在依赖双方的情况下，如果上一层状态是UNKNOWN，下一层状态是EXCEPTION，则从依次向上将整个依赖表上所有的状态全部置为EXCEPTION，如果下一层也是UNKNOWN状态，则在下一层的依赖表中增加上一层的句柄，并将未知状态最底层设为target。如果上一层状态是OK，则出现InternalError，因为上一层的句柄已经被关闭，不能再增加对它依赖的对象。

void markDependency(int dependent, int target) {            if (dependent == NULL_HANDLE || target == NULL_HANDLE) {                return;            }            switch (status[dependent]) {                case STATUS_UNKNOWN:                    switch (status[target]) {                        case STATUS_OK:                            // ignore dependencies on objs with no exception忽略没有异常的对象上依赖                            break;                        case STATUS_EXCEPTION:                            // eagerly propagate exception急切传播的异常                            markException(dependent,                                (ClassNotFoundException) entries[target]);//如果依赖是未知状态也需将它们改为异常状态                            break;                        case STATUS_UNKNOWN:                            // add to dependency list of target增加到依赖目标列表                            if (deps[target] == null) {                                deps[target] = new HandleList();                            }                            deps[target].add(dependent);                            // remember lowest unresolved target seen记录被看见最低的未解决目标                            if (lowDep < 0 || lowDep > target) {                                lowDep = target;                            }                            break;                        default:                            throw new InternalError();                    }                    break;                case STATUS_EXCEPTION:                    break;                default:                    throw new InternalError();            }        }

finish是关闭句柄，是唯一可以将状态设为STATUS_OK的方法，标记给出的句柄为结束状态，说明这个句柄不会有新的依赖标记。调用设置和结束方法必须以后进先出的顺序。必须要handle之前不存在无法确认的状态才能修改状态为OK

void finish(int handle) {            int end;            if (lowDep < 0) {                // 没有还没处理的未知状态，只需要解决当前句柄                end = handle + 1;            } else if (lowDep >= handle) {                // handle之后存在还没有处理的未知状态，但上层句柄都已经解决了                end = size;                lowDep = -1;            } else {                // handle之前还有没有处理的向前引用，还不能解决所有对象                return;            }            // change STATUS_UNKNOWN -> STATUS_OK in selected span of handles            for (int i = handle; i < end; i++) {                switch (status[i]) {                    case STATUS_UNKNOWN:                        status[i] = STATUS_OK;                        deps[i] = null;                        break;                    case STATUS_OK:                    case STATUS_EXCEPTION:                        break;                    default:                        throw new InternalError();                }            }        }