核心组件概述

在 Java 原生序列化体系中，ObjectStreamField 与 ObjectStreamClass 承担了底层元数据映射的职责。前者相当于反射字段 Field 的序列化增强包装，负责记录单个属性的类型、签名及布局偏移；后者则是类级别的序列化描述符，缓存了类的接口特征、序列版本标识（SUID）、自定义读写方法引用以及完整的字段快照。理解这两个类的运行机理，是掌握 ObjectOutputStream 数据流转路径的关键。

字段描述符：ObjectStreamField 内部实现

ObjectStreamField 本质上是一个轻量级的数据载体，专门用于在序列化流中传递属性级别的元数据。它不依赖任何外部容器，所有必需信息均在初始化时固化。

核心成员变量定义

// 替换原有结构，采用更具语义化的命名
private final String fieldName;         // 原始字段名称
private final String jvmTypeSignature;  // JVM 规范层面的类型签名
private final Class targetType;      // 运行时实际类型
private final boolean exclusiveFlag;    // 是否启用非共享写模式（对应原 unshared）
private final Field reflectField;       // 关联的 java.lang.reflect.Field 实例
private int bufferOffset = 0;           // 该字段在连续内存块中的相对起始位置

• bufferOffset：序列化器在处理包含多个成员的对象时，会将连续的基本类型数据合并为一个原生缓冲区。此偏移量用于定位当前属性在字节数组中的具体索引，上层类描述符通过该值直接映射内存地址。
• jvmTypeSignature：遵循 JVM 二进制规范的类型缩写，确保跨平台或跨版本流能够准确还原数据类型。

类型代码对照表如下：

基础数据类型	JVM 类型码
byte	B
short	S
int	I
long	J
float	F
double	D
char	C
boolean	Z
类引用	L
数组	[

构造逻辑与类型签名生成

public ObjectStreamField(String name, Class target, boolean exclusive) {
    this.fieldName = name;
    this.targetType = target;
    this.exclusiveFlag = exclusive;
    // 生成并缓存全局唯一的类型签名
    this.jvmTypeSignature = buildJvmSignature(target).intern();
    this.reflectField = null;
}

// 重构后的签名构建算法
private static String buildJvmSignature(Class cls) {
    StringBuilder sigBuilder = new StringBuilder();
    // 处理多维数组嵌套情况
    while (cls.isArray()) {
        sigBuilder.append('[');
        cls = cls.getComponentType();
    }
    
    // 识别基本类型
    if (cls.isPrimitive()) {
        if (cls == Integer.TYPE) sigBuilder.append('I');
        else if (cls == Byte.TYPE) sigBuilder.append('B');
        else if (cls == Long.TYPE) sigBuilder.append('J');
        else if (cls == Float.TYPE) sigBuilder.append('F');
        else if (cls == Double.TYPE) sigBuilder.append('D');
        else if (cls == Short.TYPE) sigBuilder.append('S');
        else if (cls == Character.TYPE) sigBuilder.append('C');
        else if (cls == Boolean.TYPE) sigBuilder.append('Z');
        else if (cls == Void.TYPE) sigBuilder.append('V');
        else throw new InternalError("未预期的基本类型");
    } else {
        // 引用类型格式：L完全限定名; （包名分隔符替换为 /）
        sigBuilder.append('L').append(cls.getName().replace('.', '/')).append(';');
    }
    return sigBuilder.toString();
}

类描述符：ObjectStreamClass 架构设计

ObjectStreamClass 充当了 Class 对象的序列化代理。它不仅提取了静态元数据，还通过反射绑定了类中可能存在的钩子方法，并利用工厂模式管理虚拟机内的单例缓存。

缓存模型与状态标记

// 类别与运行时特征
private Class runtimeClass;              // 目标 Java 类
private String className;                   // 全限定名快照
private volatile Long cachedSUID;           // 序列版本标识缓存

private boolean isDynamicProxy;             // 是否为动态代理类
private boolean isEnumConstant;             // 是否为枚举常量
private boolean implementsSerializable;     // 是否实现 Serializable
private boolean implementsExternalizable;   // 是否实现 Externalizable

// 自定义序列化钩子方法反射缓存
private Constructor instantiator;        // 无参构造函数或 NativeAccessor
private Method customWriteObject;           // private void writeObject(ObjectOutputStream)
private Method customReadObject;            // private void readObject(ObjectInputStream, ObjectStream)
private Method skipEmptyData;               // private void readObjectNoData()
private Method stateReplacement;            // private Object writeReplace()
private Method resolvedValue;               // private Object readResolve()
private boolean hasCustomWriteLogic;        // customWriteObject 是否存在

// 继承链关系
private ObjectStreamClass selfDescriptor;   // 当前类描述
private ObjectStreamClass parentDescriptor; // 父类描述

// 序列化字段集合
private ObjectStreamField[] persistentFields;

该类在初始化阶段即完成大部分元数据的预计算，避免在高频序列化操作中重复执行反射调用。

实例化与查找机制

构造器被声明为私有，外界必须通过静态查询方法获取实例。该机制配合内部缓存实现线程安全的懒加载：

/** 仅处理实现了 Serializable 接口的类 */
public static ObjectStreamClass lookup(Class cl) {
    return resolveDescriptor(cl, false);
}

/** 强制提取所有类型的序列化相关元数据（含未实现接口的类） */
public static ObjectStreamClass lookupAny(Class cl) {
    return resolveDescriptor(cl, true);
}

序列号获取策略

序列版本控制是保证反序列化兼容性的核心。系统优先查找显式声明的 SUID，若缺失则自动计算哈希校验值：

// 尝试从字节码中提取用户定义的 serialVersionUID
private static Long extractExplicitSUID(Class cls) {
    try {
        Field uidField = cls.getDeclaredField("serialVersionUID");
        // 验证修饰符组合：static + final
        int requiredMask = Modifier.STATIC | Modifier.FINAL;
        if ((uidField.getModifiers() & requiredMask) == requiredMask) {
            uidField.setAccessible(true);
            return uidField.getLong(null);
        }
    } catch (Exception ignored) { /* 忽略非法声明 */ }
    return null;
}

/** 对外暴露的统一获取入口 */
public long getSerialVersionUID() {
    if (cachedSUID != null) {
        return cachedSUID;
    }
    // 降级方案：基于类结构生成默认指纹
    return computeFallbackSUID(runtimeClass);
}

可序列化字段过滤规则

并非所有字段都会参与网络传输。提取逻辑严格区分显式配置与隐式默认行为：

/** 收集符合序列化条件的字段数组 */
private static ObjectStreamField[] collectSerialFields(Class cls)
    throws InvalidClassException {
    
    ObjectStreamField[] candidateFields;
    // 排除接口、代理类及 Externalizable 实现
    if (implementsSerializable(cls) && !isExternalizable(cls) && !isProxy(cls)) {
        // 优先读取 @Serial 注解或 transient/static 过滤后的默认列表
        candidateFields = inspectExplicitFields(cls);
        if (candidateFields == null || candidateFields.length == 0) {
            candidateFields = gatherImplicitFields(cls);
        }
        // 按字段名称排序以保证跨设备字节序一致
        Arrays.sort(candidateFields, Comparator.comparing(f -> f.fieldName));
    } else {
        candidateFields = EMPTY_FIELD_ARRAY;
    }
    return candidateFields;
}

/** 默认采集逻辑：剔除 static 与 transient 标记的成员 */
private static ObjectStreamField[] gatherImplicitFields(Class cls) {
    List<ObjectStreamField> pool = new ArrayList<>();
    int exclusionMask = Modifier.STATIC | Modifier.TRANSIENT;
    
    for (Field member : cls.getDeclaredFields()) {
        if ((member.getModifiers() & exclusionMask) == 0) {
            pool.add(new ObjectStreamField(member.getName(), member.getType(), false));
        }
    }
    return pool.isEmpty() ? EMPTY_FIELD_ARRAY : pool.toArray(EMPTY_FIELD_ARRAY);
}

数据写入流程拆解

当序列化引擎进入实际 IO 阶段时，会遍历类继承树并将数据分块写入输出流：

/** 执行对象主体数据的串行化输出 */
private void serializeObjectGraph(Object target, ObjectStreamClass descriptor) throws IOException {
    // 划分类层级数据槽位（当前类 + 所有非 Object 父类）
    ObjectStreamClass.ClassDataSlot[] layoutSlots = descriptor.getLayoutOrder();
    
    for (ObjectStreamClass.ClassDataSlot slot : layoutSlots) {
        persistClassData(target, slot.descriptor);
    }
}

/** 针对单一类层级的字段批量处理 */
private void persistClassData(Object target, ObjectStreamClass desc) throws IOException {
    // 1. 原生类型连续打包
    int primPayloadLength = desc.calculatePrimitiveCapacity();
    ensureBufferCapacity(primPayloadLength);
    
    // 将基本类型字段值拷贝至临时内存块
    desc.extractPrimitiveValues(target, tempPrimBuffer);
    bout.writeBytes(tempPrimBuffer, primPayloadLength, false);
    
    // 2. 引用类型递归展开
    ObjectStreamField[] fieldRegistry = desc.getFieldTable();
    int objFieldCount = desc.countObjectReferences();
    Object[] refContainer = new Object[objFieldCount];
    int primitiveCount = fieldRegistry.length - objFieldCount;
    
    // 提取对象类型字段的实时值
    desc.extractReferenceValues(target, refContainer);
    
    // 逐个触发深层序列化
    for (int idx = 0; idx < objFieldCount; idx++) {
        ObjectStreamField currentField = fieldRegistry[primitiveCount + idx];
        writeTargetNode(refContainer[idx], currentField.isExclusiveFlag);
    }
}

上述流程清晰展示了 Java 序列化如何将复杂对象图分解为"原生数据块"与"引用节点"交替输出的标准协议。偏移量计算、签名匹配与反射缓存共同保障了数据转换的高效性与准确性。