Serialize Fields Based on Custom Criteria in Jackson

By using Jackson, we can serialize only those fields that meet specific custom criteria. Sometimes, we need to serialize a field of type int only when its value is positive. If its value is negative, we will skip it entirely.

Control the serialization process by using the Jackson filter

Jackson Filter plays an important role in controlling the serialization. We use the @JsonFilter annotation. The @JsonFilter annotation is used to define the custom filter on our entity.

We use the JsonFilter annotation in the following way:

@JsonFilter("customFilter")
public class TestFilter {
	private int intData;

    	public TestFilter() {
        		super();
    	}
    	public int getIntValue() {
        		return intValue;
    	}
    	public void setIntValue(int intValue) {
        		this.intValue = intValue;
    	}	
}  

We use the following steps to serialize the fields based on the custom criteria:

Define the filter on our entity class using the @JsonFilter
Define the custom PropertyFilter.
Hook the filter into the ObjectMapper.
Serialize the entity.

Let's take an example in which we use the above steps to serialize the fields based on the custom criteria.

JsonFilterExample1.java

import java.io.IOException;
import java.util.Scanner;
import com.fasterxml.jackson.annotation.JsonFilter;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.ser.BeanPropertyWriter;
import com.fasterxml.jackson.databind.ser.FilterProvider;
import com.fasterxml.jackson.databind.ser.PropertyFilter;
import com.fasterxml.jackson.databind.ser.PropertyWriter;
import com.fasterxml.jackson.databind.ser.impl.SimpleBeanPropertyFilter;
import com.fasterxml.jackson.databind.ser.impl.SimpleFilterProvider;

// create class JsonFilterExample1 to understand the use of custom filter
public class JsonFilterExample1 {
	
	//main() method
	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, id;  
			System.out.println("Enter College Name:");  
			name = sc.nextLine();  
			System.out.println("Enter College Id:");  
			id = 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, Integer.valueOf(id), university, new Address(street, state, city), rank);
			// call getFilterProvider() method to get FilterProvider which we use to set the filter into the ObjectMapper
			FilterProvider provider = getFilterProvider();
			
			// serialize College by using a filter
			String jsonString = mapper.writer(provider).writeValueAsString(colg);
			System.out.println(jsonString);
		} catch (IOException e) {   
			e.printStackTrace();  
		}  
		//close Scanner class object  
		sc.close();
	}
	public static FilterProvider getFilterProvider() {	
		// create a custom filter
		PropertyFilter customFilter = new SimpleBeanPropertyFilter() {
			@Override
			public void serializeAsField(
					Object obj, JsonGenerator generator, SerializerProvider provider, PropertyWriter writer
					)throws Exception {		// handle exception
			      		if (include(writer)) {
			      			if (!writer.getName().equals("collegeId")) {
			      				writer.serializeAsField(obj, generator, provider);
			      				return;
			      			}
			      			int intValue = ((College) obj).collegeId;
			      			if (intValue >= 0) {
			      				writer.serializeAsField(obj, generator, provider);
			      			}
			      			} else if (!generator.canOmitFields()) {
			      				writer.serializeAsOmittedField(obj, generator, provider);
			      			}
			}
			@Override
			protected boolean include(BeanPropertyWriter writer) {
				return true;
			}
			@Override
			protected boolean include(PropertyWriter writer) {
				return true;
			}
		};
		// create filter provider by adding IntFilter to SimpleFilterProvider and return it to the main() method
		FilterProvider filterObj = new SimpleFilterProvider().addFilter("IntFilter", customFilter);
		return filterObj;
	}
}
//create class College by using @JsonFilter to use the custom filter for serializing
@JsonFilter("IntFilter")
class College {    

	//Creating properties of College class    
	public String name;      
	public int collegeId; 
	public String university;   
	public Address address; 
	public String rank;   

	// constructor  
	College(String name, int collegeId, String university, Address address, String rank){  
		this.name = name;  
		this.university = university;  
		this.address = address;  
		this.rank = rank;  
		this.collegeId = collegeId;
	}  
}
//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 Fields Based on Custom Criteria in Jackson

Let's take another example to understand how we can skip the complete Object based on some condition. We skip all those objects where the isHidden property will be equal to true.

We use the following steps to skip the complete Object for serializing by using JsonFilter.

First, we create Hidable interface by using the @JsonIgnoreProperties({"hidden", "isHidden"}).
Next, we create two classes, i.e., College and Address, which implement the Hidable We use the @JsonIgnoreProperties({"hidden", "isHidden"}) annotation to make sure that the isHidden property or hidden properties are not included in JSON.
We create a custom serializer, i.e., HidableJavaSerializer, for skipping the Object at the time or serializing.
We use the BeanSerializerModifier for injecting the default serializer in our custom HidableJavaSerializer.

Let's implement the code for all the above points which we mentioned above.

Hidable.java

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
@JsonIgnoreProperties({"hidden", "isHidden"})
public interface Hidable {
	boolean isHidden();
}

HidableJavaSerializer.java

import java.io.IOException;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
// create class HidableJavaSerializer to create a serializer
public class HidableJavaSerializer extends JsonSerializer<Hidable> {
	// create a variable of type JsonSerializer
    	private JsonSerializer<Object> serializer;
    	// parameterized constructor
   	public HidableJavaSerializer(JsonSerializer<Object> serializer) {
        		this.serializer = serializer;
    	}
    	// override isEmpty method of JsonSerializer
    	@Override
    	public boolean isEmpty(SerializerProvider provider, Hidable data) {
    		return (data == null || data.isHidden());
    	}
    	// override serialize method of JsonSerializer
   	@Override
   	public void serialize(Hidable data, JsonGenerator generator, SerializerProvider provider) throws IOException, JsonProcessingException {
    		if (data.isHidden()) {
            			return;
        		}
        		// use serialize method of JSonSerializer
        		serializer.serialize(data, generator, provider);
    	}
}

JsonFilterExample2.java

import java.io.IOException;
import java.util.Scanner;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.JsonInclude.Include;
import com.fasterxml.jackson.databind.BeanDescription;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationConfig;
import com.fasterxml.jackson.databind.module.SimpleModule;
import com.fasterxml.jackson.databind.ser.BeanSerializerModifier;

// create class JsonFilterExample2 to understand the use of custom filter for skipping Object
public class JsonFilterExample2 {
	
	//main() method
	@SuppressWarnings("serial")
	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, showAdd, showColg;  
			boolean isAdd, isColg;
			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();
			System.out.println("Is college serializable(Yes/No)?:");  
			showColg = sc.nextLine();
			System.out.println("Is address serializable(Yes/No)?:");  
			showAdd = sc.nextLine();
			if(showColg.equals("Yes")) {
				isColg = false;
			}else {
				isColg = true;
			}
			if(showAdd.equals("Yes")) {
				isAdd = false;
			}else {
				isAdd = true;
			}
			
			// set values to College  object by using constructor  
			colg = new College(name, university, new Address(street, state, city, isAdd), rank, isColg);
			
			// use bean serializer modifier for injecting the default serializer in out custom HidableJavaSerializer
			mapper.setSerializationInclusion(Include.NON_EMPTY)
			.registerModule(new SimpleModule() {
			    @Override
			    public void setupModule(SetupContext context) {
			        super.setupModule(context);
			        context.addBeanSerializerModifier(new BeanSerializerModifier() {
			            @SuppressWarnings("unchecked")
						@Override
			            public JsonSerializer<?> modifySerializer( SerializationConfig config, BeanDescription beanDesc, JsonSerializer<?> serializer) {
			                if (Hidable.class.isAssignableFrom(beanDesc.getBeanClass())) {
			                    return new HidableJavaSerializer((JsonSerializer<Object>) serializer);
			                }
			                return serializer;
			            }
			        });
			    }
			});
			
			// serialize College by using a filter
			String jsonString = mapper.writeValueAsString(colg);
			System.out.println(jsonString);
		} catch (IOException e) {   
			e.printStackTrace();  
		}  
		//close Scanner class object  
		sc.close();
	}
}
//create class College by implementing Hidable interface
@JsonIgnoreProperties({ "hidden", "isHidden" })
class College implements Hidable {    
	//Creating properties of College class    
	public String name;      
	public String university;   
	public Address address; 
	public String rank;  
	public boolean isHidden;
	// constructor  
	College(String name, String university, Address address, String rank, boolean isHidden){  
		this.name = name;  
		this.university = university;  
		this.address = address;  
		this.rank = rank;  
		this.isHidden = isHidden;
	}

	@Override
	public boolean isHidden() {
		return isHidden;
	}  
}
//create class Address by implementing Hidable interface
@JsonIgnoreProperties({ "hidden", "isHidden" })
class Address implements Hidable{  
	public String street;
	public String state;
	public String city;
	public boolean isHidden;
	
	Address(String street, String state, String city, boolean isHidden){  
		  this.street = street;
		  this.state = state;
		  this.city = city;
		  this.isHidden = isHidden;
	}
	@Override
	public boolean isHidden() {
		return isHidden;
	}         
}

Output: