¿Cuándo se usa la propiedad @JsonProperty y para qué se utiliza?

Este frijol ‘Estado’:

public class State { private boolean isSet; @JsonProperty("isSet") public boolean isSet() { return isSet; } @JsonProperty("isSet") public void setSet(boolean isSet) { this.isSet = isSet; } } 

se envía por cable usando la callback de ‘éxito’ de ajax:

  success : function(response) { if(response.State.isSet){ alert('success called successfully) } 

¿Se requiere la anotación @JsonProperty aquí? ¿Cuál es la ventaja de usarlo? Creo que puedo eliminar esta anotación sin causar ningún efecto secundario.

Leyendo sobre esta anotación en https://github.com/FasterXML/jackson-annotations/wiki/Jackson-Annotations ¿No sé cuándo se debe usar esto?

Aquí hay un buen ejemplo. Lo uso para cambiar el nombre de la variable porque el JSON proviene de un entorno .Net donde las propiedades comienzan con una letra mayúscula.

 public class Parameter { @JsonProperty("Name") public String name; @JsonProperty("Value") public String value; } 

Esto analiza correctamente a / desde el JSON:

 "Parameter":{ "Name":"Parameter-Name", "Value":"Parameter-Value" } 

Creo que OldCurmudgeon y StaxMan son correctos, pero aquí hay una respuesta de oraciones con un ejemplo simple para ti.

@JsonProperty (nombre), le dice a Jackson ObjectMapper que asigne el nombre de la propiedad JSON al nombre del campo anotado de Java.

 //example of json that is submitted "Car":{ "Type":"Ferrari", } //where it gets mapped public static class Car { @JsonProperty("Type") public String type; } 

bueno para lo que vale ahora … JsonProperty TAMBIÉN se utiliza para especificar métodos getter y setter para la variable aparte de la serialización y deserialización habituales. Por ejemplo, supongamos que tienes una carga útil como esta:

 { "check": true } 

y una clase Deserializer:

 public class Check { @JsonProperty("check") // It is needed else Jackson will look got getCheck method and will fail private Boolean check; public Boolean isCheck() { return check; } } 

Entonces, en este caso, se necesita la anotación JsonProperty. Sin embargo, si también tienes un método en la clase

 public class Check { //@JsonProperty("check") Not needed anymore private Boolean check; public Boolean getCheck() { return check; } } 

Eche un vistazo a esta documentación también: http://fasterxml.github.io/jackson-annotations/javadoc/2.3.0/com/fasterxml/jackson/annotation/JsonProperty.html

Sin anotaciones, el nombre de propiedad inferido (para que coincida con JSON) sería “establecido”, y no – como parece ser el bash – “isSet”. Esto se debe a que, según la especificación de Java Beans, los métodos de la forma “isXxx” y “setXxx” se toman como que significa que hay una propiedad lógica “xxx” para administrar.

Como saben, esto se trata de serializar y desalinizar un objeto. Supongamos que hay un objeto:

 public class Parameter { public String _name; public String _value; } 

La serialización de este objeto es:

 { "_name": "...", "_value": "..." } 

El nombre de la variable se usa directamente para serializar datos. Si va a eliminar la API del sistema de la implementación del sistema, en algunos casos, debe cambiar el nombre de la variable en serialización / deserialización. @JsonProperty es un metadato para decirle al serializador cómo hacer un objeto en serie. Es usado para:

  • nombre de la variable
  • acceso (LEER, ESCRIBIR)
  • valor por defecto
  • requerido / opcional

del ejemplo:

 public class Parameter { @JsonProperty( value="Name", required=true, defaultValue="No name", access= Access.READ_WRITE) public String _name; @JsonProperty( value="Value", required=true, defaultValue="Empty", access= Access.READ_WRITE) public String _value; } 

Como adición a otras respuestas, la anotación @JsonProperty es realmente importante si usa la anotación @JsonCreator en clases que no tienen un constructor no-arg.

 public class ClassToSerialize { public enum MyEnum { FIRST,SECOND,THIRD } public String stringValue = "ABCD"; public MyEnum myEnum; @JsonCreator public ClassToSerialize(MyEnum myEnum) { this.myEnum = myEnum; } public static void main(String[] args) throws IOException { ObjectMapper mapper = new ObjectMapper(); ClassToSerialize classToSerialize = new ClassToSerialize(MyEnum.FIRST); String jsonString = mapper.writeValueAsString(classToSerialize); System.out.println(jsonString); ClassToSerialize deserialized = mapper.readValue(jsonString, ClassToSerialize.class); System.out.println("StringValue: " + deserialized.stringValue); System.out.println("MyEnum: " + deserialized.myEnum); } } 

En este ejemplo, el único constructor está marcado como @JsonCreator , por lo tanto, Jackson usará este constructor para crear la instancia. Pero el resultado es como:

Serializado: {“stringValue”: “ABCD”, “myEnum”: “FIRST”}

Excepción en el subproceso “principal” com.fasterxml.jackson.databind.exc.InvalidFormatException: No se puede construir la instancia de com.avl.mbdtool.verificationmodule.exceptiondocument.ClassToSerialize $ MyEnum a partir del valor de cadena ‘stringValue’: valor no uno de la instancia de Enum declarada nombres: [PRIMERO, SEGUNDO, TERCERO]

Pero después de @JsonProperty anotación @JsonProperty en el constructor:

 @JsonCreator public ClassToSerialize(@JsonProperty("myEnum") MyEnum myEnum) { this.myEnum = myEnum; } 

La deserialización es exitosa:

Serializado: {“myEnum”: “FIRST”, “stringValue”: “ABCD”}

StringValue: ABCD

MyEnum: PRIMERO

Agregar JsonProperty también garantiza la seguridad en caso de que alguien decida que quiere cambiar uno de los nombres de propiedad sin darse cuenta de que la clase en cuestión será serializada en un objeto Json. Si cambian el nombre de la propiedad, JsonProperty asegura que se usará en el objeto Json, y no en el nombre de la propiedad.

De JsonProperty javadoc,

Define el nombre de la propiedad lógica, es decir, el nombre del campo del objeto JSON que se usará para la propiedad. Si el valor está vacío, String (que es el valor predeterminado), intentará usar el nombre del campo anotado.