如何用 Jackson 序列化/反序列化 DefaultMutableTreeNode？

Question

我们如何使用 Jackson 将 Swing 的 DefaultMutableTreeNode 序列化/反序列化到 JSON 或从 JSON 序列化/反序列化？

有一个相关的问题 How to serialize DefaultMutableTreeNode (Java) to JSON?。 但它要求的是 Gson，而不是 Jackson（而且只有 用于序列化，而不是用于反序列化）。

对于DefaultMutableTreeNode杰克逊的默认 由于各种原因，序列化/序列化不起作用：

• 它包含同样是DefaultMutableTreeNode 对象的子对象。 但它没有规范的 getter 和 setter 方法 （如getChildren() 和setChildren(...)）。
• 它包含反向引用（通过方法getParent()、getRoot()、 getPath()) 这将导致无限递归和 StackOverflow 在序列化期间。
• 它有许多冗余的getter方法（如isLeaf()， getNextSibling(), getLastChild(), ...) 不需要 被序列化，因为它们是从其他属性派生的。

Answer 1

您可以自定义 Jackson 的 ObjectMapper JsonSerializer 和 JsonDeserializer 特别 用于将DefaultMutableTreeNode 转换为 JSON 反之亦然。

ObjectMapper objectMapper = new ObjectMapper()
    .registerModule(new SimpleModule()
        .addSerializer(DefaultMutableTreeNode.class, new DefaultMutableTreeNodeSerializer())
        .addDeserializer(DefaultMutableTreeNode.class, new DefaultMutableTreeNodeDeserializer()))
    .enable(SerializationFeature.INDENT_OUTPUT);

下面的DefaultMutableTreeNodeSerializer负责 用于将DefaultMutableTreeNode 转换为 JSON。 它写入allowsChildren、userObject 和children DefaultMutableTreeNode 到 JSON。 它不写它的parent，因为那会 导致无限递归和 StackOverflowError。 相反，父子关系被编码在嵌套的 JSON输出的结构。

public class DefaultMutableTreeNodeSerializer extends JsonSerializer<DefaultMutableTreeNode> {

    @Override
    public void serialize(DefaultMutableTreeNode node, JsonGenerator gen, SerializerProvider serializers)
            throws IOException {
        gen.writeStartObject();
        gen.writeBooleanField("allowsChildren", node.getAllowsChildren());
        gen.writeObjectField("userObject", node.getUserObject());
        if (node.getChildCount() > 0)
            gen.writeObjectField("children", Collections.list(node.children()));
        // Don't write node.getParent(), it would lead to infinite recursion.
        gen.writeEndObject();
    }
}

为了测试，您可以序列化样本JTree的根节点， 然后再次反序列化。

JTree tree = new JTree(); // a sample tree
Object root = tree.getModel().getRoot(); // a DefaultMutableTreeNode
String json = objectMapper.writeValueAsString(root);
System.out.println(json);
DefaultMutableTreeNode root2 = objectMapper.readValue(json, DefaultMutableTreeNode.class);

它会生成以下 JSON 输出：

{
  "allowsChildren" : true,
  "userObject" : "JTree",
  "children" : [ {
    "allowsChildren" : true,
    "userObject" : "colors",
    "children" : [ {
      "allowsChildren" : true,
      "userObject" : "blue"
    }, {
      "allowsChildren" : true,
      "userObject" : "violet"
    }, {
      "allowsChildren" : true,
      "userObject" : "red"
    }, {
      "allowsChildren" : true,
      "userObject" : "yellow"
    } ]
  }, {
    "allowsChildren" : true,
    "userObject" : "sports",
    "children" : [ {
      "allowsChildren" : true,
      "userObject" : "basketball"
    }, {
      "allowsChildren" : true,
      "userObject" : "soccer"
    }, {
      "allowsChildren" : true,
      "userObject" : "football"
    }, {
      "allowsChildren" : true,
      "userObject" : "hockey"
    } ]
  }, {
    "allowsChildren" : true,
    "userObject" : "food",
    "children" : [ {
      "allowsChildren" : true,
      "userObject" : "hot dogs"
    }, {
      "allowsChildren" : true,
      "userObject" : "pizza"
    }, {
      "allowsChildren" : true,
      "userObject" : "ravioli"
    }, {
      "allowsChildren" : true,
      "userObject" : "bananas"
    } ]
  } ]
}

下面的DefaultMutableTreeNodeDeserializer 是 负责将 JSON 转换回DefaultMutableTreeNode。

DefaultMutableTreeNode 非常不像 POJO 因此不能与杰克逊一起工作。 因此，我创建了一个行为良好的 POJO 助手类 （带有属性allowsChildren，userObject 和children) 并让 Jackson 将 JSON 内容反序列化到此类中。 然后我转换POJO 对象（及其POJO 孩子）到DefaultMutableTreeNode 对象 （与DefaultMutableTreeNode 孩子）。

public class DefaultMutableTreeNodeDeserializer extends JsonDeserializer<DefaultMutableTreeNode> {

    @Override
    public DefaultMutableTreeNode deserialize(JsonParser parser, DeserializationContext context)
            throws IOException {
        return parser.readValueAs(POJO.class).toDefaultMutableTreeNode();
    }

    private static class POJO {

        private boolean allowsChildren;
        private Object userObject;
        private List<POJO> children;
        // no need for: POJO parent

        public DefaultMutableTreeNode toDefaultMutableTreeNode() {
            DefaultMutableTreeNode node = new DefaultMutableTreeNode();
            node.setAllowsChildren(allowsChildren);
            node.setUserObject(userObject);
            if (children != null) {
                for (POJO child : children) {
                    node.add(child.toDefaultMutableTreeNode());  // recursion
                    // this did also set the parent of the child-node
                }
            }
            return node;
        }

        // Following setters needed by Jackson's deserialization:

        public void setAllowsChildren(boolean allowsChildren) {
            this.allowsChildren = allowsChildren;
        }

        public void setUserObject(Object userObject) {
            this.userObject = userObject;
        }

        public void setChildren(List<POJO> children) {
            this.children = children;
        }
    }
}