使用 Jackson 序列化和反序列化特定字段

2025年3月17日 | 阅读 7 分钟

在本节中，我们将探讨可以通过哪些方式控制字段是否被序列化/反序列化。 Jackson 提供了以下几种方式来使字段被序列化或反序列化。

通过将字段声明为 public
通过使用 getter 方法（可序列化和可反序列化）
通过使用 setter 方法（仅可反序列化）
通过全局序列化所有字段
在序列化/反序列化时重命名属性

让我们一个一个地来理解它们

1. 通过将字段声明为 Public

这是使字段可序列化和反序列化的最简单方法之一。在这种方式中，我们只需将字段声明为 public 即可。我们将声明一个包含 public、protected 和 private 字段的类。

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

默认情况下，只有可用的字段才会被序列化为 JSON。

让我们举个例子来了解如何通过将字段声明为 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;
	}         
}

输出

Serialize and Deserialize Specific Fields in Jackson

2. 通过使用 getter 方法

在前一种方法中，我们将字段标记为 public，以使其可序列化和反序列化。大多数时候，我们需要序列化或反序列化一个非 public 字段，或者说，包私有字段和 private 字段。为了序列化/反序列化一个非 public 字段，我们只需使用该字段的 getter。

让我们举个例子来了解如何序列化一个非 public 字段。

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

输出

3. 通过使用 setter 方法

getter 方法用于可序列化和可反序列化，而 setter 方法仅用于可反序列化。我们使用 setter 方法如下所示

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

让我们举个例子来了解如何使用 setter 方法使非 public 字段可反序列化。

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

输出

4. 通过全局序列化所有字段

在某些情况下，我们无法直接修改源代码，因此我们需要一种方法，通过该方法 Jackson 可以处理来自外部的 private 字段。这种全局配置将在 ObjectMapper 级别完成。我们只需打开 AutoDetect 功能即可将其用于序列化。

我们按如下方式打开 AutoDetect 功能

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

让我们举个例子来了解如何使用 AutoDetect 功能来使所有字段可序列化。

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

输出

5. 在序列化/反序列化时重命名属性

在上面的示例中，我们控制了将要序列化或反序列化的字段。除此之外，我们还可以控制字段映射到 JSON 和返回的方式。

为了更改字段名称，我们使用 @JsonProperty 注解。在注解构造函数中，我们传递属性的名称。

让我们举个例子来了解如何使用 @JsonProperty 注解来更改用于序列化的字段名称。

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

输出