Tree Model Nodes in Jackson

In Jackson, Tree Model Node is one of the most important concepts which we are going to discuss in this section. We will use Tree Model Node for various conversions and for adding, modifying, and removing nodes.

Let’s understand how we can create a Node, transform a Node, manipulate a Node, locate a Node, and iterate over the Nodes one by one:

Creating a Node

First, we will create an instance of the ObjectMapper class with the help of the default constructor.

ObjectMapper mapper =new ObjectMapper();

Now, we can construct a JsonNode from any one of the following three ways:

We can create a Node From Scratch, i.e., the simplest way of creating a Node. However, we also have two ways to create a JsonNode from scratch also:
1. By using the createObjectNode() method of the ObjectMapper class.
  JsonNode node = mapper.createObjectNode();
2. We can also create a Node from the JsonNodeFactory class in the following way:
  JsonNode node = JsonNodeFactory.instance.objectNode();
We can also create a JsonNode by parsing from a JSON source. To learn more about this way, go through the following link:
https://tutoraspire.com/parsing-string-to-jsonnode-jackson
We can also create JsonNode by converting it from the Java object. We use the valueToTree() method of the ObjectMapper class to form JsonNode from a Java object.
JsonNode node = mapper.valueToTree(fromValue)
Alternatively, we can also use the convertValue API for this purpose.
JsonNode node = mapper.convertValue(fromValue, JsonNode.class)

Let’s take an example to understand how we can create a JsonNode by using the valueToTree() method.

ValueToTreeJsonNode.java

  // import required classes and package if any    import java.util.Scanner;    import com.fasterxml.jackson.databind.JsonNode;    import com.fasterxml.jackson.databind.ObjectMapper;       // create class ValueToTreeJsonNode to construct JSonNode from scratch    public class ValueToTreeJsonNode {              // main() method start        public static void main(String args[]) {                      String name, date,  time;                      // create Scanner class object            Scanner sc = new Scanner(System.in);                      System.out.println(“Enter movie name:”);            name = sc.nextLine();                      System.out.println(“Enter show date in dd-mm-yyyy format:”);            date = sc.nextLine();                      System.out.println(“Enter show time in hh:mm:ss AM/PM:”);            time = sc.nextLine();                      // create an instance of BookShow            BookShow show = new BookShow(name, date, time);                      // create an instance of ObjectMapper class            ObjectMapper mapper = new ObjectMapper();                      // construct JsonNode from scratch by using the valurToTree() method            JsonNode node = mapper.valueToTree(show);                      // get movie, date and time from JsonNode            String movieName = node.get(“movie”).textValue();            String movieDate = node.get(“date”).textValue();            String movieTime = node.get(“time”).textValue();                      System.out.println(“Movie Name ===>”+movieName);            System.out.println(“Movie Date ===>”+movieDate);            System.out.println(“Movie Time ===>”+movieTime);                      // close Scanner class object            sc.close();        }    }       // create class BookShow      class BookShow{              public String movie;        public String date;        public String time;              BookShow(){            movie = null;            date = null;            time = null;        }        BookShow(String movie, String date, String time){            this.movie = movie;            this.date = date;            this.time = time;        }    }  

Output:

Tree Model Nodes in Jackson

Transforming a Node

We can transform a Tree Node into a string or Java object.

Tree Model Nodes in Jackson

Convert Tree Node into a JSON String

We transform a Tree Node into a JSON string when we need to write a Tree Node as JSON to the destination. Here, the destination can be an OutputStream, a File, or a writer. We use the writeValue() method of the mapper class in the following way:

mapper.writeValue(destination, node)

Let’s take an example to understand how we can use the writeValue() method to write JsonNode as JSON into the destination file.

WriteOutAsJSONExample.java

  // import required classes and package   import java.io.File;   import java.io.IOException;   import java.util.Scanner;      import com.fasterxml.jackson.databind.JsonNode;   import com.fasterxml.jackson.databind.ObjectMapper;      // create class WriteOutAsJSONExample for transforming a Node   public class WriteOutAsJSONExample {             // main() method start       public static void main(String[] args) throws IOException {                     String name, date,  time;                     // create Scanner class object           Scanner sc = new Scanner(System.in);                     System.out.println(“Enter movie name:”);           name = sc.nextLine();                     System.out.println(“Enter show date in dd-mm-yyyy format:”);           date = sc.nextLine();                     System.out.println(“Enter show time in hh:mm:ss AM/PM:”);           time = sc.nextLine();                     // create an instance of BookShow           BookShow show = new BookShow(name, date, time);                     // create an instance of ObjectMapper class           ObjectMapper mapper = new ObjectMapper();                     // convert BookShow into String           String jsonString = mapper.writeValueAsString(show);                     // construct JsonNode by using readTree() method           JsonNode newNode = mapper.readTree(jsonString);                     //create an instance of the File           File file = new File(“C:/Users/shubh/OneDrive/Desktop/BookShow.json”);                     // write JSON to BookShow.json file           mapper.writeValue(file, newNode);                     System.out.println(“Record save successfully”);                     // close Scanner class           sc.close();       }   }      // create class BookShow   class BookShow{             public String movie;       public String date;       public String time;             BookShow(){           movie = null;BookShow               date = null;           time = null;       }             BookShow(String movie, String date, String time){           this.movie = movie;           this.date = date;           this.time = time;       }   }  

Output:

Tree Model Nodes in Jackson

Convert Tree Node into a Java object

We can also transform JSON Node into a Java Object by using the treeToValue API. The treeToValue() method of the ObjectMapper class accept two parameters, i.e., JsonNode and Object.class:

The treeToValue() method is similar to the convertValue() method of ObjectMapper class.

We can also convert JsonNode to Java Object by using the token stream. We use the treeAsTokens() and readValue() methods in the following way:

Let’s take an example in which we will convert a JsonNode into a Java object by using all these three ways:

ConvertJsonNodeToJavaObject.java

  //import required classes and package      import java.io.File;   import java.io.IOException;   import java.util.Scanner;      import com.fasterxml.jackson.core.JsonParser;   import com.fasterxml.jackson.databind.JsonNode;   import com.fasterxml.jackson.databind.ObjectMapper;      //create class ConvertJsonNodeToJavaObject for converting JsonNode to java object   public class ConvertJsonNodeToJavaObject {             // main() method start       public static void main(String[] args) throws IOException {                     String name, date,  time;                     // create Scanner class object           Scanner sc = new Scanner(System.in);                     System.out.println(“Enter movie name:”);           name = sc.nextLine();                     System.out.println(“Enter show date in dd-mm-yyyy format:”);           date = sc.nextLine();                     System.out.println(“Enter show time in hh:mm:ss AM/PM:”);           time = sc.nextLine();                     // create an instance of BookShow           BookShow show = new BookShow(name, date, time);                     // create an instance of ObjectMapper class           ObjectMapper mapper = new ObjectMapper();                     // convert BookShow into String           String jsonString = mapper.writeValueAsString(show);                     // construct JsonNode by using readTree() method           JsonNode newNode = mapper.readTree(jsonString);                     // convert using treeToValue() method           BookShow obj1 = mapper.treeToValue(newNode, BookShow.class);                     // convert using convertValue() method           BookShow obj2 = mapper.convertValue(newNode, BookShow.class);                     // convert using JsonParser and readValue() method           JsonParser parser = mapper.treeAsTokens(newNode);           BookShow obj3 = mapper.readValue(parser, BookShow.class);                     System.out.println(“treeToValue ===>”+obj1.movie);           System.out.println(“convertValue ===>”+obj2.movie);           System.out.println(“readValue ===>”+obj3.movie);                     // close Scanner class           sc.close();       }   }      //create class BookShow      class BookShow{             public String movie;       public String date;       public String time;             BookShow(){           movie = null;           date = null;           time = null;       }             BookShow(String movie, String date, String time){           this.movie = movie;           this.date = date;           this.time = time;       }   }  

Output:

Tree Model Nodes in Jackson

Manipulating Tree Nodes

We can manipulate Tree Nodes by using Jackson. Manipulating Tree Nodes include Locating a Node, Adding a New Node, Editing a Node, and Removing a Node.

Let’s understand each one of them one by one with an example:

Locating a specific Node

We use the following steps to locate a specific JsonNode from JSON:

Form JSON string(can read JSON from a file as a string or can serialize a Java object as a string).
Use the readTree() method of the ObjectMapper class to get the root node of the JSON tree.
Use the path() method of the JsonNode to reach out to the specific JsonNode.
Print the value of the JsonNode by using the textValue() method of JsonNode.

Let’s implement the code for locating a specific node by using above discussed steps:

ManipulatingNodeExample1.java

  // import required classes and package if any   import java.io.IOException;   import com.fasterxml.jackson.databind.JsonNode;   import com.fasterxml.jackson.databind.ObjectMapper;      // create class ManipulatingNodeExample1 to locate fName   public class ManipulatingNodeExample1 {             // main() method start       public static void main(String args[]) throws IOException, ClassNotFoundException {                     // create an instance of Employee           Employee emp = new Employee(new EmployeeName(“Sharon”, “Lorenz”), “27”, “Ms T. Globelle”                                       + ” Paragon Productions PO Box 5404 Los Angeles, CA 90210 USA”);                     // create an instance of ObjectMapper class           ObjectMapper mapper = new ObjectMapper();                     String jsonString = mapper.writeValueAsString(emp);           System.out.println(jsonString);                     // construct JsonNode by using readTree() method           JsonNode newNode = mapper.readTree(jsonString);                     //locating fName           JsonNode fNameNode = newNode.path(“empName”).path(“fName”);                     System.out.println(“Employee First Name ===> “+fNameNode.textValue());                 }   }      // create class Employee   class Employee{              public EmployeeName empName;       public String age;       public String address;             // default constructor       public Employee() {           empName = null;           age = null;           address = null;       }             // parameterized constructor       public Employee(EmployeeName empName, String age, String address) {           this.empName = empName;           this.age = age;           this.address = address;       }   }      class EmployeeName{             public String fName;       public String lName;             // default constructor       public EmployeeName() {           fName = null;           lName = null;       }             // parameterized constructor       public EmployeeName(String fName, String lName) {           this.fName = fName;           this.lName = lName;       }   }   

Output:

Tree Model Nodes in Jackson

Adding a New Node

We can add a new node as a child node of another node. We use the put() method for adding a node. We use put() method in the following way:

Jackson provides several overloaded variants of the put method, which we can use for adding new nodes of different value types.

However, Jackson provide several other methods for adding child node such as putArray(), putObject(), putPOJO(), putRawValue() and putNull().

Let’s take an example to understand how we can use put() method to add a node as a child.

ManipulatingNodeExample2.java

  //import required classes and package if any   import java.io.IOException;   import com.fasterxml.jackson.databind.JsonNode;   import com.fasterxml.jackson.databind.ObjectMapper;   import com.fasterxml.jackson.databind.node.ObjectNode;      //create class ManipulatingNodeExample2 to locate fName   public class ManipulatingNodeExample2 {             // main() method start       public static void main(String args[]) throws IOException, ClassNotFoundException {                     // create an instance of Employee           Employee emp = new Employee(new EmployeeName(“Sharon”, “Lorenz”), “27”);                     // create an instance of ObjectMapper class           ObjectMapper mapper = new ObjectMapper();                     String jsonString = mapper.writeValueAsString(emp);           System.out.println(jsonString);                     // construct JsonNode by using readTree() method           JsonNode newNode = mapper.readTree(jsonString);                     // convert JsonNode to ObjectNode           ObjectNode empObj = (ObjectNode)newNode;                     // create an ObjectNode for address           ObjectNode address = mapper.createObjectNode();           address.put(“city”, “Los Angeles”).put(“state”, “California 90210”).put(“country”, “USA”);                     // add address node to Employee           empObj.set(“address”, address);                     // serialize ObjectNode           String jsonStr = mapper.writeValueAsString(empObj);           System.out.println(“After adding address node ===>”);           System.out.println(jsonStr);                 }   }      //create class Employee   class Employee{              public EmployeeName empName;       public String age;             // default constructor       public Employee() {           empName = null;           age = null;       }             // parameterized constructor       public Employee(EmployeeName empName, String age) {           this.empName = empName;           this.age = age;       }   }      class EmployeeName{             public String fName;       public String lName;             // default constructor       public EmployeeName() {           fName = null;           lName = null;       }             // parameterized constructor       public EmployeeName(String fName, String lName) {           this.fName = fName;           this.lName = lName;       }   }  

Output:

Tree Model Nodes in Jackson

Editing a Node

Just like adding a new JsonNode, we can edit the value of a specific JsonNode. We use the following steps for editing a specific JsonNode:

Form JSON string(can read JSON from a file as a string or can serialize a Java object as a string).
Use the readTree() method of the ObjectMapper class to get the root node of the JSON tree.
Convert JsonNode into ObjectNode in the following way:
ObjectNode obj = ((ObjectNode) rootNode)
We use the set() method for overriding a specific JsonNode.

Let’s implement the code for editing a specific node by using above discussed steps:

ManipulatingNodeExample3.java

  //import required classes and package if any   import java.io.IOException;   import com.fasterxml.jackson.databind.JsonNode;   import com.fasterxml.jackson.databind.ObjectMapper;   import com.fasterxml.jackson.databind.node.ObjectNode;      //create class ManipulatingNodeExample3 for editing a specific Node   public class ManipulatingNodeExample3 {             // main() method start       public static void main(String args[]) throws IOException, ClassNotFoundException {                     // create an instance of Employee           Employee emp = new Employee(new EmployeeName(“Sharon”, “Lorenz”), “27”, new Address(“Los Angeles”                                                                                               , “California 90210”, “USA”));                     // create an instance of ObjectMapper class           ObjectMapper mapper = new ObjectMapper();                     String jsonString = mapper.writeValueAsString(emp);           System.out.println(jsonString);                     // construct JsonNode by using readTree() method           JsonNode rootNode = mapper.readTree(jsonString);                     // get addressNode           JsonNode addressNode = rootNode.path(“address”);                     // convert rootNode to ObjectNode           ObjectNode empObj = (ObjectNode)rootNode;                     // convert addressNode to ObjectNode           ObjectNode addressObj = (ObjectNode)addressNode;                     // edit city, state and country           addressObj.put(“city”, “Haryana”);           addressObj.put(“state”, “Punjab”);           addressObj.put(“country”, “India”);                     // add addressObj node to Employee           empObj.set(“address”, addressObj);                     // serialize ObjectNode           String jsonStr = mapper.writeValueAsString(empObj);           System.out.println(“nAfter editing city, state and country ===>”);           System.out.println(jsonStr);                 }   }      //create class Employee   class Employee{              public EmployeeName empName;       public String age;       public Address address;             // default constructor       public Employee() {           empName = null;           age = null;           address = null;       }             // parameterized constructor       public Employee(EmployeeName empName, String age, Address address) {           this.empName = empName;           this.age = age;           this.address = address;       }   }      class EmployeeName{             public String fName;       public String lName;             // default constructor       public EmployeeName() {           fName = null;           lName = null;       }             // parameterized constructor       public EmployeeName(String fName, String lName) {           this.fName = fName;           this.lName = lName;       }   }      class Address{             public String city;       public String state;       public String country;             // default constructor       public Address() {           city = null;           state = null;           country = null;       }             // parameterized constructor       public Address(String city, String state, String country) {           this.city = city;           this.state = state;           this.country = country;       }   }   

Output:

Tree Model Nodes in Jackson

Removing a Node

Just like adding or editing a node, we can also remove a specific node from the JsonNode. We remove a specific node by calling the remove() method or remove API on its parent node. We use the following steps for editing a specific JsonNode:

Form JSON string(can read JSON from a file as a string or can serialize a Java object as a string).
Use the readTree() method of the ObjectMapper class to get the root node of the JSON tree.
Convert JsonNode into ObjectNode in the following way:
ObjectNode obj = ((ObjectNode) rootNode)
We use the remove() method for removing a specific JsonNode.

Let’s implement the code for removing a specific node by using above discussed steps:

ManipulatingNodeExample4.java

  //import required classes and package if any   import java.io.IOException;   import com.fasterxml.jackson.databind.JsonNode;   import com.fasterxml.jackson.databind.ObjectMapper;   import com.fasterxml.jackson.databind.node.ObjectNode;      //create class ManipulatingNodeExample4 for removing a specific Node   public class ManipulatingNodeExample4 {             // main() method start       public static void main(String args[]) throws IOException, ClassNotFoundException {                     // create an instance of Employee           Employee emp = new Employee(new EmployeeName(“Sharon”, “Lorenz”), “27”, new Address(“Los Angeles”                                                                                               , “California 90210”, “USA”));                     // create an instance of ObjectMapper class           ObjectMapper mapper = new ObjectMapper();                     String jsonString = mapper.writeValueAsString(emp);           System.out.println(jsonString);                     // construct JsonNode by using readTree() method           JsonNode rootNode = mapper.readTree(jsonString);                     // get addressNode           JsonNode addressNode = rootNode.path(“address”);                     // convert rootNode to ObjectNode           ObjectNode empObj = (ObjectNode)rootNode;                     // convert addressNode to ObjectNode           ObjectNode addressObj = (ObjectNode)addressNode;                     // remove state and country           addressObj.remove(“city”);           addressObj.remove(“state”);                     // add addressObj node to Employee           empObj.set(“address”, addressObj);                     // serialize ObjectNode           String jsonStr = mapper.writeValueAsString(empObj);           System.out.println(“nAfter removing city and state ===>”);           System.out.println(jsonStr);                 }   }   //create class Employee   class Employee{              public EmployeeName empName;       public String age;       public Address address;             // default constructor       public Employee() {           empName = null;           age = null;           address = null;       }             // parameterized constructor       public Employee(EmployeeName empName, String age, Address address) {           this.empName = empName;           this.age = age;           this.address = address;       }   }      class EmployeeName{             public String fName;       public String lName;             // default constructor       public EmployeeName() {           fName = null;           lName = null;       }             // parameterized constructor       public EmployeeName(String fName, String lName) {           this.fName = fName;           this.lName = lName;       }   }      class Address{             public String city;       public String state;       public String country;             // default constructor       public Address() {           city = null;           state = null;           country = null;       }             // parameterized constructor       public Address(String city, String state, String country) {           this.city = city;           this.state = state;           this.country = country;       }   }  

Output:

Tree Model Nodes in Jackson

Iterating over the Nodes

In order to iterate over the nodes, we first need to reformat them into YAML. A JSON document can contain three types of nodes, i.e., Value, Object, and Array. JSON document contains nodes in a hierarchical tree structure. So, we will start iterating the JSON document at the top and go through all the child nodes.

We will use a recursive process for iterating the JSON nodes. In the recursive method, we will pass the root node of the JSON document.

We will use the following steps for iterating over the nodes:

Form JSON string(can read JSON from a file as a string or can serialize a Java object as a string).
Use the readTree() method of the ObjectMapper class to get the root node of the JSON tree.
Create a recursive method, i.e., processNode(), in which we pass the root node, yaml, and index.
The processNode() method handles different node types. It uses JsonNode.fields because it provides us access to both the field name and field value.
The processNode() method adds the field name to the output and then processes its value as a child node by passing it to the processNode() method.

Let’s implement the code for iterating all the nodes by using the above-discussed steps:

ManipulatingNodeExample5.java

  //import required classes and package, if any      import java.io.IOException;   import java.util.ArrayList;   import java.util.Iterator;   import java.util.List;   import java.util.Map.Entry;      import com.fasterxml.jackson.databind.JsonNode;   import com.fasterxml.jackson.databind.ObjectMapper;      //create class ManipulatingNodeExample5 for iterating all nodes   public class ManipulatingNodeExample5 {             // main() method start       public static void main(String args[]) throws IOException, ClassNotFoundException {                     // create a list of Address           List
<address> addresses = new ArrayList
<address>();                     Address address1 = new Address(“Haryana”, “Punjab”, “India”);           Address address2 = new Address(“Los Angeles”, “California 90210”, “USA”);                     // add address to list           addresses.add(address1);           addresses.add(address2);                     // create an instance of Employee           Employee emp = new Employee(new EmployeeName(“Sharon”, “Lorenz”), “27”, addresses);                     // create an instance of ObjectMapper class           ObjectMapper mapper = new ObjectMapper();                     String jsonString = mapper.writeValueAsString(emp);           System.out.println(jsonString);                     // construct JsonNode by using readTree() method           JsonNode rootNode = mapper.readTree(jsonString);                     // create an instance of StringBuilder           StringBuilder builderAsYAML = new StringBuilder();                     // call processNode() method for root node           processNode(rootNode, builderAsYAML, 0);                     System.out.println(“nAfter iterating all nodes ===>”);           System.out.println(builderAsYAML.toString());       }             // create processNode() method for iterating all nodes       public static void processNode(JsonNode node, StringBuilder builderAsYAML, int depth) {                     // process value type node           if (node.isValueNode()) {               // use append() of StringBuilder to append node value               builderAsYAML.append(node.asText());           }           //process array type node           else if (node.isArray()) {               // use for loop for processing each node of the array               for (JsonNode arrayItem : node) {                   // call addNode() for adding node to builderAsYAML                   addNode(arrayItem, builderAsYAML, depth, true);               }           }           // process Object type node           else if (node.isObject()) {               // call addNode() for adding node to builderAsYAML               addNode(node, builderAsYAML, depth, false);           }       }       // create addNode() method for adding node value to builderAsYAML       public static void addNode(JsonNode node, StringBuilder builderAsYAML, int depth, boolean isItemArray) {           // crate an iterator of fields           Iterator> fields = node.fields();                     boolean isFirst = true;                     // iterate fields using while           while (fields.hasNext()) {               // store next field               Entry jsonField = fields.next();                             // call appendFieldName() to add field name to builderAsYAML               appendFieldName(builderAsYAML, jsonField.getKey(), depth, isItemArray && isFirst);                             // process jsonField to add value to builderAsYAML               processNode(jsonField.getValue(), builderAsYAML, depth+1);                             isFirst = false;           }       }       // create appendFieldName() method adding field name to builderAsYAML       public static void appendFieldName(StringBuilder builderAsYAML, String fieldName, int depth, boolean isFirstInArray) {                     //add field name to builderAsYAML if builderAsYAML is not empty           if (builderAsYAML.length() > 0) {               // add next line to builderAsYAML               builderAsYAML.append(“n”);                             // calculate expected depth               int expectedDepth = (isFirstInArray) ? depth-1 : depth;               for(int i = 0; i < expectedDepth; i++) {                   // append space                   builderAsYAML.append(”  “);               }               if (isFirstInArray) {                   // append dash(-)                   builderAsYAML.append(“- “);               }           }                     // append field name           builderAsYAML.append(fieldName);           builderAsYAML.append(“: “);       }         }      //create class Employee   class Employee{        public EmployeeName empName;       public String age;       public List
<address> addresses;             // default constructor       public Employee() {           empName = null;           age = null;           addresses = null;       }             // parameterized constructor       public Employee(EmployeeName empName, String age, List
<address> addresses) {           this.empName = empName;           this.age = age;           this.addresses = addresses;       }   }      class EmployeeName{             public String fName;       public String lName;             // default constructor       public EmployeeName() {           fName = null;           lName = null;       }       // parameterized constructor       public EmployeeName(String fName, String lName) {           this.fName = fName;           this.lName = lName;       }   }      class Address{       public String city;       public String state;       public String country;             // default constructor       public Address() {           city = null;           state = null;           country = null;       }             // parameterized constructor       public Address(String city, String state, String country) {           this.city = city;           this.state = state;           this.country = country;       }   }  </address>
</address>
<p>,></p></address>
</address>
<p></p>

Output:

Tree Model Nodes in Jackson

Next TopicTypes of events in Java

Tree Model Nodes in Jackson

Tree Model Nodes in Jackson

Creating a Node

Transforming a Node

Convert Tree Node into a JSON String

Convert Tree Node into a Java object

Manipulating Tree Nodes

Locating a specific Node

Adding a New Node

Editing a Node

Removing a Node

Iterating over the Nodes

Java 32-Bit Download For Windows 10

Selenium IDE- Locating Strategies By CSS

You may also like