An instructional tutorial on the Jackson JSON Java Parser API.
Jackson JSON Java Parser is highly favored and also utilized in the Spring framework. However, the Java JSON Processing API is not user-friendly and lacks the capability to automatically convert JSON to Java objects and vice versa. Thankfully, there are alternative APIs available for JSON processing. In our previous article, we discovered the Google Gson API and witnessed its user-friendly nature and ease of use.
The Java parser for Jackson JSON.
If we want to incorporate the Jackson JSON Java API into our project, one option is to include it in the project’s build path. Alternatively, if we are using Maven, we can include the following dependency.
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.2.3</version>
</dependency>
The jackson-databind jar relies on the jackson-core and jackson-annotations libraries. Therefore, if you are directly adding them to the build path, ensure you add all three to avoid encountering a runtime error. The Jackson JSON Parser API simplifies the conversion of JSON to POJO Objects and allows for easy conversion to Maps from JSON data. Additionally, Jackson also supports generics and directly converts them from JSON to an object.
Example of Jackson JSON
To illustrate the conversion of JSON to a POJO/Java object, we will use a intricate example that includes nested objects and arrays. This conversion will involve the utilization of arrays, lists, and maps in Java objects. The JSON data that we will be working with is stored in a file called employee.txt, which follows the structure outlined below.
{
"id": 123,
"name": "Pankaj",
"permanent": true,
"address": {
"street": "Albany Dr",
"city": "San Jose",
"zipcode": 95129
},
"phoneNumbers": [
123456,
987654
],
"role": "Manager",
"cities": [
"Los Angeles",
"New York"
],
"properties": {
"age": "29 years",
"salary": "1000 USD"
}
}
We possess java classes that correspond to the provided json data.
package com.scdev.jackson.model;
public class Address {
private String street;
private String city;
private int zipcode;
public String getStreet() {
return street;
}
public void setStreet(String street) {
this.street = street;
}
public String getCity() {
return city;
}
public void setCity(String city) {
this.city = city;
}
public int getZipcode() {
return zipcode;
}
public void setZipcode(int zipcode) {
this.zipcode = zipcode;
}
@Override
public String toString(){
return getStreet() + ", "+getCity()+", "+getZipcode();
}
}
The Address class corresponds to the inner object of the root JSON data.
package com.scdev.jackson.model;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
public class Employee {
private int id;
private String name;
private boolean permanent;
private Address address;
private long[] phoneNumbers;
private String role;
private List<String> cities;
private Map<String, String> properties;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public boolean isPermanent() {
return permanent;
}
public void setPermanent(boolean permanent) {
this.permanent = permanent;
}
public Address getAddress() {
return address;
}
public void setAddress(Address address) {
this.address = address;
}
public long[] getPhoneNumbers() {
return phoneNumbers;
}
public void setPhoneNumbers(long[] phoneNumbers) {
this.phoneNumbers = phoneNumbers;
}
public String getRole() {
return role;
}
public void setRole(String role) {
this.role = role;
}
@Override
public String toString(){
StringBuilder sb = new StringBuilder();
sb.append("***** Employee Details *****\n");
sb.append("ID="+getId()+"\n");
sb.append("Name="+getName()+"\n");
sb.append("Permanent="+isPermanent()+"\n");
sb.append("Role="+getRole()+"\n");
sb.append("Phone Numbers="+Arrays.toString(getPhoneNumbers())+"\n");
sb.append("Address="+getAddress()+"\n");
sb.append("Cities="+Arrays.toString(getCities().toArray())+"\n");
sb.append("Properties="+getProperties()+"\n");
sb.append("*****************************");
return sb.toString();
}
public List<String> getCities() {
return cities;
}
public void setCities(List<String> cities) {
this.cities = cities;
}
public Map<String, String> getProperties() {
return properties;
}
public void setProperties(Map<String, String> properties) {
this.properties = properties;
}
}
The employee is the Java bean that represents the main JSON object. Now, we will explore how we can convert JSON to a Java object by utilizing the Jackson JSON parser API.
package com.scdev.jackson.json;
import java.io.File;
import java.io.IOException;
import java.io.StringWriter;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.scdev.jackson.model.Address;
import com.scdev.jackson.model.Employee;
public class JacksonObjectMapperExample {
public static void main(String[] args) throws IOException {
//read json file data to String
byte[] jsonData = Files.readAllBytes(Paths.get("employee.txt"));
//create ObjectMapper instance
ObjectMapper objectMapper = new ObjectMapper();
//convert json string to object
Employee emp = objectMapper.readValue(jsonData, Employee.class);
System.out.println("Employee Object\n"+emp);
//convert Object to json string
Employee emp1 = createEmployee();
//configure Object mapper for pretty print
objectMapper.configure(SerializationFeature.INDENT_OUTPUT, true);
//writing to console, can write to any output stream such as file
StringWriter stringEmp = new StringWriter();
objectMapper.writeValue(stringEmp, emp1);
System.out.println("Employee JSON is\n"+stringEmp);
}
public static Employee createEmployee() {
Employee emp = new Employee();
emp.setId(100);
emp.setName("David");
emp.setPermanent(false);
emp.setPhoneNumbers(new long[] { 123456, 987654 });
emp.setRole("Manager");
Address add = new Address();
add.setCity("Bangalore");
add.setStreet("BTM 1st Stage");
add.setZipcode(560100);
emp.setAddress(add);
List<String> cities = new ArrayList<String>();
cities.add("Los Angeles");
cities.add("New York");
emp.setCities(cities);
Map<String, String> props = new HashMap<String, String>();
props.put("salary", "1000 Rs");
props.put("age", "28 years");
emp.setProperties(props);
return emp;
}
}
When the program above is executed, the resulting output will be displayed.
Employee Object
***** Employee Details *****
ID=123
Name=Pankaj
Permanent=true
Role=Manager
Phone Numbers=[123456, 987654]
Address=Albany Dr, San Jose, 95129
Cities=[Los Angeles, New York]
Properties={age=29 years, salary=1000 USD}
*****************************
Employee JSON is
//printing same as above json file data
The com.fasterxml.jackson.databind.ObjectMapper is the key class in the Jackson API. It offers readValue() and writeValue() methods for converting JSON to a Java Object and vice versa. The ObjectMapper class can be reused and initialized as a Singleton object. It offers numerous versions of readValue() and writeValue() methods for working with byte arrays, Files, input/output streams, and Reader/Writer objects.
Converting JSON to Map using Jackson JSON.
Occasionally, we might come across a JSON object similar to the one provided, within the data.txt file.
{
"name": "David",
"role": "Manager",
"city": "Los Angeles"
}
We aim to transform it into a Map instead of a Java object that has the same properties and keys. This can be easily done in Jackson JSON API using the following code which utilizes two methods.
//converting json to Map
byte[] mapData = Files.readAllBytes(Paths.get("data.txt"));
Map<String,String> myMap = new HashMap<String, String>();
ObjectMapper objectMapper = new ObjectMapper();
myMap = objectMapper.readValue(mapData, HashMap.class);
System.out.println("Map is: "+myMap);
//another way
myMap = objectMapper.readValue(mapData, new TypeReference<HashMap<String,String>>() {});
System.out.println("Map using TypeReference: "+myMap);
After we run the above code, we obtain the following result.
Map is: {name=David, role=Manager, city=Los Angeles}
Map using TypeReference: {name=David, role=Manager, city=Los Angeles}
Read a specific JSON key using Jackson JSON.
There are instances where we only require certain values from a json data. In such cases, it is not advisable to convert the entire JSON into an object. The Jackson JSON API offers an alternative by allowing us to read json data in a tree-like DOM Parser manner. This enables us to access specific elements within the JSON object. The code provided below demonstrates how to extract specific entries from a json file.
//read json file data to String
byte[] jsonData = Files.readAllBytes(Paths.get("employee.txt"));
//create ObjectMapper instance
ObjectMapper objectMapper = new ObjectMapper();
//read JSON like DOM Parser
JsonNode rootNode = objectMapper.readTree(jsonData);
JsonNode idNode = rootNode.path("id");
System.out.println("id = "+idNode.asInt());
JsonNode phoneNosNode = rootNode.path("phoneNumbers");
Iterator<JsonNode> elements = phoneNosNode.elements();
while(elements.hasNext()){
JsonNode phone = elements.next();
System.out.println("Phone No = "+phone.asLong());
}
When we run the code snippet, we receive the subsequent result.
id = 123
Phone No = 123456
Phone No = 987654
Jackson JSON offers the capability to modify a JSON document.
The Java API of Jackson JSON offers convenient options for adding, modifying, and deleting keys in JSON data. Afterward, we can either save it as a new JSON file or write it to any stream. The following code illustrates how to accomplish this effortlessly.
byte[] jsonData = Files.readAllBytes(Paths.get("employee.txt"));
ObjectMapper objectMapper = new ObjectMapper();
//create JsonNode
JsonNode rootNode = objectMapper.readTree(jsonData);
//update JSON data
((ObjectNode) rootNode).put("id", 500);
//add new key value
((ObjectNode) rootNode).put("test", "test value");
//remove existing key
((ObjectNode) rootNode).remove("role");
((ObjectNode) rootNode).remove("properties");
objectMapper.writeValue(new File("updated_emp.txt"), rootNode);
Once you run the above code and check the new file, you’ll observe that the “role” and “properties” keys are missing. Additionally, you’ll see that the “id” value is now 500 and a new key called “test” has been included in the updated_emp.txt file.
One possible paraphrase of “Jackson JSON Streaming API Example” could be “An instance showcasing the usage of the Jackson JSON Streaming API.”
The Jackson JSON Java API also offers streaming capabilities, which are beneficial when dealing with large JSON data. This feature allows the API to read the file as tokens, resulting in reduced memory usage. The only drawback of using the streaming API is that we need to handle all the tokens during the parsing of the JSON data. For instance, if we have the JSON data {“role”:”Manager”}, the tokens would be retrieved in the following order: { (start object), “role” (key name), “Manager” (key value), and } (end object). It is important to note that the colon (:) is not considered a token since it serves as a delimiter in JSON.
package com.scdev.jackson.json;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import com.fasterxml.jackson.core.JsonFactory;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonToken;
import com.scdev.jackson.model.Address;
import com.scdev.jackson.model.Employee;
public class JacksonStreamingReadExample {
public static void main(String[] args) throws JsonParseException, IOException {
//create JsonParser object
JsonParser jsonParser = new JsonFactory().createParser(new File("employee.txt"));
//loop through the tokens
Employee emp = new Employee();
Address address = new Address();
emp.setAddress(address);
emp.setCities(new ArrayList<String>());
emp.setProperties(new HashMap<String, String>());
List<Long> phoneNums = new ArrayList<Long>();
boolean insidePropertiesObj=false;
parseJSON(jsonParser, emp, phoneNums, insidePropertiesObj);
long[] nums = new long[phoneNums.size()];
int index = 0;
for(Long l :phoneNums){
nums[index++] = l;
}
emp.setPhoneNumbers(nums);
jsonParser.close();
//print employee object
System.out.println("Employee Object\n\n"+emp);
}
private static void parseJSON(JsonParser jsonParser, Employee emp,
List<Long> phoneNums, boolean insidePropertiesObj) throws JsonParseException, IOException {
//loop through the JsonTokens
while(jsonParser.nextToken() != JsonToken.END_OBJECT){
String name = jsonParser.getCurrentName();
if("id".equals(name)){
jsonParser.nextToken();
emp.setId(jsonParser.getIntValue());
}else if("name".equals(name)){
jsonParser.nextToken();
emp.setName(jsonParser.getText());
}else if("permanent".equals(name)){
jsonParser.nextToken();
emp.setPermanent(jsonParser.getBooleanValue());
}else if("address".equals(name)){
jsonParser.nextToken();
//nested object, recursive call
parseJSON(jsonParser, emp, phoneNums, insidePropertiesObj);
}else if("street".equals(name)){
jsonParser.nextToken();
emp.getAddress().setStreet(jsonParser.getText());
}else if("city".equals(name)){
jsonParser.nextToken();
emp.getAddress().setCity(jsonParser.getText());
}else if("zipcode".equals(name)){
jsonParser.nextToken();
emp.getAddress().setZipcode(jsonParser.getIntValue());
}else if("phoneNumbers".equals(name)){
jsonParser.nextToken();
while (jsonParser.nextToken() != JsonToken.END_ARRAY) {
phoneNums.add(jsonParser.getLongValue());
}
}else if("role".equals(name)){
jsonParser.nextToken();
emp.setRole(jsonParser.getText());
}else if("cities".equals(name)){
jsonParser.nextToken();
while (jsonParser.nextToken() != JsonToken.END_ARRAY) {
emp.getCities().add(jsonParser.getText());
}
}else if("properties".equals(name)){
jsonParser.nextToken();
while(jsonParser.nextToken() != JsonToken.END_OBJECT){
String key = jsonParser.getCurrentName();
jsonParser.nextToken();
String value = jsonParser.getText();
emp.getProperties().put(key, value);
}
}
}
}
}
JsonParser is the streaming API provided by Jackson to read and process JSON data. We utilize it for reading data from a file and then employ the parseJSON() function to iterate through the tokens and construct our Java object. It is important to observe that the parseJSON() function is recursively invoked for “address” as it is a nested object within the JSON data. When parsing arrays, we iterate through the JSON document. To generate JSON data using the streaming API, we can make use of the JsonGenerator class.
package com.scdev.jackson.json;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Set;
import com.fasterxml.jackson.core.JsonFactory;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.util.DefaultPrettyPrinter;
import com.scdev.jackson.model.Employee;
public class JacksonStreamingWriteExample {
public static void main(String[] args) throws IOException {
Employee emp = JacksonObjectMapperExample.createEmployee();
JsonGenerator jsonGenerator = new JsonFactory()
.createGenerator(new FileOutputStream("stream_emp.txt"));
//for pretty printing
jsonGenerator.setPrettyPrinter(new DefaultPrettyPrinter());
jsonGenerator.writeStartObject(); // start root object
jsonGenerator.writeNumberField("id", emp.getId());
jsonGenerator.writeStringField("name", emp.getName());
jsonGenerator.writeBooleanField("permanent", emp.isPermanent());
jsonGenerator.writeObjectFieldStart("address"); //start address object
jsonGenerator.writeStringField("street", emp.getAddress().getStreet());
jsonGenerator.writeStringField("city", emp.getAddress().getCity());
jsonGenerator.writeNumberField("zipcode", emp.getAddress().getZipcode());
jsonGenerator.writeEndObject(); //end address object
jsonGenerator.writeArrayFieldStart("phoneNumbers");
for(long num : emp.getPhoneNumbers())
jsonGenerator.writeNumber(num);
jsonGenerator.writeEndArray();
jsonGenerator.writeStringField("role", emp.getRole());
jsonGenerator.writeArrayFieldStart("cities"); //start cities array
for(String city : emp.getCities())
jsonGenerator.writeString(city);
jsonGenerator.writeEndArray(); //closing cities array
jsonGenerator.writeObjectFieldStart("properties");
Set<String> keySet = emp.getProperties().keySet();
for(String key : keySet){
String value = emp.getProperties().get(key);
jsonGenerator.writeStringField(key, value);
}
jsonGenerator.writeEndObject(); //closing properties
jsonGenerator.writeEndObject(); //closing root object
jsonGenerator.flush();
jsonGenerator.close();
}
}
Comparatively, JsonGenerator is simpler to use than JsonParser. This serves as a quick reference tutorial for the Jackson JSON Parser Java API. The Jackson JSON Java API is user-friendly and offers numerous options to facilitate developers when working with JSON data. You can download the project from the provided link and experiment with it to discover more options available in the Jackson Json API.
Get the Jackson JSON Project.
Source: Jackson’s GitHub Page
Rephrased: Page on GitHub belonging to Jackson
More tutorials
JSON fundamentals(Opens in a new browser tab)
One example of Spring REST XML and JSON(Opens in a new browser tab)
How can JSON Data be modified using jq?(Opens in a new browser tab)
OkHttp on Android(Opens in a new browser tab)
the ObjectOutputStream in Java(Opens in a new browser tab)