Diferentes nombres de propiedad JSON durante la serialización y deserialización

Puedes usar @jsonAlias que se introdujo en jackson 2.9.0

Ejemplo:

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

Enlazaría dos pares getters/setters diferentes a una variable:

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

Puede usar una combinación de @JsonSetter y @JsonGetter para controlar la deserialización y la serialización de su propiedad, respectivamente.

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

Esto no era lo que esperaba como solución (aunque es un caso de uso legítimo). Mi requisito era permitir que un cliente con errores existente (una aplicación móvil que ya se lanzó) use nombres alternativos.

La solución radica en proporcionar un método setter separado como este:

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

Es posible tener un par getter/setter normal. Solo necesita especificar el modo de acceso en @JsonProperty

Aquí está la prueba unitaria para eso:

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

Obtuve la salida de la siguiente manera:

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

Deben haber incluido esto como una característica, porque ahora establecer un @JsonProperty diferente para un getter y setter resulta exactamente lo que esperaría (nombre de propiedad diferente durante la serialización y deserialización para el mismo campo). Jackson versión 2.6.7

Puedes escribir una clase serializada para hacer eso:

Símbolo de clase pública

{ símbolo de cadena privada;

 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 extiende JsonSerializer {

@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);