logo标签列表

杰克逊序列化：XML和JSON的不同格式

javajsonxmlserializationjackson
6

我使用Jackson将应用程序的模型序列化/反序列化为JSON和XML（需要两者都有）。

模型类:

@JacksonXmlRootElement
public class Data { 
    @JsonProperty("attributes")
    @JsonDeserialize(using = AttributesDeserializer.class)
    @JsonSerialize(using = AttributesSerializer.class)
    @JacksonXmlElementWrapper
    private Map<Key, Map<String, Attribute>> attributes;

....

public class Key {
        private Integer id;
        private String name;

....

public class Attribute {
    private Integer id;
    private Integer value;
    private String name;

我需要我的JSON看起来像这样：
 {
  "attributes": [
    {
      "key": {
        "id": 10,
        "name": "key1"
      },
      "value": {
        "numeric": {
          "id": 1,
          "value": 100,
          "name": "numericAttribute"
        },
        "text": {
          "id": 2,
          "value": 200,
          "name": "textAttribute"
        }
      }
    },
    {
      "key": {
        "id": 20,
        "name": "key2"
      },
      "value": {
        "numeric": {
          "id": 1,
          "value": 100,
          "name": "numericAttribute"
        },
        "text": {
          "id": 2,
          "value": 200,
          "name": "textAttribute"
        }
      }
    }
  ]
}

我的XML文件看起来像这样：

<Data>
    <attributes>
        <key>
            <id>10</id>
            <name>key1</name>
        </key>
        <value>
            <numeric>
                <id>1</id>
                <value>100</value>
                <name>numericAttribute</name>
            </numeric>
            <text>
                <id>2</id>
                <value>200</value>
                <name>textAttribute</name>
            </text>
        </value>
        <key>
            <id>20</id>
            <name>key2</name>
        </key>
        <value>
            <numeric>
                <id>1</id>
                <value>100</value>
                <name>numericAttribute</name>
            </numeric>
            <text>
                <id>2</id>
                <value>200</value>
                <name>textAttribute</name>
            </text>
        </value>
    </attributes>
</Data>

我使用自定义序列化程序获取所需的JSON和XML数据：
public class AttributesSerializer extends JsonSerializer<Map<Key, Map<String, Attribute>>> {

    @Override
    public void serialize(Map<Key, Map<String, Attribute>> map, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException, JsonProcessingException {
        jsonGenerator.writeStartArray();
        for (Map.Entry<Key, Map<String, Attribute>> entry : map.entrySet()) {
            jsonGenerator.writeStartObject();
            jsonGenerator.writeObjectField("key", entry.getKey());
            jsonGenerator.writeObjectFieldStart("value");
            for (Map.Entry<String, Attribute> attributesEntry : entry.getValue().entrySet()) {
                jsonGenerator.writeObjectField(attributesEntry.getKey(), attributesEntry.getValue());
            }
            jsonGenerator.writeEndObject();
            jsonGenerator.writeEndObject();
        }
        jsonGenerator.writeEndArray();
    }
}

对于使用自定义反序列化器的JSON，反序列化工作正常：

public class AttributesDeserializer extends JsonDeserializer<Map<Key, Map<String, Attribute>>> {
    @Override
    public Map<Key, Map<String, Attribute>> deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException {
        JsonNode node = jsonParser.getCodec().readTree(jsonParser);
        if (node.size() == 0) {
            return null;
        }
        ObjectMapper om = new ObjectMapper();
        Map<Key, Map<String, Attribute>> attributes = new HashMap<>();
        node.forEach(jsonNode -> {
            Map<String, Attribute> attributesMap = new HashMap<>();
            JsonNode keyNode = jsonNode.get("key");
            Key key = om.convertValue(keyNode, Key.class);
            JsonNode valueNode = jsonNode.get("value");
            Iterator<Map.Entry<String, JsonNode>> attributesIterator = valueNode.fields();
            while(attributesIterator.hasNext()) {
                Map.Entry<String, JsonNode> field = attributesIterator.next();
                Attribute attribute = om.convertValue(field.getValue(), Attribute.class);
                attributesMap.put(field.getKey(), attribute);
            }
            attributes.put(key, attributesMap);
        });


        return attributes;
    }
}

虽然 JSON 没有问题，但是在反序列化 XML 时应用程序崩溃：

Exception in thread "main" com.fasterxml.jackson.databind.JsonMappingException: (was java.lang.NullPointerException) (through reference chain: ro.alexsvecencu.jackson.Data["attributes"])
    at com.fasterxml.jackson.databind.JsonMappingException.wrapWithPath(JsonMappingException.java:388)
    at com.fasterxml.jackson.databind.JsonMappingException.wrapWithPath(JsonMappingException.java:348)
    at com.fasterxml.jackson.databind.deser.BeanDeserializerBase.wrapAndThrow(BeanDeserializerBase.java:1599)
    at com.fasterxml.jackson.databind.deser.BeanDeserializer.vanillaDeserialize(BeanDeserializer.java:278)
    at com.fasterxml.jackson.databind.deser.BeanDeserializer.deserialize(BeanDeserializer.java:140)
    at com.fasterxml.jackson.databind.ObjectMapper._readMapAndClose(ObjectMapper.java:3798)
    at com.fasterxml.jackson.databind.ObjectMapper.readValue(ObjectMapper.java:2740)
    at ro.alexsvecencu.jackson.Main.main(Main.java:27)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:483)
    at com.intellij.rt.execution.application.AppMain.main(AppMain.java:134)
Caused by: java.lang.NullPointerException
    at ro.alexsvecencu.jackson.AttributesDeserializer.lambda$deserialize$0(AttributesDeserializer.java:29)
    at ro.alexsvecencu.jackson.AttributesDeserializer$$Lambda$1/1709366259.accept(Unknown Source)
    at java.lang.Iterable.forEach(Iterable.java:75)
    at ro.alexsvecencu.jackson.AttributesDeserializer.deserialize(AttributesDeserializer.java:24)
    at ro.alexsvecencu.jackson.AttributesDeserializer.deserialize(AttributesDeserializer.java:15)
    at com.fasterxml.jackson.databind.deser.SettableBeanProperty.deserialize(SettableBeanProperty.java:499)
    at com.fasterxml.jackson.databind.deser.impl.MethodProperty.deserializeAndSet(MethodProperty.java:101)
    at com.fasterxml.jackson.databind.deser.BeanDeserializer.vanillaDeserialize(BeanDeserializer.java:276)
    ... 9 more

发生的情况是，我的自定义反序列化器在处理XML时崩溃了，因为很明显它没有将所有属性解释为“数组”，当我遍历jsonNode的子项时，它将迭代键/值。此外，通过调试，我注意到反序列化器仅针对XML中最后一个标记的属性进行调用。
有没有办法告诉Jackson使用特定的自定义反序列化器/序列化器，以使其在XML和JSON之间有所不同？这是我认为可以解决问题的一种方式。
我的XML可能格式有点不同（我在形式上并不受限制，但JSON必须保持该格式）。在这种灵活性下，您是否看到任何解决我的问题的替代方法？我可以使用JAXB等其他工具来处理XML，但我基本上只能使用Jackson来处理两者。
3个回答
4
我为你提供了一个部分解决方案。通过使用Jackson mixin feature，可以为XML和JSON创建不同的自定义反序列化程序/序列化程序。
首先，您需要创建另一个POJO类，该类具有与Data类相同名称的属性，但使用不同的注释来进行自定义反序列化程序/序列化程序。
@JacksonXmlRootElement
public static class XmlData
{
    @JsonProperty("attributes")
    @JsonDeserialize(using = XmlAttributesDeserializer.class)  // specify different serializer
    @JsonSerialize(using = XmlAttributesSerializer.class)  // specify different deserializer
    @JacksonXmlElementWrapper
    public Map<Key, Map<String, Attribute>> attributes;
}

接下来，您需要创建一个Jackson Module，将Data类与混合类XmlData相关联。
@SuppressWarnings("serial")
public static class XmlModule extends SimpleModule
{
    public XmlModule()
    {
        super("XmlModule");
    }

    @Override
    public void setupModule(SetupContext context)
    {
        context.setMixInAnnotations(Data.class, XmlData.class);
    }
}

这是一个测试方法，展示了如何将模块注册到映射器并动态地序列化为不同的格式：

public static void main(String[] args)
{
    Attribute a1 = new Attribute();
    a1.id = 1;
    a1.value = 100;
    a1.name = "numericAttribute";
    Attribute a2 = new Attribute();
    a2.id = 2;
    a2.value = 200;
    a2.name = "textAttribute";
    Map<String, Attribute> atts = new HashMap<>();
    atts.put("numeric", a1);
    atts.put("text", a2);
    Key k1 = new Key();
    k1.id = 10;
    k1.name = "key1";
    Key k2 = new Key();
    k2.id = 20;
    k2.name = "key2";
    Data data = new Data();
    data.attributes = new HashMap<>();
    data.attributes.put(k1, atts);
    data.attributes.put(k2, atts);

    ObjectMapper mapper;
    if ("xml".equals(args[0])) {
        mapper = new XmlMapper();
        mapper.registerModule(new XmlModule());
    } else {
        mapper = new ObjectMapper();
    }
    try {
        mapper.writeValue(System.out, data);
    } catch (Exception e) {
        e.printStackTrace();
    }
}
0

是否可以使用仅一个序列化器/反序列化器来处理Json和Xml，然后在它们内部检查JsonGenerator的类型（json或xml），并应用与特定格式相关的逻辑？就像这样

    public class AttributeSerializer extends JsonSerializer<Map<Key, Map<String, Attribute>>> {

    @Override
    public void serialize(Map<Key, Map<String, Attribute>> value, JsonGenerator gen, SerializerProvider serializers)
        throws IOException, JsonProcessingException {
            if (gen instanceof ToXmlGenerator) {
                //apply logic to format xml structure
            } else {
                //apply logic to format json or else 
            }
    }
}

我知道使用 instaceOf 不是一个好的架构，但这样我们可以避免为 XML 重复创建 DTO。

0
除了sharonbn提供的解决方案外，我发现如果您能将字段封装到另一个类中，然后通过模块为Json（ObjectMapper）或Xml（XmlMapper）注册不同的序列化程序，也可以解决问题。
以下是一个示例：
public class CustomSerializers {

    public static class PojoField {

        PojoField() {
            value = "PojoField";
        }

        public String value;
    }

    @JacksonXmlRootElement
    public static class Pojo {

        Pojo() {
            field = new PojoField();
        }

        @JsonProperty("field")
        public PojoField field;
    }

    public static class PojoFieldJSonSerializer extends JsonSerializer<PojoField> {

        @Override
        public void serialize(PojoField pojoField, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException, JsonProcessingException {
            jsonGenerator.writeObject(pojoField.value + " in JSON");
        }
    }

    public static class PojoFieldXmlSerializer extends JsonSerializer<PojoField> {

        @Override
        public void serialize(PojoField pojoField, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException, JsonProcessingException {
            jsonGenerator.writeObject(pojoField.value + " in XMl");
        }
    }

    public static void main(String []args) throws IOException {
        Pojo pojo = new Pojo();

        SimpleModule objectMapperModule = new SimpleModule();
        objectMapperModule.addSerializer(PojoField.class, new PojoFieldJSonSerializer());
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.registerModule(objectMapperModule);

        objectMapper.writeValue(new File("pojo.json"), pojo);

        SimpleModule xmlMapperModule = new SimpleModule();
        xmlMapperModule.addSerializer(PojoField.class, new PojoFieldXmlSerializer());
        XmlMapper xmlMapper = new XmlMapper();
        xmlMapper.registerModule(xmlMapperModule);

        xmlMapper.writeValue(new File("pojo.xml"), pojo);

    }
}

JSON 的输出将是：
{"field": "PojoField in JSON"}

XML的输出：
<Pojo>
    <field>PojoField in XMl</field>
</Pojo>
网页内容由stack overflow 提供, 点击上面的
可以查看英文原文，
原文链接