如何从内部类型推导包装类型的Jackson TypeReference，隐藏实现细节

背景：TypeReference的局限与泛型擦除 #

Jackson的TypeReference需要通过子类化来固化泛型参数的具体类型，示例：

final var typeRef = new TypeReference<List<MyType<MyArg>>>() {};
final List<MyType<MyArg>> list = mapper.readValue(input, typeRef);
final MyType<MyArg> first = list.get(0);

这种方式仅在子类化时能明确完整类型时有效。如果把逻辑提取到泛型方法中会直接失效：

<T> T convert(final String input) {
  final var typeRef = new TypeReference<List<MyType<T>>>() {};
  final List<MyType<T>> list = mapper.readValue(input, typeRef);
  return list;
}

final MyType<MyArg> first = list.get(0);

原因是泛型擦除会让TypeReference实际退化为new TypeReference<List<MyType<Object>>>() {}，反序列化结果大概率会变成List<MyType<Map<String, Object>>>。

需求场景 #

现有以下嵌套泛型的record定义：

private record MyResponse<T>(MyResult<T> result) {}

private record MyResult<T>(List<T> values) {}

private record MyStringValue(String name) {
    @Override public String toString() {
        return "'" + name + "'";
    }
}

以及核心转换方法：

<T> MyResult<T> convert(final String input, final TypeReference<MyResponse<T>> typeRef) {
    try {
        return objectMapper.readValue(input, typeRef).result();
    } catch (final JsonProcessingException ex) {
        throw new RuntimeException(ex);
    }
}

希望实现一个unwrap方法，让调用者只需要关注内部的业务类型（比如MyStringValue），无需知晓MyResponse和MyResult这些包装类的存在，避免调用时必须传入TypeReference<MyResponse<MyResult<T>>>这种冗长的类型签名。

可行实现方案 #

可以利用Jackson的TypeFactory手动构造嵌套的参数化类型，在unwrap方法内部封装包装类的类型细节，完全无需暴露给调用者：

<T> List<T> unwrap(final String input, final TypeReference<T> elementTypeRef) {
    // 构造MyResult<T>的参数化类型
    Type myResultType = TypeFactory.defaultInstance()
        .constructParametricType(MyResult.class, elementTypeRef.getType());
    // 构造MyResponse<MyResult<T>>的参数化类型
    Type wrappedType = TypeFactory.defaultInstance()
        .constructParametricType(MyResponse.class, myResultType);
    
    // 创建对应包装类型的TypeReference
    TypeReference<MyResponse<MyResult<T>>> wrappedTypeRef = new TypeReference<>() {
        @Override
        public Type getType() {
            return wrappedType;
        }
    };
    
    // 调用转换方法并解包返回结果
    return convert(input, wrappedTypeRef).values();
}

调用方式 #

调用者只需传入内部元素类型的TypeReference，完全无需关心包装类：

final List<MyStringValue> values = unwrap(input, new TypeReference<MyStringValue>() {});

适配子类场景 #

如果MyResponse存在子类，只需将constructParametricType的第一个参数替换为对应的子类Class即可，比如：

Type wrappedType = TypeFactory.defaultInstance()
    .constructParametricType(MySubResponse.class, myResultType);

这种方式绕过了泛型擦除的限制，成功将包装类的实现细节隐藏起来，调用者只需要关注实际业务类型即可。

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