jackson反序列化：如何将特定属性映射到getters和setters，以及将所有属性加载到同一个POJO的映射中？

Question

我需要将JSON字符串反序列化到POJO类中，场景如下：

• 一些基本的JSON属性应该映射到POJO类中的getters和setters字段。
• 所有JSON属性都应该加载到同一个POJO类的映射文件中。

例如，我有以下JSON字符串：

"entry":[
   {
        "id": "1",
        "name": "Type",
        "type": "General",
        "updated": "Tue, 12 Aug 2014 05:24:01.397Z",
        "summary": {
            "lang": "en",
            "value": "Testing for content"
        }
    },
    {
        "id": "1",
        "name": "Type",
        "type": "General",
        "updated": "Tue, 12 Aug 2014 05:24:01.397Z",
        "summary": {
            "lang": "en",
         "value": "Testing for content"
        }
      }
  ]

现在我需要将上面的JSON字符串反序列化为以下POJO类：

public class EntryType
{
    private String id;

    private String name;

    private String type;

    private String updated;

    private Map<String,Object> allJsonProperties;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getUpdated() {
        return updated;
    }

    public void setUpdated(String updated) {
        this.updated = updated;
    }

    public Map<String, Object> getAllJsonProperties() {
        return allJsonProperties;
    }

    public void setAllJsonProperties(Map<String, Object> allJsonProperties) {
        this.allJsonProperties = allJsonProperties;
    }

}

我能够将id、name、type、updated映射到适当的POJO类字段。但我不知道如何将id、name、type、updated和summary属性再次加载到Map（allJsonProperties）字段中。有谁能指导我如何算出这个吗？。

注意：我使用的是jackson API2.2.2版

Answer 1

您可以考虑将对象反序列化两次。首先，使用一个构造函数创建一个实例，该构造函数带有标记有@JSONCreator注释的映射参数。其次，使用objectmapper.readerforupdating方法用json值填充新创建的实例。

这里有一个例子：

public class JacksonForUpdate {

    public static class Bean {
        private String name;
        private Map<String, Object> properties;

        public void setName(String name) {
            this.name = name;
        }

        @JsonCreator
        public Bean(Map<String, Object> properties) {
            this.properties = properties;
        }

        @Override
        public String toString() {
            return "Bean{" +
                    "name='" + name + '\'' +
                    ", properties=" + properties +
                    '}';
        }
    }
    public static void main(String[] args) throws IOException {
        ObjectMapper mapper = new ObjectMapper();
        final String json = "{\"name\":\"value\"}";
        Bean object = mapper.readValue(json, Bean.class);
        System.out.println(mapper.readerForUpdating(object).readValue(json));
    }
}

输出：

Bean{name='value', properties={name=value}}

更新：上面的解决方案不适用对象数组的反序列化。一种可能的解决方法是使用JSONNODe构造对象，使用ObjectMapper.ConvertValue转换设置属性映射，并像前面一样填充字段值。

注意，objectmapper需要在这个bean类中是可访问的，这可以使用jackson值注入来完成。

这里有一个例子：

public class JacksonForUpdate2 {

    public static class Bean {
        private String name;
        private Map<String, Object> properties;

        public void setName(String name) {
            this.name = name;
        }

        @JsonCreator
        public Bean(JsonNode node, @JacksonInject ObjectMapper mapper) throws IOException {
            this.properties = mapper.convertValue(node, Map.class);
            mapper.readerForUpdating(this).readValue(node);
        }

        @Override
        public String toString() {
            return "Bean{" +
                    "name='" + name + '\'' +
                    ", properties=" + properties +
                    '}';
        }
    }
    public static void main(String[] args) throws IOException {
        ObjectMapper mapper = new ObjectMapper();
        // make the mapper to be available for the bean
        mapper.setInjectableValues(new InjectableValues.Std().addValue(ObjectMapper.class, mapper));
        final String json = "[{\"name\":\"value\"},{\"name\":\"value2\"}]";
        System.out.println( mapper.readValue(json, new TypeReference<List<Bean>>() {}));
    }
}

输出：

[Bean{name='value', properties={name=value}}, Bean{name='value2', properties={name=value2}}]

不过这看起来不再那么优雅了。