Jackson运行时构造参数化JavaType解决泛型反序列化类型擦除问题

我太懂你这个困扰了——泛型类型擦除简直是Jackson反序列化的噩梦，尤其是这种继承多层泛型类的场景，运行时丢失了具体的泛型参数信息，Jackson就只能把内部字段默认反序列化成LinkedHashMap，直接导致ClassCastException。

好在你思路是对的：让用户传入Class<T>来补充丢失的类型信息，完全可以通过Jackson的TypeFactory构造出带泛型参数的完整类型，解决这个问题。下面给你两种可行的实现方案：

方案一：修改TypeReference的类型返回值 #

我们可以在TypedEventHandler里新增接收Class<T>的构造函数，用TypeFactory构造出参数化的JavaType，然后重写匿名TypeReference的getType()方法返回这个完整类型，这样Jackson就能拿到准确的泛型信息了：

public abstract class TypedEventHandler<T> extends AbstractTypedEventHandler<TypedEvent<T>, T> {
    // 无参构造改成需要传入具体的Class<T>
    protected TypedEventHandler(Class<T> resourceType) {
        super(buildTypedEventReference(resourceType));
    }

    protected TypedEventHandler(ObjectMapper mapper, Class<T> resourceType) {
        super(mapper, buildTypedEventReference(resourceType));
    }

    private static <T> TypeReference<TypedEvent<T>> buildTypedEventReference(Class<T> resourceType) {
        // 构造参数化类型：TypedEvent<T>，其中T是传入的具体类
        JavaType parameterizedType = TypeFactory.defaultInstance()
                .constructParametricType(TypedEvent.class, resourceType);
        
        // 返回自定义的TypeReference，重写getType方法返回我们构造的参数化类型
        return new TypeReference<TypedEvent<T>>() {
            @Override
            public Type getType() {
                return parameterizedType;
            }
        };
    }
}

用户使用的时候只需要在子类构造时传入具体的Class：

public class PojoEventHandler extends TypedEventHandler<Pojo> {
    public PojoEventHandler() {
        super(Pojo.class); // 这里传入具体的Pojo类
    }

    @Override
    public boolean handleEvent(TypedEvent<Pojo> event) {
        Pojo pojo = event.getResource(); // 现在不会再抛出ClassCastException了
        // 你的业务处理逻辑
        return true;
    }
}

方案二：直接使用JavaType替代TypeReference #

如果觉得TypeReference的匿名内部类有点绕，也可以直接在AbstractTypedEventHandler里改用JavaType来存储类型信息，这是Jackson内部用来表示类型的核心结构，更直接灵活：

首先修改父类AbstractTypedEventHandler：

public abstract class AbstractTypedEventHandler<E extends TypedEvent<T>, T> implements EventHandler<E> {
    @Getter private final ObjectMapper handlerMapper;
    @Getter private final JavaType eventType; // 把TypeReference换成JavaType

    protected AbstractTypedEventHandler(JavaType eventType) {
        this(JsonMapper.builder().configure(MapperFeature.ALLOW_FINAL_FIELDS_AS_MUTATORS, false).build(), eventType);
    }

    protected AbstractTypedEventHandler(ObjectMapper handlerMapper, JavaType eventType) {
        this.handlerMapper = handlerMapper;
        this.eventType = eventType;
    }

    @Override
    public boolean parseMessage(JsonNode text, Tracer tracer) throws IOException {
        E event = handlerMapper.treeToValue(text, eventType); // 直接用JavaType反序列化
        return handleEvent(event);
    }

    public abstract boolean handleEvent(E event);
}

然后修改TypedEventHandler：

public abstract class TypedEventHandler<T> extends AbstractTypedEventHandler<TypedEvent<T>, T> {
    protected TypedEventHandler(Class<T> resourceType) {
        super(buildParameterizedType(resourceType));
    }

    protected TypedEventHandler(ObjectMapper mapper, Class<T> resourceType) {
        super(mapper, buildParameterizedType(resourceType));
    }

    private static <T> JavaType buildParameterizedType(Class<T> resourceType) {
        // 直接构造TypedEvent<T>的参数化JavaType
        return TypeFactory.defaultInstance()
                .constructParametricType(TypedEvent.class, resourceType);
    }
}

用户的子类用法和方案一完全一致，同样传入Pojo.class即可。

为什么这两种方案能解决问题？ #

核心原因是：通过用户传入的Class<T>，我们在运行时手动构造出了包含完整泛型参数的类型信息（TypedEvent<Pojo>），而不是依赖被擦除的泛型类型。Jackson拿到这个完整的类型后，就知道要把TypedEvent内部的resource字段反序列化成Pojo，而不是默认的LinkedHashMap了。

内容来源于stack exchange