Property Inclusion Annotations in Jackson

Jackson provides more than one Property Inclusion annotation such as JsonIgnoreProperties, JsonIgnore, JsonIgnoreType, etc. These annotations are used for both serializing and deserialization. Each annotation is used in different use cases.

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

@JsonIgnoreProperties

@JsonIgnoreProperties annotation is an important property inclusion annotation that we mainly use for marking property or list of properties to be ignored. It is mainly used at the class level.

Let's take an example to understand how it works.

JsonIgnorePropertiesExample.java

// import required classes and package if any
import java.io.IOException;
import java.util.Scanner;

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.databind.ObjectMapper;

// create class JsonIgnorePropertiesExample to understand the working of annotation
public class JsonIgnorePropertiesExample {
    
    //main() methods start
    public static void main(String args[]) {
        
        // create an instance of ObjectMapper class
        ObjectMapper mapper = new ObjectMapper();
        
        // create Scanner class object
        Scanner sc= new Scanner(System.in);		
        
        // using try-catch for serializing Product
        try {
            
            Product product;
            
            String proId, proName, proPrice, proExpiry;
            
            System.out.println("Enter Product Id:");
            proId = sc.nextLine();
            
            System.out.println("Enter Product Name");
            proName = sc.nextLine();
            
            System.out.println("Enter Product Price");
            proPrice = sc.nextLine();
            
            System.out.println("Enter Product Expiry");
            proExpiry = sc.nextLine();
            
            // set values to Student object by using constructor
            product = new Product(proId, proName, proPrice, proExpiry);   
            
            // serialize Product using mapper
            String jsonString = mapper
                .writerWithDefaultPrettyPrinter()
                .writeValueAsString(product);
            System.out.println(jsonString);
        }
        catch (IOException e) { 
            e.printStackTrace();
        }
        
        //close Scanner class object
        sc.close();
        
    }
}

//create class Product by using @JsonIgnoreProperties
@JsonIgnoreProperties({ "proId", "expire" })
class Product {  
    
    //Creating properties of Product class  
    public String proId;    
    public String name;    
    public String price;
    public String expire; 
    
    // constructor
    Product(String proId, String name, String price, String expire){
        this.proId = proId;
        this.name = name;
        this.price = price;
        this.expire = expire;
    }
    
}

Output:

@JsonIgnore

@JsonIgnore annotation is another property inclusion annotation used for marking property or list of properties to be ignored. The only difference between @JsonIgnoreProperties and @JsonIgnore is that @JsonIgnore is used at field level, whereas @JsonIgnoreProperties is used as class level.

Let's take an example to understand how it works.

JsonIgnoreExample.java

//import required classes and package if any
import java.io.IOException;
import java.util.Scanner;

import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.databind.ObjectMapper;

//create class JsonIgnorePropertiesExample to understand the working of annotation
public class JsonIgnoreExample {
    
    //main() methods start
    public static void main(String args[]) {
        
        // create an instance of ObjectMapper class
        ObjectMapper mapper = new ObjectMapper();
        
        // create Scanner class object
        Scanner sc= new Scanner(System.in);
        
        // using try-catch for serializing Product
        try {
            
            Product product;
            
            String proId, proName, proPrice, proExpiry;
            
            System.out.println("Enter Product Id:");
            proId = sc.nextLine();
            
            System.out.println("Enter Product Name");
            proName = sc.nextLine();
            
            System.out.println("Enter Product Price");
            proPrice = sc.nextLine();
            
            System.out.println("Enter Product Expiry");
            proExpiry = sc.nextLine();
            
            // set values to Student object by using constructor
            product = new Product(proId, proName, proPrice, proExpiry);   
            
            // serialize Product using mapper
            String jsonString = mapper
                .writerWithDefaultPrettyPrinter()
                .writeValueAsString(product);
            System.out.println(jsonString);
        }
        catch (IOException e) { 
            e.printStackTrace();
        }   
        
        // close Scanner class object
        sc.close();
    }
}

//create class Product by using @JsonIgnore
class Product {  
    
    //Creating properties of Product class  
    public String proId;    
    public String name;    
    public String price;
    @JsonIgnore
    public String expire; 
    
    // constructor
    Product(String proId, String name, String price, String expire){
        this.proId = proId;
        this.name = name;
        this.price = price;
        this.expire = expire;
    }
    
}

Output:

@JsonIgnoreType

@JsonIgnoreType is another annotation that we also used to mark a special type property to be ignored. Let's take the example of @JsonIgnoreType annotation to understand how it works.

JsonIgnoreTypeExample.java

//import required classes and package if any
import java.io.IOException;
import java.util.Scanner;

import com.fasterxml.jackson.annotation.JsonIgnoreType;
import com.fasterxml.jackson.databind.ObjectMapper;

//create class JsonIgnoreTypeExample to understand the working of annotation
public class JsonIgnoreTypeExample {
    
    //main() methods start
    public static void main(String args[]) {
        
        // create an instance of ObjectMapper class
        ObjectMapper mapper = new ObjectMapper();
        
        // create Scanner class object
        Scanner sc= new Scanner(System.in);
        
        // using try-catch for serializing Product
        try {
            
            Product product;
            
            String proId, proName, proPrice, proExpiry;
            
            System.out.println("Enter Product Id:");
            proId = sc.nextLine();
            
            System.out.println("Enter Product Name");
            proName = sc.nextLine();
            
            System.out.println("Enter Product Price");
            proPrice = sc.nextLine();
            
            System.out.println("Enter Product Expiry");
            proExpiry = sc.nextLine();
            
            // set values to Student object by using constructor
            product = new Product(proId, proName, proPrice, proExpiry);   
            
            // serialize Product using mapper
            String jsonString = mapper
                .writerWithDefaultPrettyPrinter()
                .writeValueAsString(product);
            System.out.println(jsonString);
        }
        catch (IOException e) { 
            e.printStackTrace();
        }   
        
        //close Scanner class object
        sc.close();
        
    }
}

//create class Product by using @JsonIgnore
class Product {  
    
    //Creating properties of Product class  
    public String proId;    
    public Name name;    
    public String price;
    public String expire; 
    
    // constructor
    Product(String proId, String name, String price, String expire){
        this.proId = proId;
        this.name = new Name(name);
        this.price = price;
        this.expire = expire;
    }
    
    @JsonIgnoreType
    class Name {
        public String name;
        Name(String name){
            this.name = name;
        }       
    }
}

Output:

@JsonInclude

@JsonInclude is another important property inclusion annotation used to exclude properties with default, null or empty values. Let's take an example to understand how the annotation is used for excluding nulls from serialization.

JsonIncludeExample.java

//import required classes and package if any
import java.io.IOException;
import java.util.Scanner;

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.databind.ObjectMapper;

//create class JsonIncludeExample to understand the working of annotation
public class JsonIncludeExample {
    
    //main() methods start
    public static void main(String args[]) {
        
        // create an instance of ObjectMapper class
        ObjectMapper mapper = new ObjectMapper();
        
        // create Scanner class object
        Scanner sc= new Scanner(System.in);		
        
        // using try-catch for serializing Product
        try {
            
            Product product;
            
            String proId, proName, proPrice, proExpiry;
            
            System.out.println("Enter Product Id:");
            proId = sc.nextLine();
            
            System.out.println("Enter Product Name");
            proName = sc.nextLine();
            
            System.out.println("Enter Product Price");
            proPrice = sc.nextLine();
            
            // set values to Student object by using constructor
            product = new Product(proId, proName, proPrice, null);   
            
            // serialize Product using mapper
            String jsonString = mapper
                .writerWithDefaultPrettyPrinter()
                .writeValueAsString(product);
            System.out.println(jsonString);
        }
        catch (IOException exception) { 
            exception.printStackTrace();
        }
        
        //close Scanner class object
        sc.close();
        
    }
}

//create class Product by using @JsonInclude
@JsonInclude(JsonInclude.Include.NON_NULL)
class Product {  
    
    //Creating properties of Product class  
    public String proId;    
    public String name;    
    public String price;
    public String expire; 
    
    // constructor
    Product(String proId, String name, String price, String expire){
        this.proId = proId;
        this.name = name;
        this.price = price;
        this.expire = expire;
    }
}

Output:

@JsonAutoDetect

@JsonAutoDetect is another important property inclusion annotation used to include properties that are not accessible otherwise. Let's understand how the annotation is used for including non-accessible properties.

JsonAutoDetectExample.java

//import required classes and package if any
import java.io.IOException;
import java.util.Scanner;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.databind.ObjectMapper;

//create class JsonAutoDetectExample to understand the working of annotation
public class JsonAutoDetectExample {
    
    //main() methods start
    public static void main(String args[]) {
        
        // create an instance of ObjectMapper class
        ObjectMapper mapper = new ObjectMapper();
        
        // create Scanner class object
        Scanner sc= new Scanner(System.in);		
        
        // using try-catch for serializing Product
        try {
            
            Product product;
            
            String proId, proName, proPrice, proExpiry;
            
            System.out.println("Enter Product Id:");
            proId = sc.nextLine();
            
            System.out.println("Enter Product Name");
            proName = sc.nextLine();
            
            System.out.println("Enter Product Price");
            proPrice = sc.nextLine();
            
            System.out.println("Enter Product Expiry");
            proExpiry = sc.nextLine();
            
            // set values to Student object by using constructor
            product = new Product(proId, proName, proPrice, proExpiry);   
            
            // serialize Product using mapper
            String jsonString = mapper
                .writerWithDefaultPrettyPrinter()
                .writeValueAsString(product);
            System.out.println(jsonString);
        }
        catch (IOException e) { 
            e.printStackTrace();
        }
        
        //close Scanner class object
        sc.close();
        
    }
}

//create class Product by using @JsonAutoDetect
@JsonAutoDetect(fieldVisibility = JsonAutoDetect.Visibility.ANY)
class Product {  
    
    //Creating properties of Product class  
    private String proId;    
    private String name;    
    private String price;
    private String expire; 
    
    // constructor
    Product(String proId, String name, String price, String expire){
        this.proId = proId;
        this.name = name;
        this.price = price;
        this.expire = expire;
    } 
}

Output: