Java序列化 ObjectInputStream源码解析-阿里云开发者社区

开发者社区> 灰色的风> 正文

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();
                }
            }
        }

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
两行代码修复了解析MySQL8.x binlog错位的问题!!
MySQL是互联网行业使用的最多的关系型数据库之一,而且MySQL又是开源的,对于MySQL的深入研究,能够加深我们对于数据库原理的理解。自从开源了mykit-data之后,不少小伙伴试用后,反馈mykit-data无法正确的解析MySQL8的binlog。于是我测试了下,mykit-data在解析MySQL5.x的binlog时,没有啥问题,能够正确的解析出结果数据。然而,在解析MySQL8.x的binlog时,总是与binlog日志位数相差12位而导致解析失败。
16 0
Qt之解析XML(QXmlStreamReader)
简述 QXmlStreamReader 类提供了一个快速解析器,用于通过简单的流 API 读取格式良好的 XML。与之相对应的是 QXmlStreamWriter(写入 XML)。 相比较 Qt 自己的 SAX 解析器(见 QXmlSimpleReader),QXmlStreamReader 更快,更方便。某些情况下,在使用 DOM 树(见 QDomDocument)的应
3393 0
Java网络编程与NIO详解11:Tomcat中的Connector源码分析(NIO)
Tomcat 中的 NIO 源码分析 转自https://www.javadoop.com/post/tomcat-nio#toc1 之前写了两篇关于 NIO 的文章,第一篇介绍了 NIO 的 Channel、Buffer、Selector 使用,第二篇介绍了非阻塞 IO 和异步 IO,并展示了简单的用例。
1708 0
Java线程池架构(一)原理和源码解析
在前面介绍JUC的文章中,提到了关于线程池Execotors的创建介绍,在文章:《java之JUC系列-外部Tools》中第一部分有详细的说明,请参阅; 文章中其实说明了外部的使用方式,但是没有说内部是如何实现的,为了加深对实现的理解,在使用中可以放心,我们这里将做源码解析以及反馈到原理 上,Executors工具可以创建普通的线程池以及schedule调度任务的调度池,其实两者实现上还是有一些区别,但是理解了ThreadPoolExecutor,在看ScheduledThreadPoolExecutor就非常轻松了,后面的文章中也会专门介绍这块,但是需要先看这篇文章。
1120 0
Java集合之HashMap源码解析
HashMap HashMap 是 Map 的一个实现类,它代表的是一种键值对的数据存储形式。 大多数情况下可以直接定位到它的值,因而具有很快的访问速度,但遍历顺序却是不确定的。
696 0
前后端交互之封装Ajax+SpringMVC源码分析
为什么需要封装呢?因为用的多,我想将其封装成函数,当我想用它时,只需将那个函数对应的js文件引入即可,而不要重复写很多相同代码,利于开发效率的提高。 无论是$.ajax或$.post、$.get等,在开发中是经常用到的。
875 0
java.util.concurrent解析——FutureTask源码解析
和Java异步打交道就不能回避掉`Runnable`,`Callable`,`Future`,`FutureTask`等类,首先来介绍下这几个类的区别
2234 0
Microsoft Visual Studio与Firefly 一直提示加载项目,更新源码状态问题
        笔记本一开始安装的是vs2010,由于近期开发要用vs2008与vs2005于是今天又把2008、2005安装上了,但在打开项目的时候,先是提示加载项目文件,然后一直提示更新源码状态,很慢很慢的,之前只有vs2010的时候,打开是很快的,现在不管是用2008、2005、2010就没有一个快的,源码管理用的是firefly,有人知道为什么会出现这种情况吗?        
1003 0
+关注
灰色的风
热衷于Java尤其是中间件开发和Linux与分布式系统和性能优化学习,数据结构算法与源码阅读爱好者,互联网技术与行业追捧者,半科班生,对算法岗持保留态度
37
文章
0
问答
文章排行榜
最热
最新
相关电子书
更多
《2021云上架构与运维峰会演讲合集》
立即下载
《零基础CSS入门教程》
立即下载
《零基础HTML入门教程》
立即下载