JAVA基础4---序列化和反序列化深入整理（Hessian序列化）

一、Hessian序列化用法

1、maven依赖

<dependency>
      <groupId>com.caucho</groupId>
      <artifactId>hessian</artifactId>
      <version>4.0.38</version>
</dependency>

2、序列化和反序列化

/** Hessian序列化 */
    public static byte[] hessianSerialize(Object object){
        Hessian2Output oo = null;
        byte[] result = null;
        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            oo = new Hessian2Output(bos);
            oo.writeObject(object);
            oo.flush();
            result = bos.toByteArray();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return result;
    }

    /** Hessian反序列化 */
    public static Object hessianSerializeToObj(byte[] bytes){
        Object result = null;
        try{
            ByteArrayInputStream is = new ByteArrayInputStream(bytes);
            Hessian2Input input = new Hessian2Input(is);
            result = input.readObject();
        }catch (Exception e){
            e.printStackTrace();
        }
        return result;
    }

Hessian的序列化和反序列化分别是依靠Hessian2Output和Hessian2Input来实现，首先是定义一个二进制字节流对象ByteArrayOutputStream和ByteArrayOutputStream对象，分别通过对应的Hessian对象进行二进制流的读写操作。

所以说核心逻辑主要在于Hessian2Output的writeObejct方法和Hessian2Input的readObject方法。 

二、Hessian序列化源码解析

2.1、序列化源码解析

1、首先分析Hessian2Output的初始化过程，源码如下：

/** 输出字节流对象*/
    protected OutputStream _os;

    public Hessian2Output(OutputStream os)
    {
        init(os);
    }

    /** 初始化*/
    public void init(OutputStream os)
    {
        reset();
        _os = os;
    }

    /** 重置所有的指针和引用*/
    public void reset()
    {
        if (_refs != null) {
            _refs.clear();
            _refCount = 0;
        }

        _classRefs.clear();
        _typeRefs = null;
        _offset = 0;
        _isPacket = false;
        _isUnshared = false;
    }

Hessian2Output的内部有一个OutputStream属性，用于将对象序列化后的字节流写入到此对象中，构造方法主要是重置了所有和序列化相关的熟悉，并且给字节流对象进行初始化

2、writeObejct方法解析

public void writeObject(Object object)throws IOException
    {
        /** 1.如果对象为空,则写入空对象 */
        if (object == null) {
            writeNull();
            return;
        }
        /** 2.根据对象的Class来获取序列化器 */
        Serializer serializer = findSerializerFactory().getObjectSerializer(object.getClass());
        /** 3.调用序列化器的writeObject进行对象序列化 */
        serializer.writeObject(object, this);
    }

方法比较简单，如果对象为空就写入空数据；如果对象不为空，那么就根据对象的Class信息构造一个指定类型的序列化器对象，然后直接调用序列化器的writeObejct方法进行序列化。

2.1、当对象为空时

    public final static int SIZE = 8 * 1024;

        /** 字节数组缓存 */
    private final byte []_buffer = new byte[SIZE];

    /** 字节数组偏移量 */
    private int _offset;

    /** 写入空对象 */
    public void writeNull() throws IOException
    {
        int offset = _offset;
        byte []buffer = _buffer;

        if (SIZE <= offset + 16) {
            /** 如果字节数组缓存不足,则将缓存数据写入到OutputStream中并清除缓存*/
            flushBuffer();
            offset = _offset;
        }
        /** 写入字符串N表示当前的对象为空对象 */
        buffer[offset++] = 'N';
        /** 更新偏移量*/
        _offset = offset;
    }

    /** 清除缓存,并将缓存数据写入输出字节流中*/
    public final void flushBuffer()
            throws IOException
    {
        int offset = _offset;
        OutputStream os = _os;

        if (! _isPacket && offset > 0) {
            _offset = 0;
            if (os != null)
                os.write(_buffer, 0, offset);
        }
        else if (_isPacket && offset > 4) {
            int len = offset - 4;

            _buffer[0] |= (byte) 0x80;
            _buffer[1] = (byte) (0x7e);
            _buffer[2] = (byte) (len >> 8);
            _buffer[3] = (byte) (len);
            _offset = 4;

            if (os != null)
                os.write(_buffer, 0, offset);

            _buffer[0] = (byte) 0x00;
            _buffer[1] = (byte) 0x56;
            _buffer[2] = (byte) 0x56;
            _buffer[3] = (byte) 0x56;
        }
    }

writeNull方法逻辑不复杂，主要就是在字节数组中写入字符串"N"即可。这里可以看出Hessian2Output对象内部有一个字节数组缓存_buffer对象和一个数组写入偏移量_offset变量。

字节数组缓存大小为8 * 1024个字节相当于 8K的容量，序列化的时候会先将序列化的字节流写入缓存中，当缓存容量不足的时在调用flushbuffer方法将缓冲区的数据写入字节流对象中，并清除缓冲区。

2.2、当对象不为空时

当对象不为空时，进行序列化的时候需要根据对象类型进行不同的序列化方式，比如String有String的序列化方式，List有List的序列化方式，而且通常还有用户自定义的实体类，还需要有对象的序列化方式。

对象序列化的接口为Serializer，定义如下：

public interface Serializer {
        public void writeObject(Object obj, AbstractHessianOutput out)throws IOException;
    }

具体的实现类比较多，针对不同的类型有不同的实现子类，

2.2.1、基本数据类型序列化

对于常用的基本数据类型及对应的数组类型，Hessian提供了基本数据类型序列化器BasicSerializer，在ContextSerializerFactory类中进行了初始化注册，代码如下：

addBasic(void.class, "void", BasicSerializer.NULL);

    addBasic(Boolean.class, "boolean", BasicSerializer.BOOLEAN);
    addBasic(Byte.class, "byte", BasicSerializer.BYTE);
    addBasic(Short.class, "short", BasicSerializer.SHORT);
    addBasic(Integer.class, "int", BasicSerializer.INTEGER);
    addBasic(Long.class, "long", BasicSerializer.LONG);
    addBasic(Float.class, "float", BasicSerializer.FLOAT);
    addBasic(Double.class, "double", BasicSerializer.DOUBLE);
    addBasic(Character.class, "char", BasicSerializer.CHARACTER_OBJECT);
    addBasic(String.class, "string", BasicSerializer.STRING);
    addBasic(Object.class, "object", BasicSerializer.OBJECT);
    addBasic(java.util.Date.class, "date", BasicSerializer.DATE);

    addBasic(boolean.class, "boolean", BasicSerializer.BOOLEAN);
    addBasic(byte.class, "byte", BasicSerializer.BYTE);
    addBasic(short.class, "short", BasicSerializer.SHORT);
    addBasic(int.class, "int", BasicSerializer.INTEGER);
    addBasic(long.class, "long", BasicSerializer.LONG);
    addBasic(float.class, "float", BasicSerializer.FLOAT);
    addBasic(double.class, "double", BasicSerializer.DOUBLE);
    addBasic(char.class, "char", BasicSerializer.CHARACTER);

    addBasic(boolean[].class, "[boolean", BasicSerializer.BOOLEAN_ARRAY);
    addBasic(byte[].class, "[byte", BasicSerializer.BYTE_ARRAY);
    _staticSerializerMap.put(byte[].class.getName(), ByteArraySerializer.SER);
    addBasic(short[].class, "[short", BasicSerializer.SHORT_ARRAY);
    addBasic(int[].class, "[int", BasicSerializer.INTEGER_ARRAY);
    addBasic(long[].class, "[long", BasicSerializer.LONG_ARRAY);
    addBasic(float[].class, "[float", BasicSerializer.FLOAT_ARRAY);
    addBasic(double[].class, "[double", BasicSerializer.DOUBLE_ARRAY);
    addBasic(char[].class, "[char", BasicSerializer.CHARACTER_ARRAY);
    addBasic(String[].class, "[string", BasicSerializer.STRING_ARRAY);
    addBasic(Object[].class, "[object", BasicSerializer.OBJECT_ARRAY);

虽然基本数据类型都是通过BasicSerializer进行序列化，但是不同的类型都是有不同的type的，BasicSerializer根据不同的type进行不同的序列化逻辑处理。具体的序列化逻辑如下：

/** 基本数据类型*/
    public void writeObject(Object obj, AbstractHessianOutput out)
            throws IOException
    {
        switch (_code) {
            case BOOLEAN:
                out.writeBoolean(((Boolean) obj).booleanValue());
                break;

            case BYTE:
            case SHORT:
            case INTEGER:
                out.writeInt(((Number) obj).intValue());
                break;

            case LONG:
                out.writeLong(((Number) obj).longValue());
                break;

            case FLOAT:
            case DOUBLE:
                out.writeDouble(((Number) obj).doubleValue());
                break;

            case CHARACTER:
            case CHARACTER_OBJECT:
                out.writeString(String.valueOf(obj));
                break;

            case STRING:
                out.writeString((String) obj);
                break;

            case STRING_BUILDER:
                out.writeString(((StringBuilder) obj).toString());
                break;

            case DATE:
                out.writeUTCDate(((Date) obj).getTime());
                break;

            case BOOLEAN_ARRAY:
            {
                if (out.addRef(obj))
                    return;

                boolean []data = (boolean []) obj;
                boolean hasEnd = out.writeListBegin(data.length, "[boolean");
                for (int i = 0; i < data.length; i++)
                    out.writeBoolean(data[i]);

                if (hasEnd)
                    out.writeListEnd();

                break;
            }

            case BYTE_ARRAY:
            {
                byte []data = (byte []) obj;
                out.writeBytes(data, 0, data.length);
                break;
            }

            case SHORT_ARRAY:
            {
                if (out.addRef(obj))
                    return;

                short []data = (short []) obj;
                boolean hasEnd = out.writeListBegin(data.length, "[short");

                for (int i = 0; i < data.length; i++)
                    out.writeInt(data[i]);

                if (hasEnd)
                    out.writeListEnd();
                break;
            }

            case INTEGER_ARRAY:
            {
                if (out.addRef(obj))
                    return;

                int []data = (int []) obj;

                boolean hasEnd = out.writeListBegin(data.length, "[int");

                for (int i = 0; i < data.length; i++)
                    out.writeInt(data[i]);

                if (hasEnd)
                    out.writeListEnd();

                break;
            }

            case LONG_ARRAY:
            {
                if (out.addRef(obj))
                    return;

                long []data = (long []) obj;

                boolean hasEnd = out.writeListBegin(data.length, "[long");

                for (int i = 0; i < data.length; i++)
                    out.writeLong(data[i]);

                if (hasEnd)
                    out.writeListEnd();
                break;
            }

            case FLOAT_ARRAY:
            {
                if (out.addRef(obj))
                    return;

                float []data = (float []) obj;

                boolean hasEnd = out.writeListBegin(data.length, "[float");

                for (int i = 0; i < data.length; i++)
                    out.writeDouble(data[i]);

                if (hasEnd)
                    out.writeListEnd();
                break;
            }

            case DOUBLE_ARRAY:
            {
                if (out.addRef(obj))
                    return;

                double []data = (double []) obj;
                boolean hasEnd = out.writeListBegin(data.length, "[double");

                for (int i = 0; i < data.length; i++)
                    out.writeDouble(data[i]);

                if (hasEnd)
                    out.writeListEnd();
                break;
            }

            case STRING_ARRAY:
            {
                if (out.addRef(obj))
                    return;

                String []data = (String []) obj;

                boolean hasEnd = out.writeListBegin(data.length, "[string");

                for (int i = 0; i < data.length; i++) {
                    out.writeString(data[i]);
                }

                if (hasEnd)
                    out.writeListEnd();
                break;
            }

            case CHARACTER_ARRAY:
            {
                char []data = (char []) obj;
                out.writeString(data, 0, data.length);
                break;
            }

            case OBJECT_ARRAY:
            {
                if (out.addRef(obj))
                    return;

                Object []data = (Object []) obj;

                boolean hasEnd = out.writeListBegin(data.length, "[object");

                for (int i = 0; i < data.length; i++) {
                    out.writeObject(data[i]);
                }

                if (hasEnd)
                    out.writeListEnd();
                break;
            }

            case NULL:
                out.writeNull();
                break;

            case OBJECT:
                ObjectHandleSerializer.SER.writeObject(obj, out);
                break;

            case BYTE_HANDLE:
                out.writeObject(new ByteHandle((Byte) obj));
                break;

            case SHORT_HANDLE:
                out.writeObject(new ShortHandle((Short) obj));
                break;

            case FLOAT_HANDLE:
                out.writeObject(new FloatHandle((Float) obj));
                break;

            default:
                throw new RuntimeException(_code + " unknown code for " + obj.getClass());
        }
    }

逻辑比较清晰，根据类型调用对应的write方法，如果是数组类型会在write数据前后分别调用writeListBegin和writeListEnd方法表示写入数组的开始和结束标记。

如字符串的序列化方法writeString源码如下：

/** 序列化字符串*/
    public void writeString(String value)throws IOException
    {
        int offset = _offset;
        byte []buffer = _buffer;

        /** 缓冲区满了则写入流对象并清理缓存*/
        if (SIZE <= offset + 16) {
            flushBuffer();
            offset = _offset;
        }

        /** 如果值为空则写入'N'标记*/
        if (value == null) {
            buffer[offset++] = (byte) 'N';
            _offset = offset;
        }
        else {
            int length = value.length();
            int strOffset = 0;
            /** 如果字符串长度大于32K则拆分成多个32K大小的字符串进行写入 */
            while (length > 0x8000) {
                int sublen = 0x8000;
                offset = _offset;
                if (SIZE <= offset + 16) {
                    flushBuffer();
                    offset = _offset;
                }

                // chunk can't end in high surrogate
                char tail = value.charAt(strOffset + sublen - 1);

                if (0xd800 <= tail && tail <= 0xdbff)
                    sublen--;

                /** 依次写入字符串标记'R' 长度占用字节数 实际长度值*/
                buffer[offset + 0] = (byte) BC_STRING_CHUNK;
                buffer[offset + 1] = (byte) (sublen >> 8);
                buffer[offset + 2] = (byte) (sublen);

                _offset = offset + 3;
                /** 写入字符串的具体数据 */
                printString(value, strOffset, sublen);

                length -= sublen;
                strOffset += sublen;
            }

            offset = _offset;

            if (SIZE <= offset + 16) {
                flushBuffer();
                offset = _offset;
            }

            if (length <= STRING_DIRECT_MAX) {
                buffer[offset++] = (byte) (BC_STRING_DIRECT + length);
            }
            else if (length <= STRING_SHORT_MAX) {
                buffer[offset++] = (byte) (BC_STRING_SHORT + (length >> 8));
                buffer[offset++] = (byte) (length);
            }
            else {
                buffer[offset++] = (byte) ('S');
                buffer[offset++] = (byte) (length >> 8);
                buffer[offset++] = (byte) (length);
            }

            _offset = offset;

            printString(value, strOffset, length);
        }
    }

写入字符串时会先写入标记，如果字符串过长会进行拆分成多个子字符串，子字符串写入标记为"R",非子字符串会写入字符串标记"S",并且会在标记后面写入字符串的长度,最终才会窒息printString方法将字符串数据写入字节数组中。

printString方法的逻辑就是遍历字符串的每一位，依次将字符串的每个字符写入字节数组中。源码如下：

public void printString(String v, int strOffset, int length)throws IOException
    {
        int offset = _offset;
        byte []buffer = _buffer;

        for (int i = 0; i < length; i++) {
            if (SIZE <= offset + 16) {
                _offset = offset;
                flushBuffer();
                offset = _offset;
            }

            char ch = v.charAt(i + strOffset);

            if (ch < 0x80)
                buffer[offset++] = (byte) (ch);
            else if (ch < 0x800) {
                buffer[offset++] = (byte) (0xc0 + ((ch >> 6) & 0x1f));
                buffer[offset++] = (byte) (0x80 + (ch & 0x3f));
            }
            else {
                buffer[offset++] = (byte) (0xe0 + ((ch >> 12) & 0xf));
                buffer[offset++] = (byte) (0x80 + ((ch >> 6) & 0x3f));
                buffer[offset++] = (byte) (0x80 + (ch & 0x3f));
            }
        }
        _offset = offset;
    }

其他基本数据类型的写入逻辑基本上和字符串的写入逻辑一致，都是在写入数据之前先写入标记，然后直接写入数据，比如Long类型就会写入标记"L",Double类型就写入"D", Int类型就写入"I"。

可以看出相比于JDK的序列化方式，在数据类型上来说Hessian的序列化就会比JDK的序列化写入的数据量要小很多。Hessian将基本数据类型仅仅用一个字符来表示，而JDK序列化会将类的全路径序列化。

如String类型的序列化，Hessian序列化字符串类型仅仅写入标记"S"，而JDK序列化需要写入类路径"java.lang.String"

2.2.2、自定义数据类型序列化

自定义数据类型的序列化是通过UnsafeSerializer进行的序列化，源码如下：

public void writeObject(Object obj, AbstractHessianOutput out)throws IOException
    {
        if (out.addRef(obj)) {
            return;
        }

        Class<?> cl = obj.getClass();
        /** 写入Object类型开始标记 将类名存入Map中,并记录该类的引用次数 */
        int ref = out.writeObjectBegin(cl.getName());

        /** 如果引用次数大于0则表示已经被引用过*/
        if (ref >= 0) {
            /** 直接写入实例 */
            writeInstance(obj, out);
        }
        /** 值为-1表示第一次引用 */
        else if (ref == -1) {
            /** 写入类的定义,依次写入属性个数和所有属性的名称 */
            writeDefinition20(out);
            /** 写入类的名称 */
            out.writeObjectBegin(cl.getName());
            /** 写入实例 */
            writeInstance(obj, out);
        }
        else {
            writeObject10(obj, out);
        }
    }

主要逻辑为先获取Class的引用次数，如果Class已经引用过了则不需要重新解析，直接写入对象即可；如果Class没有引用过则先写入类的定义，包括属性的个数和依次写入所有属性的名称。然后在写入类的名称，最后再执行writeInstance方法写入实例对象。

writeDefinition20方法源码如下：

/** 写入类的定义*/
    private void writeDefinition20(AbstractHessianOutput out)throws IOException
    {
        /** 写入类的属性个数*/
        out.writeClassFieldLength(_fields.length);
        /** 依次写入属性的名称*/
        for (int i = 0; i < _fields.length; i++) {
            Field field = _fields[i];
            out.writeString(field.getName());
        }
    }

 writeObjectBegin方法源码如下：

/** 开始写入对象*/
    public int writeObjectBegin(String type)throws IOException
    {
        //获取类的引用次数
        int newRef = _classRefs.size();
        int ref = _classRefs.put(type, newRef, false);
        if (newRef != ref) {
            if (SIZE < _offset + 32)
                flushBuffer();

            if (ref <= OBJECT_DIRECT_MAX) {
                _buffer[_offset++] = (byte) (BC_OBJECT_DIRECT + ref);
            }
            else {
                //写入类的引用次数
                _buffer[_offset++] = (byte) 'O';
                writeInt(ref);
            }

            return ref;
        }
        else {
            if (SIZE < _offset + 32)
                flushBuffer();

            _buffer[_offset++] = (byte) 'C';

            writeString(type);

            return -1;
        }
    }

writeInstance方法源码如下：

/** 写入对象实例 */
    final public void writeInstance(Object obj, AbstractHessianOutput out)throws IOException
    {
        try {
            /** 获取所有属性序列化器对象 */
            FieldSerializer []fieldSerializers = _fieldSerializers;
            int length = fieldSerializers.length;

            for (int i = 0; i < length; i++) {
                /** 遍历分别执行属性的序列化方法 */
                fieldSerializers[i].serialize(out, obj);
            }
        } catch (RuntimeException e) {
            throw new RuntimeException(e.getMessage() + "
 class: "
                    + obj.getClass().getName()
                    + " (object=" + obj + ")",
                    e);
        } catch (IOException e) {
            throw new IOExceptionWrapper(e.getMessage() + "
 class: "
                    + obj.getClass().getName()
                    + " (object=" + obj + ")",
                    e);
        }
    }

写入实例的整体逻辑比较简单，就是针对每个字段都有一个序列化器，然后遍历执行所有属性对应的序列化器的序列化方法即可，如果属性是自定义类型就继续按自定义类型继续遍历属性类的所有属性。直到最终都是基本数据类型属性为止。

2.2、反序列化源码解析

和序列化相反，反序列化是通过输入流Hessian2Input对象的readObject方法来实现的，源码如下：

 /** 反序列化对象*/
    public Object readObject() throws IOException
    {
        /** 调用read()方法读取字节,第一次就读取第一个字节 */
        int tag = _offset < _length ? (_buffer[_offset++] & 0xff) : read();

        /** 判断字节对应的标记类型,执行对应的解析方法 */
        switch (tag) {
            case 'N':
                return null;

            case 'T':
                return Boolean.valueOf(true);

            case 'F':
                return Boolean.valueOf(false);

            // direct integer
            case 0x80: case 0x81: case 0x82: case 0x83:
            case 0x84: case 0x85: case 0x86: case 0x87:
            case 0x88: case 0x89: case 0x8a: case 0x8b:
            case 0x8c: case 0x8d: case 0x8e: case 0x8f:

            case 0x90: case 0x91: case 0x92: case 0x93:
            case 0x94: case 0x95: case 0x96: case 0x97:
            case 0x98: case 0x99: case 0x9a: case 0x9b:
            case 0x9c: case 0x9d: case 0x9e: case 0x9f:

            case 0xa0: case 0xa1: case 0xa2: case 0xa3:
            case 0xa4: case 0xa5: case 0xa6: case 0xa7:
            case 0xa8: case 0xa9: case 0xaa: case 0xab:
            case 0xac: case 0xad: case 0xae: case 0xaf:

            case 0xb0: case 0xb1: case 0xb2: case 0xb3:
            case 0xb4: case 0xb5: case 0xb6: case 0xb7:
            case 0xb8: case 0xb9: case 0xba: case 0xbb:
            case 0xbc: case 0xbd: case 0xbe: case 0xbf:
                return Integer.valueOf(tag - BC_INT_ZERO);

            /* byte int */
            case 0xc0: case 0xc1: case 0xc2: case 0xc3:
            case 0xc4: case 0xc5: case 0xc6: case 0xc7:
            case 0xc8: case 0xc9: case 0xca: case 0xcb:
            case 0xcc: case 0xcd: case 0xce: case 0xcf:
                return Integer.valueOf(((tag - BC_INT_BYTE_ZERO) << 8) + read());

            /* short int */
            case 0xd0: case 0xd1: case 0xd2: case 0xd3:
            case 0xd4: case 0xd5: case 0xd6: case 0xd7:
                return Integer.valueOf(((tag - BC_INT_SHORT_ZERO) << 16)
                        + 256 * read() + read());

            case 'I':
                return Integer.valueOf(parseInt());

            // direct long
            case 0xd8: case 0xd9: case 0xda: case 0xdb:
            case 0xdc: case 0xdd: case 0xde: case 0xdf:

            case 0xe0: case 0xe1: case 0xe2: case 0xe3:
            case 0xe4: case 0xe5: case 0xe6: case 0xe7:
            case 0xe8: case 0xe9: case 0xea: case 0xeb:
            case 0xec: case 0xed: case 0xee: case 0xef:
                return Long.valueOf(tag - BC_LONG_ZERO);

            /* byte long */
            case 0xf0: case 0xf1: case 0xf2: case 0xf3:
            case 0xf4: case 0xf5: case 0xf6: case 0xf7:
            case 0xf8: case 0xf9: case 0xfa: case 0xfb:
            case 0xfc: case 0xfd: case 0xfe: case 0xff:
                return Long.valueOf(((tag - BC_LONG_BYTE_ZERO) << 8) + read());

            /* short long */
            case 0x38: case 0x39: case 0x3a: case 0x3b:
            case 0x3c: case 0x3d: case 0x3e: case 0x3f:
                return Long.valueOf(((tag - BC_LONG_SHORT_ZERO) << 16) + 256 * read() + read());

            case BC_LONG_INT:
                return Long.valueOf(parseInt());

            case 'L':
                return Long.valueOf(parseLong());

            case BC_DOUBLE_ZERO:
                return Double.valueOf(0);

            case BC_DOUBLE_ONE:
                return Double.valueOf(1);

            case BC_DOUBLE_BYTE:
                return Double.valueOf((byte) read());

            case BC_DOUBLE_SHORT:
                return Double.valueOf((short) (256 * read() + read()));

            case BC_DOUBLE_MILL:
            {
                int mills = parseInt();

                return Double.valueOf(0.001 * mills);
            }

            case 'D':
                return Double.valueOf(parseDouble());

            case BC_DATE:
                return new Date(parseLong());

            case BC_DATE_MINUTE:
                return new Date(parseInt() * 60000L);

            case BC_STRING_CHUNK:
            case 'S':
            {
                _isLastChunk = tag == 'S';
                _chunkLength = (read() << 8) + read();

                _sbuf.setLength(0);

                parseString(_sbuf);

                return _sbuf.toString();
            }

            case 0x00: case 0x01: case 0x02: case 0x03:
            case 0x04: case 0x05: case 0x06: case 0x07:
            case 0x08: case 0x09: case 0x0a: case 0x0b:
            case 0x0c: case 0x0d: case 0x0e: case 0x0f:

            case 0x10: case 0x11: case 0x12: case 0x13:
            case 0x14: case 0x15: case 0x16: case 0x17:
            case 0x18: case 0x19: case 0x1a: case 0x1b:
            case 0x1c: case 0x1d: case 0x1e: case 0x1f:
            {
                _isLastChunk = true;
                _chunkLength = tag - 0x00;

                int data;
                _sbuf.setLength(0);

                parseString(_sbuf);

                return _sbuf.toString();
            }

            case 0x30: case 0x31: case 0x32: case 0x33:
            {
                _isLastChunk = true;
                _chunkLength = (tag - 0x30) * 256 + read();

                _sbuf.setLength(0);

                parseString(_sbuf);

                return _sbuf.toString();
            }

            case BC_BINARY_CHUNK:
            case 'B':
            {
                _isLastChunk = tag == 'B';
                _chunkLength = (read() << 8) + read();

                int data;
                ByteArrayOutputStream bos = new ByteArrayOutputStream();

                while ((data = parseByte()) >= 0)
                    bos.write(data);

                return bos.toByteArray();
            }

            case 0x20: case 0x21: case 0x22: case 0x23:
            case 0x24: case 0x25: case 0x26: case 0x27:
            case 0x28: case 0x29: case 0x2a: case 0x2b:
            case 0x2c: case 0x2d: case 0x2e: case 0x2f:
            {
                _isLastChunk = true;
                int len = tag - 0x20;
                _chunkLength = 0;

                byte []data = new byte[len];

                for (int i = 0; i < len; i++)
                    data[i] = (byte) read();

                return data;
            }

            case 0x34: case 0x35: case 0x36: case 0x37:
            {
                _isLastChunk = true;
                int len = (tag - 0x34) * 256 + read();
                _chunkLength = 0;

                byte []buffer = new byte[len];

                for (int i = 0; i < len; i++) {
                    buffer[i] = (byte) read();
                }

                return buffer;
            }

            case BC_LIST_VARIABLE:
            {
                // variable length list
                String type = readType();

                return findSerializerFactory().readList(this, -1, type);
            }

            case BC_LIST_VARIABLE_UNTYPED:
            {
                return findSerializerFactory().readList(this, -1, null);
            }

            case BC_LIST_FIXED:
            {
                // fixed length lists
                String type = readType();
                int length = readInt();

                Deserializer reader;
                reader = findSerializerFactory().getListDeserializer(type, null);

                return reader.readLengthList(this, length);
            }

            case BC_LIST_FIXED_UNTYPED:
            {
                // fixed length lists
                int length = readInt();

                Deserializer reader;
                reader = findSerializerFactory().getListDeserializer(null, null);

                return reader.readLengthList(this, length);
            }

            // compact fixed list
            case 0x70: case 0x71: case 0x72: case 0x73:
            case 0x74: case 0x75: case 0x76: case 0x77:
            {
                // fixed length lists
                String type = readType();
                int length = tag - 0x70;

                Deserializer reader;
                reader = findSerializerFactory().getListDeserializer(type, null);

                return reader.readLengthList(this, length);
            }

            // compact fixed untyped list
            case 0x78: case 0x79: case 0x7a: case 0x7b:
            case 0x7c: case 0x7d: case 0x7e: case 0x7f:
            {
                // fixed length lists
                int length = tag - 0x78;

                Deserializer reader;
                reader = findSerializerFactory().getListDeserializer(null, null);

                return reader.readLengthList(this, length);
            }

            case 'H':
            {
                return findSerializerFactory().readMap(this, null);
            }

            case 'M':
            {
                String type = readType();

                return findSerializerFactory().readMap(this, type);
            }

            case 'C':
            {
                readObjectDefinition(null);

                return readObject();
            }

            case 0x60: case 0x61: case 0x62: case 0x63:
            case 0x64: case 0x65: case 0x66: case 0x67:
            case 0x68: case 0x69: case 0x6a: case 0x6b:
            case 0x6c: case 0x6d: case 0x6e: case 0x6f:
            {
                int ref = tag - 0x60;

                if (_classDefs.size() <= ref)
                    throw error("No classes defined at reference '"
                            + Integer.toHexString(tag) + "'");

                ObjectDefinition def = _classDefs.get(ref);
                //读取实例对象
                return readObjectInstance(null, def);
            }

            case 'O':
            {
                int ref = readInt();

                if (_classDefs.size() <= ref)
                    throw error("Illegal object reference #" + ref);

                ObjectDefinition def = _classDefs.get(ref);

                return readObjectInstance(null, def);
            }

            case BC_REF:
            {
                int ref = readInt();

                return _refs.get(ref);
            }

            default:
                if (tag < 0)
                    throw new EOFException("readObject: unexpected end of file");
                else
                    throw error("readObject: unknown code " + codeName(tag));
        }
    }

这里逻辑主要是先读取标记，然后根据标记对应的类型进行判断，再执行对应的读取反解析工作。比如对象类型就会先解析到类型为'C'，则会继续执行readObjectDefintion方法进行反解析类的定义，然后再执行readObject方法继续递归执行。

readObejctDefintion方法源码如下：

/** 读取类的定义 */
    private void readObjectDefinition(Class<?> cl)throws IOException
    {
        /** 获取类型*/
        String type = readString();
        int len = readInt();

        SerializerFactory factory = findSerializerFactory();

        //获取反序列化器
        Deserializer reader = factory.getObjectDeserializer(type, null);
        //创建属性数组
        Object []fields = reader.createFields(len);
        //创建属性名称数组
        String []fieldNames = new String[len];

        //依次读取属性和属性名称的值
        for (int i = 0; i < len; i++) {
            String name = readString();
            fields[i] = reader.createField(name);
            fieldNames[i] = name;
        }
        //构造Object定义对象
        ObjectDefinition def = new ObjectDefinition(type, reader, fields, fieldNames);
        _classDefs.add(def);
    }

读取完类的定义之后，会继续读取对象的数据，会执行到readObjectInstance方法，源码如下：

 /** 读取实例 */
    private Object readObjectInstance(Class<?> cl, ObjectDefinition def) throws IOException
    {
        String type = def.getType();
        /** 获取反序列化器*/
        Deserializer reader = def.getReader();
        Object []fields = def.getFields();

        SerializerFactory factory = findSerializerFactory();

        if (cl != reader.getType() && cl != null) {
            reader = factory.getObjectDeserializer(type, cl);
            /** 执行反序列化器的读取方法*/
            return reader.readObject(this, def.getFieldNames());
        }
        else {
            return reader.readObject(this, fields);
        }
    }

该方法的逻辑主要是先获取一个反序列化器，然后执行反序列化器的readObejct方法，执行的是UnsafeDeserializer的readObject方法，源码如下：

 /** 读取对象 */
    public Object readObject(AbstractHessianInput in, String []fieldNames)throws IOException
    {
        try {
            /** 实例化对象,通过UnSafe构造对象 */
            Object obj = instantiate();
            /** 给对象的所有属性进行赋值 */
            return readObject(in, obj, fieldNames);
        } catch (IOException e) {
            throw e;
        } catch (RuntimeException e) {
            throw e;
        } catch (Exception e) {
            throw new IOExceptionWrapper(_type.getName() + ":" + e.getMessage(), e);
        }
    }

第一步实际就是调用了Unsafe的allocationInstance构建了一个对象

protected Object instantiate()
    throws Exception
  {
    return _unsafe.allocateInstance(_type);
  }

第二步就是给该对象的所有属性进行赋值，源码如下：

public Object readObject(AbstractHessianInput in, Object obj,String []fieldNames)throws IOException
    {
        try {
            int ref = in.addRef(obj);
            /** 遍历所有属性进行赋值 */
            for (String fieldName : fieldNames) {
                FieldDeserializer reader = _fieldMap.get(fieldName);
                if (reader != null)
                    /** 不同的类型调用不同类型的反序列化实例进行赋值 */
                    reader.deserialize(in, obj);
                else
                    in.readObject();
            }
            Object resolve = resolve(in, obj);

            if (obj != resolve)
                in.setRef(ref, resolve);

            return resolve;
        } catch (IOException e) {
            throw e;
        } catch (Exception e) {
            throw new IOExceptionWrapper(obj.getClass().getName() + ":" + e, e);
        }
    }

其中FieldDeserializer有很多的子类，不同的类型有不同的反序列化方式，比如字符串属性，赋值的逻辑如下：

void deserialize(AbstractHessianInput in, Object obj)
      throws IOException
    {
      String value = null;
      
      try {
        value = in.readString();
 
        _unsafe.putObject(obj, _offset, value);
      } catch (Exception e) {
        logDeserializeError(_field, obj, value, e);
      }
    }

先是读取一个字符串的值，然后还是调用UnSafe的putObejct方法进行赋值给此对象。

如果属性也是对象类型，那么就递归执行直到所有的属性都为基本数据类型并解析成功为止。