jackson自定义策略

Jackson支持在处理数据的时候，使用不同于对象字段名的JSON名称（Jackson内部使用），来代替原来的字段名进行序列化和反序列化。

主要有几种实现方式：

• 使用@JsonProperty指定固定的名称进行名称映射；
• 使用预定义的命名策略PropertyNamingStrategy，设置全局或单个类的命名策略；
• 扩展PropertyNamingStrategy，实现自定义命名策略，读和写支持使用不同的命名策略。

一.属性名称@JsonProperty

对于需要修改名称的字段，可以在字段或getter方法添加@JsonProperty注解，指定一个固定的名称来替代原来的字段名。

public class AnimalPropertyName {

    @JsonProperty("animalName") // 字段重命名. 可以对字段或getter进行声明
    private String name;
    private int sex;
    private Integer weight;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @JsonProperty("animalSex") // 字段重命名. 可以对字段或getter进行声明
    public int getSex() {
        return sex;
    }

    public void setSex(int sex) {
        this.sex = sex;
    }

    public Integer getWeight() {
        return weight;
    }

    public void setWeight(Integer weight) {
        this.weight = weight;
    }

    @Override
    public String toString() {
        return "Animal [name=" + name + ", sex=" + sex + ", weight=" + weight + "]";
    }

}

• 使用@JsonProperty(“字段别名”)注解，序列化和反序列化时使用指定的名称替代字段名

     @Test
      public void propertyName() throws IOException, JsonProcessingException {
          AnimalPropertyName animal = new AnimalPropertyName();
          animal.setName("sam");
          animal.setSex(26);
          animal.setWeight(100);
  
          ObjectMapper mapper = new ObjectMapper();
  
          // 序列化
          String jsonString = mapper.writeValueAsString(animal);
          System.out.println(jsonString);
  
          // 正确反序列化
          String jsonString2 = "{\"weight\":200,\"animalName\":\"sam2\",\"animalSex\":2}";
          AnimalPropertyName animal2 = mapper.readValue(jsonString2, AnimalPropertyName.class);
          System.out.println(animal2.toString());
  
          // 错误反序列化. 不能使用原来的字段名name和sex，需要使用注解的名称animalName和animalSex
          String jsonString3 = "{\"weight\":200,\"name\":\"sam2\",\"sex\":2}";
          ;
          AnimalPropertyName animal3 = mapper.readValue(jsonString3, AnimalPropertyName.class);
          System.out.println(animal3.toString());
      }
  

• 执行结果

  {"weight":100,"animalName":"sam","animalSex":26}
  Animal [name=sam2, sex=2, weight=200]
  
  
  com.fasterxml.jackson.databind.exc.UnrecognizedPropertyException: Unrecognized field "name" (class com.example.note.bean.AnimalPropertyName), not marked as ignorable (3 known properties: "weight", "animalSex", "animalName"])
   at [Source: (String)"{"weight":200,"name":"sam2","sex":2}"; line: 1, column: 23] (through reference chain: com.example.note.bean.AnimalPropertyName["name"])
  
  

可以看到，第一行的序列化和第二行的反序列化结果，符合我们的预期。

但第二个反序列化抛出了异常，提示无法识别name字段。

第一次和第二次反序列化的区别，在于第一次使用了映射之后的属性名，而第二次则使用了对象的字段名。

也就是说，如果指定了属性名称，那么在进行序列化和反序列化时，都需要使用指定的属性名称。

二 .预定义命名策略PropertyNamingStrategy

使用属性名称，可以为不同字段设置不同的名称，而且这个名称是固定的。

如果被操作的字段，都需要遵循相同的命名规则，那么可以使用命名策略PropertyNamingStrategy来简化命名操作。

全局的命名策略
Jackson为我们提供了6个默认的命名策略。

public class AnimalNaming {

	private String animalName;
	private int animalSex;
	private int animalWeight;
	
	public String getAnimalName() {
		return animalName;
	}
	
	public void setAnimalName(String animalName) {
		this.animalName = animalName;
	}
	
	public int getAnimalSex() {
		return animalSex;
	}
	
	public void setAnimalSex(int animalSex) {
		this.animalSex = animalSex;
	}
	
	public int getAnimalWeight() {
		return animalWeight;
	}
	
	public void setAnimalWeight(int animalWeight) {
		this.animalWeight = animalWeight;
	}
	
	@Override
	public String toString() {
		return "AnimalNaming [animalName=" + animalName + ", animalSex=" + animalSex + ", animalWeight=" + animalWeight
		        + "]";
	}

}

  @Test
    public void naming() throws IOException {
        AnimalNaming animal = new AnimalNaming();
        animal.setAnimalName("sam");
        animal.setAnimalSex(1);
        animal.setAnimalWeight(100);

        // 驼峰命名，字段的首字母小写. {"animalName":"sam","animalSex":1,"animalWeight":100}
        ObjectMapper mapper1 = new ObjectMapper();
        mapper1.setPropertyNamingStrategy(PropertyNamingStrategy.LOWER_CAMEL_CASE);
        System.out.println(mapper1.writeValueAsString(animal));

        // 驼峰命名，字段的首字母大写. {"AnimalName":"sam","AnimalSex":1,"AnimalWeight":100}
        ObjectMapper mapper2 = new ObjectMapper();
        mapper2.setPropertyNamingStrategy(PropertyNamingStrategy.UPPER_CAMEL_CASE);
        System.out.println(mapper2.writeValueAsString(animal));

        // 字段小写，多个单词以下划线_分隔. {"animal_name":"sam","animal_sex":1,"animal_weight":100}
        ObjectMapper mapper3 = new ObjectMapper();
        mapper3.setPropertyNamingStrategy(PropertyNamingStrategy.SNAKE_CASE);
        System.out.println(mapper3.writeValueAsString(animal));

        // 字段小写，多个单词以中横线-分隔. {"animal-name":"sam","animal-sex":1,"animal-weight":100}
        ObjectMapper mapper4 = new ObjectMapper();
        mapper4.setPropertyNamingStrategy(PropertyNamingStrategy.KEBAB_CASE);
        System.out.println(mapper4.writeValueAsString(animal));

        // 字段小写，多个单词间无分隔符. {"animalname":"sam","animalsex":1,"animalweight":100}
        ObjectMapper mapper5 = new ObjectMapper();
        mapper5.setPropertyNamingStrategy(PropertyNamingStrategy.LOWER_CASE);
        System.out.println(mapper5.writeValueAsString(animal));

        // 字段小写，多个单词以点号.分隔. {"animal.name":"sam","animal.sex":1,"animal.weight":100}
        ObjectMapper mapper6 = new ObjectMapper();
        mapper6.setPropertyNamingStrategy(PropertyNamingStrategy.LOWER_DOT_CASE);
        System.out.println(mapper6.writeValueAsString(animal));
    }

• 执行结果：

  {"animalName":"sam","animalSex":1,"animalWeight":100}
  {"AnimalName":"sam","AnimalSex":1,"AnimalWeight":100}
  {"animal_name":"sam","animal_sex":1,"animal_weight":100}
  {"animal-name":"sam","animal-sex":1,"animal-weight":100}
  {"animalname":"sam","animalsex":1,"animalweight":100}
  {"animal.name":"sam","animal.sex":1,"animal.weight":100}
  

通过ObjectMapper指定命名策略，这个策略是全局的。也就是说，只要使用了该ObjectMapper，那么都会应用该命名策略。

单个类的命名策略
如果命名策略只需要作用于某个类，那么可以使用@JsonNaming注解。

@JsonNaming(PropertyNamingStrategy.SnakeCaseStrategy.class)
public class AnimalJSONNaming {

	private String animalName;
	private int animalSex;
	private int animalWeight;
	
	public String getAnimalName() {
		return animalName;
	}
	
	public void setAnimalName(String animalName) {
		this.animalName = animalName;
	}
	
	public int getAnimalSex() {
		return animalSex;
	}
	
	public void setAnimalSex(int animalSex) {
		this.animalSex = animalSex;
	}
	
	public int getAnimalWeight() {
		return animalWeight;
	}
	
	public void setAnimalWeight(int animalWeight) {
		this.animalWeight = animalWeight;
	}
	
	@Override
	public String toString() {
		return "AnimalNaming [animalName=" + animalName + ", animalSex=" + animalSex + ", animalWeight=" + animalWeight
		        + "]";
	}

}

/**

 * 使用@JsonNaming注解，指定属性命名策略

 * 

 * @throws IOException
   */
   @Test
   public void jsonNaming() throws IOException {
   AnimalJSONNaming animal = new AnimalJSONNaming();
   animal.setAnimalName("sam");
   animal.setAnimalSex(1);
   animal.setAnimalWeight(100);

   ObjectMapper mapper = new ObjectMapper();
   System.out.println(mapper.writeValueAsString(animal));
   }

• 执行结果：

  {"animal_name":"sam","animal_sex":1,"animal_weight":100}
  

  三.自定义PropertyNamingStrategy

  看到源码可以发现预定义的策略都是继承了PropertyNamingStrategyBase这个类,于是我们自己实现他,实现一个字段大写，多个单词以下划线_分隔的策略.

  /**
   * @Auther: wxy
   * @Date: 2021/8/8 13:37
   * @Description:
   */
  public class MyStrategy extends PropertyNamingStrategy.PropertyNamingStrategyBase {
      @Override
      public String translate(String input) {
          if (input == null) return input; // garbage in, garbage out
          int length = input.length();
          StringBuilder result = new StringBuilder(length * 2);
          int resultLength = 0;
          boolean wasPrevTranslated = false;
          for (int i = 0; i < length; i++) {
              char c = input.charAt(i);
              if (i > 0 || c != '_') // skip first starting underscore
              {
                  if (Character.isUpperCase(c)) {
                      if (!wasPrevTranslated && resultLength > 0 && result.charAt(resultLength - 1) != '_') {
                          result.append('_');
                          resultLength++;
                      }
                      c = Character.toLowerCase(c);
                      wasPrevTranslated = true;
                  } else {
                      wasPrevTranslated = false;
                  }
                  result.append(c);
                  resultLength++;
              }
          }
          return resultLength > 0 ? result.toString().toUpperCase() : input.toUpperCase();
      }
  }
  

      @Test
      public void selfStrategy() throws IOException {
  
          AnimalNaming animal = new AnimalNaming();
          animal.setAnimalName("sam");
          animal.setAnimalSex(1);
          animal.setAnimalWeight(100);
          ObjectMapper objectMapper = new ObjectMapper();
          // 字段大写，多个单词以下划线_分隔. 	{"ANIMAL_NAME":"sam","ANIMAL_SEX":1,"ANIMAL_WEIGHT":100}
          objectMapper.setPropertyNamingStrategy(new MyStrategy());
          System.out.println(objectMapper.writeValueAsString(animal));
      }