Ufdjrw

How can we serialize/deserialize Swing's DefaultMutableTreeNode to/from JSON with Jackson?

There is a related question
How to serialize DefaultMutableTreeNode (Java) to JSON?.
But it asked for Gson, not Jackson (and only
for serialization, not for deserialization).

For DefaultMutableTreeNode Jackson's default
serialization/serialization doesn't work, for various reasons:

• It contains children which again are DefaultMutableTreeNode objects.
  But it doesn't have the canonical getter and setter methods for that
  (like getChildren() and setChildren(...)).


• It contains back-references (via methods getParent(), getRoot(),
  getPath()) which would lead to infinite recursion and StackOverflow
  during serialization.


• It has many redundant getter methods (like isLeaf(),
  getNextSibling(), getLastChild(), ...) which don't need
  to be serialized, because they are derived from other properties.

You can to customize Jackson's ObjectMapper with a
JsonSerializer and JsonDeserializer specially
crafted for converting a DefaultMutableTreeNode to JSON
and vice versa.

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

The DefaultMutableTreeNodeSerializer below is responsible
for converting a DefaultMutableTreeNode to JSON.
It writes the allowsChildren, userObject and children
of DefaultMutableTreeNode to JSON.
It does not write its parent, because that would
lead to infinite recursion and StackOverflowError.
Instead, the parent-child relations are encoded in the nested
structure of the JSON-output.

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();
 

For testing you can serialize the root node of a sample JTree,
and then deserialize it again.

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);

It generates the following JSON output:

 "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"
 ]
 ]

The DefaultMutableTreeNodeDeserializer below is
responsible for converting JSON back to a DefaultMutableTreeNode.

The DefaultMutableTreeNode is very not POJO-like
and thus doesn't work well together with Jackson.
Therefore I created a well-behaving POJO helper class
(with properties allowsChildren, userObject
and children)
and let Jackson deserialize the JSON content into this class.
Then I convert the POJO object (and its POJO
children) to a DefaultMutableTreeNode object
(with DefaultMutableTreeNode children).

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;