使用 Jackson 根据自定义条件序列化字段

17 Mar 2025 | 5 分钟阅读

通过使用 Jackson，我们可以仅序列化满足特定自定义条件的字段。有时，我们仅需要在其值为正数时序列化 int 类型的字段。如果它的值为负数，我们将完全跳过它。

使用 Jackson 过滤器控制序列化过程

Jackson 过滤器 在控制序列化中起着重要作用。我们使用 @JsonFilter 注解。 @JsonFilter 注解用于在我们的实体上定义自定义过滤器。

我们使用 JsonFilter 注解的方式如下所示

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

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

我们使用以下步骤根据自定义条件序列化字段

使用 @JsonFilter 在我们的实体类上定义过滤器
定义自定义 PropertyFilter。
将过滤器钩入 ObjectMapper。
序列化实体。

让我们举一个例子，在其中我们使用上述步骤根据自定义条件序列化字段。

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;
	}         
}

输出

Serialize Fields Based on Custom Criteria in Jackson

让我们再举一个例子，以了解我们如何根据某些条件跳过完整的对象。我们将跳过所有 isHidden 属性等于 true 的对象。

我们使用以下步骤通过使用 JsonFilter 跳过序列化完整的对象。

首先，我们使用 @JsonIgnoreProperties({"hidden", "isHidden"}) 创建 Hidable 接口。
接下来，我们创建两个类，即 College 和 Address，它们实现了 Hidable。我们使用 @JsonIgnoreProperties({"hidden", "isHidden"}) 注解来确保 isHidden 属性或 hidden 属性不包含在 JSON 中。
我们创建一个自定义序列化器，即 HidableJavaSerializer，用于在序列化时跳过对象。
我们使用 BeanSerializerModifier 将默认序列化器注入到我们的自定义 HidableJavaSerializer 中。

让我们为上面提到的所有要点实现代码。

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;
	}         
}

输出

下一篇使用 Jackson 序列化和反序列化枚举

使用 Jackson 根据自定义条件序列化字段

使用 Jackson 过滤器控制序列化过程

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Jackson 教程

Jackson 注解

序列化/反序列化

高级编组

使用 Jackson 根据自定义条件序列化字段

使用 Jackson 过滤器控制序列化过程

相关帖子

使用 Jackson 比较 JSON 对象

将布尔值序列化和反序列化为整数

Jackson JSON 视图

序列化和反序列化枚举

反序列化为集合和数组

Map 序列化和反序列化

Jackson 日期

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器