@Constructorproperties annotation understanding and its corresponding usage

1. Say first conclusion

1. @ConstructorProperties annotation Not at all json Inside , It is jdk Classes carried by itself .
   

2. When a class has Multiple constructors , It's going on json When converting to an object , When you need to specify which constructor it uses , have access to @ConstructorProperties annotation , tell json In the process of transformation , Which constructor to use to deserialize as an object .

3. By default, without any other conditions ,json When deserializing to an object using a constructor ：

   1. If there is a parameterless constructor , And when there is a parameter constructor , first Will choose Parameter free constructor Deserialization .
   2. If there are multiple parameterized constructors , But there is no parameterless constructor , first Will choose The parameterized constructor with the most parameters Deserialization .
   3. In both cases , If new conditions @ConstructorProperties Annotations of words , first choice Constructor annotated by this Deserialization .

4. @ConstructorProperties A note Can replace json In the annotations @JsonCreator And @JsonProperty At the same time .

5. stay springboot Use in @ConstructorProperties annotation , The function of its annotation parameters is completely invalid , The function of this annotation is only ： tell ObjectMapper Use that constructor to deserialize , The cause has not been found .

2. Get started using

1. @JsonCreator And @JsonProperty Use

1. @JsonCreator Specify which constructor to use for deserialization .

2. @JsonProperty Appoint json Object field name , Correspondence with specific attribute names .

3. The code is as follows ：

   @ToString
   public class AA {
         
   
       private String name;
   
       private String password;
   
       public AA(String name){
         
           System.out.println(" Use a constructor with only one parameter ");
           this.name = name;
       }
   
   	//  Specify to use this constructor for deserialization 
   	// @JsonProperty("pwd")  named , attribute password  And json Of pwd The corresponding field 
       @JsonCreator
       public AA(@JsonProperty("name") String name, @JsonProperty("pwd") String password) {
         
           System.out.println(" All parameter constructor is used ");
           this.name = name;
           this.password = password;
       }
   }
   

   public class demo {
         
       public static void main(String[] args) throws Exception{
         
           String jsonStr = "{\n" +
                   " \"name\":\"1\",\n" +
                   " \"pwd\":\"123\"\n" +
                   "}";
   
           ObjectMapper objectMapper = new ObjectMapper();
           final AA aa = objectMapper.readValue(jsonStr, AA.class);
           System.out.println(aa);
       }
   }
   

   

2. @ConstructorProperties Use

1. @ConstructorProperties Completely replaceable @JsonCreator And @JsonProperty.

2. Annotation parameters are specified json Field , And Constructors The correspondence of parameters , Binding relationship .

3. The code is as follows ：

   @ToString
   public class AA {
         
   
       private String name;
   
       private String password;
   	
   	public AA(String name){
         
       	System.out.println(" Use a constructor with only one parameter ");
       	this.name = name;
   	}
   
   	//  The annotation parameter specifies json Field , And   Constructors   The correspondence of parameters 
   	//  Attribute password  And json Of pwd The corresponding field 
   	//  Attribute namee  And json Of name The corresponding field 
       @ConstructorProperties({
         "name", "pwd"})
       public AA(String name, String password) {
         
           System.out.println(" All parameter constructor is used ");
           this.name = name;
           this.password = password;
       }
   }
   

   public class demo {
         
       public static void main(String[] args) throws Exception{
         
           String jsonStr = "{\n" +
                   " \"name\":\"1\",\n" +
                   " \"pwd\":\"123\"\n" +
                   "}";
   
           ObjectMapper objectMapper = new ObjectMapper();
           final AA aa = objectMapper.readValue(jsonStr, AA.class);
           System.out.println(aa);
       }
   }
   

   

4. The @ConstructorProperties annotation The parameter is to specify json Field , And Constructors The correspondence of parameters
   Change the code to @ConstructorProperties({“pwd”, “name”})

   @ToString
   public class AA {
         
   
       private String name;
   
       private String password;
   
       public AA(String name) {
         
           System.out.println(" Use a constructor with only one parameter ");
           this.name = name;
       }
       
   	//  Willingly   The correspondence is reversed 
   	//  So the binding relationship here is ：
   	// json Of pwd  Corresponding  name
   	// json Of name  Corresponding  password
       @ConstructorProperties({
         "pwd", "name"})
       public AA(String name, String password) {
         
           System.out.println(" All parameter constructor is used ");
           this.name = name;
           this.password = password;
       }
   }
   
   public class demo {
         
       public static void main(String[] args) throws Exception{
         
           String jsonStr = "{\n" +
                   " \"pwd\":\"123\",\n" +
                   " \"name\":\"1\"\n" +
                   "}";
   
           ObjectMapper objectMapper = new ObjectMapper();
           final AA aa = objectMapper.readValue(jsonStr, AA.class);
           System.out.println(aa);
       }
   }
   

   
   It can be seen from the above figure , Original name=1, Now it is name=123

3. Verification conclusion

1. Prepare for

1. Below ObjectMapper, All are be based on ObjectMapper, After all, it is springboot Default json Transformation tools .

2. Prepare an entity class , One controller layer ：

   @ToString
   public class AA {
         
   
       private String name;
   
       private String password;
   
       public AA(String name){
         
           System.out.println(" Use a constructor with only one parameter ");
           this.name = name;
       }
   
       public AA(String name, String password) {
         
           System.out.println(" All parameter constructor is used ");
           this.name = name;
           this.password = password;
       }
   
       public AA(){
         
           System.out.println(" Use parameterless constructor ");
       }
   }
   
   @RestController
   public class ConstructorTestController {
         
   
       @PostMapping("/test/A")
       public void testA(@RequestBody AA a){
         
           System.out.println(a);
       }
   }
   

3. stay AA On entity class , Only add @ToString Method , For the convenience of viewing its attribute assignment , There is no way to add @Getter perhaps @Setter annotation , because json The transformation can also be based on these two methods , You can refer to ：(ObjectMapper)Json The basic principle of transforming objects

4. Based on the third point above , Do a little science popularization ,json The transformation of Priority of usage yes ：set Method 、public Of field attribute 、get Method 、 Constructors .

2. Verify the existence of both nonparametric and parametric structures

1. Nonparametric structure and parametric structure exist at the same time , Priority is the parameterless constructor ：
   

2. If... Is used at this time @ConstructorProperties({“name”, “password”}), Priority is the constructor specified by the annotation

   @ToString
   public class AA {
         
   
       private String name;
   
       private String password;
   
       public AA(String name) {
         
           System.out.println(" Use a constructor with only one parameter ");
           this.name = name;
       }
   
       @ConstructorProperties({
         "name", "password"})
       public AA(String name, String password) {
         
           System.out.println(" All parameter constructor is used ");
           this.name = name;
           this.password = password;
       }
   
       public AA() {
         
           System.out.println(" Use parameterless constructor ");
       }
   }
   

   

3. Verify that only With parameter constructor

1. When there is only a parameter constructor , Without any other comments , The priority is Constructor with the most parameters deserialize .

2. The code is as follows ：

   @ToString
   public class AA {
         
   
       private String name;
   
       private String password;
   
       public AA(String name) {
         
           System.out.println(" Use a constructor with only one parameter ");
           this.name = name;
       }
   
       public AA(String name, String password) {
         
           System.out.println(" All parameter constructor is used ");
           this.name = name;
           this.password = password;
       }
       
   }
   

   

   Some people might say , Because it's just right json There are two fields , All constructors that use full parameters , Now we change it to only name Field json request ：

   
   It can be seen from the above that , priority ： Is the constructor with the most parameters

3. When we use @ConstructorProperties annotation , The annotation parameter is written name,password
   
   

4. Or the annotation parameters are only written name
   

4. stay springboot Use in @ConstructorProperties When the annotation , Parameter function completely fails

1. In the QuickStart , We Mention of @ConstructorProperties Annotated parameters , Yes, it will json Field corresponds to the parameters of its constructor

2. But after testing , stay springboot in , It doesn't seem like this , The code is as follows ：
   The corresponding relation is ：json Field of pwd Corresponding attribute name,json Field of name Corresponding attribute password

   @ToString
   public class AA {
         
   
       private String name;
   
       private String password;
   
       public AA(String name) {
         
           System.out.println(" Use a constructor with only one parameter ");
           this.name = name;
       }
   
       @ConstructorProperties({
         "pwd", "name"})
       public AA(String name, String password) {
         
           System.out.println(" All parameter constructor is used ");
           this.name = name;
           this.password = password;
       }
   
   }