基于值反序列化到通用成员

Question

我有这样一个通用类：

public class Pojo<T> {
    
    @JsonProperty("value")
    public T[] values;
};

T可以包含String、LocalDateTime或intger。String和intger之间的区别似乎工作正常，很可能是因为这些类型在序列化的JSON文件中表示不同。然而，当我在JSON对象中有一个日期时间时（参见示例），它无论如何都会被解析为字符串。

value字段的实际使用类型是由输入决定的。虽然我在下面的最小示例中确实有这方面的知识，但这并不适用于我程序中该代码的所有使用。我只能依赖字段value的值模式。

public class Main {
    ObjectMapper mapper = new ObjectMapper();
    mapper.registerModule(new JavaTimeModule());
    mapper.configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);

    String json = "{\"value\": \"2022-02-22T12:00:00\"}";
    Pojo<?> deserialized = mapper.readValue(json, Pojo.class);
    assert deserialized.value[0] instanceof LocalDateTime;
}

我还没有成功修补JsonTypeInfo。如果该字段的所有值都匹配模式yyyy-MM-dd'T'hh:MM:ss，是否有方法将该值字段解析为LocalDateTime对象的数组？

Answer 1

这是你的问题——Pojo

ObjectMapper不知道要将T解析为什么类型。要告诉它类型，您需要使用带有TypeReference的readValue重载，或者使用带有JavaType的重载。我发现JavaType更容易阅读，下面是一个例子：

public class Test {

    public static void main(String[] args) throws Exception {
        ObjectMapper mapper = new ObjectMapper();
        mapper.registerModule(new JavaTimeModule());
        mapper.configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);

        String json = "{\"value\": \"2022-02-22T12:00:00\"}";
        JavaType javaType = TypeFactory.defaultInstance().constructParametricType(Pojo.class, LocalDateTime.class);
        Pojo<LocalDateTime> deserialized = mapper.readValue(json, javaType);
        System.out.println(deserialized.values[0].toLocalDate());
        System.out.println(deserialized.values[0].toLocalTime());
    }
}

当构造参数化JavaType时，第一个参数是类本身，接下来是具体的泛型类型。

编辑：考虑到新的信息，我能想到的最好的方法是自定义反序列化程序，它在运行时解析类型。比如：

public class UnknownTypeDeserializer<T> extends StdDeserializer<Pojo<T>> {

    private final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss");

    public UnknownTypeDeserializer() {
        super((Class<?>) null);
    }

    @Override
    public Pojo<T> deserialize(JsonParser parser, DeserializationContext ctxt) throws IOException, JacksonException {
        JsonNode node = parser.getCodec().readTree(parser);
        String value = node.get("value").asText();
        Pojo<T> pojo = new Pojo<>();
        T[] arr;
        try {
            arr = (T[]) new LocalDateTime[]{LocalDateTime.parse(value, this.formatter)};
        } catch (Exception exc) {
            try {
                arr = (T[]) new Integer[]{Integer.parseInt(value)};
            } catch (NumberFormatException numberFormatException) {
                arr = (T[]) new String[]{value};
            }
        }
        pojo.values = arr;
        return pojo;
    }
}

这个想法是尝试解析到LocalDateTime，如果不可能，尝试解析到int，如果不可能，再次保留为String。这是非常丑陋的方法，但我只是想说明这个想法。与其捕捉异常，不如检查格式，例如使用正则表达式，并根据正则表达式匹配，解析以纠正类型。我用字符串和int测试了它，它实际上是有效的。

public class Test {

    public static void main(String[] args) throws Exception {
        ObjectMapper mapper = new ObjectMapper();
        mapper.registerModule(new JavaTimeModule());
        SimpleModule simpleModule = new SimpleModule();
        simpleModule.addDeserializer(Pojo.class, new UnknownTypeDeserializer<>());
        mapper.registerModule(simpleModule);

        String json1 = "{\"value\": \"2022-02-22T12:00:00\"}";
        Pojo<?> deserialized1 = mapper.readValue(json1, Pojo.class);
        System.out.println("is date - " + (deserialized1.values[0] instanceof LocalDateTime));

        String json2 = "{\"value\": \"bla bla bla\"}";
        Pojo<?> deserialized2 = mapper.readValue(json2, Pojo.class);
        System.out.println("is string - " + (deserialized2.values[0] instanceof String));

        String json3 = "{\"value\": 41}";
        Pojo<?> deserialized3 = mapper.readValue(json3, Pojo.class);
        System.out.println("is int - " + (deserialized3.values[0] instanceof Integer));
    }
}