初探Java序列化(2)-writeObject/readObject

        上一篇《初探Java序列化(Serialization)》给我们大体介绍了什么是序列化和反序列化，以及解析了一下序列化出来的文件。接着我们看看JDK具体如何序列化一个Object。

        在序列化过程中，虚拟机会试图调用对象类里的writeObject() 和readObject()，进行用户自定义的序列化和反序列化，如果没有则调用ObjectOutputStream.defaultWriteObject() 和ObjectInputStream.defaultReadObject()。同样，在ObjectOutputStream和ObjectInputStream中最重要的方法也是writeObject() 和 readObject()，递归地写出/读入byte。

        所以用户可以通过writeObject()和 readObject()自定义序列化和反序列化逻辑。对一些敏感信息加密的逻辑也可以放在此。【不过此处不会检查serialVersionUID】

        对于一个Obj来说，都是先写类信息description，再写属性field。

        下面是defaultWriteObject()和defaultReadObject()，详见JDK1.8的ObjectOutputStream和ObjectInputStream。

    public void defaultWriteObject() throws IOException {        SerialCallbackContext ctx = curContext;        if (ctx == null) {            throw new NotActiveException("not in call to writeObject");        }        Object curObj = ctx.getObj();        ObjectStreamClass curDesc = ctx.getDesc();        bout.setBlockDataMode(false);        defaultWriteFields(curObj, curDesc);        bout.setBlockDataMode(true);    }    private void defaultWriteFields(Object obj, ObjectStreamClass desc) {        Class<?> cl = desc.forClass();        if (cl != null && obj != null && !cl.isInstance(obj))             throw new ClassCastException();        desc.checkDefaultSerialize();        int primDataSize = desc.getPrimDataSize();        if (primVals == null || primVals.length < primDataSize)             primVals = new byte[primDataSize];        desc.getPrimFieldValues(obj, primVals);        bout.write(primVals, 0, primDataSize, false);        ObjectStreamField[] fields = desc.getFields(false);        Object[] objVals = new Object[desc.getNumObjFields()];        int numPrimFields = fields.length - objVals.length;        desc.getObjFieldValues(obj, objVals);        for (int i = 0; i < objVals.length; i++) {            if (extendedDebugInfo)                 debugInfoStack.push(                    "field (class \"" + desc.getName() + "\", name: \"" +                    fields[numPrimFields + i].getName() + "\", type: \"" +                    fields[numPrimFields + i].getType() + "\")");            writeObject0(objVals[i], fields[numPrimFields + i].isUnshared());    }

        从上面的代码能看出来，JAVA在序列化write的过程中，根据field的类型分成 基本类型 和 对象。

解析基本类型 getPrimFieldValues()

        JAVA会把对象中field的相应内存地址记录起来，拼装在FieldReflector对象中，然后通过unsafe来读取其中的基本类型的值，并将其转换成最终要写出的byte[]。

        【上述操作在ObjectStreamClass中完成】

        fieldRefl = getReflector(fields, this);FieldReflector(ObjectStreamField[] fields) {            this.fields = fields;            int nfields = fields.length;            readKeys = new long[nfields];            writeKeys = new long[nfields];            offsets = new int[nfields];            typeCodes = new char[nfields];            ArrayList<Class<?>> typeList = new ArrayList<>();            Set<Long> usedKeys = new HashSet<>();            for (int i = 0; i < nfields; i++) {                ObjectStreamField f = fields[i];                Field rf = f.getField();                long key = (rf != null) ?                    unsafe.objectFieldOffset(rf) : Unsafe.INVALID_FIELD_OFFSET;                readKeys[i] = key;                writeKeys[i] = usedKeys.add(key) ? key : Unsafe.INVALID_FIELD_OFFSET;                offsets[i] = f.getOffset();                typeCodes[i] = f.getTypeCode();                if (!f.isPrimitive())                     typeList.add((rf != null) ? rf.getType() : null);            }            types = typeList.toArray(new Class<?>[typeList.size()]);            numPrimFields = nfields - types.length;        }void getPrimFieldValues(Object obj, byte[] buf) {            if (obj == null) throw new NullPointerException();            for (int i = 0; i < numPrimFields; i++) {                long key = readKeys[i];                int off = offsets[i];                switch (typeCodes[i]) {                    case 'Z':                        Bits.putBoolean(buf, off, unsafe.getBoolean(obj, key));                        break;                    case 'B':                        buf[off] = unsafe.getByte(obj, key);                        break;                    case 'C':                        Bits.putChar(buf, off, unsafe.getChar(obj, key));                        break;                    case 'S':                        Bits.putShort(buf, off, unsafe.getShort(obj, key));                        break;                    case 'I':                        Bits.putInt(buf, off, unsafe.getInt(obj, key));                        break;                    case 'F':                        Bits.putFloat(buf, off, unsafe.getFloat(obj, key));                        break;                    case 'J':                        Bits.putLong(buf, off, unsafe.getLong(obj, key));                        break;                    case 'D':                        Bits.putDouble(buf, off, unsafe.getDouble(obj, key));                        break;                    default: throw new InternalError();                }            }        }

        【基本类型和byte的相互转换，都是在Bits类中处理的，如果你对其感兴趣，可以好好研究一下JAVA中的基本类型和byte的转换】

        另外对于float和double都是先转换成long，再转成byte。

public static native int floatToRawIntBits(floatvalue);

public static native long doubleToRawLongBits(doublevalue);

解析对象类型 getObjFieldValues()

        写对象比基本类型要复杂，JDK先要查看Class是不是已经有序列化的记录，可以直接复用ClassDesc；另外需要判断对象的类型，Null,Handle,Class,Array,String,Enum等。最后在writeOrdinaryObject()中又会调用writeSerialData()和defaultWriteFields()来递归写入基本类型。

        详细可以参考ObjectOutputStream.writeObject0()如下。

    private void writeObject0(Object obj, boolean unshared) {        boolean oldMode = bout.setBlockDataMode(false);        depth++;        try {            // check for replacement object            Object orig = obj;            Class<?> cl = obj.getClass();            ObjectStreamClass desc;            for (;;) {                Class<?> repCl;                desc = ObjectStreamClass.lookup(cl, true);                if (!desc.hasWriteReplaceMethod() ||                    (obj = desc.invokeWriteReplace(obj)) == null ||                    (repCl = obj.getClass()) == cl) break;                cl = repCl;            }            if (enableReplace) {                Object rep = replaceObject(obj);                if (rep != obj && rep != null) {                    cl = rep.getClass();                    desc = ObjectStreamClass.lookup(cl, true);                }                obj = rep;            }            // if object replaced, run through original checks a second time            if (obj != orig) {                subs.assign(orig, obj);                if (obj == null) {                    writeNull();                    return;                } else if (!unshared && (h = handles.lookup(obj)) != -1) {                    writeHandle(h);                    return;                } else if (obj instanceof Class) {                    writeClass((Class) obj, unshared);                    return;                } else if (obj instanceof ObjectStreamClass) {                    writeClassDesc((ObjectStreamClass) obj, unshared);                    return;                }            }            // remaining cases            if (obj instanceof String) {                writeString((String) obj, unshared);            } else if (cl.isArray()) {                writeArray(obj, desc, unshared);            } else if (obj instanceof Enum) {                writeEnum((Enum<?>) obj, desc, unshared);            } else if (obj instanceof Serializable) {                writeOrdinaryObject(obj, desc, unshared);            } else                 throw new NotSerializableException(cl.getName());        } finally {            depth--;            bout.setBlockDataMode(oldMode);        }    }

        另外，我看了一下典型的String序列化策略。第一个字符作为String的类型标识，有普通String和长String，然后接着标记长度，最后才是用UTF写内容。

    private void writeString(String str, boolean unshared) throws IOException {        handles.assign(unshared ? null : str);        long utflen = bout.getUTFLength(str);        if (utflen <= 0xFFFF) {            bout.writeByte(TC_STRING);            bout.writeUTF(str, utflen);        } else {            bout.writeByte(TC_LONGSTRING);            bout.writeLongUTF(str, utflen);        }    }    void writeUTF(String s, long utflen) throws IOException {        if (utflen > 0xFFFFL)             throw new UTFDataFormatException();        writeShort((int) utflen);        writeBytes(s);    }