Serialize and Deserialize Specific Fields in Jackson

In this section, we will explore various ways through which we can control whether the field is serialized/deserialized or not. Jackson provides the following ways to make a field as serialized or deserialized.

By making a field public
By using the getter method (Both serializable and de-serializable)
By using the setter method (Deserializable Only)
By making all fields globally Serializable
Rename the property on Serialization/Deserialization

Let's understand each one of them one by one:

1. By making a field Public

It is one of the simplest ways by which we can make a field serialize and de-serialize. In this way, we simply make the field public for this. We will declare a class with a public, a protected and a private field.

public class Product { 
private String name; 
int productId; 
protected float price; 
public boolean available;
}

By default, only the available field will be serialized to JSON.

Let's take an example to understand how we can make a field serializable and de-serializable by making it public.

SerializeAndDeserializeExample1.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 SerializeAndDeserializeExample1
public class SerializeAndDeserializeExample1 {  
	//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
		try {  
			College colg;  
			String name, university, street, state, city, rank;  
			System.out.println("Enter College Name:");  
			name = sc.nextLine();  
			System.out.println("Enter University Name:");  
			university = sc.nextLine();  
			System.out.println("Enter Street:");  
			street = sc.nextLine();  
			System.out.println("Enter City:");  
			city = sc.nextLine();
			System.out.println("Enter State:");  
			state = sc.nextLine();
			System.out.println("Enter College Rank:");  
			rank = sc.nextLine();  
			// set values to College  object by using constructor  
			colg = new College(name, university, new Address(street, state, city), rank);
			// serialize College using mapper  
			String jsonString = mapper
					.writerWithDefaultPrettyPrinter()  
					.writeValueAsString(colg);  
			System.out.println(jsonString);  
		} catch (IOException e) {   
			e.printStackTrace();  
		}  
		//close Scanner class object  
		sc.close();  
	}  
}
//create class College
class College {    
	//Creating properties of College class    
	public String name;      
	protected String university;   
	private Address address; 
	private String rank;   
	// constructor  
	College(String name, String university, Address address, String rank){  
		this.name = name;  
		this.university = university;  
		this.address = address;  
		this.rank = rank;  
	}  
}
//create class Address 
class Address {  
	public String street;
	public String state;
	public String city;
	
	Address(String street, String state, String city){  
		  this.street = street;
		  this.state = state;
		  this.city = city;
	}         
}

Output:

Serialize and Deserialize Specific Fields in Jackson

2. By using the getter method

In the previous method, we marked the field public to make it serializable and de-serializable. Most of the time, we need to serialize or deserialize a non-public field or, can say, package-private and private field. In order to serialize/deserialize a non-public field, we simply use the getter for the field.

Let's take an example to understand how we can serialize a non-public field.

SerializeAndDeserializeExample2.java

//import required classes and package if any  
import java.io.IOException;  
import java.util.Scanner;
import com.fasterxml.jackson.databind.ObjectMapper;
//create class SerializeAndDeserializeExample2
public class SerializeAndDeserializeExample2 {  
	//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
		try {  

			College colg;  

			String name, university, street, state, city, rank;  

			System.out.println("Enter College Name:");  
			name = sc.nextLine();  

			System.out.println("Enter University Name:");  
			university = sc.nextLine();  

			System.out.println("Enter Street:");  
			street = sc.nextLine();  
			
			System.out.println("Enter City:");  
			city = sc.nextLine();
			
			System.out.println("Enter State:");  
			state = sc.nextLine();
			
			System.out.println("Enter College Rank:");  
			rank = sc.nextLine();  

			// set values to College  object by using constructor  
			colg = new College(name, university, new Address(street, state, city), rank);
			
			// serialize College using mapper  
			String jsonString = mapper
					.writerWithDefaultPrettyPrinter()  
					.writeValueAsString(colg);  
			System.out.println(jsonString);  
	            
		} catch (IOException e) {   
			e.printStackTrace();  
		}  

		//close Scanner class object  
		sc.close();  

	}  
}
//create class College
class College {    

	//Creating properties of College class    
	public String name;      
	protected String university;   
	private Address address; 
	private String rank;   

	// constructor  
	College(String name, String university, Address address, String rank){  
		this.name = name;  
		this.university = university;  
		this.address = address;  
		this.rank = rank;  
	}  
	
	// make a getter for address field to make it serializable 
	public Address getAddress() {
        return address;
    }

}
//create class Address 
class Address {  
	public String street;
	public String state;
	public String city;
	
	Address(String street, String state, String city){  
		  this.street = street;
		  this.state = state;
		  this.city = city;
	}         
}

Output:

3. By using the setter method

The getter method is used for both serializable and de-serializable, whereas the setter method is used for only de-serializable. We use the setter method in the following way:

public class MyClass {
private int myInt;
   	public void setIntValue(int myInt) {
      		this.myInt = myInt;
    	}	
    	public int getIntValue() {
       		return myInt;
    	}
}

Let's take an example to understand how we can use the setter method to make a non-public field de-serializable.

SerializeAndDeserializeExample3.java

//import required classes and package if any  
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;
//create class SerializeAndDeserializeExample3
public class SerializeAndDeserializeExample3 {  
	//main() methods start  
	public static void main(String args[]) {  
		// create an instance of ObjectMapper class  
		ObjectMapper mapper = new ObjectMapper();  
		String json = "{\"name\":\"ABES\",\"university\":\"AKTU\", \"address\":\"NH-24 Highway GZB UP\", \"rank\":\"1\"}"; 
		// de-serializing Json into Java object  
		College colg;
		try {
			colg = mapper.readerFor(College.class).readValue(json);
			// serialize College using mapper  
			String jsonString = mapper
					.writerWithDefaultPrettyPrinter()  
					.writeValueAsString(colg);  
			System.out.println(jsonString);  
		} catch (JsonMappingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (JsonProcessingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}  
}
//create class College
class College {    
	//Creating properties of College class    
	public String name;      
	public String university;   
	public String address; 
	private String rank;   
	// default constructor 
	College(){
	}
	// constructor  
	College(String name, String university, String address, String rank){  
		this.name = name;  
		this.university = university;  
		this.address = address;  
		this.rank = rank;  
	}  
	public String getRank() {  
		return rank;  
	}
	public void setRank(String rank) {  
		this.rank = rank;  
	}
}

Output:

4. By making all the fields globally serializable

In some cases, we cannot directly modify the source code, so we need a way through which Jackson can deal with private fields from outside. This global configuration will be done at the ObjectMapper level. We simply turn on the AutoDetect function to use it for serialization.

We turn on the AutoDetect function in the following way:

ObjectMapper map = new ObjectMapper();
map.setVisibility(PropertyAccessor.ALL, Visibility.NONE);
map.setVisibility(PropertyAccessor.FIELD, Visibility.ANY);

Let's take an example to understand how we can use AutoDetect function to make all fields serializable.

SerializeAndDeserializeExample4.java

import com.fasterxml.jackson.annotation.JsonAutoDetect.Visibility;
import com.fasterxml.jackson.annotation.PropertyAccessor;
//import required classes and package if any  
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;
//create class SerializeAndDeserializeExample4
public class SerializeAndDeserializeExample4 {  
	//main() methods start  
	public static void main(String args[]) {  
		// create an instance of ObjectMapper class  
		ObjectMapper mapper = new ObjectMapper();
		mapper.setVisibility(PropertyAccessor.FIELD, Visibility.ANY);
		String json = "{\"name\":\"ABES\",\"university\":\"AKTU\", \"address\":\"NH-24 Highway GZB UP\", \"rank\":\"1\"}";  
	       
		// de-serializing Json into Java object  
		College colg;
		try {
			colg = mapper.readerFor(College.class).readValue(json);
			
			// serialize College using mapper  
			String jsonString = mapper
					.writerWithDefaultPrettyPrinter()  
					.writeValueAsString(colg);  
			System.out.println(jsonString);  
		    
		} catch (JsonMappingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (JsonProcessingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}  
}
//create class College
class College {    

	//Creating properties of College class    
	private String name;      
	private String university;   
	private String address; 
	private String rank;   
	
	// default constructor 
	College(){
		
	}
	
	// constructor  
	College(String name, String university, String address, String rank){  
		this.name = name;  
		this.university = university;  
		this.address = address;  
		this.rank = rank;  
	}
}

Output:

5. Rename the name of a property on Serialization/Deserialization

In the above examples, we have controlled over the fields that are going to serialize or deserialize. Going beyond it, we can also have control over the way a field maps to JSON and back.

In order to change the field name, we use the @JsonProperty annotation. In the annotation constructor, we pass the name of the property.

Let's take an example to understand how we can use @JsonProperty annotation to change the name of the field for serialization.

SerializeAndDeserializeExample5.java

//import required classes and package if any  
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;
//create class SerializeAndDeserializeExample5 
public class SerializeAndDeserializeExample5 {  
	//main() methods start  
	public static void main(String args[]) {  
		// create an instance of ObjectMapper class  
		ObjectMapper mapper = new ObjectMapper();  
		String json = "{\"name\":\"ABES\",\"university\":\"AKTU\", \"address\":\"NH-24 Highway GZB UP\", \"rank\":\"1\"}";  
		// de-serializing Json into Java object  
		College colg;
		try {
			colg = mapper.readerFor(College.class).readValue(json);
			// print id, name and course of student  
		    System.out.println(colg.getCollegeName());  
		    System.out.println(colg.getUniversityName());  
		    System.out.println(colg.getAddress());
		    System.out.println(colg.getRank());
		} catch (JsonMappingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (JsonProcessingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}  
} 
//create class College
class College {    
	//Creating properties of College class    
	private String name;      
	private String university;   
	private String address; 
	private String rank;   
	// default constructor 
	College(){
	}	
	// constructor  
	College(String name, String university, String address, String rank){  
		this.name = name;  
		this.university = university;  
		this.address = address;  
		this.rank = rank;  
	}  
	@JsonProperty("name")  
	public String getCollegeName() {  
		return name;  
	}
	public void setCollegeName(String name) {  
		this.name = name;  
	}
	@JsonProperty("university")  
	public String getUniversityName() {  
		return university;  
	}
	public void setUniversityName(String university) {  
		this.university = university;
	}
	public String getAddress() {  
		return address;  
	}
	public void setAddress(String address) {  
		this.address = address;  
	}
	public String getRank() {  
		return rank;  
	}
	public void setRank(String rank) {  
		this.rank = rank;  
	}
}

Output: