General Annotations in Jackson

General annotations include several basic annotations which we use in serialization and deserialization. JsonProperty and JsonView are the two generally used annotations at the time of serialization and deserialization.

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

@JsonProperty

It is an important general annotation that we used for marking the non-standard getter/setter method, i.e., to be used with respect to Json Property. Let's take an example to understand how it works:

JsonPropertyExample.java

// import required classes and package
import java.io.IOException;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.ObjectMapper;

// create class JsonPropertyExample to understand how it works 
public class JsonPropertyExample {
    
    // main() method start
    public static void main(String args[]) throws IOException {
        
        // create an instance of ObjectMapper class
        ObjectMapper mapper = new ObjectMapper();
        
        String json = "{\"name\":\"Sharon\",\"id\":101, \"course\":\"MCA\"}";
        
        // de-serializing Json into Java object
        Student std = mapper.readerFor(Student.class).readValue(json);
        
        // print id, name and course of student
        System.out.println(std.getStdId());
        System.out.println(std.getStdName());
        System.out.println(std.getCourse());
    }
}
class Student {
    private int id;
    private String name;
    private String course;
    
    // default constructor
    Student(){
        
    }
    // parameterized constructor 
    Student(int id, String name, String course){
        this.id = id;
        this.name = name;
        this.course = course;
    }
    @JsonProperty("")
    public int getStdId() {
        return id;
    }
    @JsonProperty("id")
    public void setStdId(int id) {
        this.id = id;
    }
    @JsonProperty("name")
    public String getStdName() {
        return name;
    }
    @JsonProperty("name")
    public void setStdName(String name) {
        this.name = name;
    }  
    @JsonProperty("course")
    public String getCourse() {
        return course;
    }
    @JsonProperty("course")
    public void setCourse(String course) {
        this.course = course;
    }  
}

Output:

@JsonFormat

It is another important annotation that is used for specifying the format at the time of serialization and deserialization. It is mostly used for specifying date format.

Let's take an example to understand how annotation is used for specifying a format for the date field.

JsonFormatExample.java

//import required classes and package

import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.ObjectMapper;

//create class JsonFormatExample to understand how it works 
public class JsonFormatExample {
    
    // main() method start
    public static void main(String args[]) throws IOException, ParseException  {
        
        // create an instance of ObjectMapper class
        ObjectMapper mapper = new ObjectMapper();
        
        // create Scanner class object
        Scanner sc= new Scanner(System.in);
        
        try{
            
            Student std = new Student();
            
            String stdId, stdName, stdCourse, stdAddmission;
            
            System.out.println("Enter Student Id:");
            stdId = sc.nextLine();
            std.setStdId(stdId);
            
            System.out.println("Enter Student Name:");
            stdName = sc.nextLine();
            std.setStdName(stdName);
            
            System.out.println("Enter Course Name:");
            stdCourse = sc.nextLine();
            std.setCourse(stdCourse);
            
            System.out.println("Enter Addmission Date(dd-MM-yyyy):");
            stdAddmission = sc.nextLine();
            
            SimpleDateFormat sdf = new SimpleDateFormat("dd-MM-yyyy");
            Date date = sdf.parse(stdAddmission);
            std.setAddmission(date);
            
            // convert Java type into Json string
            String jsonString = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(std); 
            System.out.println(jsonString); 
        } 
        catch (IOException e) { 
            e.printStackTrace(); 
        }
        
        // close Scanner class object
        sc.close();
    }
}
class Student {
    private String id;
    private String name;
    public String course;
    @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "dd-MM-yyyy")
    public Date addmission;
    
    // getter and setter
    @JsonProperty("id")
    public String getStdId() {
        return id;
    }
    @JsonProperty("id")
    public void setStdId(String id) {
        this.id = id;
    }
    @JsonProperty("name")
    public String getStdName() {
        return name;
    }
    @JsonProperty("name")
    public void setStdName(String name) {
        this.name = name;
    }  
    public String getCourse() {
        return course;
    }
    public void setCourse(String course) {
        this.course = course;
    }
    public Date getAddmission() {
        return addmission;
    }
    public void setAddmission(Date addmission) {
        this.addmission = addmission;
    } 
}

Output:

@JsonUnwrapped

It is another important annotation that comes in general annotations. It is used for unwrapping an object's values at the time or serialization and deserialization.

Let's take an example to understand how the annotation is used for wrapping the values.

JsonUnwrapperdExample.java

//import required classes and package
import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonUnwrapped;
import com.fasterxml.jackson.databind.ObjectMapper;

//create class JsonUnwrapperdExample to understand the working of it
public class JsonUnwrapperdExample {
    
    // main() method start
    public static void main(String args[]) throws IOException, ParseException  {
        
        // create an instance of ObjectMapper class
        ObjectMapper mapper = new ObjectMapper();
        
        // create Scanner class object
        Scanner sc= new Scanner(System.in);
        
        try{
            
            Student std = new Student();
            
            String stdId, firstName, lastName, stdCourse, stdAddmission;
            
            System.out.println("Enter Student Id:");
            stdId = sc.nextLine();
            std.setStdId(stdId);
            
            System.out.println("Enter First Name:");
            firstName = sc.nextLine();
            
            System.out.println("Enter Last Name:");
            lastName = sc.nextLine();
            
            std.setStdName(new Student.Name(firstName, lastName));
            
            System.out.println("Enter Course Name:");
            stdCourse = sc.nextLine();
            std.setCourse(stdCourse);
            
            System.out.println("Enter Addmission Date(dd-MM-yyyy):");
            stdAddmission = sc.nextLine();
            
            SimpleDateFormat sdf = new SimpleDateFormat("dd-MM-yyyy");
            Date date = sdf.parse(stdAddmission);
            std.setAddmission(date);
            
            // convert Java type into Json string
            String jsonString = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(std); 
            System.out.println(jsonString); 
        } 
        catch (IOException e) { 
            e.printStackTrace(); 
        }
        
        // close Scanner class object
        sc.close();
    }
}
class Student {
    private String id;
    @JsonUnwrapped
    public Name name;
    public String course;
    @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "dd-MM-yyyy")
    public Date addmission;
    
    // getter and setter
    @JsonProperty("id")
    public String getStdId() {
        return id;
    }
    @JsonProperty("id")
    public void setStdId(String id) {
        this.id = id;
    }
    @JsonProperty("name")
    public Name getStdName() {
        return name;
    }
    @JsonProperty("name")
    public void setStdName(Name name) {
        this.name = name;
    }  
    public String getCourse() {
        return course;
    }
    public void setCourse(String course) {
        this.course = course;
    }
    public Date getAddmission() {
        return addmission;
    }
    public void setAddmission(Date addmission) {
        this.addmission = addmission;
    } 
    static class Name {
        public String firstName;
        public String lastName;
        
        // parameterized constructor
        public Name(String firstName, String lastName) {
            this.firstName = firstName;
            this.lastName = lastName;
        }
    }
}

Output:

@JsonUnwrapped

It is another important annotation that is used for controlling values to be serialized or not. Let's take an example to understand how the annotation is used for controlling the values.

JsonViewExample.java

//import required classes and package
import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonView;
import com.fasterxml.jackson.databind.ObjectMapper;

//create class JsonViewExample to understand how it works 
public class JsonViewExample {
    
    // main() method start
    public static void main(String args[]) throws IOException, ParseException  {
        
        // create an instance of ObjectMapper class
        ObjectMapper mapper = new ObjectMapper();
        
        // create Scanner class object
        Scanner sc= new Scanner(System.in);
        
        try{
            
            Student std = new Student();
            
            String stdId, stdName, stdCourse, stdAddmission;
            
            System.out.println("Enter Student Id:");
            stdId = sc.nextLine();
            std.setStdId(stdId);
            
            System.out.println("Enter Student Name:");
            stdName = sc.nextLine();
            std.setStdName(stdName);
            
            System.out.println("Enter Course Name:");
            stdCourse = sc.nextLine();
            std.setCourse(stdCourse);
            
            System.out.println("Enter Addmission Date(dd-MM-yyyy):");
            stdAddmission = sc.nextLine();
            
            SimpleDateFormat sdf = new SimpleDateFormat("dd-MM-yyyy");
            Date date = sdf.parse(stdAddmission);
            std.setAddmission(date);
            
            // convert Java type into Json string
            String jsonString = mapper.writerWithDefaultPrettyPrinter().withView(Views.Public.class).writeValueAsString(std); 
            System.out.println(jsonString); 
        } 
        catch (IOException e) { 
            e.printStackTrace(); 
        }
        
        // close Scanner class object
        sc.close();
    }
}
class Student {
    @JsonView(Views.Public.class)
    private String id;
    @JsonView(Views.Public.class)
    private String name;
    @JsonView(Views.Internal.class)
    public String course;
    @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "dd-MM-yyyy")@JsonView(Views.Public.class)
    public Date addmission;
    
    // getter and setter
    @JsonProperty("id")
    public String getStdId() {
        return id;
    }
    @JsonProperty("id")
    public void setStdId(String id) {
        this.id = id;
    }
    @JsonProperty("name")
    public String getStdName() {
        return name;
    }
    @JsonProperty("name")
    public void setStdName(String name) {
        this.name = name;
    }  
    public String getCourse() {
        return course;
    }
    public void setCourse(String course) {
        this.course = course;
    }
    public Date getAddmission() {
        return addmission;
    }
    public void setAddmission(Date addmission) {
        this.addmission = addmission;
    } 
}
class Views {
    
    static class Public {
        
    }
    static class Internal extends Public {
        
    }
}

Output:

@JsonManagedReferences/@JsonBackReferences

@JsonManagedReference and @JsonBackReferences are the two important annotations that are used for displaying the relationship with the parent-child relationship.

@JsonManagedReference is used for referring to parent objects whereas @JsonBackReferences is used for marking child objects.

Let's take an example to understand how both annotations are used for displaying relationship between objects.

JsonReferenceExample.java

//import required classes and package
import java.io.IOException;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

import com.fasterxml.jackson.annotation.JsonBackReference;
import com.fasterxml.jackson.annotation.JsonManagedReference;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.ObjectMapper;

//create class JsonReferenceExample to understand how it works 
public class JsonReferenceExample {
    
    // main() method start
    public static void main(String args[]) throws IOException, ParseException  {
        
        // create an instance of ObjectMapper class
        ObjectMapper mapper = new ObjectMapper();
        
        // create Scanner class object
        Scanner sc= new Scanner(System.in);
        
        try{
            
            Student std = new Student();
            
            String stdId, stdName, stdCourse;
            
            System.out.println("Enter Student Id:");
            stdId = sc.nextLine();
            std.setStdId(stdId);
            
            System.out.println("Enter Student Name:");
            stdName = sc.nextLine();
            std.setStdName(stdName);
            
            System.out.println("Enter Course Name:");
            stdCourse = sc.nextLine();
            std.setCourse(stdCourse);
            
            Book obj1 = new Book(121,"Learn C Programming", std);
            Book obj2 = new Book(131,"Learn Advance Java", std);
            
            std.addBook(obj1);
            std.addBook(obj2);
            
            // convert Java type into Json string
            String jsonString = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(obj1); 
            System.out.println(jsonString); 
        } 
        catch (IOException e) { 
            e.printStackTrace(); 
        }
        
        // close Scanner class object
        sc.close();
    }
}
class Student {
    private String id;
    private String name;
    public String course;
    
    @JsonBackReference
    public List<Book> books;
    
    // default constructor
    public Student() {
        this.books = new ArrayList<Book>();
    }
    // getter and setter
    @JsonProperty("id")
    public String getStdId() {
        return id;
    }
    @JsonProperty("id")
    public void setStdId(String id) {
        this.id = id;
    }
    @JsonProperty("name")
    public String getStdName() {
        return name;
    }
    @JsonProperty("name")
    public void setStdName(String name) {
        this.name = name;
    }  
    public String getCourse() {
        return course;
    }
    public void setCourse(String course) {
        this.course = course;
    }
    public void addBook(Book book){
        books.add(book);
    }
}
class Book {
    public int bookId;
    public String bookName;
    
    Book(int bookId, String bookName, Student bookOwner){
        this.bookId = bookId;
        this.bookName = bookName;
        this.bookOwner = bookOwner;
    }
    @JsonManagedReference
    public Student bookOwner;
}

Output:

@JsonIdentityInfo

When objects have a parent-child relationship, @JsonIdentityInfo is used for indicating that object identity will be used during serialization/deserialization.

Let's take an example to understand the working of @JsonIdentityInfo annotation.

JsonIdentityInfoExample.java

//import required classes and package
import java.io.IOException;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

import com.fasterxml.jackson.annotation.JsonIdentityInfo;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.ObjectIdGenerators;
import com.fasterxml.jackson.databind.ObjectMapper;

//create class JsonIdentityInfoExample to understand how it works 
public class JsonIdentityInfoExample {
    
    // main() method start
    public static void main(String args[]) throws IOException, ParseException  {
        
        // create an instance of ObjectMapper class
        ObjectMapper mapper = new ObjectMapper();
        
        // create Scanner class object
        Scanner sc= new Scanner(System.in);
        
        try{
            
            Student std = new Student();
            
            String stdId, stdName, stdCourse;
            
            System.out.println("Enter Student Id:");
            stdId = sc.nextLine();
            std.setStdId(stdId);
            
            System.out.println("Enter Student Name:");
            stdName = sc.nextLine();
            std.setStdName(stdName);
            
            System.out.println("Enter Course Name:");
            stdCourse = sc.nextLine();
            std.setCourse(stdCourse);
            
            Book obj1 = new Book(121,"Learn C Programming", std);
            Book obj2 = new Book(131,"Learn Advance Java", std);
            
            std.addBook(obj1);
            std.addBook(obj2);
            
            // convert Java type into Json string
            String jsonString = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(obj1); 
            System.out.println(jsonString); 
        } 
        catch (IOException e) { 
            e.printStackTrace(); 
        }
        
        // close Scanner class object
        sc.close();
    }
}
@JsonIdentityInfo(generator = ObjectIdGenerators.PropertyGenerator.class, property = "id")
class Student {
    private String id;
    private String name;
    public String course;
    public List<Book> books;
    
    // default constructor
    public Student() {
        this.books = new ArrayList<Book>();
    }
    // getter and setter
    @JsonProperty("id")
    public String getStdId() {
        return id;
    }
    @JsonProperty("id")
    public void setStdId(String id) {
        this.id = id;
    }
    @JsonProperty("name")
    public String getStdName() {
        return name;
    }
    @JsonProperty("name")
    public void setStdName(String name) {
        this.name = name;
    }  
    public String getCourse() {
        return course;
    }
    public void setCourse(String course) {
        this.course = course;
    }
    public void addBook(Book book){
        books.add(book);
    }
}
@JsonIdentityInfo(generator = ObjectIdGenerators.PropertyGenerator.class, property = "bookId")
class Book {
    public int bookId;
    public String bookName;
    public Student bookOwner;
    
    Book(int bookId, String bookName, Student bookOwner){
        this.bookId = bookId;
        this.bookName = bookName;
        this.bookOwner = bookOwner;
    }
}

Output:

@JsonFilter

@JsonFilter is another useful annotation that we used for applying filters at the time of serialization/deserialization.

Let's take an example to understand how we can apply filters by using @JsonFilter.

JsonFilterExample.java

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

import com.fasterxml.jackson.annotation.JsonFilter;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.ser.FilterProvider;
import com.fasterxml.jackson.databind.ser.impl.SimpleBeanPropertyFilter;
import com.fasterxml.jackson.databind.ser.impl.SimpleFilterProvider;

//create class JsonFilterExample to understand the working of annotation
public class JsonFilterExample {
    
    //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 in dd-mm-yyyy format");
            proExpiry = sc.nextLine();
            
            // set values to Student object by using constructor
            product = new Product(proId, proName, proPrice, proExpiry);   
            
            FilterProvider filters = new SimpleFilterProvider() .addFilter(
                "nameFilter", SimpleBeanPropertyFilter.filterOutAllExcept("name"));
            
            // serialize Product using mapper
            String jsonString = mapper
                .writer(filters)
                .withDefaultPrettyPrinter()
                .writeValueAsString(product);
            System.out.println(jsonString);
        }
        catch (IOException e) { 
            e.printStackTrace();
        }
        
        //close Scanner class object
        sc.close();
        
    }
}
//create class Product by using @JsonFilter
@JsonFilter("nameFilter")
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: