Java序列化 ObjectInputStream源码解析

上一篇讲了类的序列化，今天要讲类的反序列化，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(); } } }