Jackson 中的反序列化注解

17 Mar 2025 | 6 分钟阅读

当我们将 JSON 字符串反序列化为对象时，会使用反序列化注解。Jackson 库提供了几个反序列化注解，例如 @JsonCreator、@JacksonInject、@JsonAnySetter 等。这些注解主要用于 setter 方法

让我们通过一个例子来逐一理解它们。

@JsonCreator

@JsonCreator 注解是用于微调工厂方法或构造函数（即用于反序列化）的最常用的反序列化注解之一。我们还使用 @JsonProperty 注解来使用 @JsonCreator 注解。

让我们举个例子来理解我们如何将其与 @JsonProperty 注解一起使用。

JsonCreatorExample.java

//import required classes and package if any
import java.io.IOException;
import java.text.ParseException;

import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.annotation.JsonCreator; 
import com.fasterxml.jackson.annotation.JsonProperty; 

//create class JsonCreatorExample to understand how we can use it with @JsonProperty
public class JsonCreatorExample {
    //main method start 
    public static void main(String args[]) throws ParseException {
        
        // create instance of the ObjectSerialization class
        ObjectMapper obj = new ObjectMapper();
        
        try {
            
            String jsonString = "{\"proId\":\"001\",\"proName\":\"MX Pro 20\",\"price\":\"25k\"}"; 
            System.out.println(jsonString);
            
            NewProduct newProd = obj 
                .readerFor(NewProduct.class) 
                .readValue(jsonString); 
            System.out.println("Product Id: "+newProd.newProId +", Product Name: " + newProd.newProName+", Product Price: "+newProd.newProPrice);
            
        } catch (JsonParseException e) {
            e.printStackTrace();
        } catch (JsonMappingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } 
    }
}
//create class NewProduct
class NewProduct {  
    //Creating properties of Product class 
    public String newProId;    
    public String newProName;    
    public String newProPrice;
    
    //Getter and Setters
    public String getProId() {  
        return newProId;  
    }  
    
    @JsonCreator
    public void setProId(@JsonProperty("proId") String newProId) {  
        this.newProId = newProId;  
    }  
    public String getName() {  
        return newProName;  
    }  
    @JsonCreator
    public void setProName(@JsonProperty("proName") String newProName) {  
        this.newProName = newProName;  
    }  
    public String getPrice() {  
        return newProPrice;  
    }  
    @JsonCreator
    public void setPrice(@JsonProperty("price") String newProPrice) {  
        this.newProPrice = newProPrice;  
    }
}

输出

@JacksonInject

另一个重要的反序列化注解用于插入属性值，而不是从 Json 输入解析它。

让我们看一个例子，在这个例子中，我们将使用 @JacksonInject 注解将值插入到对象中，而不是从 Json 中解析。

JacksonInjectExample.java

// import required classes and package if any 
import java.io.IOException; 
import java.text.ParseException;
import java.util.Scanner;

import com.fasterxml.jackson.annotation.JacksonInject; 
import com.fasterxml.jackson.databind.InjectableValues; 
import com.fasterxml.jackson.databind.ObjectMapper; 

// create class JacksonInjectExample to understand the working of @JacksonInject annotation
public class JacksonInjectExample {
    
    // main() method start
    public static void main(String args[]) throws ParseException{ 
        
        String jsonString = "{\"name\":\"Nicholas\",\"email\":\"nicholas.clemens@gmail.com\"}"; 
        
        // create Scanner class object
        Scanner sc= new Scanner(System.in);
        
        System.out.println("Enter Student Id of Nicholas: ");
        int stdId = sc.nextInt();
        
        // create an instance of InjectableValues and use it to add student id to the object
        InjectableValues values = new InjectableValues.Std().addValue(int.class, stdId); 
        
        // create an instance of ObjectMapper class
        ObjectMapper mapper = new ObjectMapper(); 
        
        // use try-catch block to add value to the object
        try {
            
            // create instance of the Student class
            Student student = mapper
                .reader(values) 
                .forType(Student.class) 
                .readValue(jsonString); 
            
            
            System.out.println("\n Student Id : "+student.stdId +"\n Student Name : " + student.name +"\n Student Email : " + student.email); 
        }
        catch (IOException e) { 
            e.printStackTrace(); 
        } 
        
        // close Scanner class object
        sc.close();
    }
}
class Student {
    public String name; 
    
    public String email;
    
    @JacksonInject 
    public int stdId;  
}

输出

@JsonAnySetter

@JsonAnySetter 是另一个重要的反序列化注解，我们在反序列化 Json 时使用它。它类似于 @JsonAnyGetter 注解。

它们之间唯一的区别是，@JsonAnySetter 允许 setter 方法返回一个 Map，我们用它来反序列化，而 @JsonAnyGetter 允许 getter 方法做同样的事情，但返回的 map 用于序列化。返回的 map 用于以与其他属性相同的方式反序列化 JSON 的附加属性。

让我们举个例子来理解该注解的工作原理。

JsonAnySetterExample.java

//import required classes and package
import java.io.IOException; 
import java.util.HashMap; 
import java.util.Map;
import java.util.Scanner;

import com.fasterxml.jackson.annotation.JsonAnySetter; 
import com.fasterxml.jackson.databind.ObjectMapper; 

//create class JsonAnySetterExample to understand the working of annotation
public class JsonAnySetterExample { 
    
    // main() method start
    public static void main(String args[]){
        
        // create instance of ObjectMapper class
        ObjectMapper mapper = new ObjectMapper(); 
        
        // create Scanner class object
        Scanner sc= new Scanner(System.in);
        
        try{
            
            String jsonString = "{\"Id\" : \"1\",\"Name\" : \"Brittany\",\"Email\" : \"brittany.hart@gmail.com\"}"; 
            
            Faculty data = mapper.readerFor(Faculty.class).readValue(jsonString); 
            
            System.out.println(data.getFacultyData().get("Id")); 
            System.out.println(data.getFacultyData().get("Name"));
            System.out.println(data.getFacultyData().get("Email"));
            
        } 
        catch (IOException e) { 
            e.printStackTrace(); 
        }
        
        // close Scanner class object
        sc.close();
    }
}
class Faculty {
    
    private Map<String, String> facultyData; 
    
    public Faculty(){ 
        facultyData = new HashMap<>(); 
    } 
    public Map<String, String> getFacultyData(){ 
        return facultyData; 
    } 
    @JsonAnySetter
    public void add(String key, String value){ 
        facultyData.put(key, value); 
    } 
}

输出 1

如果我们不使用 @JsonAnySetter 注解，我们的代码将为 Id、Name 和 Email 字段抛出 UnrecognizedPropertyException。

输出 2

当我们在 setter 方法中添加 @JsonAnySetter 注解时，我们的代码将执行，没有任何错误。

@JsonSetter

@JsonSetter 是另一个反序列化注解，我们也在反序列化 Json 时使用它。它类似于 @JsonGetter 注解。

它们之间唯一的区别是，@JsonGetter 用于序列化 JSON 的附加属性，而 @JsonSetter 用于反序列化 JSON 的附加属性。

让我们举个例子来理解该注解的工作原理。

JsonSetterExample.java

//import required classes and package 
import java.io.IOException;
import com.fasterxml.jackson.annotation.JsonSetter; 
import com.fasterxml.jackson.databind.ObjectMapper;  
//create class JsonSetterExample to understand the JsonSetter annotation 
public class JsonSetterExample {   
    //main() method start 
    public static void main(String args[]){
        //create instance of ObjectMapper class 
        ObjectMapper mapper = new ObjectMapper();  
        try{ 
            //convert Java type into Json string 
            String jsonString = "{\"facId\" : \"1\",\"facName\" : \"Brittany\",\"facEmail\" : \"brittany.hart@gmail.com\"}";  
            System.out.println(jsonString);  
            
            Faculty faculty = mapper.readerFor(Faculty.class).readValue(jsonString);
            System.out.println(faculty.getFacultyName()); 
            
        } catch (IOException e) {  
            e.printStackTrace();  
        } 
    } 
} 
class Faculty { 
    private String id; 
    private String name; 
    private String email; 
    
    @JsonSetter("facId")
    public void setFacultyId(String id){ 
        this.id = id; 
    }  
    @JsonSetter("facName")
    public void setFacultyName(String name){ 
        this.name = name;
    } 
    @JsonSetter("facEmail")
    public void setFacultyEmail(String email){ 
        this.email = email; 
    } 
    public String getFacultyId(){ 
        return id; 
    }  
    public String getFacultyName(){ 
        return name; 
    } 
    public String getFacultyEmail(){ 
        return email; 
    } 
}

输出

如果我们不使用 @JsonSetter 注解，我们的代码将为 facId, facName 和 facEmail 字段抛出 UnrecognizedPropertyException。

输出 2

当我们在 setter 方法中添加 @JsonSetter 注解时，我们的代码将执行，没有任何错误。

@JsonDeserialize

这是一个重要的反序列化注解，我们用它来定义一个自定义的反序列化器，用于反编组 json 对象。

让我们举个例子来理解它如何帮助反序列化 Json。

JsonDeserializerExample.java

//import required classes and package 
import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.deser.std.StdDeserializer; 
import com.fasterxml.jackson.databind.annotation.JsonDeserialize; 

//create class JsonDeserializerExample to understand the JsonDeserializer annotation 
public class JsonDeserializerExample {  
    
    //main() method start 
    public static void main(String args[]){
        
        //create instance of ObjectMapper class 
        ObjectMapper mapper = new ObjectMapper();  
        
        try{ 
            //convert Java type into Json string 
            String jsonString = "{\"id\" : \"1\",\"name\" : \"Brittany\",\"dateOfJoinning\" : \"20-12-2020\"}";  
            System.out.println(jsonString);  
            
            Faculty faculty = mapper
                .readerFor(Faculty.class)
                .readValue(jsonString);
            System.out.println(faculty.getFacultyDateOfJoin()); 
            
        } catch (IOException e) {  
            e.printStackTrace();  
        } 
    } 
} 

class Faculty { 
    
    public String id; 
    public String name; 
    
    @JsonDeserialize(using = DateDeserializer.class) 
    public Date dateOfJoinning; 
    
    public void setFacultyId(String id){ 
        this.id = id; 
    }  
    
    public void setFacultyName(String name){ 
        this.name = name;
    } 
    
    public void setFacultyDateOfJoin(Date dateOfJoinning){ 
        this.dateOfJoinning = dateOfJoinning; 
    } 
    
    public String getFacultyId(){ 
        return id; 
    }  
    
    public String getFacultyName(){ 
        return name; 
    } 
    
    public Date getFacultyDateOfJoin(){ 
        return dateOfJoinning; 
    } 
} 

//create custom deserializer by extending StdSerializer<Date>
class DateDeserializer extends StdDeserializer<Date> {
    
    // declare and initialize serialVersionUID
    private static final long serialVersionUID = 1L;
    
    // create an instance of the SimpleDateFormat
    private static SimpleDateFormat sdf = new SimpleDateFormat("dd-MM-yyyy");
    
    // default and parameterized constructor
    public DateDeserializer() { 
        this(null); 
    } 
    public DateDeserializer(Class<Date> date) { 
        super(date); 
    }
    
    // override deserialize method
    @Override 
    public Date deserialize(JsonParser jsonParser, DeserializationContext ctx) throws IOException, JsonProcessingException { 
        String dateVal = jsonParser.getText(); 
        try {
            return sdf.parse(dateVal); 
        } catch (ParseException e) { 
            e.printStackTrace(); 
        }    
        return null; 
    }   
}

输出

@JsonEnumDefaultValue

这是一个重要的反序列化注解，我们在使用 Enum 时使用它。它主要用于我们需要使用默认值反序列化未知枚举值时。

让我们举个例子来理解它如何帮助反序列化 Json。

JsonDeserializerExample.java

// import required classes and package if any
import java.io.IOException; 
import java.text.ParseException; 

import com.fasterxml.jackson.annotation.JsonEnumDefaultValue; 
import com.fasterxml.jackson.databind.DeserializationFeature; 
import com.fasterxml.jackson.databind.ObjectMapper; 

// create class JsonEnumDefaultValueExample to understand the working of annotation
public class JsonEnumDefaultValueExample {
    
    // main() method start
    public static void main(String args[]) throws ParseException{
        
        // create an instance of ObjectMapper class
        ObjectMapper mapper = new ObjectMapper();
        
        // use enable method of the class for enabling DeserializationFeature
        mapper.enable(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_USING_DEFAULT_VALUE);
        
        // json string for enum
        String jsonString = "\"abc\""; 
        
        // use try-catch block for deserializing an unknown enum
        try {
            
            LETTERS value = mapper.readValue(jsonString, LETTERS.class); 
            System.out.println(value); 
        } catch (IOException e) { 
            e.printStackTrace(); 
        }   
    }	  
}

// create enum for letters
enum LETTERS {
    A, B, @JsonEnumDefaultValue UNKNOWN 
        }

输出