带有空元素键的Jackson JsonNode

Question

我使用jackson-dataformat-xml(2.9)将XML解析为JSONode，然后将其解析为JSON（XML是非常动态的，所以我使用JSONode而不是绑定到POJO。例如，“元素名”和“id”的名称可能不同）。

在JSON解析阶段，其中一个元素键是空字符串（“”）。

XML：

<elementName>
      <id type="pid">abcdef123</id>
</elementName>

public Parser() {
        ObjectMapper jsonMapper = new ObjectMapper();
        XmlMapper xmlMapper = new XmlMapper(new XmlFactory(new WstxInputFactory()));
}

public InputStream parseXmlResponse(InputStream xmlStream) {
        InputStream stream = null;

        try {
            JsonNode node = xmlMapper.readTree(xmlStream);
            stream = new ByteArrayInputStream(jsonMapper.writer().writeValueAsBytes(node));
        } catch (IOException e) {
            e.printStackTrace();
        }

        return stream;
    }

JSON：

结果：

{
   "elementName": {
     "id": {
        "type": "pid",
        "": "abcdef123"
     }
   },
}

预期：

{
   "elementName": {
     "id": {
        "type": "pid",
        "value": "abcdef123"
     }
   },
}

我的想法是无论何时找到空密钥“”，并用“值”替换它。无论是在XML反序列化还是在JSON序列化期间。我尝试使用默认的序列化程序，筛选器，但没有使它以一种良好和简洁的方式工作。

非常感谢提出建议。

基于@Shoek的建议，我决定编写一个自定义序列化程序，以避免在过程中创建中间对象（ObjectNode）。

public class CustomNode {
    private JsonNode jsonNode;

    public CustomNode(JsonNode jsonNode) {
        this.jsonNode = jsonNode;
    }

    public JsonNode getJsonNode() {
        return jsonNode;
    }
}

public class CustomObjectsResponseSerializer extends StdSerializer<CustomNode> {

    protected CustomObjectsResponseSerializer() {
        super(CustomNode.class);
    }

    @Override
    public void serialize(CustomNode node, JsonGenerator jgen, SerializerProvider provider) throws IOException {
        convertObjectNode(node.getJsonNode(), jgen, provider);
    }

    private void convertObjectNode(JsonNode node, JsonGenerator jgen, SerializerProvider provider) throws IOException {
        jgen.writeStartObject();
        for (Iterator<String> it = node.fieldNames(); it.hasNext(); ) {
            String childName = it.next();
            JsonNode childNode = node.get(childName);
            // XML parser returns an empty string as value name. Replacing it with "value"
            if (Objects.equals("", childName)) {
                childName = "value";
            }

            if (childNode instanceof ArrayNode) {
                jgen.writeFieldName(childName);
                convertArrayNode(childNode, jgen, provider);
            } else if (childNode instanceof ObjectNode) {
                jgen.writeFieldName(childName);
                convertObjectNode(childNode, jgen, provider);
            } else {
                provider.defaultSerializeField(childName, childNode, jgen);
            }
        }
        jgen.writeEndObject();

    }

    private void convertArrayNode(JsonNode node, JsonGenerator jgen, SerializerProvider provider) throws IOException {
        jgen.writeStartArray();
        for (Iterator<JsonNode> it = node.elements(); it.hasNext(); ) {
            JsonNode childNode = it.next();

            if (childNode instanceof ArrayNode) {
                convertArrayNode(childNode, jgen, provider);
            } else if (childNode instanceof ObjectNode) {
                convertObjectNode(childNode, jgen, provider);
            } else {
                provider.defaultSerializeValue(childNode, jgen);
            }
        }
        jgen.writeEndArray();
    }
}

Answer 1

您还可以简单地对JSON DOM进行后处理，遍历所有对象，并将空字符串的键重命名为“value”。

争用条件：这样的密钥可能已经存在，并且不能覆盖
（例如 abcdef123 )。

用法:
（注意：您不应该静默地禁止异常并返回null，而是允许它传播，以便调用方可以决定在需要时捕获并应用故障转移逻辑）

public InputStream parseXmlResponse(InputStream xmlStream) throws IOException {
    JsonNode node = xmlMapper.readTree(xmlStream);
    postprocess(node);
    return new ByteArrayInputStream(jsonMapper.writer().writeValueAsBytes(node));
}

private void postprocess(JsonNode jsonNode) {

    if (jsonNode.isArray()) {
        ArrayNode array = (ArrayNode) jsonNode;
        Iterable<JsonNode> elements = () -> array.elements();

        // recursive post-processing
        for (JsonNode element : elements) {
            postprocess(element);
        }
    }
    if (jsonNode.isObject()) {
        ObjectNode object = (ObjectNode) jsonNode;
        Iterable<String> fieldNames = () -> object.fieldNames();

        // recursive post-processing
        for (String fieldName : fieldNames) {
            postprocess(object.get(fieldName));
        }
        // check if an attribute with empty string key exists, and rename it to 'value',
        // unless there already exists another non-null attribute named 'value' which
        // would be overwritten.
        JsonNode emptyKeyValue = object.get("");
        JsonNode existing = object.get("value");
        if (emptyKeyValue != null) {
            if (existing == null || existing.isNull()) {
                object.set("value", emptyKeyValue);
                object.remove("");
            } else {
                System.err.println("Skipping empty key value as a key named 'value' already exists.");
            }
        }
    }
}

输出：正如预期的那样。

{
   "elementName": {
     "id": {
        "type": "pid",
        "value": "abcdef123"
     }
   },
}

编辑：关于性能的注意事项：

我使用一个大型XML文件(enwikiquote-20200520-pages-articles-multistream.XML,en.wikiquote XML dump,498.4 MB）进行了100轮测试，测试时间如下（使用deltas与system.nanotime()):

• 平均读取时间（文件，SSD):2870.96ms
  (jsonnode=xmlmapper.readtree(xmlStream)；)
• 平均后处理时间:0.04ms
  (后处理（节点）；)
• 平均写入时间（内存）:0.31ms
  (new ByteArrayInputStream(jsonMapper.writer().writeValueasBytes(node))；)

对于从一个大约500 MB的文件构建对象树来说，这只是一毫秒的几分之一--因此性能非常出色，无需担心。