Utiliser uniquement @JsonIgnore pendant la sérialisation, mais pas la désérialisation

J'ai un objet utilisateur qui est envoyé vers et depuis le serveur. Lorsque j'envoie l'objet utilisateur, je ne veux pas envoyer le mot de passe haché au client. J'ai donc ajouté @JsonIgnorela propriété de mot de passe, mais cela l'empêche également d'être désérialisé dans le mot de passe, ce qui rend difficile l'inscription des utilisateurs lorsqu'ils n'ont pas de mot de passe.

Comment puis-je seulement @JsonIgnoreappliquer à la sérialisation et non à la désérialisation? J'utilise Spring JSONView, donc je n'ai pas une tonne de contrôle sur ObjectMapper.

Ce que j'ai essayé:

1. Ajouter @JsonIgnoreà la propriété
2. Ajouter @JsonIgnoreuniquement sur la méthode getter

La façon exacte de procéder dépend de la version de Jackson que vous utilisez. Cela a changé autour de la version 1.9 , avant cela, vous pouvez le faire en ajoutant @JsonIgnoreau getter.

Ce que vous avez essayé:

Ajoutez @JsonIgnore sur la méthode getter uniquement

Faites cela et ajoutez également une @JsonPropertyannotation spécifique pour votre nom de champ "mot de passe" JSON à la méthode de définition du mot de passe sur votre objet.

Des versions plus récentes de Jackson ont ajouté READ_ONLYet WRITE_ONLYdes arguments d'annotation pour JsonProperty. Vous pouvez donc aussi faire quelque chose comme:

@JsonProperty(access = Access.WRITE_ONLY)
private String password;

Les documents peuvent être trouvés ici .

Pour ce faire, il suffit de deux annotations:

1. @JsonIgnore
2. @JsonProperty

Utiliser @JsonIgnoresur le membre de classe et son getter, et @JsonPropertysur son setter. Un exemple d'illustration aiderait à faire ceci:

class User {

    // More fields here
    @JsonIgnore
    private String password;

    @JsonIgnore
    public String getPassword() {
        return password;
    }

    @JsonProperty
    public void setPassword(final String password) {
        this.password = password;
    }
}

Depuis la version 2.6: une manière plus intuitive est d'utiliser l' com.fasterxml.jackson.annotation.JsonPropertyannotation sur le terrain:

@JsonProperty(access = Access.WRITE_ONLY)
private String myField;

Même s'il existe un getter, la valeur du champ est exclue de la sérialisation.

JavaDoc dit:

/**
 * Access setting that means that the property may only be written (set)
 * for deserialization,
 * but will not be read (get) on serialization, that is, the value of the property
 * is not included in serialization.
 */
WRITE_ONLY

Si vous en avez besoin dans l'autre sens, utilisez-le Access.READ_ONLY.

Dans mon cas, j'ai Jackson (dé) sérialise automatiquement les objets que je renvoie d'un contrôleur Spring MVC (j'utilise @RestController avec Spring 4.1.6). J'ai dû utiliser com.fasterxml.jackson.annotation.JsonIgnoreau lieu de org.codehaus.jackson.annotate.JsonIgnore, car sinon, cela n'a tout simplement rien fait.

"user": {
        "firstName": "Musa",
        "lastName": "Aliyev",
        "email": "klaudi2012@gmail.com",
        "passwordIn": "98989898", (or encoded version in front if we not using https)
        "country": "Azeribaijan",
        "phone": "+994707702747"
    }

@CrossOrigin(methods=RequestMethod.POST)
@RequestMapping("/public/register")
public @ResponseBody MsgKit registerNewUsert(@RequestBody User u){

        root.registerUser(u);

    return new MsgKit("registered");
}  

@Service
@Transactional
public class RootBsn {

    @Autowired UserRepository userRepo;

    public void registerUser(User u) throws Exception{

        u.setPassword(u.getPasswordIn());
        //Generate some salt and  setPassword (encoded -  salt+password)
        User u=userRepo.save(u);

        System.out.println("Registration information saved");
    }

}

    @Entity        
@JsonIgnoreProperties({"recordDate","modificationDate","status","createdBy","modifiedBy","salt","password"})
                    public class User implements Serializable {
                        private static final long serialVersionUID = 1L;

                        @Id
                        @GeneratedValue(strategy=GenerationType.AUTO)
                        private Long id;

                        private String country;

                        @Column(name="CREATED_BY")
                        private String createdBy;

                        private String email;

                        @Column(name="FIRST_NAME")
                        private String firstName;

                        @Column(name="LAST_LOGIN_DATE")
                        private Timestamp lastLoginDate;

                        @Column(name="LAST_NAME")
                        private String lastName;

                        @Column(name="MODIFICATION_DATE")
                        private Timestamp modificationDate;

                        @Column(name="MODIFIED_BY")
                        private String modifiedBy;

                        private String password;

                        @Transient
                        private String passwordIn;

                        private String phone;

                        @Column(name="RECORD_DATE")
                        private Timestamp recordDate;

                        private String salt;

                        private String status;

                        @Column(name="USER_STATUS")
                        private String userStatus;

                        public User() {
                        }
                // getters and setters
                }

Un autre moyen simple de gérer cela est d'utiliser l'argument allowSetters=truedans l'annotation. Cela permettra de désérialiser le mot de passe dans votre dto mais il ne le sérialisera pas dans un corps de réponse qui utilise contient un objet.

exemple:

@JsonIgnoreProperties(allowSetters = true, value = {"bar"})
class Pojo{
    String foo;
    String bar;
}

Les deux fooet barsont remplis dans l'objet, mais seul foo est écrit dans un corps de réponse.