Java 序列化和反序列化（三）Serializable 源码分析 - 2
目录
在上一篇文章中围绕 ObjectOutputStream#writeObject 讲解了一下序列化的整个流程，这中间很多地方涉及到了 ObjectStreamClass 和 ObjectStreamField 这两个类。
-
ObjectStreamField按官方的说法是是字段的序列化描述符，本质是对 Field 字段的包装，包括字段名、字段值等。可以通过 ObjectStreamClass#getFields 获取所有需要序列化的字段信息。 -
ObjectStreamClass按官方的说法是类的序列化描述符，本质是对 Class 类的包装，提取了序列化时类的一些信息，包括字段的描述信息和 serialVersionUID。可以使用 lookup 方法找到/创建在此 Java VM 中加载的具体类的 ObjectStreamClass。
1. ObjectStreamField
ObjectStreamField 只是一个简单的 JavaBean，保存了序列化过程中字段的元数据信息，包括字段的类型、类型代码、签名等。 可以通过 ObjectStreamClass#getFields 获取所有需要序列化的字段信息。
1.1 数据结构
private final String name; // 1. field name
private final String signature; // 2. canonical JVM signature of field type
private final Class<?> type; // 3. 字段类型
private final boolean unshared; // 4. 序列化时字段是否是 unshared
private final Field field; // 5. Field
private int offset = 0; // 6. 序列化时数据在 buffer 中的偏移量
-
offset在序列化的过程中，当一个对象的成员属性个数超过一个时，JVM 会将会把所有的成员属性打包成一个“组”来操作，而 offset 就是这个组中当前描述的成员属性的偏移量，上层的 ObjectStreamClass 在调用当前这个成员属性的时候就使用偏移量进行引用定位操作； -
signature该属性描述了 JVM 中成员属性的类型签名
| JavaType | TypeCode |
|---|---|
| byte | B |
| short | S |
| int | I |
| long | J |
| float | F |
| double | D |
| char | C |
| boolean | Z |
| class | L |
| arrary | [ |
1.2 构造函数
public ObjectStreamField(String name, Class<?> type, boolean unshared) {
this.name = name;
this.type = type;
this.unshared = unshared;
signature = getClassSignature(type).intern();
field = null;
}
unshared 在 ObjectOutputStream源码分析的writeObject和writeUnshared区别进行了简单的说明，这里重点说一下 signature 这个属性，具体的方法如下：
// JVM 中类型签名
private static String getClassSignature(Class<?> cl) {
StringBuilder sbuf = new StringBuilder();
while (cl.isArray()) {
sbuf.append('[');
cl = cl.getComponentType();
}
if (cl.isPrimitive()) {
if (cl == Integer.TYPE) {
sbuf.append('I');
} else if (cl == Byte.TYPE) {
sbuf.append('B');
} else if (cl == Long.TYPE) {
sbuf.append('J');
} else if (cl == Float.TYPE) {
sbuf.append('F');
} else if (cl == Double.TYPE) {
sbuf.append('D');
} else if (cl == Short.TYPE) {
sbuf.append('S');
} else if (cl == Character.TYPE) {
sbuf.append('C');
} else if (cl == Boolean.TYPE) {
sbuf.append('Z');
} else if (cl == Void.TYPE) {
sbuf.append('V');
} else {
throw new InternalError();
}
} else {
sbuf.append('L' + cl.getName().replace('.', '/') + ';');
}
return sbuf.toString();
}
2. ObjectStreamClass
ObjectStreamClass 按官方的说法是类的序列化描述符，本质是对 Class 类的包装，提取了类序列化时的一些信息，包括字段的描述信息和 serialVersionUID 和需要序列化的字段 fields。本文只介绍一些 ObjectStreamClass 常用用法，更多关于ObjectStreamClass源码分析
2.1 数据结构
// 类的基本信息
private Class<?> cl; // 1. Class
private String name; // 2. cl.getName()
private volatile Long suid; // 3. serialVersionUID
private boolean isProxy; // 4. Proxy.isProxyClass(cl)
private boolean isEnum; // 5. Enum.class.isAssignableFrom(cl)
private boolean serializable; // 6. Serializable.class.isAssignableFrom(cl)
private boolean externalizable; // 7. Externalizable.class.isAssignableFrom(cl)
// Serializable 接口默认的方法，通过反射调用
private Constructor<?> cons; // 默认的构造函数
private Method writeObjectMethod; // writeObject
private Method readObjectMethod; // readObject
private Method readObjectNoDataMethod; // readObjectNoData
private Method writeReplaceMethod; // writeReplace
private Method readResolveMethod; // readResolve
private boolean hasWriteObjectData; // writeObjectMethod!=null
// localDesc表示本类的描述信息，superDesc表示父类的描述信息
private ObjectStreamClass localDesc; // this
private ObjectStreamClass superDesc; // 父类，superDesc=lookup(superCl, false)
// 要序列化的字段信息，通过 getSerialFields(c1) 获取
private ObjectStreamField[] fields; // 序列化的字段信息
总结： 通过这些字段信息可以看到 ObjectStreamClass 提取了类序列化时的一些基本信息，这些信息大部分都是在其构造时就提取出来了。
2.2 构造函数
private ObjectStreamClass(final Class<?> cl) {
// 1. 类的基本信息获取
this.cl = cl;
name = cl.getName();
isProxy = Proxy.isProxyClass(cl);
isEnum = Enum.class.isAssignableFrom(cl);
serializable = Serializable.class.isAssignableFrom(cl);
externalizable = Externalizable.class.isAssignableFrom(cl);
Class<?> superCl = cl.getSuperclass();
superDesc = (superCl != null) ? lookup(superCl, false) : null;
localDesc = this;
// 2. Serializable 接口默认的方法，通过反射调用
if (serializable) {
if (isEnum) {
suid = Long.valueOf(0);
fields = NO_FIELDS;
return null;
}
if (cl.isArray()) {
fields = NO_FIELDS;
return null;
}
suid = getDeclaredSUID(cl); // serialVersionUID
try {
fields = getSerialFields(cl); // 序列化的字段信息
computeFieldOffsets();
} catch (InvalidClassException e) {
serializeEx = deserializeEx = new ExceptionInfo(e.classname, e.getMessage());
fields = NO_FIELDS;
}
if (externalizable) {
cons = getExternalizableConstructor(cl);
} else {
cons = getSerializableConstructor(cl);
writeObjectMethod = getPrivateMethod(cl, "writeObject",
new Class<?>[] { ObjectOutputStream.class }, Void.TYPE);
readObjectMethod = getPrivateMethod(cl, "readObject",
new Class<?>[] { ObjectInputStream.class }, Void.TYPE);
readObjectNoDataMethod = getPrivateMethod(cl, "readObjectNoData", null, Void.TYPE);
hasWriteObjectData = (writeObjectMethod != null);
}
writeReplaceMethod = getInheritableMethod(cl, "writeReplace", null, Object.class);
readResolveMethod = getInheritableMethod(cl, "readResolve", null, Object.class);
return null;
} else {
suid = Long.valueOf(0);
fields = NO_FIELDS;
}
// 省略异常处理 ...
initialized = true;
}
总结： 这个构造函数是私有的，可以通过 lookup 获取一个类的 ObjectStreamClass。
// false 表示只获取实现了 Serializable 接口的类
public static ObjectStreamClass lookup(Class<?> cl) {
return lookup(cl, false);
}
// true 表示不管是否实现这个接口都提取相关的信息
public static ObjectStreamClass lookupAny(Class<?> cl) {
return lookup(cl, true);
}
2.3 提取序列号：getDeclaredSUID
// 提取 serialVersionUID 字段信息
private static Long getDeclaredSUID(Class<?> cl) {
try {
Field f = cl.getDeclaredField("serialVersionUID");
int mask = Modifier.STATIC | Modifier.FINAL;
if ((f.getModifiers() & mask) == mask) {
f.setAccessible(true);
return Long.valueOf(f.getLong(null));
}
} catch (Exception ex) {
}
return null;
}
public long getSerialVersionUID() {
if (suid == null) { // 显示的配置了 serialVersionUID 就直接返回
return computeDefaultSUID(cl); // 生成一个默认的序列号 id
}
return suid.longValue();
}
总结： getDeclaredSUID 方法提取 serialVersionUID 字段信息。如果没有配置，getSerialVersionUID 方法会通过 computeDefaultSUID 生成一个默认的序列号。
2.4 提取需要序列化字段：getSerialFields
// 提取需要序列化字段
private static ObjectStreamField[] getSerialFields(Class<?> cl)
throws InvalidClassException {
ObjectStreamField[] fields;
if (Serializable.class.isAssignableFrom(cl) &&
!Externalizable.class.isAssignableFrom(cl) &&
!Proxy.isProxyClass(cl) &&
!cl.isInterface()) {
// serialPersistentFields 配置需要序列化的字段
if ((fields = getDeclaredSerialFields(cl)) == null) {
// 默认的序列化字段
fields = getDefaultSerialFields(cl);
}
Arrays.sort(fields);
} else {
fields = NO_FIELDS;
}
return fields;
}
// 对外暴露的方法，获取可序列化的字段
public ObjectStreamField[] getFields() {
return getFields(true);
}
ObjectStreamField[] getFields(boolean copy) {
return copy ? fields.clone() : fields;
}
总结： getDeclaredSerialFields 提取的是 serialPersistentFields 字段显示配置的 serialPersistentFields 需要序列化的字段，如果没有配置(大部分情况都是这样的)则提取默认的字段。
// getDeclaredFields 提取本类中的所有字段，只要不是 static 或 transient 修辞的都会序列化
private static ObjectStreamField[] getDefaultSerialFields(Class<?> cl) {
Field[] clFields = cl.getDeclaredFields();
ArrayList<ObjectStreamField> list = new ArrayList<>();
int mask = Modifier.STATIC | Modifier.TRANSIENT;
for (int i = 0; i < clFields.length; i++) {
if ((clFields[i].getModifiers() & mask) == 0) {
list.add(new ObjectStreamField(clFields[i], false, true));
}
}
int size = list.size();
return (size == 0) ? NO_FIELDS :
list.toArray(new ObjectStreamField[size]);
}
2.5 其它方法
private void writeSerialData(Object obj, ObjectStreamClass desc) throws IOException {
// 获取要序列化的类，包括实现了 Serializable 接口的父类
ObjectStreamClass.ClassDataSlot[] slots = desc.getClassDataLayout();
for (int i = 0; i < slots.length; i++) {
defaultWriteFields(obj, slots[i].desc);
}
}
private void defaultWriteFields(Object obj, ObjectStreamClass desc) throws IOException {
// 1. Java 原生类型序列化
int primDataSize = desc.getPrimDataSize(); // 1.1 获取原生类型字段的长度
if (primVals == null || primVals.length < primDataSize) {
primVals = new byte[primDataSize];
}
desc.getPrimFieldValues(obj, primVals); // 1.2 获取原生类型字段的值
bout.write(primVals, 0, primDataSize, false); // 1.3 原生类型序列化
// 2. Java 对象类型序列化，递归调用 writeObject0 方法
ObjectStreamField[] fields = desc.getFields(false); // 2.1 获取所有序列化的字段
Object[] objVals = new Object[desc.getNumObjFields()];
int numPrimFields = fields.length - objVals.length;
desc.getObjFieldValues(obj, objVals); // 2.2 获取所有序列化字段的值
for (int i = 0; i < objVals.length; i++) { // 2.3 递归完成序列化
writeObject0(objVals[i], fields[numPrimFields + i].isUnshared());
}
}
总结： 其它用到的方法了解一下用法即可，就不往下深究了。
参考：
- 《ObjectStreamClass源码分析》：https://blog.csdn.net/silentbalanceyh/article/details/8250096
每天用心记录一点点。内容也许不重要，但习惯很重要！