序列化和反序列化过程中JSON属性的不同名称

是否有可能：类中有一个字段，而在Jackson库中进行序列化/反序列化时却有不同的名称？

例如，我有“ Coordiantes”类。

class Coordinates{
  int red;
}

对于从JSON反序列化，希望具有以下格式：

{
  "red":12
}

但是当我序列化对象时，结果应该是这样的：

{
  "r":12
}

我试图通过@JsonProperty在getter和setter上都应用注释（具有不同的值）来实现此目的：

class Coordiantes{
    int red;

    @JsonProperty("r")
    public byte getRed() {
      return red;
    }

    @JsonProperty("red")
    public void setRed(byte red) {
      this.red = red;
    }
}

但我有一个例外：

org.codehaus.jackson.map.exc.UnrecognizedPropertyException：无法识别的字段“红色”

刚刚测试，这有效：

public class Coordinates {
    byte red;

    @JsonProperty("r")
    public byte getR() {
      return red;
    }

    @JsonProperty("red")
    public void setRed(byte red) {
      this.red = red;
    }
}

这个想法是方法名称应该不同，所以杰克逊将其解析为不同的字段，而不是一个字段。

这是测试代码：

Coordinates c = new Coordinates();
c.setRed((byte) 5);

ObjectMapper mapper = new ObjectMapper();
System.out.println("Serialization: " + mapper.writeValueAsString(c));

Coordinates r = mapper.readValue("{\"red\":25}",Coordinates.class);
System.out.println("Deserialization: " + r.getR());

结果：

Serialization: {"r":5}
Deserialization: 25

您可以使用@jsonAlias在杰克逊2.9.0中引入的功能

例：

public class Info {
  @JsonAlias({ "red" })
  public String r;
}

这r在序列化期间使用，但red在反序列化期间用作别名。不过，这仍然允许r反序列化。

您可以结合使用@JsonSetter和@JsonGetter来分别控制属性的反序列化和序列化。这也将允许您保留与实际字段名称相对应的标准化getter和setter方法名称。

import com.fasterxml.jackson.annotation.JsonSetter;    
import com.fasterxml.jackson.annotation.JsonGetter;

class Coordinates {
    private int red;

    //# Used during serialization
    @JsonGetter("r")
    public int getRed() {
        return red;
    }

    //# Used during deserialization
    @JsonSetter("red")
    public void setRed(int red) {
        this.red = red;
    }
}

我将两个不同的获取器/设置器对绑定到一个变量：

class Coordinates{
    int red;

    @JsonProperty("red")
    public byte getRed() {
      return red;
    }

    public void setRed(byte red) {
      this.red = red;
    }

    @JsonProperty("r")
    public byte getR() {
      return red;
    }

    public void setR(byte red) {
      this.red = red;
    }
}

可以有正常的吸气剂/设定剂对。您只需要在中指定访问模式@JsonProperty

这是为此的单元测试：

public class JsonPropertyTest {

  private static class TestJackson {

    private String color;

    @JsonProperty(value = "device_color", access = JsonProperty.Access.READ_ONLY)
    public String getColor() {
      return color;
    };

    @JsonProperty(value = "color", access = JsonProperty.Access.WRITE_ONLY)
    public void setColor(String color) {
      this.color = color;
    }

  }

  @Test
  public void shouldParseWithAccessModeSpecified() throws Exception {
    String colorJson = "{\"color\":\"red\"}";
    ObjectMapper mapper = new ObjectMapper();
    TestJackson colotObject = mapper.readValue(colorJson, TestJackson.class);

    String ser = mapper.writeValueAsString(colotObject);
    System.out.println("Serialized colotObject: " + ser);
  }
}

我得到的输出如下：

Serialized colotObject: {"device_color":"red"}

这不是我期望的解决方案（尽管这是合法的用例）。我的要求是允许现有的错误客户端（已发布的移动应用程序）使用备用名称。

解决方案在于提供一个单独的setter方法，如下所示：

@JsonSetter( "r" )
public void alternateSetRed( byte red ) {
    this.red = red;
}

我知道这是一个老问题，但是对我来说，当我发现它与Gson库冲突时，我就可以使用它，因此，如果您使用的是Gson，请使用@SerializedName("name")代替@JsonProperty("name")希望这会有所帮助

注释@JsonAlias一下Jackson 2.9+中引入的内容，而无需提及@JsonProperty要使用多个别名（json属性的不同名称）进行反序列化的项目。

我将com.fasterxml.jackson.annotation.JsonAlias包装与com.fasterxml.jackson.databind.ObjectMapper我的用例保持一致。

例如：

@Data
@Builder
public class Chair {

    @JsonAlias({"woodenChair", "steelChair"})
    private String entityType;

}


@Test
public void test1() {

   String str1 = "{\"woodenChair\":\"chair made of wood\"}";
   System.out.println( mapper.readValue(str1, Chair.class));
   String str2 = "{\"steelChair\":\"chair made of steel\"}";
   System.out.println( mapper.readValue(str2, Chair.class));

}

正常工作。

他们必须将此功能包括在内，因为现在@JsonProperty为getter和setter 设置一个不同的结果将完全符合您的期望（在同一字段的序列化和反序列化期间，不同的属性名称）。杰克逊2.6.7版

您可以编写一个序列化类来做到这一点：

public class Symbol

{
     private String symbol;

     private String name;

     public String getSymbol() {
        return symbol;
    }
    public void setSymbol(String symbol) {
        this.symbol = symbol;
    }    
    public String getName() {
        return name;
    }    
    public void setName(String name) {
        this.name = name;
    }
}

public class SymbolJsonSerializer extends JsonSerializer<Symbol> {

    @Override
    public void serialize(Symbol symbol, JsonGenerator jgen, SerializerProvider serializers) throws IOException, JsonProcessingException {
        jgen.writeStartObject();

        jgen.writeStringField("symbol", symbol.getSymbol());
         //Changed name to full_name as the field name of Json string
        jgen.writeStringField("full_name", symbol.getName());
        jgen.writeEndObject(); 
    }
}

            ObjectMapper mapper = new ObjectMapper();

            SimpleModule module = new SimpleModule();
            module.addSerializer(Symbol.class, new SymbolJsonSerializer());
            mapper.registerModule(module); 

            //only convert non-null field, option...
            mapper.setSerializationInclusion(Include.NON_NULL); 

            String jsonString = mapper.writeValueAsString(symbolList);