Question

我们正在使用一个API，而api提供了xml字段。我们必须为我们的使用者将xml转换为json。我们要求只显示XML格式的内容，并且仅显示那些字段。

如果字段存在且值存在
如果字段不存在，请不要显示它
如果字段为空/无值，则按原样显示该字段。

我看到的是一般注释

@JsonInclude(NON_EMPTY)可用于排除空值。我无法使用它，因为我仍然想在json中查看具有空值的空字段

@JsonInclude(NON_ABSENT)可用于排除空值和“不存在”的值。我无法使用它，因为我仍然想查看json中的空字段和空字段。与JsonInclude (NON_NULL)

相同

所以我的问题是，如果我不指定任何这些属性，我可以实现我想要的吗？换句话说，如果我不指定任何这些，杰克逊的行为就是显示动态意义上具有空值的所有字段？我主要关心的是这里的动态响应。对于每个请求，字段可以存在或不存在。我们必须在json中显示我们在XML中收到的确切信息

Answer 1

如果要将null值字段与不存在的字段区分开，最通用的方法是使用Map或JsonNode而不是POJO。 POJO类具有恒定的结构，Map或JsonNode具有动态的-仅包含您实际放置的内容。让我们创建一个简单的应用，该应用从文件中读取XML负载并创建JSON响应：

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.dataformat.xml.XmlMapper;

import java.io.File;
import java.util.Map;

public class JsonApp {

    public static void main(String[] args) throws Exception {
        File xmlFile = new File("./resource/test.xml").getAbsoluteFile();

        XmlMapper xmlMapper = new XmlMapper();
        Map map = xmlMapper.readValue(xmlFile, Map.class);

        ObjectMapper jsonMapper = new ObjectMapper();
        String json = jsonMapper.writeValueAsString(map);

        System.out.println(json);
    }
}

现在来看一些示例，我们测试将为JSON，empty和不存在的节点生成什么null。

测试0-0

输入XML：

<Root>
    <a>A</a>
    <b>1</b>
    <c>
        <c1>Rick</c1>
        <c2>58</c2>
    </c>
</Root>

结果JSON为：

{"a":"A","b":"1","c":{"c1":"Rick","c2":"58"}}

测试0-1

输入XML：

<Root>
    <a>A</a>
    <c>
        <c1>Rick</c1>
        <c2/>
    </c>
</Root>

输出JSON：

{"a":"A","c":{"c1":"Rick","c2":null}}

测试0-2

输入XML：

<Root>
    <c/>
</Root>

输出JSON：

{"c":null}

这种简单快速的解决方案的最大问题是我们丢失了基元的类型信息。例如，如果b为Integer，则应在JSON中将其作为没有引号的数字基元返回："左右。为了解决这个问题，我们应该使用POJO模型，该模型允许我们找到所有必需的类型。让我们为示例创建POJO模型：

@JsonFilter("allowedFields")
class Root {
    private String a;
    private Integer b;
    private C c;

    // getters, setters
}

@JsonFilter("allowedFields")
class C {
    private String c1;
    private Integer c2;

    // getters, setters
}

我们需要将简单的XML -> Map -> JSON算法更改为以下一种算法：

以Map或JsonNode的格式读取JSON
查找所有字段名称
使用找到的名称创建FilterProvider-注意，过滤器已注册为allowedFields名称，与@JsonFilter批注中使用的名称相同。
将Map转换为POJO以进行强制转换。
用过滤器写POJO

简单的应用可能如下所示：

import com.fasterxml.jackson.annotation.JsonFilter;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.fasterxml.jackson.databind.ser.impl.SimpleBeanPropertyFilter;
import com.fasterxml.jackson.databind.ser.impl.SimpleFilterProvider;
import com.fasterxml.jackson.dataformat.xml.XmlMapper;

import java.io.File;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Set;

public class JsonApp {

    public static void main(String[] args) throws Exception {
        File xmlFile = new File("./resource/test.xml").getAbsoluteFile();

        NodesWalker walker = new NodesWalker();

        XmlMapper xmlMapper = new XmlMapper();
        JsonNode root = xmlMapper.readValue(xmlFile, JsonNode.class);
        Set<String> names = walker.findAllNames(root);

        SimpleFilterProvider filterProvider = new SimpleFilterProvider();
        filterProvider.addFilter("allowedFields", SimpleBeanPropertyFilter.filterOutAllExcept(names));

        ObjectMapper jsonMapper = new ObjectMapper();
        jsonMapper.setFilterProvider(filterProvider);

        Root rootConverted = jsonMapper.convertValue(root, Root.class);
        String json = jsonMapper.writeValueAsString(rootConverted);

        System.out.println(json);
    }
}

class NodesWalker {

    public Set<String> findAllNames(JsonNode node) {
        Set<String> names = new HashSet<>();

        LinkedList<JsonNode> nodes = new LinkedList<>();
        nodes.add(node);
        while (nodes.size() > 0) {
            JsonNode first = nodes.removeFirst();
            if (first.isObject()) {
                ObjectNode objectNode = (ObjectNode) first;
                objectNode.fields().forEachRemaining(e -> {
                    names.add(e.getKey());
                    JsonNode value = e.getValue();
                    if (value.isObject() || value.isArray()) {
                        nodes.add(value);
                    }
                });
            } else if (first.isArray()) {
                ArrayNode arrayNode = (ArrayNode) first;
                arrayNode.elements().forEachRemaining(e -> {
                    if (e.isObject() || e.isArray()) {
                        nodes.add(e);
                    }
                });
            }
        }

        return names;
    }
}

测试1-0

输入XML：

<Root>
    <a>A</a>
    <b>1</b>
    <c>
        <c1>Rick</c1>
        <c2>58</c2>
    </c>
</Root>

输出JSON：

{"a":"A","b":1,"c":{"c1":"Rick","c2":58}}

测试1-1

输入XML：

<Root>
    <b>1</b>
    <c>
        <c2/>
    </c>
</Root>

输出JSON：

{"b":1,"c":{"c2":null}}

测试1-2

输入XML：

<Root>
    <c/>
</Root>

输出JSON：

{"c":null}

所有这些测试之后，我们发现动态检查字段是null，empty还是absent并不是一件容易的事。即便如此，以上两种解决方案仍适用于简单模型，您应该针对要生成的所有响应对其进行测试。当模型是复杂的并且包含许多复杂的注释时，例如：@JsonTypeInfo侧的@JsonSubTypes，Jackson或@XmlElementWrapper侧的@XmlAnyElement，JAXB使这项任务很难执行。

我认为您的示例中最好的解决方案是使用@JsonInclude(NON_NULL)，它将XML端的所有设置字段发送给客户端。 null和absent在客户端应被相同对待。业务逻辑不应依赖于null有效负载中将事实字段设置为absent或JSON的事实。

另请参阅：

如何区分杰克逊库中的空值字段和缺席字段

1 个答案:

测试0-0

测试0-1

测试0-2

测试1-0

测试1-1

测试1-2