Wanneer wordt de eigenschap @JsonProperty gebruikt en waarvoor wordt deze gebruikt?

Deze boon ‘State’ :

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

wordt over de draad verzonden met de ajax ‘succes’-callback:

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

Is de annotatie @JsonProperty hier vereist? Wat is het voordeel om het te gebruiken?
Ik denk dat ik deze aantekening kan verwijderen zonder bijwerkingen te veroorzaken.

Lezen over deze annotatie op https://github.com/FasterXML/jackson -annotations/wiki/Jackson-Annotations Ik weet niet wanneer dit moet worden gebruikt ?

Antwoord 1, autoriteit 100%

Hier is een goed voorbeeld. Ik gebruik het om de variabele te hernoemen omdat de JSON afkomstig is uit een .Net-omgeving waar eigenschappen beginnen met een hoofdletter.

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

Dit parseert correct naar/van de JSON:

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

Antwoord 2, autoriteit 18%

Ik denk dat OldCurmudgeon en StaxMan allebei gelijk hebben, maar hier is één zinsantwoord met een eenvoudig voorbeeld voor jou.

@JsonProperty(name), vertelt Jackson ObjectMapper om de naam van de JSON-eigenschap toe te wijzen aan de naam van het geannoteerde Java-veld.

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

Antwoord 3, autoriteit 15%

nou voor wat het nu waard is… JsonProperty wordt OOK gebruikt om getter- en setter-methoden voor de variabele te specificeren, afgezien van de gebruikelijke serialisatie en deserialisatie. Stel bijvoorbeeld dat u een payload heeft zoals deze:

{
  "check": true
}

en een klasse 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;
  }
}

In dit geval is JsonProperty-annotatie nodig. Als je echter ook een methode in de klasse

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

Bekijk ook deze documentatie:
http://fasterxml.github .io/jackson-annotations/javadoc/2.3.0/com/fasterxml/jackson/annotation/JsonProperty.html

Antwoord 4, autoriteit 8%

Zonder annotaties zou de afgeleide eigenschapsnaam (die overeenkomt met JSON) “set” zijn en niet — zoals de bedoeling lijkt te zijn — “isSet”. Dit komt omdat volgens de Java Beans-specificatie, methoden van de vorm “isXxx” en “setXxx” worden opgevat als een logische eigenschap “xxx” om te beheren.

Antwoord 5, autoriteit 3%

Het toevoegen van de JsonProperty zorgt ook voor veiligheid in het geval dat iemand besluit een van de eigenschapsnamen te wijzigen, zich niet realiserend dat de betreffende klasse zal worden geserialiseerd naar een Json-object. Als ze de eigenschapsnaam wijzigen, zorgt de JsonProperty ervoor dat deze wordt gebruikt in het Json-object en niet in de eigenschapsnaam.

Antwoord 6, autoriteit 2%

Zoals je weet, draait het allemaal om het serialiseren en ontzilten van een object. Stel dat er een object is:

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

De serialisatie van dit object is:

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

De naam van de variabele wordt direct gebruikt om gegevens te serialiseren. Als u op het punt staat de systeem-API uit de systeemimplementatie te verwijderen, moet u in sommige gevallen de variabele hernoemen in serialisatie/deserialisatie. @JsonProperty is een metagegevens om serializer te vertellen hoe een serieel object. Het wordt gebruikt om:

• naam van variabele
• toegang (LEZEN, SCHRIJVEN)
• standaardwaarde
• vereist/optioneel

van voorbeeld:

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

Antwoord 7, autoriteit 2%

Vergeet naast alle bovenstaande antwoorden het deel van de documentatie niet dat zegt

Markerannotatie die kan worden gebruikt om een ​​niet-statische methode te definiëren als a
“setter” of “getter” voor een logische eigenschap (afhankelijk van zijn
handtekening), of niet-statisch objectveld dat moet worden gebruikt (geserialiseerd,
gedeserialiseerd) als een logische eigenschap.

Als je een non-static methode in je klas hebt die geen conventionele getter or setter is, dan kun je deze laten werken als een getter and setter door de annotatie erop te gebruiken. Zie onderstaand voorbeeld

public class Testing {
    private Integer id;
    private String username;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getIdAndUsername() {
        return id + "." + username; 
    }
    public String concatenateIdAndUsername() {
        return id + "." + username; 
    }
}

Als het bovenstaande object geserialiseerd is, bevat het antwoord

• gebruikersnaam van getUsername()
• id van getId()
• idAndUsername van getIdAndUsername*

Aangezien de methode getIdAndUsername begint met get, wordt het behandeld als een normale getter, vandaar dat je zoiets zou kunnen annoteren met @JsonIgnore.

Als je hebt gemerkt dat de concatenateIdAndUsername niet wordt geretourneerd en dat komt omdat de naam niet begint met get en als je wilt dat het resultaat van die methode wordt opgenomen in de antwoord dan kunt u @JsonProperty("...") gebruiken en het zou worden behandeld als een normale getter/setter zoals vermeld in de hierboven gemarkeerde documentatie.

Antwoord 8

Als aanvulling op andere antwoorden, is de @JsonProperty annotatie erg belangrijk als je de @JsonCreator annotatie gebruikt in klassen die geen no-arg constructor hebben.

p>

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

In dit voorbeeld is de enige constructor gemarkeerd als @JsonCreator, daarom zal Jackson deze constructor gebruiken om de instantie te maken. Maar de output is als:

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

Uitzondering in
draad “hoofd”
com.fasterxml.jackson.databind.exc.InvalidFormatException: kan niet
constructie instantie van
ClassToSerialize$MyEnum
van String waarde ‘stringValue’: waarde niet een van gedeclareerde Enum
instantienamen: [FIRST, SECOND, THIRD]

Maar na de toevoeging van de @JsonProperty annotatie in de constructor:

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

De deserialisatie is gelukt:

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

StringValue: ABCD

MyEnum: EERSTE

Antwoord 9

Van JsonProperty javadoc,

Definieert de naam van de logische eigenschap, d.w.z. de naam van het JSON-objectveld die voor de eigenschap moet worden gebruikt. Als de waarde leeg is, zal String (wat de standaard is), proberen de naam van het veld te gebruiken dat is geannoteerd.