Jackson @JsonIgnore, @JsonIgnoreProperties and @JsonIgnoreType

By Arvind Rai, March 16, 2018

This page will walk through Jackson @JsonIgnore, @JsonIgnoreProperties and @JsonIgnoreType annotations example. These annotations are used to ignore logical properties in JSON serialization and deserialization. @JsonIgnore is annotated at a class property level to ignore it. @JsonIgnoreProperties is annotated at class level and we need to specify the logical properties of that class to ignore them. @JsonIgnoreType is annotated at class level and it ignores the complete class. @JsonIgnore and @JsonIgnoreType has an element value which accepts Boolean values to make it active and inactive. @JsonIgnoreProperties has elements that are allowGetters, allowSetters, ignoreUnknown and value. The element value in @JsonIgnoreProperties specifies the names of properties to ignore. On this page we will provide complete example to use @JsonIgnore, @JsonIgnoreProperties and @JsonIgnoreType in JSON serialization and deserialization step by step.

1. Technologies Used
2. @JsonIgnore
3. @JsonIgnoreProperties
4. @JsonIgnoreType
5. Complete Example
6. References
7. Download Source Code

1. Technologies Used

Find the technologies being used in our example.
1. Java 9
2. Jackson 2.9.4
3. Gradle 4.3.1
4. Eclipse Oxygen

2. @JsonIgnore

@JsonIgnore is used to ignore the logical property used in serialization and deserialization. @JsonIgnore can be used at setter, getter or field. It is used as following.
Using field:

@JsonIgnore
private String category;

Using getter method:

@JsonIgnore
public String getCategory() {
  return category;
}

Using setter method:

@JsonIgnore
public void setCategory(String category) {
   this.category = category;
}

In all the above cases the logical property is category. In deserialization, application will throw exception as Unrecognized field "category". In serialization there will be no category field in JSON output. @JsonIgnore can be used with @JsonProperty as given below.

@JsonIgnore
@JsonProperty("bookCategory")	
private String category;

In the above code snippet, logical property is bookCategory. As we are using @JsonIgnore, so during JSON serialization and deserialization the logical property bookCategory will not be available.

@JsonIgnore has element value which is optional. Using Boolean we can make it active and inactive. We can use it as following.

@JsonIgnore(false)
private String category;

In the above code we have made @JsonIgnore inactive by passing false value. Now the logical property category will be available in JSON serialization and deserialization.

3. @JsonIgnoreProperties

@JsonIgnoreProperties ignores the specified logical properties in JSON serialization and deserialization. It is annotated at class level. Find the code snippet.

@JsonIgnoreProperties({ "bookName", "bookCategory" })
public class Book {
   @JsonProperty("bookId")
   private String id;
	
   @JsonProperty("bookName")		
   private String name;

   @JsonProperty("bookCategory")	
   private String category;  
   ------
}

The logical properties bookName and bookCategory has been specified in @JsonIgnoreProperties annotation. So these logical properties will not take part in JSON serialization and deserialization. If other logical properties such as bookId has been annotated with @JsonIgnore then all these logical properties will be ignored in JSON serialization and deserialization. It means the union of logical properties ignored by @JsonIgnore and @JsonIgnoreProperties are considered to be ignored in JSON serialization and deserialization.

@JsonIgnoreProperties has elements that are allowGetters, allowSetters, ignoreUnknown and value. The element value specifies name of properties to ignore.

3.1. @JsonIgnoreProperties allowGetters

When we pass true to allowGetters element, the getters will be allowed for the specified logical properties. It means the specified logical properties in @JsonIgnoreProperties will take part in JSON serialization but not in deserialization.

@JsonIgnoreProperties(value={ "bookName", "bookCategory" }, allowGetters= true)
public class Book {
------
}

In the above code, the logical properties bookName and bookCategory will take part in JSON serialization but not in deserialization.

3.2. @JsonIgnoreProperties allowSetters

When we pass true to allowSetters element, the setters will be allowed for the specified logical properties. It means the specified logical properties in @JsonIgnoreProperties will take part in JSON deserialization but not in serialization.

@JsonIgnoreProperties(value={ "bookName", "bookCategory" }, allowSetters= true)
public class Book {
------
}

In the above code, the logical properties bookName and bookCategory will take part in JSON deserialization but not in serialization.

3.3. @JsonIgnoreProperties ignoreUnknown

When we pass true to ignoreUnknown element, then in deserialization if JSON data has a field for which there is no logical property then that JSON field will be ignored and no error will be thrown. It can be used as following.

@JsonIgnoreProperties(ignoreUnknown = true)
public class Book {
	@JsonProperty("bookId")
	private String id;
	
	@JsonProperty("bookName")		
	private String name;

	@JsonProperty("bookCategory")	
	private String category;  
}

In the above class we have bookId, bookName and bookCategory logical properties. Suppose we have a JSON data with some unknown fields.

{
  "bookId" : "A101",
  "bookName" : "Learning Java",
  "bookCategory" : "Java",
  "pubYear" : "2018",
  "price" : "200",
}

In the above JSON fields, pubYear and price has no corresponding logical properties in Book class. In deserialization, we will not get exception because we are using ignoreUnknown = true in @JsonIgnoreProperties annotation.

4. @JsonIgnoreType

@JsonIgnoreType can be annotated at class level. It ignores all logical properties of annotated class in JSON serialization and deserialization. It is used as following.

@JsonIgnoreType
public class Address {
  @JsonProperty("city")	
  private String city;
  
  @JsonProperty("country")
  private String country;
  ------
}

Now suppose Address is being used in Writer class.

public class Writer {
    ------
    @JsonProperty("writerAddress")
    private Address address;
}

The logical property writerAddress will be ignored in serialization and deserialization of Writer class.

@JsonIgnoreType has element value which is optional. Using Boolean we can make it active and inactive. We can use it as following.

@JsonIgnoreType(false)
public class Address {
------
}

In the above code we have made @JsonIgnoreType inactive by passing false value. Now the Address class will be available in JSON serialization and deserialization.

5. Complete Example

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.4'
    compile group: 'com.fasterxml.jackson.core', name: 'jackson-databind', version: '2.9.4'
    compile group: 'com.fasterxml.jackson.core', name: 'jackson-annotations', version: '2.9.4'
}

Address.java

package com.concretepage;
import com.fasterxml.jackson.annotation.JsonIgnoreType;
import com.fasterxml.jackson.annotation.JsonProperty;

@JsonIgnoreType
public class Address {
  @JsonProperty("city")	
  private String city;
  
  @JsonProperty("country")
  private String country;
  
  public Address() {}
  public Address(String city, String country) {
	this.city = city;
	this.country = country;
  } 
  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;
  }
}

Book.java

package com.concretepage;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.JsonProperty;

@JsonIgnoreProperties({"bookName", "bookCategory"})
public class Book {
	@JsonProperty("bookId")
	private String id;
	
	@JsonProperty("bookName")		
	private String name;

	@JsonProperty("bookCategory")	
	private String category;  
	
  	public Book(){}
  	public Book(String id, String name, String category) {
  		this.id = id;
  		this.name = name;
  		this.category = category;
  	}
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getCategory() {
		return category;
	}
	public void setCategory(String category) {
		this.category = category;
	}
}

Writer.java

package com.concretepage;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;

public class Writer {
	@JsonProperty("writerId")	
	private Integer id; 
	
	@JsonIgnore
	@JsonProperty("writerName")
	private String name;
	
	@JsonProperty("writerBook")	
	private Book book;
	
	@JsonProperty("writerAddress")
	private Address address;

  	public Writer(){}
  	public Writer(Integer id, String name, Book book, Address address){
  		this.id = id;
  		this.name = name;
  		this.book = book;
  		this.address = address;
  	}	
	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 Book getBook() {
		return book;
	}
	public void setBook(Book book) {
		this.book = book;
	}
	public Address getAddress() {
		return address;
	}
	public void setAddress(Address address) {
		this.address = address;
	}
}

Run the code for serialization.
ObjectToJSON.java

package com.concretepage;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
public class ObjectToJSON {
  public static void main(String[] args) throws JsonProcessingException {
     ObjectMapper mapper = new ObjectMapper();
     Book book = new Book("A101", "Learning Java", "Java");
     Address address = new Address("Noida", "India");
     Writer writer = new Writer(110, "Mohit", book, address);
     String jsonWriter = mapper.writerWithDefaultPrettyPrinter()
		 .writeValueAsString(writer);
     System.out.println(jsonWriter);
  }
}

Output

{
  "name" : "Mohit",
  "writerId" : 110,
  "writerBook" : {
    "bookId" : "A101"
  }
}

If we use neither @JsonIgnore nor @JsonIgnoreProperties nor @JsonIgnoreType in the above example then the output will be as given below.

{
  "writerId" : 110,
  "writerName" : "Mohit",
  "writerBook" : {
    "bookId" : "A101",
    "bookName" : "Learning Java",
    "bookCategory" : "Java"
  },
  "writerAddress" : {
    "city" : "Noida",
    "country" : "India"
  }
}

Now run the code for deserialization.
JSONToObject.java

package com.concretepage;
import java.io.IOException;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;
public class JSONToObject {
	public static void main(String[] args) throws JsonParseException, JsonMappingException, IOException {
	   String jsonData = 
		    "{"
		      +"\"writerId\" : 111,"
			 // +"\"writerName\" : \"Mahesh\","
			  +"\"writerBook\" : {"
			     +"\"bookId\" : \"A101\""
			 //    +"\"bookName\" : \"Learning Spring\","
			 //    +"\"bookCategory\" : \"Spring\""
			  +"}"
			 // +"\"writerAddress\" : {"
			 //    +"\"city\" : \"Noida\","
			 //    +"\"country\" : \"India\""
			 // +"}"
			 +"}";
	   ObjectMapper mapper = new ObjectMapper();
	   Writer writer = mapper.readValue(jsonData, Writer.class);
	   System.out.println(writer.getId());
	   //System.out.println(writer.getName());
	   Book book = writer.getBook();
	   System.out.println(book.getId());
	   //System.out.println(book.getName()+", "+ book.getCategory());
	   //System.out.println(book.getName()+", "+ book.getCategory());
	  // Address address = writer.getAddress();
	  // System.out.println(address.getCity()+", "+ address.getCountry());
	}
}

Output