Quand la propriété @JsonProperty est-elle utilisée et à quoi sert-elle ?

Question

Ce haricot 'State' :

public class State {

    private boolean isSet;

    @JsonProperty("isSet")
    public boolean isSet() {
        return isSet;
    }

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

}

est envoyé par câble en utilisant le rappel ajax 'success' :

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

L'annotation @JsonProperty est-elle nécessaire ici ? Quel est l'avantage de l'utiliser ? Je pense que je peux supprimer cette annotation sans provoquer d'effets secondaires.

En lisant cette annonce sur https://github.com/FasterXML/jackson-annotations/wiki/Jackson-Annotations Je ne sais pas quand il faut l'utiliser ?

Answer 1

L'ajout de la propriété JsonProperty garantit également la sécurité au cas où quelqu'un déciderait de changer le nom d'une des propriétés sans se rendre compte que la classe en question sera sérialisée en un objet Json. S'il change le nom de la propriété, JsonProperty garantit qu'il sera utilisé dans l'objet Json, et non dans le nom de la propriété.

Answer 2

En plus de toutes les réponses ci-dessus, n'oubliez pas la partie de la documentation qui dit que

annotation de marqueur qui peut être utilisée pour définir une méthode non statique en tant qu'une "setter" ou "getter" pour une propriété logique (selon sa signature) ou un champ d'objet non statique à utiliser (sérialisé). signature), ou un champ d'objet non statique à utiliser (sérialisé, désérialisé) comme une propriété logique.

Si vous avez un non-static dans votre classe qui n'est pas une méthode conventionnelle getter or setter alors vous pouvez le faire agir comme un getter and setter en utilisant l'annotation sur celui-ci. Voir l'exemple ci-dessous

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

Lorsque l'objet ci-dessus est sérialisé, alors la réponse contiendra

• nom d'utilisateur de getUsername()
• id de getId()
• idAndUsername de getIdAndUsername *

Puisque la méthode getIdAndUsername commence par get alors il est traité comme un getter normal, d'où la raison pour laquelle vous pouvez l'annoter de la manière suivante @JsonIgnore .

Si vous avez remarqué le concatenateIdAndUsername n'est pas renvoyée, car son nom ne commence pas par get et si vous souhaitez que le résultat de cette méthode soit inclus dans la réponse, vous pouvez utiliser la fonction @JsonProperty("...") et elle serait traitée comme normale getter/setter comme mentionné dans la documentation mise en évidence ci-dessus.

Answer 3

En complément des autres réponses, @JsonProperty est vraiment importante si vous utilisez l'annotation @JsonCreator dans les classes qui n'ont pas de constructeur sans argument.

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

Dans cet exemple, le seul constructeur est marqué en tant que @JsonCreator Jackson utilisera donc ce constructeur pour créer l'instance. Mais la sortie est comme :

Serialized : {"stringValue" : "ABCD", "myEnum" : "FIRST"}

Exception dans le fil d'exécution "main". com.fasterxml.jackson.databind.exc.InvalidFormatException : Impossible de construire une instance de ClassToSerialize$MyEnum from String value 'stringValue' : valeur ne faisant pas partie des Enum déclarés noms d'instance : [FIRST, SECOND, THIRD].

Mais après l'ajout de la @JsonProperty dans le constructeur :

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

La désérialisation est réussie :

Serialized : {"myEnum" : "FIRST", "stringValue" : "ABCD"}

StringValue : ABCD

MyEnum : FIRST

Answer 4

Extrait de la javadoc de JsonProperty,

Définit le nom de la propriété logique, c'est-à-dire le nom du champ de l'objet JSON à utiliser pour la propriété. Si la valeur est une chaîne vide (ce qui est la valeur par défaut), on essaiera d'utiliser le nom du champ qui est annoté.