Jackson Ignore Null and Empty Fields
October 15, 2017
Include.NON_NULL to ignore fields with Null values and Include.NON_EMPTY to ignore fields with Empty values. By default Jackson does not ignore Null and Empty fields while writing JSON. We can configure Include.NON_NULL and Include.NON_EMPTY at property level as well as at class level using @JsonInclude annotation. To configure Include.NON_NULL and Include.NON_EMPTY globally for every class we need to do it at ObjectMapper level using its setSerializationInclusion() method. Here on this page we will provide complete examples to use Include.NON_NULL and Include.NON_EMPTY at property level with @JsonInclude annotation and using ObjectMapper to ignore Null and Empty fields globally. We will also provide examples to ignore Null and Empty values for a Map.
Contents
Gradle to Resolve Jackson API
Find the Gradle file to resolve Jackson API.build.gradle
apply plugin: 'java'
apply plugin: 'eclipse'
archivesBaseName = 'Concretepage'
version = '1'
repositories {
mavenCentral()
}
dependencies {
compile group: 'com.fasterxml.jackson.core', name: 'jackson-core', version: '2.9.1'
compile group: 'com.fasterxml.jackson.core', name: 'jackson-databind', version: '2.9.1'
compile group: 'com.fasterxml.jackson.core', name: 'jackson-annotations', version: '2.9.1'
}
Include.NON_NULL and Include.NON_EMPTY
To ignore Null fields in JSON, Jackson providesInclude.NON_NULL and to ignore Empty fields Jackson provides Include.NON_EMPTY.
Include.NON_NULL: Indicates that only properties with not null values will be included in JSON.
Include.NON_EMPTY: Indicates that only properties that are not empty will be included in JSON. Non-empty can have different meaning for different objects such as
List with size zero will be considered as empty. In case of Map to check empty isEmpty() is called.
Include is an enum inside JsonInclude. Include has properties that are ALWAYS, NON_NULL, NON_ABSENT, NON_EMPTY, NON_DEFAULT, CUSTOM, USE_DEFAULTS. These properties can be used at property level, class level and we can configure globally using ObjectMapper. Find the sample code.
1. Using Include.NON_NULL and Include.NON_EMPTY at Property level
Find the code snippet.
public class Person {
@JsonInclude(Include.NON_NULL)
private String city;
@JsonInclude(Include.NON_EMPTY)
private String country;
------
}
city is null then it will not be included while writing JSON for Person object. In the same way if the value in country is empty then it will not be included in JSON.
2. Using Include.NON_NULL and Include.NON_EMPTY at Class level
Find the code snippet for
Include.NON_NULL at class level.
@JsonInclude(Include.NON_NULL)
public class Person {
------
}
Include.NON_NULL at class level means any property of this class having null value will not be included in JSON.
Now find the code snippet for
Include.NON_EMPTY at class level.
@JsonInclude(Include.NON_EMPTY)
public class Person {
------
}
Include.NON_EMPTY at class level means any property of this class having empty value will not be included in JSON.
3. Using Include.NON_NULL and Include.NON_EMPTY globally with ObjectMapper
Find the code snippet.
ObjectMapper mapper = new ObjectMapper(); mapper.setSerializationInclusion(Include.NON_NULL); mapper.setSerializationInclusion(Include.NON_EMPTY);
ObjectMapper with Include.NON_NULL and Include.NON_EMPTY using setSerializationInclusion() that ignore Null and Empty values globally for every class. Now when we write JSON using mapper instance for any given object, then the properties of that object having null or empty value will not be included in JSON. For example if we want to write any object into JSON as string we will write code as following.
String jsonBook = mapper.writerWithDefaultPrettyPrinter()
.writeValueAsString(book);
1. Example of Include.NON_NULL and Include.NON_EMPTY at Property Level
Find the example ofInclude.NON_NULL and Include.NON_EMPTY at property level.
Person.java
package com.concretepage;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonInclude.Include;
public class Person {
private Integer id;
private String name;
@JsonInclude(Include.NON_NULL)
private String city;
@JsonInclude(Include.NON_EMPTY)
private String country;
public Person(){}
public Person(Integer id, String name, String city, String country){
this.id = id;
this.name = name;
this.city = city;
this.country = country;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getCity() {
return city;
}
public void setCity(String city) {
this.city = city;
}
public String getCountry() {
return country;
}
public void setCountry(String country) {
this.country = country;
}
}
package com.concretepage;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
public class IgnoreNullEmptyAtPropertyLevel {
public static void main(String[] args) throws JsonProcessingException {
ObjectMapper mapper = new ObjectMapper();
Person person = new Person(110, "Mohit", null, "");
String jsonPerson = mapper.writerWithDefaultPrettyPrinter()
.writeValueAsString(person);
System.out.println(jsonPerson);
}
}
{
"id" : 110,
"name" : "Mohit"
}
Include.NON_NULL and Include.NON_EMPTY, output will be as following.
{
"id" : 110,
"name" : "Mohit",
"city" : null,
"country" : ""
}
2. Example of Include.NON_NULL and Include.NON_EMPTY Globally with ObjectMapper
Find the example ofInclude.NON_NULL and Include.NON_EMPTY with ObjectMapper
Book.java
package com.concretepage;
public class Book {
private Integer id;
private String name;
private String writer;
private String category;
public Book(){}
public Book(Integer id, String name, String writer, String category) {
this.id = id;
this.name = name;
this.writer = writer;
this.category = category;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getWriter() {
return writer;
}
public void setWriter(String writer) {
this.writer = writer;
}
public String getCategory() {
return category;
}
public void setCategory(String category) {
this.category = category;
}
}
package com.concretepage;
import com.fasterxml.jackson.annotation.JsonInclude.Include;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
public class IgnoreNullEmptyWithObjectMapper {
public static void main(String[] args) throws JsonProcessingException {
ObjectMapper mapper = new ObjectMapper();
mapper.setSerializationInclusion(Include.NON_NULL);
mapper.setSerializationInclusion(Include.NON_EMPTY);
Book book = new Book(101, "Spring", null, "");
String jsonBook = mapper.writerWithDefaultPrettyPrinter()
.writeValueAsString(book);
System.out.println(jsonBook);
}
}
{
"id" : 101,
"name" : "Spring"
}
Include.NON_NULL and Include.NON_EMPTY, output will be as following.
{
"id" : 101,
"name" : "Spring",
"writer" : null,
"category" : ""
}
3. Example to Ignore Null and Empty Values for Map
Here we will provide two examples to ignore Null and Empty values for aMap.
Example-1: Find the example to write JSON of an object which have a property of
Map type annotated with Include.NON_EMPTY.
Company.java
package com.concretepage;
import java.util.Map;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonInclude.Include;
public class Company {
private String name;
@JsonInclude(Include.NON_EMPTY)
private Map<String, String> employess;
public Company() {}
public Company(String name, Map<String, String> employess) {
this.name = name;
this.employess = employess;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Map<String, String> getEmployess() {
return employess;
}
public void setEmployess(Map<String, String> employess) {
this.employess = employess;
}
}
package com.concretepage;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
public class IgnoreNullEmptyMap {
public static void main(String[] args) throws JsonProcessingException {
ObjectMapper mapper = new ObjectMapper();
List<Company> list = new ArrayList<>();
Map<String, String> map = new HashMap<>();
map.put("A11", "Mahesh");
Company company1 = new Company("AAAA", map);
list.add(company1);
Company company2 = new Company("BBBB", new HashMap<>());
list.add(company2);
Company company3 = new Company("CCCC", null);
list.add(company3);
String jsonCompany = mapper.writerWithDefaultPrettyPrinter()
.writeValueAsString(list);
System.out.println(jsonCompany);
}
}
[ {
"name" : "AAAA",
"employess" : {
"A11" : "Mahesh"
}
}, {
"name" : "BBBB"
}, {
"name" : "CCCC"
} ]
Include.NON_NULL and Include.NON_EMPTY, output will be as following.
[ {
"name" : "AAAA",
"employess" : {
"A11" : "Mahesh"
}
}, {
"name" : "BBBB",
"employess" : { }
}, {
"name" : "CCCC",
"employess" : null
} ]
Example-2: Find the example to write JSON of
Map instance using Include.NON_NULL and Include.NON_EMPTY with ObjectMapper.
IgnoreNullEmptyMapWithObjectMapper
package com.concretepage;
import java.util.HashMap;
import java.util.Map;
import com.fasterxml.jackson.annotation.JsonInclude.Include;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
public class IgnoreNullEmptyMapWithObjectMapper {
public static void main(String[] args) throws JsonProcessingException {
ObjectMapper mapper = new ObjectMapper();
mapper.setSerializationInclusion(Include.NON_NULL);
mapper.setSerializationInclusion(Include.NON_EMPTY);
Map<String, String> map = new HashMap<>();
map.put("A11", "Mahesh");
map.put("A22", null);
map.put("A33", "");
String jsonMap = mapper.writerWithDefaultPrettyPrinter()
.writeValueAsString(map);
System.out.println(jsonMap);
}
}
{
"A11" : "Mahesh"
}
Include.NON_NULL and Include.NON_EMPTY, output will be as following.
{
"A11" : "Mahesh",
"A22" : null,
"A33" : ""
}
