Question

我正在使用Jackson数据绑定来处理发送到REST API和从REST API发送的JSON的序列化和反序列化的团队。 API广泛使用我们称之为“关键值”的臭名昭着且难以处理的模式。不幸的是，JSON的格式不受我们控制，所以我试图找到一种好的，简单的方法来处理它们的序列化和反序列化。

键值始终以下列模式显示：

"key_name":[{
    "key":"key_name"
    "value":<AN_OBJECT>
}]

值得注意的是，它们总是采用其中包含单个对象的数组的形式，并且对象内的键属性的值始终与外部数组的键相同。该值可以是任何有效的JSON值，包括数组或其他对象。键值本身没有值的类型指示符，但它对于给定的键值始终是相同的类型，因此我们在DTO类中指定它。

理想情况下，我想要的是使用数据绑定序列化和反序列化这些属性的简单，可重复的方法。 This question涉及在个人基础上处理非常相似的模式，但由于我们有许多不同的DTO使用该模式，我想要一些可以重复使用的东西。

例如，我希望能够编写一个看起来像这样的DTO类：

public class ContactInfo {
    private String id;
    private KeyValue<String> email;
    private KeyValue<String> phone_number;
    private KeyValue<Address> address;

    // Getters and setters

    public static class Address {
        private String street;
        private String city;
        private String state;
        private String zip;

        // Getters and setters
    }
}

并且能够通过数据绑定JSON序列化和反序列化，如下所示：

{
    "id":"123456",
    "email":[{
        "key":"email",
        "value":"fakeperson@example.com"
    }],
    "phone_number":[{
        "key":"phone_number",
        "value":"1-555-555-1234"
    }],
    "address":[{
        "key":"address",
        "value":{
            "street":"123 Main Street",
            "city":"New York City",
            "state":"NY",
            "zip":"12345
        }
    }]
}

我们已经有一个适用于String键值的解决方案，但在尝试将其概括为非字符串键值对象时遇到了麻烦。

现有的类看起来像这样：

@JsonSerialize(using = KeyValueSerializer.class)
@JsonDeserialize(using = KeyValueDeserializer.class)
public class KeyValue {

    private String key;
    private String value;

    // Omitted getters and setters...
}

public class KeyValueSerializer extends JsonSerializer<KeyValue> {

    @Override
    public void serialize(KeyValue keyValue, JsonGenerator jgen, SerializerProvider provider)
        throws IOException, JsonProcessingException {
        jgen.writeStartArray();
        jgen.writeStartObject();
        jgen.writeStringField("label", keyValue.getKey());
        jgen.writeStringField("value", keyValue.getValue());
        jgen.writeEndObject();
        jgen.writeEndArray();
    }
}

public class KeyValueDeserializer extends StdDeserializer<KeyValue> {

    protected KeyValueDeserializer() {
        super(KeyValue.class);
    }

    @Override
    public KeyValue deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException,
        JsonProcessingException {
        JsonNode node = jp.getCodec().readTree(jp);
        String value = node.findValue("value").asText();
        String key = node.findValue("key").asText();
        return new KeyValue(key, value);
    }

}

当试图概括这个类时，我遇到了类型和反序列化的问题。我尝试在自定义反序列化器中使用类似的东西：

objectMapper.readValue(valueNode.traverse(), objectMapper.getTypeFactory()
    .constructParametricType(TypedKeyValue.class, type)));

但我不知道如何确定预期类型应该是什么。

除了自定义序列化程序和反序列化程序之外，我还研究了使用“UNWRAP_SINGLE_VALUE_ARRAYS”反序列化功能查看的内容。但是，我们正在使用一个共享框架，其中包含反序列化器来访问API，我不想为每个人启用该标志，因为只有我们的团队正在使用这个特定的API。我也找不到只为特定类或属性启用该标志的方法。

所以，我的问题是，有没有办法做我想要的？我不一定需要使用自定义序列化器和反序列化器或泛型，但解决方案需要能够在大量DTO中轻松添加和维护，因此我不希望每个类都有很多代码或重复的包装类，如果我可以避免它。

Answer 1

您不需要自定义序列化程序/反序列化程序。只需使用反映JSON结构的类以及@JsonCreator annotation on the constructor。

您的KeyValue课程可以建模为KeyValueElement的列表：

@SuppressWarnings("serial")
public class KeyValue<T>
    extends LinkedList<KeyValueElement<T>> {

    public KeyValue() {
    }

    public KeyValue(String key, T value) {
        Map<String, Object> map = new HashMap<>(1);
        map.put(key, value);
        KeyValueElement<T> elem = new KeyValueElement<>(map);
        this.add(elem);
    }
}

我提供了2个构造函数：一个用于Jackson（一个用no-args），另一个用于缓解键值对的创建。 生成的JSON的正确性取决于您如何实例化此类。

KeyValueElement类可以建模如下：

public class KeyValueElement<T> {

    private String key;

    private T value;

    @SuppressWarnings("unchecked")
    @JsonCreator
    public KeyValueElement(Map<String, Object> delegate) {
        this.key = (String) delegate.get("key");
        this.value = (T) delegate.get("value");
    }

    public String getKey() {
        return this.key;
    }

    public void setKey(String key) {
        this.key = key;
    }

    public T getValue() {
        return this.value;
    }

    public void setValue(T value) {
        this.value = value;
    }
}

然后，只需使用您的ContactInfo课程，无需任何注释。这是一个测试：

ObjectMapper mapper = new ObjectMapper().setPropertyNamingStrategy(
    PropertyNamingStrategy.CAMEL_CASE_TO_LOWER_CASE_WITH_UNDERSCORES);

String json = "{\"id\":\"123456\",\"email\":[{\"key\":\"email\",\"value\":\"fakeperson@example.com\"}],\"phone_number\":[{\"key\":\"phone_number\",\"value\":\"1-555-555-1234\"}],\"address\":[{\"key\":\"address\",\"value\":{\"street\":\"123 Main Street\",\"city\":\"New York City\",\"state\":\"NY\",\"zip\":\"12345\"}}]}";

ContactInfo contactInfo = mapper.readValue(json, ContactInfo.class);

String serialized = mapper.writeValueAsString(contactInfo);

System.out.println(json.equals(serialized)); // true

我们的想法是让您的课程反映您的JSON结构，以便您的KeyValue<T>实际上是List<KeyValueElement<T>>（只有一个元素），其中KeyValueElement<T>是简单的键值对。

＆＃34;棘手＆＃34;部分是让杰克逊知道如何反序化每个KeyValueElement<T>。这是@JsonCreator注释派上用场并发挥其魔力的时候。

Jackson：通过数据绑定对单值数组中的泛型对象进行序列化/反序列化

1 个答案: