Type Handling Annotations in Jackson

Type Handling annotations are used for handling types of properties. Jackson provides more than one Type Handling annotations such as JsonTypeInfo, JsonSubTypes, and JsonTypeName. Type Handling annotation can be used at the time of serializing an object or deserializing a Json string.

Let's understand each one of them one by one with an example to understand how these annotations are used for type handling.

@JsonTypeInfo

It is one of the most used Type Handling annotations which we used at the time of serializing an object. It is used for indicating the details of what type of information to include in serialization and deserialization.

Let's take an example to understand how the annotation is used for getting the detail of information.

JsonTypeInfoExample.java

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

import com.fasterxml.jackson.annotation.JsonSubTypes;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.JsonTypeInfo.As;
import com.fasterxml.jackson.annotation.JsonTypeName;
import com.fasterxml.jackson.databind.ObjectMapper;

// create class JsonTypeInfoExample to understand the use of @JsonTypeInfo
public class JsonTypeInfoExample {
    
    // main() method start
    public static void main(String args[]) throws IOException {
        
        // create Scanner class object
        Scanner sc= new Scanner(System.in);		
        
        ShapeInfo shapeObj;
        
        String name;
        Double radious;
        
        System.out.println("Enter name of Circle:");
        name = sc.nextLine();
        
        System.out.println("Enter radious of Circle:");
        radious = sc.nextDouble();
        
        // create an instance of Shape class
        shapeObj = new JsonTypeInfoExample.CircleInfo(name, radious);
        
        // Serialize CircleInfo
        String result = new ObjectMapper()
            .writerWithDefaultPrettyPrinter()
            .writeValueAsString(shapeObj);
        System.out.println(result); 
        
        // json string to de-serialize
        String jsonString = "{\"name\":\"squareTest\",\"length\":0.5, \"type\":\"square\"}";
        System.out.println("Json data to deserialize: "+jsonString);
        
        // use ObjectMapper class for deserializing json
        SquareInfo square = new ObjectMapper().readerFor(ShapeInfo.class).readValue(jsonString);
        System.out.println(square.name);
        
        // close Scanner class object
        sc.close();
        
    }
    
    // create class ShapeInfo by using @JsonTypeInfo and @JsonSubTypes
    @JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = As.PROPERTY, property = "type") @JsonSubTypes({
        @JsonSubTypes.Type(value = SquareInfo.class, name = "square"),
            @JsonSubTypes.Type(value = CircleInfo.class, name = "circle")
            })
    static class ShapeInfo {
        public String name; 
        
        // parameterized constructor
        ShapeInfo(String name){
            this.name = name;
        }
    }
    
    // create class CircleInfo that extend ShapeInfo
    @JsonTypeName("square")
    static class SquareInfo extends ShapeInfo {
        public double length;
        
        // default constructor for setting default values
        SquareInfo(){
            this(null,0.0);
        }
        
        // parameterized constructor to set user define values
        SquareInfo(String name, double length){
            super(name);
            this.length = length;
        }
    }
    
    // create class CircleInfo that extend Shape
    @JsonTypeName("circle")
    static class CircleInfo extends ShapeInfo {
        public double circleRadius;  
        
        // default constructor for setting default values
        CircleInfo(){
            this(null,0.0);
        }
        
        // parameterized constructor to set user define values
        CircleInfo(String circleName, double circleRadius) {
            super(circleName);
            this.circleRadius = circleRadius;
        }
    }
}

Output:

@JsonSubTypes

It is another most used THandling annotation, which we also used at the time of serializing and deserializing an object. It is used for indicating subtypes of types annotated. The @JsonSubTypes annotation is used with @JsonTypeInfo annotation.

Let's take an example to understand the use of annotation.

JsonSubTypesExample.java

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

import com.fasterxml.jackson.annotation.JsonSubTypes;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.JsonTypeInfo.As;
import com.fasterxml.jackson.annotation.JsonTypeName;
import com.fasterxml.jackson.databind.ObjectMapper;

//create class JsonSubTypesExample to understand the use of @JsonSubTypes
public class JsonSubTypesExample {
    
    // main() method start
    public static void main(String args[]) throws IOException {
        
        // create Scanner class object
        Scanner sc= new Scanner(System.in);		
        
        PersonInfo personObj;
        
        String name;
        String id;
        
        System.out.println("Enter Name of Student:");
        name = sc.nextLine();
        
        System.out.println("Enter Student Id:");
        id = sc.nextLine();
        
        // create an instance of Person class
        personObj = new JsonSubTypesExample.StudentInfo(name, id);
        
        // Serialize CircleInfo
        String result = new ObjectMapper()
            .writerWithDefaultPrettyPrinter()
            .writeValueAsString(personObj);
        System.out.println(result); 
        
        // json string to de-serialize
        String jsonString = "{\"name\":\"Sharon Lorenz\",\"id\":\"0121\", \"type\":\"faculty\"}";
        System.out.println("Json data to deserialize: "+jsonString);
        
        // use ObjectMapper class for deserializing json
        FacultyInfo faculty = new ObjectMapper().readerFor(PersonInfo.class).readValue(jsonString);
        System.out.println(faculty.name);
        
        // close Scanner class object
        sc.close();
        
    }
    
    // create class PersonInfo by using @JsonTypeInfo and @JsonSubTypes
    @JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = As.PROPERTY, property = "type") @JsonSubTypes({
        @JsonSubTypes.Type(value = StudentInfo.class, name = "student"),
            @JsonSubTypes.Type(value = FacultyInfo.class, name = "faculty")
            })
    static class PersonInfo {
        public String name; 
        
        // parameterized constructor
        PersonInfo(String name){
            this.name = name;
        }
    }
    
    // create class StudentInfo that extend PersonInfo
    @JsonTypeName("student")
    static class StudentInfo extends PersonInfo {
        public String id;
        
        // default constructor for setting default values
        StudentInfo(){
            this(null, "");
        }
        
        // parameterized constructor to set user define values
        StudentInfo(String name, String id){
            super(name);
            this.id = id;
        }
    }
    
    // create class FacultyInfo that extend PersonInfo
    @JsonTypeName("faculty")
    static class FacultyInfo extends PersonInfo {
        public String id;  
        
        // default constructor for setting default values
        FacultyInfo(){
            this(null,"");
        }
        
        // parameterized constructor to set user define values
        FacultyInfo(String name, String id) {
            super(name);
            this.id = id;
        }
    }
}

Output:

@JsonTypeName

It is another important Type Handling annotation, i.e., used for setting types name to be used for annotated class.

Let's take an example to understand how the annotation works in Java:

JsonTypeNameExample.java

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

import com.fasterxml.jackson.annotation.JsonSubTypes;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.JsonTypeInfo.As;
import com.fasterxml.jackson.annotation.JsonTypeName;
import com.fasterxml.jackson.databind.ObjectMapper;

// create class JsonTypeNameExample to understand the use of @JsonTypeName
public class JsonTypeNameExample {
    
    // main() method start
    public static void main(String args[]) throws IOException {
        
        // create Scanner class object
        Scanner sc= new Scanner(System.in);		
        
        ShapeInfo shapeObj;
        
        String name;
        Double radious;
        
        System.out.println("Enter name of Circle:");
        name = sc.nextLine();
        
        System.out.println("Enter radious of Circle:");
        radious = sc.nextDouble();
        
        // create an instance of Shape class
        shapeObj = new JsonTypeNameExample.CircleInfo(name, radious);
        
        // Serialize CircleInfo
        String result = new ObjectMapper()
            .writerWithDefaultPrettyPrinter()
            .writeValueAsString(shapeObj);
        System.out.println(result); 
        
        // json string to de-serialize
        String jsonString = "{\"name\":\"squareTest\",\"length\":0.5, \"type\":\"square\"}";
        System.out.println("Json data to deserialize: "+jsonString);
        
        // use ObjectMapper class for deserializing json
        SquareInfo square = new ObjectMapper().readerFor(ShapeInfo.class).readValue(jsonString);
        System.out.println(square.name);
        
        // close Scanner class object
        sc.close();
        
    }
    
    // create class ShapeInfo by using @JsonTypeInfo and @JsonSubTypes
    @JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = As.PROPERTY, property = "type") @JsonSubTypes({
        @JsonSubTypes.Type(value = SquareInfo.class, name = "square"),
            @JsonSubTypes.Type(value = CircleInfo.class, name = "circle")
            })
    static class ShapeInfo {
        public String name; 
        
        // parameterized constructor
        ShapeInfo(String name){
            this.name = name;
        }
    }
    
    // create class CircleInfo that extend ShapeInfo
    @JsonTypeName("square")
    static class SquareInfo extends ShapeInfo {
        public double length;
        
        // default constructor for setting default values
        SquareInfo(){
            this(null,0.0);
        }
        
        // parameterized constructor to set user define values
        SquareInfo(String name, double length){
            super(name);
            this.length = length;
        }
    }
    
    // create class CircleInfo that extend Shape
    @JsonTypeName("circle")
    static class CircleInfo extends ShapeInfo {
        public double circleRadius;  
        
        // default constructor for setting default values
        CircleInfo(){
            this(null,0.0);
        }
        
        // parameterized constructor to set user define values
        CircleInfo(String circleName, double circleRadius) {
            super(circleName);
            this.circleRadius = circleRadius;
        }
    }
}

Output: