Category: Java-Json binding by Jackson

JSON Streaming

Jackson Streaming provides set of Streaming APIs to read from or Write to JSON as string. It is streaming oriented hence takes less memory footprint, it is analogous to Stax Streaming API for XML operations.

We will see simple example to write JSON string into .json file. Then read .json for input JSON string to be converted to Java Map object.

App.java

package custom.jackson.learning;

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

import com.fasterxml.jackson.core.JsonEncoding;
import com.fasterxml.jackson.core.JsonFactory;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.ObjectMapper;

public class App {

	public static void main(String[] args) throws IOException {
		
		//Write to JSON string to .json file
		 JsonFactory jsonFactory = new JsonFactory();
		 JsonGenerator jsonGenerator = jsonFactory.createGenerator(new File("Employee.json"), JsonEncoding.UTF8);

		 //start writing the JSON object
		 jsonGenerator.writeStartObject();
		 
		 //"firstName":"Suresh"
		 jsonGenerator.writeStringField("firstName", "Suresh");
		 
		 //"lastName":"Rana"
		 jsonGenerator.writeStringField("lastName", "Rana");
		 
		 //"skills":["Java","PHP","SQL"]
		 jsonGenerator.writeFieldName("skills");
		 jsonGenerator.writeStartArray();
		 jsonGenerator.writeString("Java");
		 jsonGenerator.writeString("PHP");
		 jsonGenerator.writeString("SQL");
		 jsonGenerator.writeEndArray();
		 
		 //"certified":true
		 jsonGenerator.writeBooleanField("certified", true);
		 
		 //"age":21
		 jsonGenerator.writeNumberField("age", 21);
		 
		//end writing the JSON object
		 jsonGenerator.writeEndObject();
		 jsonGenerator.close();
		
		 System.out.println("JSON Writing to Employee.json completed.");
		 
		 //read the JSON file as input and convert to Map object
		 System.out.println("Reading data from Employee.json file");
		 ObjectMapper mapper = new ObjectMapper();
         Map employeeMap = mapper.readValue(new File("Employee.json"), Map.class);
         
         System.out.println("Map created from Employee.json file ::"+employeeMap);
         
	}

}

output ::

Generated Employee.json

Java Java-Json binding by Jackson

JSON parse by Tree

JSON String can also be parsed by Tree, analgous to DOM tree for XML parsing. Jackson provides the set of APIs that will take JSON string as input and it will parse it to form in-memory JSON tree. It provides set of APIs to navigate the tree.

We will see simple example to do so

Here App.java that takes input JSON string and prepares JSON tree for navigation.

package custom.jackson.learning;

import java.util.Iterator;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

public class App {

	public static void main(String[] args) throws JsonMappingException, JsonProcessingException {
		// TODO Auto-generated method stub

		  ObjectMapper mapper = new ObjectMapper();
	     // input JSON string
		  String jsonString = "{\"firstName\":\"Suresh\", \"lastName\":\"Rana\", "
	    		    + "	\"skill\":[\"Java\",\"PHP\",\"SQL\"] , "
	      			+ "	\"certified\":\"true\", \"age\":21}";
	      
	      //Prepare in-Memory JSON Tree
	      JsonNode rootNode = mapper.readTree(jsonString);
	      
	      
	      //Navigate the JSON Tree through Nodes and elements structure to read data.
	      JsonNode firstNameNode = rootNode.path("firstName");
	      System.out.println("First Name ::"+firstNameNode.textValue());
	      
	      JsonNode lastNameNode = rootNode.path("lastName");
	      System.out.println("First Name ::"+lastNameNode.textValue());
	      
	      JsonNode skillNode = rootNode.path("skill");
	      Iterator skillItr = skillNode.elements();
	      System.out.println("Skills are ::");
	      while(skillItr.hasNext()){
	    	  JsonNode skillName = skillItr.next();
	    	  System.out.print(skillName.textValue()+" ");
	      }
	      System.out.println();
	      JsonNode certifiedNode = rootNode.path("certified");
	      System.out.println("Certified ::"+certifiedNode.booleanValue());
	      
	      JsonNode ageNode = rootNode.path("age");
	      System.out.println("age ::"+ageNode.intValue());
	}

}

Output ::

Java Java-Json binding by Jackson

Java List to JSON

Jackson provides capability to transform primitive as well as complex data types to JSON string. Here we will see List containing Map objects transformed to JSON and vice-versa.

We use Maven, hence here is POM.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>custom.jackson</groupId>
  <artifactId>learning</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>learning</name>
  <url>http://maven.apache.org</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <dependencies>
    <dependency>
	      <groupId>junit</groupId>
	      <artifactId>junit</artifactId>
	      <version>3.8.1</version>
	      <scope>test</scope>
    </dependency>
    <dependency>
	    <groupId>com.fasterxml.jackson.core</groupId>
	    <artifactId>jackson-core</artifactId>
	    <version>2.12.3</version>
   </dependency>
   <dependency>
	    <groupId>com.fasterxml.jackson.core</groupId>
	    <artifactId>jackson-databind</artifactId>
	    <version>2.12.3</version>
	</dependency>
	<dependency>
	    <groupId>com.fasterxml.jackson.core</groupId>
	    <artifactId>jackson-annotations</artifactId>
	    <version>2.12.3</version>
	</dependency>
  </dependencies>
</project>





Here is Project Structure



We have simple App.java file, that contains Main method to demonstrate the capability. It has List containing Maps. Each Map holds country information.



package custom.jackson.learning;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.fasterxml.jackson.databind.ObjectMapper;

public class App {

	public static void main(String[] args) throws Exception{
		
				//List of country with Capital city
				Map map1 = new HashMap();
				map1.put("Name", "India");
				map1.put("Capital", "Delhi");
				map1.put("Weather", "Hot");
				Map map2 = new HashMap();
				map2.put("Name", "Russia");
				map2.put("Capital", "Moscow");
				map2.put("Weather", "Cold");

				List<Map> countryList = new ArrayList<Map>();
				countryList.add(map1);
				countryList.add(map2);
				
				//Convert Map to JSON
				ObjectMapper mapper = new ObjectMapper();
				String jsonResult = mapper.writerWithDefaultPrettyPrinter()
				  .writeValueAsString(countryList);
				System.out.println("Convert List to JSON ::"+jsonResult);
				
				 
				List countryList2 = mapper.readValue(jsonResult, List.class);
				System.out.println("Convert JSON to List ::"+countryList2); 
				

	}

}






Output ::







As Seen in output, in first step we transform Java List to JSON. So it converts Java List into an Array of JSON Objects. In Second steps we take JSON Array as input and convert it back to Java List containing Map objects.

Java Java-Json binding by Jackson

Java Map to JSON

In this example we will see transformation of Java Map to JSON and vice-versa. JSON provides capability to map the primitive data types as well as standard collection objects. Jackson provides easy APIs to achieve it.

We use maven, so here is POM.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>custom.jackson</groupId>
  <artifactId>learning</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>learning</name>
  <url>http://maven.apache.org</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <dependencies>
    <dependency>
	      <groupId>junit</groupId>
	      <artifactId>junit</artifactId>
	      <version>3.8.1</version>
	      <scope>test</scope>
    </dependency>
    <dependency>
	    <groupId>com.fasterxml.jackson.core</groupId>
	    <artifactId>jackson-core</artifactId>
	    <version>2.12.3</version>
   </dependency>
   <dependency>
	    <groupId>com.fasterxml.jackson.core</groupId>
	    <artifactId>jackson-databind</artifactId>
	    <version>2.12.3</version>
	</dependency>
	<dependency>
	    <groupId>com.fasterxml.jackson.core</groupId>
	    <artifactId>jackson-annotations</artifactId>
	    <version>2.12.3</version>
	</dependency>
  </dependencies>
</project>

We have simple class with Main method to demonstrate, App2.java. It contains map of country as key, capital city as value.

package custom.jackson.learning;

import java.util.HashMap;
import java.util.Map;

import com.fasterxml.jackson.databind.ObjectMapper;

public class App2 {

	public static void main(String[] args) throws Exception{
		
		//Map of country with Capital city
		Map map = new HashMap();
		map.put("India", "Delhi");
		map.put("Japan", "Tokyo");
		map.put("China", "Beijing");
		map.put("USA", "New York");
		map.put("Russia", "Moscow");

		//Convert Map to JSON
		ObjectMapper mapper = new ObjectMapper();
		String jsonResult = mapper.writerWithDefaultPrettyPrinter()
		  .writeValueAsString(map);
		System.out.println("Convert Map to JSON ::"+jsonResult);
		
		 
		Map map2 = mapper.readValue(jsonResult, Map.class);
		System.out.println("Convert JSON to Map ::"+map2); 
		
		

	}

}

Output :

As seen above, in first step Map is converted to JSON string. In second step we are converting JSON String into Java.util.Map object.

Java Java-Json binding by Jackson

Binding JSON to POJO

We will see simple Java class Employee being transformed to and from JSON String.

Following is project structure generated by Maven

Following is POM.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>custom.jackson</groupId>
  <artifactId>learning</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>learning</name>
  <url>http://maven.apache.org</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <dependencies>
    <dependency>
	      <groupId>junit</groupId>
	      <artifactId>junit</artifactId>
	      <version>3.8.1</version>
	      <scope>test</scope>
    </dependency>
    <dependency>
	    <groupId>com.fasterxml.jackson.core</groupId>
	    <artifactId>jackson-core</artifactId>
	    <version>2.12.3</version>
   </dependency>
   <dependency>
	    <groupId>com.fasterxml.jackson.core</groupId>
	    <artifactId>jackson-databind</artifactId>
	    <version>2.12.3</version>
	</dependency>
	<dependency>
	    <groupId>com.fasterxml.jackson.core</groupId>
	    <artifactId>jackson-annotations</artifactId>
	    <version>2.12.3</version>
	</dependency>
  </dependencies>
</project>

Bean class Employee.java

package custom.jackson.learning;

public class Employee {

	private String firstName;
	private String lastName;
	private boolean isCertified;
	private int age;
	public String getFirstName() {
		return firstName;
	}
	public void setFirstName(String firstName) {
		this.firstName = firstName;
	}
	public String getLastName() {
		return lastName;
	}
	public void setLastName(String lastName) {
		this.lastName = lastName;
	}
	public boolean isCertified() {
		return isCertified;
	}
	public void setCertified(boolean isCertified) {
		this.isCertified = isCertified;
	}
	@Override
	public String toString() {
		return "Employee [firstName=" + firstName + ", lastName=" + lastName + ", isCertified=" + isCertified + ", age="
				+ age + "]";
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	
}

package custom.jackson.learning;

import java.io.IOException;

import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;

/**
 * Hello world!
 *
 */
public class App 
{
    public static void main( String[] args )
    {
    		      ObjectMapper mapper = new ObjectMapper();
    		      String jsonString = "{\"firstName\":\"Suresh\", \"lastName\":\"Rana\", \"certified\":\"true\", \"age\":21}";
    		      
    		      try{
    		    	  
    		    	 //Transform JSON to Employee Object
    		         Employee employee_Suresh = mapper.readValue(jsonString, Employee.class);
    		         
    		         System.out.println("print Java object");
    		         System.out.println(employee_Suresh);
    		         
    		         //Transform Employee object to JSON
    		         jsonString = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(employee_Suresh);
    		         
    		         System.out.println("print json converted string");
    		         System.out.println(jsonString);
    		      }
    		      catch (JsonParseException e) { e.printStackTrace();}
    		      catch (JsonMappingException e) { e.printStackTrace(); }
    		      catch (IOException e) { e.printStackTrace(); }
    }
}

Output

Java Java-Json binding by Jackson Uncategorized

Jackson dependencies

Jackson libraries are distributed under Apache License as open source. We will stick to Maven as build tool. These libraries are available on Maven repositories

Following dependencies, we will add into maven project POM.xml

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-core</artifactId>
    <version>2.12.3</version>
</dependency>

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.12.3</version>
</dependency>

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-annotations</artifactId>
    <version>2.12.3</version>
</dependency>

Java Java-Json binding by Jackson

why Jackson

JSON has been way of communication since long, between systems, modules or programs, especially in times of web services. JSON format has its own advantages such as ease of use, well supported by javascript and frameworks.

Hence it leads to have a framework in place that will ease out task of JSON to Java reading, writing , transformation of JSON data to Plain java objects etc. It can reduce lot of boilterplate code while dealing with JSON formatted data.

Jackson is an open source framework distributed under Apache license to address these problems. Principally, jackson has 3 approaches to address JSON to JAVA binding

Data binding APIs – It can map JSON formatted objects to Java Plain Objects(POJO). It also provides certain level of configurability to tailor the data binding.
JSON Tree – Set of APIs that would read JSON formatted input document and convert the in memory tree representation of JSON, analogous to DOM tree. Then provides APIs to deal with JSON tree.
Streaming API – Set of APIs to read input JSON streams, it is analogous to Stax API for XML parsing.