如何使用Jackson通过返回泛型包装类的静态工厂方法反序列化值？

我想用Jackson把JSON值反序列化为泛型包装对象Wrapped<T>，每种具体类型（比如Person、Score）都有对应的静态工厂方法来创建Wrapped<T>实例。但即使给工厂方法加了@JsonCreator注解，Jackson还是无法识别这种间接关系，抛出异常：

com.fasterxml.jackson.databind.exc.InvalidDefinitionException: Cannot construct instance of Wrapped (no Creators, like default constructor, exist): no String-argument constructor/factory method to deserialize from String value ('Carl')

核心需求：让Jackson使用返回泛型包装类的静态工厂方法完成反序列化，且JSON中不能包含类型信息，所有类型信息仅存在Java代码中。

以下是可复现问题的完整代码：

class Request {
    // 要反序列化的字段
    @JsonProperty Wrapped<Person> person;
    @JsonProperty Wrapped<Score> score;
}

class Wrapped<T> {
    // 泛型包装类，构造逻辑复杂，无法先创建值再包装，必须通过具体类型的工厂方法构造
    T value;
    public Wrapped(T value) {
        this.value = value;
    }
}

class Person {
    @JsonCreator
    public static Wrapped<Person> createWrapped(String name) {
        // 复杂构造逻辑示例
        return new Wrapped<>(new Person(name));
    }

    @JsonValue
    String name;
    public Person(String name) {
        this.name = name;
    }
}

class Score {
    @JsonCreator
    public static Wrapped<Score> createWrapped(int score) {
        // 复杂构造逻辑示例
        return new Wrapped<>(new Score(score));
    }

    @JsonValue
    int score;
    public Score(int score) {
        this.score = score;
    }
}

class Example {
    private static final String JSON_REQUEST =
            """
            {
              "person":"Carl",
              "score":20
            }
            """;

    public static void main(String[] args) throws Exception {
        Request request = new ObjectMapper()
                .readValue(JSON_REQUEST, Request.class);
        System.out.println(request.person.value.name);
        System.out.println(request.score.value.score);
    }
}

问题根源在于Jackson处理Wrapped<T>类型时，无法自动关联到对应T类型的工厂方法。我们可以通过自定义上下文感知反序列化器来解决，它能根据字段的泛型参数找到对应的工厂方法。

步骤1：实现上下文感知反序列化器 #

这个反序列化器会在初始化时读取字段的泛型信息（比如Wrapped<Person>中的Person），然后找到该类型的createWrapped工厂方法，最终调用方法完成反序列化：

import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.deser.ContextualDeserializer;
import com.fasterxml.jackson.databind.deser.std.StdDeserializer;
import java.io.IOException;
import java.lang.reflect.Method;

class WrappedDeserializer extends StdDeserializer<Wrapped<?>> implements ContextualDeserializer {
    private Class<?> valueType;
    private Method factoryMethod;

    public WrappedDeserializer() {
        super(Wrapped.class);
    }

    private WrappedDeserializer(Class<?> valueType) {
        super(Wrapped.class);
        this.valueType = valueType;
        try {
            // 查找目标类型的createWrapped静态工厂方法
            this.factoryMethod = valueType.getDeclaredMethod("createWrapped", getParameterType(valueType));
        } catch (NoSuchMethodException e) {
            throw new RuntimeException("类型" + valueType.getName() + "找不到createWrapped工厂方法", e);
        }
    }

    // 根据具体类型匹配JSON值的参数类型
    private Class<?> getParameterType(Class<?> valueType) {
        if (Person.class.equals(valueType)) {
            return String.class;
        } else if (Score.class.equals(valueType)) {
            return int.class;
        }
        throw new IllegalArgumentException("不支持的包装类型：" + valueType);
    }

    @Override
    public Wrapped<?> deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
        try {
            // 读取JSON值并调用工厂方法创建Wrapped实例
            Object jsonValue = p.readValueAs(getParameterType(valueType));
            return (Wrapped<?>) factoryMethod.invoke(null, jsonValue);
        } catch (IllegalAccessException | InvocationTargetException e) {
            throw new IOException("调用工厂方法创建Wrapped实例失败", e);
        }
    }

    @Override
    public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException {
        // 获取字段的泛型参数（比如Wrapped<Person>中的Person）
        JavaType wrapperType = property.getType();
        JavaType valueType = wrapperType.getBindings().getBoundType(0);
        return new WrappedDeserializer(valueType.getRawClass());
    }
}

步骤2：在Request字段上指定反序列化器 #

给Request中的Wrapped<T>字段添加@JsonDeserialize注解，指定使用上面的反序列化器：

class Request {
    @JsonProperty
    @JsonDeserialize(using = WrappedDeserializer.class)
    Wrapped<Person> person;

    @JsonProperty
    @JsonDeserialize(using = WrappedDeserializer.class)
    Wrapped<Score> score;
}

步骤3：验证运行 #

直接运行原Example类的main方法，就能正常输出：

Carl
20

可选优化：注册全局模块 #

如果不想在每个字段上添加注解，可以创建一个Jackson模块，全局注册反序列化器：

import com.fasterxml.jackson.databind.module.SimpleModule;

class WrappedModule extends SimpleModule {
    public WrappedModule() {
        addDeserializer(Wrapped.class, new WrappedDeserializer());
    }
}

然后初始化ObjectMapper时注册该模块：

Request request = new ObjectMapper()
        .registerModule(new WrappedModule())
        .readValue(JSON_REQUEST, Request.class);

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