如何序列化含递归结构与通配符的Java泛型类？

1. 手动嵌入类型元数据 #

Java泛型擦除会导致反序列化时丢失通配符?对应的实际类型信息，最直接的解决方式是在GenericObject中新增字段存储类型元数据，序列化时主动写入，反序列化时依据该信息完成类型转换。

修改后的类示例：

public class GenericObject<T> implements Serializable {    
    private static final long serialVersionUID = 23L;
    
    private Class<T> object1;
    private GenericObject<?> object2;
    // 新增字段存储object2的实际泛型类型
    private Type object2ActualType;

    // 设置object2时同步保存类型信息
    public void setObject2(GenericObject<?> object2) {
        this.object2 = object2;
        if (object2 != null) {
            // 通过TypeToken捕获实际泛型类型（需在创建对象时明确传入）
            this.object2ActualType = new TypeToken<GenericObject<?>>() {}.getType();
        }
    }

    // 反序列化后获取强类型的object2
    @SuppressWarnings("unchecked")
    public <U> GenericObject<U> getTypedObject2() {
        if (object2ActualType != null && object2 != null) {
            return (GenericObject<U>) object2;
        }
        return null;
    }
}

创建递归对象时，需通过TypeToken明确传入层级类型，确保序列化时类型元数据完整。

2. 自定义序列化/反序列化逻辑 #

重写writeObject和readObject方法，手动控制流的读写过程，主动写入/读取泛型类型信息，绕过默认序列化的泛型擦除限制。

示例代码：

public class GenericObject<T> implements Serializable {    
    private static final long serialVersionUID = 23L;
    
    private Class<T> object1;
    private GenericObject<?> object2;

    private void writeObject(ObjectOutputStream out) throws IOException {
        out.defaultWriteObject();
        // 写入object2的泛型参数类型
        if (object2 != null) {
            Type type = object2.getClass().getGenericSuperclass();
            if (type instanceof ParameterizedType) {
                ParameterizedType paramType = (ParameterizedType) type;
                out.writeObject(paramType.getActualTypeArguments()[0]);
            } else {
                out.writeObject(null);
            }
        } else {
            out.writeObject(null);
        }
    }

    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        in.defaultReadObject();
        // 读取类型信息并完成类型转换
        Type object2Type = (Type) in.readObject();
        if (object2Type != null && object2 != null) {
            // 可借助反射或TypeToken工具完成精准类型转换
        }
    }
}

3. 优化泛型定义，减少无界通配符依赖 #

如果业务场景允许，将无界通配符?替换为明确的泛型参数，通过多泛型参数定义层级类型，从根源减少类型模糊问题。

调整后的类示例：

public class GenericObject<T, U> implements Serializable {    
    private static final long serialVersionUID = 23L;
    
    private Class<T> object1;
    private GenericObject<U, ?> object2;
    private Class<U> object2Type;

    // 构造时明确传入各层级类型
    public GenericObject(Class<T> object1, Class<U> object2Type) {
        this.object1 = object1;
        this.object2Type = object2Type;
    }
}

4. 结合Jackson的动态类型反序列化 #

若回到JSON序列化方案，可在序列化时将类型信息嵌入JSON结构，反序列化时先解析类型字符串，再动态构建TypeReference完成反序列化。

示例流程：

// 序列化时主动添加类型字段
ObjectMapper mapper = new ObjectMapper();
mapper.addMixIn(GenericObject.class, GenericObjectTypeMixin.class);
String json = mapper.writeValueAsString(recursiveObject);

// 反序列化时先读取类型，再构建TypeReference
JsonNode node = mapper.readTree(json);
String typeStr = node.get("type").asText();
Type targetType = Class.forName(typeStr);
GenericObject<?> result = mapper.readValue(node.traverse(), TypeFactory.defaultInstance().constructType(targetType));

内容的提问来源于stack exchange，提问作者Manuel