Jackson JSON Views

JSON Views is another important element of Jackson. JSON Views is also used for serializing and deserializing Java objects. We use @JsonView annotation for customizing the view at the time of serializing/deserializing.

In this section, we will understand how we can perform serialization/deserialization using JSON Views and how we can customize the view.

Serialize Using JSON Views

In order to serialize an object by using @JsonView, we first create a view, and then we will use it for serialization. Let's take an example to understand how we can use JSON View to serialize an object.

JSONViewExample1.java

// import  required classes and package if any
import java.util.Scanner;
import com.fasterxml.jackson.annotation.JsonView;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.MapperFeature;
import com.fasterxml.jackson.databind.ObjectMapper;

// create class JSONViewExample1 to serialize an object using JSON View
public class JSONViewExample1 {
	// main() method start
	@SuppressWarnings("deprecation")
	public static void main(String args[]) throws JsonProcessingException {
		String id, name;
		// create an instance of Scanner class
		Scanner sc = new Scanner(System.in);
		
		System.out.println("Enter Student Id: ");
		id = sc.nextLine();
		
		System.out.println("Enter Student Name: ");
		name = sc.nextLine();
		
		// close Scanner class object
		sc.close();
		
		// create Student object
		Student std = new Student(id, name);

		// create an instance of ObjectMapper class
	    ObjectMapper mapper = new ObjectMapper();
	    
	    // disable DEFAULT_VIEW_INCLUSION mapper feature
	    mapper.disable(MapperFeature.DEFAULT_VIEW_INCLUSION);

	    String result = mapper
	    		.writerWithView(Views.Public.class)
	    		.writeValueAsString(std);
	    
	    System.out.println("Java object after serializing:"+result);
		
	}
	
}

// create class Student
class Student {
	
	// instance variable
    	public String stdId;

    	// instance variable with @JsonView
    	@JsonView(Views.Public.class)
    	public String stdName;
    
    	// default constructor
    	Student(){
    		this.stdId = null;
    		this.stdName = null;
    	}
    
    	// parameterized constructor
    	Student(String stdId, String stdName){
    		this.stdId = stdId;
    		this.stdName = stdName;
    	}
}

// create class for View
class Views {
	// create class public
    	public static class Public {
    	}
}

Output:

By using multiple JSON Views, we can also serialize an object in Java. Here, we create a view where the Internal view extends to the Public one. So, the Views class looks like this:

public class Views {
	public static class Public {
    	}

    	public static class Internal extends Public {
    	}
}

We will modify the Student class. In the Student class, stdId and stdName fields will be included in the Public view. We create a new field, i.e., the course which will be included in the Internal view. So, our Student class looks like this:

public class Student{
 
    	@JsonView(Views.Public.class)
    	public int stdId;

    	@JsonView(Views.Public.class)
    	public String stdName;

    	@JsonView(Views.Internal.class)
    	public String course;
}

Now, let's take an example to understand how, we can serialize an object using multiple JSON Views:

JSONViewExample2.java

//import  required classes and package if any
import java.util.Scanner;
import com.fasterxml.jackson.annotation.JsonView;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.MapperFeature;
import com.fasterxml.jackson.databind.ObjectMapper;

//create class JSONViewExample2 to serialize an object using multiple JSON Views
public class JSONViewExample2 {
	
	// main() method start
	@SuppressWarnings("deprecation")
	public static void main(String args[]) throws JsonProcessingException {
		
		String id, name, course;
		
		// create an instance of Scanner class
		Scanner sc = new Scanner(System.in);
		
		System.out.println("Enter Student Id: ");
		id = sc.nextLine();
		
		System.out.println("Enter Student Name: ");
		name = sc.nextLine();
		
		System.out.println("Enter Course Name: ");
		course = sc.nextLine();
		
		// close Scanner class object
		sc.close();
		
		// create Student object
		Student std = new Student(id, name, course);

		// create an instance of ObjectMapper class
	    	ObjectMapper mapper = new ObjectMapper();
	    
	    	// disable DEFAULT_VIEW_INCLUSION mapper feature
	    	mapper.disable(MapperFeature.DEFAULT_VIEW_INCLUSION);

	    	String result = mapper
	    		.writerWithView(Views.Public.class)
	    		.writeValueAsString(std);
	    
	    System.out.println("Java object after serializing:"+result);
		
	}
	
}

//create class Student
class Student {

	@JsonView(Views.Public.class)
	public String stdId;

	@JsonView(Views.Public.class)
	public String stdName;

	@JsonView(Views.Internal.class)
	public String course;
 
	// default constructor
	Student(){
		this.stdId = null;
		this.stdName = null;
		this.course = null;
	}
 
	// parameterized constructor
	Student(String stdId, String stdName, String course){
		this.stdId = stdId;
		this.stdName = stdName;
		this.course = course;
	}
}

//create class for View
class Views {
	public static class Public {
    
	}
	
	public static class Internal extends Public {
    
	}
}

Output:

Deserialize using JSON Views

Just like serialization, we can also deserialize JSON strings into Java objects by using JSON Views. Let's take an example to understand how deserialization is done by using JSON Views.

JSONViewExample3.java

//import  required classes and package if any
import com.fasterxml.jackson.annotation.JsonView;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;

//create class JSONViewExample3 to deserialize JSON string into POJO by using JSON Views
public class JSONViewExample3 {
	
	// main() method start
	public static void main(String args[]) throws JsonMappingException, JsonProcessingException{
		
		// JSON string to parse
		String jsonString = "{\"stdId\":\"121\", \"stdName\":\"Nicholas\"}";

		// create an instance of ObjectMapper class
	    	ObjectMapper mapper = new ObjectMapper();
	    
	    	// deserialize JSON string in Java object by using Jackson View
	    	Student std = mapper
	    		.readerWithView(Views.Public.class)
	    		.forType(Student.class)
	    		.readValue(jsonString);
		
	    	// print student Id and Name
	    	System.out.println("Student Id: "+std.stdId);
	    	System.out.println("Student Name: "+std.stdName);
	}
	
}

//create class Student
class Student {
	
	// instance variable
	public String stdId;

	// instance variable with @JsonView
	@JsonView(Views.Public.class)
	public String stdName;
 
	// default constructor
	Student(){
		this.stdId = null;
		this.stdName = null;
	}
 
	// parameterized constructor
	Student(String stdId, String stdName){
		this.stdId = stdId;
		this.stdName = stdName;
	}
}

//create class for View
class Views {
	// create class public
	public static class Public {
	}
}

Output:

Serialize using the customize JSON Views

We can also Java objects by using the customize JSON View. In order to serialize Java objects by using the customize JSON View, we first customize the JSON view by using BeanPropertyWriter. We create the 65UpperCasingWriter class by extending BeanPropertyWriter for transforming the student name to upper case.

Let's create the UpperCasingWriter class for transforming the student name to upper case.

UpperCasingWriter.java

import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.ser.BeanPropertyWriter;

// create class UpperCasingWriter to transform student name to upper case
public class UpperCasingWriter extends BeanPropertyWriter {
	
	// create a variable of type BeanPropertyWriter
    	BeanPropertyWriter writer;

    	// parameterized constructor of UpperCasingWriter
    	public UpperCasingWriter(BeanPropertyWriter writer) {
        
    		super(writer);
        	this.writer = writer;
    	}

    	// override serializeAsField() method of BeanPropertyWriter
    	@Override
    	public void serializeAsField(Object bean, JsonGenerator generator, SerializerProvider provider) throws Exception {
    	
    		// get student name from Object and store it to a variable of type String
        	String name = ((Student) bean).stdName;
        
        	// change name to upper case if it is not null
        	name = (name == null) ? "" : name.toUpperCase();
        
        	// write stdName in JSON by using generator
        	generator.writeStringField("stdName", name);
    	}
}

Now, we will create a custom modifier to set the student name BeanPropertyWriter with our CustomCasingWriter.

CustomBeanSerializerModifier.java

// import required classes and package if any
import java.util.List;
import com.fasterxml.jackson.databind.BeanDescription;
import com.fasterxml.jackson.databind.SerializationConfig;
import com.fasterxml.jackson.databind.ser.BeanPropertyWriter;
import com.fasterxml.jackson.databind.ser.BeanSerializerModifier;

// create class CustomBeanSerializerModifier to set the student name BeanPropertyWriter with our custom UpperCasingWriter
public class CustomBeanSerializerModifier extends BeanSerializerModifier{

	// override changeProperties method of BeanSerializerModifier
    	@Override
    	public List<BeanPropertyWriter> changeProperties( SerializationConfig configObj, BeanDescription beanDescObj, 
    		List<BeanPropertyWriter> beanProperties) {
    	
    		// use for loop for iterating bean properties
    		for (int i = 0; i < beanProperties.size(); i++) {
    		
    			//get BeanPropertyWriter by using the get() method of List and store it into a variable of type BeanPropertyWriter
    			BeanPropertyWriter writer = beanProperties.get(i);
    		
    			// check whether the writer name equals to stdName or not
    			if (writer.getName() == "stdName") {
    			
    				// set UpperCasingWriter by using set method
                		beanProperties.set(i, new UpperCasingWriter(writer));
            		}
        	}
    		// return bean properties
        	return beanProperties;
    	}
}

Let's take an example to understand how serialization is done by using customize JSON View.

JSONViewExample4.java

//import  required classes and package if any
import java.util.Scanner;
import com.fasterxml.jackson.annotation.JsonView;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.ser.BeanSerializerFactory;
import com.fasterxml.jackson.databind.ser.SerializerFactory;

//create class JSONViewExample4 to serialize an object using the customize JSON Views
public class JSONViewExample4 {
	
	// main() method start
	public static void main(String args[]) throws JsonProcessingException {
		
		String id, name, course;
		
		// create an instance of Scanner class
		Scanner sc = new Scanner(System.in);
		
		System.out.println("Enter Student Id: ");
		id = sc.nextLine();
		
		System.out.println("Enter Student Name: ");
		name = sc.nextLine();
		
		System.out.println("Enter Course Name: ");
		course = sc.nextLine();
		
		// close Scanner class object
		sc.close();
		
		// create Student object
		Student std = new Student(id, name, course);

		// create an instance of SerializerFactory by using BeanSerializerFactory and CustomBeanSerializerModifier
		SerializerFactory factory = BeanSerializerFactory.instance
				.withSerializerModifier(new CustomBeanSerializerModifier());
			
		// create an instance of ObjectMapper class
		ObjectMapper mapper = new ObjectMapper();
		
		// set serializer factory to the maaper
	    	mapper.setSerializerFactory(factory);

	    	String jsonString = mapper.writerWithView(Views.Public.class).writeValueAsString(std);
	    
	    	System.out.println("Java object after serializing: "+jsonString);
		
	}
	
}

//create class Student
class Student {

	@JsonView(Views.Public.class)
	public String stdId;

	@JsonView(Views.Public.class)
	public String stdName;

	@JsonView(Views.Internal.class)
	public String course;

	// default constructor
	Student(){
		this.stdId = null;
		this.stdName = null;
		this.course = null;
	}

	// parameterized constructor
	Student(String stdId, String stdName, String course){
		this.stdId = stdId;
		this.stdName = stdName;
		this.course = course;
	}
}

//create class for View
class Views {
	public static class Public {
  
	}
	
	public static class Internal extends Public {
  
	}
}

Output: