Quando a propriedade @JsonProperty é usada e para que é usada?

Este bean ‘Estado’:

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

é enviado pelo fio usando o callback ajax ‘success’:

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

A anotação @JsonProperty é necessária aqui? Qual é a vantagem de usá-lo? Acho que posso remover essa anotação sem causar efeitos colaterais.

Lendo sobre este annotion em https://github.com/FasterXML/jackson-annotations/wiki/Jackson-Annotations Eu não sei quando isso é necessário para ser usado?

Aqui está um bom exemplo. Eu uso-o para renomear a variável porque o JSON é proveniente de um ambiente .Net onde as propriedades começam com uma letra maiúscula.

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

Isso analisa corretamente para / do JSON:

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

Eu acho que o OldCurmudgeon e o StaxMan estão corretos, mas aqui está uma resposta de frase com um exemplo simples para você.

@JsonProperty (nome), diz ao Jackson ObjectMapper para mapear o nome da propriedade JSON para o nome do campo Java anotado.

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

bem pelo que vale a pena agora … JsonProperty também é usado para especificar os methods getter e setter para a variável, além da serialização e desserialização usuais. Por exemplo, suponha que você tenha uma carga assim:

 { "check": true } 

e uma class 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; } } 

Então, neste caso, a anotação JsonProperty é neeeded. No entanto, se você também tiver um método na class

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

Veja também esta documentação: http://fasterxml.github.io/jackson-annotations/javadoc/2.3.0/com/fasterxml/jackson/annotation/JsonProperty.html

Sem annotations, o nome da propriedade inferida (para corresponder de JSON) seria “set” e não – como parece ser a intenção – “isSet”. Isso ocorre porque, de acordo com a especificação Java Beans, os methods de formulário “isXxx” e “setXxx” são considerados como significando que existe uma propriedade lógica “xxx” para gerenciar.

Como você sabe, isso é tudo sobre serializar e dessalinizar um object. Suponha que haja um object:

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

A serialização deste object é:

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

O nome da variável é usado diretamente para serializar os dados. Se você estiver prestes a remover a API do sistema da implementação do sistema, em alguns casos, será necessário renomear a variável na serialização / desserialização. @JsonProperty é um metadado para informar ao serializador como o object serial. É usado para:

  • nome variável
  • access (LEITURA, ESCRITA)
  • valor padrão
  • obrigatório / opcional

do exemplo:

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

Além de outras respostas, a anotação @JsonProperty é realmente importante se você usar a anotação @JsonCreator em classs que não tenham um construtor 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); } } 

Neste exemplo, o único construtor é marcado como @JsonCreator , portanto, Jackson usará esse construtor para criar a instância. Mas a saída é como:

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

Exceção no thread “main” com.fasterxml.jackson.databind.exc.InvalidFormatException: Não é possível construir a instância de com.avl.mbdtool.verificationmodule.exceptiondocument.ClassToSerialize $ MyEnum from Valor da string ‘stringValue’: valor não é um da instância Enum declarada nomes: [PRIMEIRO, SEGUNDO, TERCEIRO]

Mas depois da adição da anotação @JsonProperty no construtor:

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

A desserialização é bem sucedida:

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

StringValue: ABCD

MyEnum: PRIMEIRO

Adicionando o JsonProperty também garante segurança no caso de alguém decidir que deseja alterar um dos nomes de propriedade não perceber que a class em questão será serializada para um object Json. Se eles alterarem o nome da propriedade, o JsonProperty garante que ele será usado no object Json e não no nome da propriedade.

De JsonProperty javadoc,

Define o nome da propriedade lógica, isto é, o nome do campo do object JSON a ser usado para a propriedade. Se o valor estiver vazio String (que é o padrão), tentará usar o nome do campo anotado.