Ignorer les champs de l'objet Java de manière dynamique lors de l'envoi en tant que JSON depuis Spring MVC

J'ai une classe de modèle comme celle-ci, pour l'hibernation

@Entity
@Table(name = "user", catalog = "userdb")
@JsonIgnoreProperties(ignoreUnknown = true)
public class User implements java.io.Serializable {

    private Integer userId;
    private String userName;
    private String emailId;
    private String encryptedPwd;
    private String createdBy;
    private String updatedBy;

    @Id
    @GeneratedValue(strategy = IDENTITY)
    @Column(name = "UserId", unique = true, nullable = false)
    public Integer getUserId() {
        return this.userId;
    }

    public void setUserId(Integer userId) {
        this.userId = userId;
    }

    @Column(name = "UserName", length = 100)
    public String getUserName() {
        return this.userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    @Column(name = "EmailId", nullable = false, length = 45)
    public String getEmailId() {
        return this.emailId;
    }

    public void setEmailId(String emailId) {
        this.emailId = emailId;
    }

    @Column(name = "EncryptedPwd", length = 100)
    public String getEncryptedPwd() {
        return this.encryptedPwd;
    }

    public void setEncryptedPwd(String encryptedPwd) {
        this.encryptedPwd = encryptedPwd;
    }

    public void setCreatedBy(String createdBy) {
        this.createdBy = createdBy;
    }

    @Column(name = "UpdatedBy", length = 100)
    public String getUpdatedBy() {
        return this.updatedBy;
    }

    public void setUpdatedBy(String updatedBy) {
        this.updatedBy = updatedBy;
    }
}

Dans le contrôleur Spring MVC, en utilisant DAO, je suis capable d'obtenir l'objet. et retour en tant qu'objet JSON.

@Controller
public class UserController {

    @Autowired
    private UserService userService;

    @RequestMapping(value = "/getUser/{userId}", method = RequestMethod.GET)
    @ResponseBody
    public User getUser(@PathVariable Integer userId) throws Exception {

        User user = userService.get(userId);
        user.setCreatedBy(null);
        user.setUpdatedBy(null);
        return user;
    }
}

La vue de la pièce se fait à l'aide d'AngularJS, elle obtiendra donc JSON comme ceci

{
  "userId" :2,
  "userName" : "john",
  "emailId" : "[email protected]",
  "encryptedPwd" : "Co7Fwd1fXYk=",
  "createdBy" : null,
  "updatedBy" : null
}

Si je ne veux pas définir un mot de passe chiffré, je définirai également ce champ comme nul.

Mais je ne veux pas comme ça, je ne veux pas envoyer tous les champs côté client. Si je ne veux pas de mot de passe, mis à jour par, créé par les champs à envoyer, mon résultat JSON devrait être comme

{
  "userId" :2,
  "userName" : "john",
  "emailId" : "[email protected]"
}

La liste des champs que je ne veux pas envoyer au client provenant d'une autre table de base de données. Cela changera donc en fonction de l'utilisateur connecté. Comment puis-je faire cela?

J'espère que vous avez ma question.

Ajoutez l' @JsonIgnoreProperties("fieldname")annotation à votre POJO.

Ou vous pouvez utiliser @JsonIgnoreavant le nom du champ que vous souhaitez ignorer lors de la désérialisation de JSON. Exemple:

@JsonIgnore
@JsonProperty(value = "user_password")
public String getUserPassword() {
    return userPassword;
}

Exemple GitHub

Je sais que je suis un peu en retard à la fête, mais je suis tombé sur cela aussi il y a quelques mois. Toutes les solutions disponibles ne m'attiraient pas beaucoup (mixins? Ugh!), Alors j'ai fini par créer une nouvelle bibliothèque pour rendre ce processus plus propre. Il est disponible ici si quelqu'un souhaite l'essayer: https://github.com/monitorjbl/spring-json-view .

L'utilisation de base est assez simple, vous utilisez l' JsonViewobjet dans vos méthodes de contrôleur comme ceci:

import com.monitorjbl.json.JsonView;
import static com.monitorjbl.json.Match.match;

@RequestMapping(method = RequestMethod.GET, value = "/myObject")
@ResponseBody
public void getMyObjects() {
    //get a list of the objects
    List<MyObject> list = myObjectService.list();

    //exclude expensive field
    JsonView.with(list).onClass(MyObject.class, match().exclude("contains"));
}

Vous pouvez également l'utiliser en dehors du printemps:

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.module.SimpleModule;
import static com.monitorjbl.json.Match.match;

ObjectMapper mapper = new ObjectMapper();
SimpleModule module = new SimpleModule();
module.addSerializer(JsonView.class, new JsonViewSerializer());
mapper.registerModule(module);

mapper.writeValueAsString(JsonView.with(list)
      .onClass(MyObject.class, match()
        .exclude("contains"))
      .onClass(MySmallObject.class, match()
        .exclude("id"));

Puis-je le faire dynamiquement?

Créer une classe de vue:

public class View {
    static class Public { }
    static class ExtendedPublic extends Public { }
    static class Internal extends ExtendedPublic { }
}

Annoter votre modèle

@Document
public class User {

    @Id
    @JsonView(View.Public.class)
    private String id;

    @JsonView(View.Internal.class)
    private String email;

    @JsonView(View.Public.class)
    private String name;

    @JsonView(View.Public.class)
    private Instant createdAt = Instant.now();
    // getters/setters
}

Spécifiez la classe de vue dans votre contrôleur

@RequestMapping("/user/{email}")
public class UserController {

    private final UserRepository userRepository;

    @Autowired
    UserController(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    @RequestMapping(method = RequestMethod.GET)
    @JsonView(View.Internal.class)
    public @ResponseBody Optional<User> get(@PathVariable String email) {
        return userRepository.findByEmail(email);
    }

}

Exemple de données:

{"id":"5aa2496df863482dc4da2067","name":"test","createdAt":"2018-03-10T09:35:31.050353800Z"}

Nous pouvons le faire en définissant access sur JsonProperty.Access.WRITE_ONLYlors de la déclaration de la propriété.

@JsonProperty( value = "password", access = JsonProperty.Access.WRITE_ONLY)
@SerializedName("password")
private String password;

Ajoutez @JsonInclude(JsonInclude.Include.NON_NULL)(force Jackson à sérialiser les valeurs nulles) à la classe ainsi qu'au @JsonIgnorechamp de mot de passe.

Vous pourriez bien sûr définir @JsonIgnore sur createdBy et updatedBy également si vous voulez toujours ignorer alors et pas seulement dans ce cas spécifique.

METTRE À JOUR

Dans le cas où vous ne souhaitez pas ajouter l'annotation au POJO lui-même, une excellente option est les annotations Mixin de Jackson. Consultez la documentation

Oui, vous pouvez spécifier quels champs sont sérialisés en tant que réponse JSON et lesquels ignorer. C'est ce que vous devez faire pour implémenter les propriétés Ignorer dynamiquement.

1) Tout d'abord, vous devez ajouter @JsonFilter de com.fasterxml.jackson.annotation.JsonFilter sur votre classe d'entité en tant que.

import com.fasterxml.jackson.annotation.JsonFilter;

@JsonFilter("SomeBeanFilter")
public class SomeBean {

  private String field1;

  private String field2;

  private String field3;

  // getters/setters
}

2) Ensuite, dans votre contrôleur, vous devez ajouter créer l'objet MappingJacksonValue et définir des filtres dessus et à la fin, vous devez retourner cet objet.

import java.util.Arrays;
import java.util.List;

import org.springframework.http.converter.json.MappingJacksonValue;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import com.fasterxml.jackson.databind.ser.FilterProvider;
import com.fasterxml.jackson.databind.ser.impl.SimpleBeanPropertyFilter;
import com.fasterxml.jackson.databind.ser.impl.SimpleFilterProvider;

@RestController
public class FilteringController {

  // Here i want to ignore all properties except field1,field2.
  @GetMapping("/ignoreProperties")
  public MappingJacksonValue retrieveSomeBean() {
    SomeBean someBean = new SomeBean("value1", "value2", "value3");

    SimpleBeanPropertyFilter filter = SimpleBeanPropertyFilter.filterOutAllExcept("field1", "field2");

    FilterProvider filters = new SimpleFilterProvider().addFilter("SomeBeanFilter", filter);

    MappingJacksonValue mapping = new MappingJacksonValue(someBean);

    mapping.setFilters(filters);

    return mapping;
  }
}

Voici ce que vous obtiendrez en réponse:

{
  field1:"value1",
  field2:"value2"
}

au lieu de cela:

{
  field1:"value1",
  field2:"value2",
  field3:"value3"
}

Ici, vous pouvez voir qu'il ignore les autres propriétés (field3 dans ce cas) en réponse à l'exception de la propriété field1 et field2.

J'espère que cela t'aides.

Si j'étais vous et que je voulais le faire, je n'utiliserais pas mon entité User dans la couche Controller. Vous pouvez utiliser Apache BeanUtils (méthode copyProperties) pour copier les données de l'entité User vers UserDto.

J'ai créé un JsonUtil qui peut être utilisé pour ignorer les champs lors de l'exécution tout en donnant une réponse.

Exemple d'utilisation: Le premier argument doit être n'importe quelle classe POJO (Student) et ignoreFields est des champs séparés par des virgules que vous voulez ignorer en réponse.

 Student st = new Student();
 createJsonIgnoreFields(st,"firstname,age");

import java.util.logging.Logger;

import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.map.ObjectWriter;
import org.codehaus.jackson.map.ser.FilterProvider;
import org.codehaus.jackson.map.ser.impl.SimpleBeanPropertyFilter;
import org.codehaus.jackson.map.ser.impl.SimpleFilterProvider;

public class JsonUtil {

  public static String createJsonIgnoreFields(Object object, String ignoreFields) {
     try {
         ObjectMapper mapper = new ObjectMapper();
         mapper.getSerializationConfig().addMixInAnnotations(Object.class, JsonPropertyFilterMixIn.class);
         String[] ignoreFieldsArray = ignoreFields.split(",");
         FilterProvider filters = new SimpleFilterProvider()
             .addFilter("filter properties by field names",
                 SimpleBeanPropertyFilter.serializeAllExcept(ignoreFieldsArray));
         ObjectWriter writer = mapper.writer().withFilters(filters);
         return writer.writeValueAsString(object);
     } catch (Exception e) {
         //handle exception here
     }
     return "";
   }

   public static String createJson(Object object) {
        try {
         ObjectMapper mapper = new ObjectMapper();
         ObjectWriter writer = mapper.writer().withDefaultPrettyPrinter();
         return writer.writeValueAsString(object);
        }catch (Exception e) {
         //handle exception here
        }
        return "";
   }
 }    

J'ai résolu en utilisant uniquement @JsonIgnorecomme @kryger l'a suggéré. Ainsi votre getter deviendra:

@JsonIgnore
public String getEncryptedPwd() {
    return this.encryptedPwd;
}

Vous pouvez @JsonIgnorebien sûr définir sur le terrain, le setter ou le getter comme décrit ici .

Et, si vous souhaitez protéger le mot de passe crypté uniquement du côté de la sérialisation (par exemple lorsque vous devez vous connecter à vos utilisateurs), ajoutez cette @JsonPropertyannotation à votre champ :

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

Plus d'infos ici .

J'ai trouvé une solution pour moi avec Spring et Jackson

Spécifiez d'abord le nom du filtre dans l'entité

@Entity
@Table(name = "SECTEUR")
@JsonFilter(ModelJsonFilters.SECTEUR_FILTER)
public class Secteur implements Serializable {

/** Serial UID */
private static final long serialVersionUID = 5697181222899184767L;

/**
 * Unique ID
 */
@Id
@JsonView(View.SecteurWithoutChildrens.class)
@Column(name = "id")
@GeneratedValue(strategy = GenerationType.IDENTITY)
private long id;

@JsonView(View.SecteurWithoutChildrens.class)
@Column(name = "code", nullable = false, length = 35)
private String code;

/**
 * Identifiant du secteur parent
 */
@JsonView(View.SecteurWithoutChildrens.class)
@Column(name = "id_parent")
private Long idParent;

@OneToMany(fetch = FetchType.LAZY)
@JoinColumn(name = "id_parent")
private List<Secteur> secteursEnfants = new ArrayList<>(0);

}

Ensuite, vous pouvez voir la classe de noms de filtres de constantes avec le FilterProvider par défaut utilisé dans la configuration de ressort

public class ModelJsonFilters {

public final static String SECTEUR_FILTER = "SecteurFilter";
public final static String APPLICATION_FILTER = "ApplicationFilter";
public final static String SERVICE_FILTER = "ServiceFilter";
public final static String UTILISATEUR_FILTER = "UtilisateurFilter";

public static SimpleFilterProvider getDefaultFilters() {
    SimpleBeanPropertyFilter theFilter = SimpleBeanPropertyFilter.serializeAll();
    return new SimpleFilterProvider().setDefaultFilter(theFilter);
}

}

Configuration du ressort:

@EnableWebMvc
@Configuration
@ComponentScan(basePackages = "fr.sodebo")

public class ApiRootConfiguration extends WebMvcConfigurerAdapter {

@Autowired
private EntityManagerFactory entityManagerFactory;


/**
 * config qui permet d'éviter les "Lazy loading Error" au moment de la
 * conversion json par jackson pour les retours des services REST<br>
 * on permet à jackson d'acceder à sessionFactory pour charger ce dont il a
 * besoin
 */
@Override
public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {

    super.configureMessageConverters(converters);
    MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
    ObjectMapper mapper = new ObjectMapper();

    // config d'hibernate pour la conversion json
    mapper.registerModule(getConfiguredHibernateModule());//

    // inscrit les filtres json
    subscribeFiltersInMapper(mapper);

    // config du comportement de json views
    mapper.configure(MapperFeature.DEFAULT_VIEW_INCLUSION, false);

    converter.setObjectMapper(mapper);
    converters.add(converter);
}

/**
 * config d'hibernate pour la conversion json
 * 
 * @return Hibernate5Module
 */
private Hibernate5Module getConfiguredHibernateModule() {
    SessionFactory sessionFactory = entityManagerFactory.unwrap(SessionFactory.class);
    Hibernate5Module module = new Hibernate5Module(sessionFactory);
    module.configure(Hibernate5Module.Feature.FORCE_LAZY_LOADING, true);

    return module;

}

/**
 * inscrit les filtres json
 * 
 * @param mapper
 */
private void subscribeFiltersInMapper(ObjectMapper mapper) {

    mapper.setFilterProvider(ModelJsonFilters.getDefaultFilters());

}

}

Enfin, je peux spécifier un filtre spécifique dans restConstoller quand j'ai besoin ...

@RequestMapping(value = "/{id}/droits/", method = RequestMethod.GET)
public MappingJacksonValue getListDroits(@PathVariable long id) {

    LOGGER.debug("Get all droits of user with id {}", id);

    List<Droit> droits = utilisateurService.findDroitsDeUtilisateur(id);

    MappingJacksonValue value;

    UtilisateurWithSecteurs utilisateurWithSecteurs = droitsUtilisateur.fillLists(droits).get(id);

    value = new MappingJacksonValue(utilisateurWithSecteurs);

    FilterProvider filters = ModelJsonFilters.getDefaultFilters().addFilter(ModelJsonFilters.SECTEUR_FILTER, SimpleBeanPropertyFilter.serializeAllExcept("secteursEnfants")).addFilter(ModelJsonFilters.APPLICATION_FILTER,
            SimpleBeanPropertyFilter.serializeAllExcept("services"));

    value.setFilters(filters);
    return value;

}

Placez @JsonIgnoresur le champ ou son getter, ou créez un dto personnalisé

@JsonIgnore
private String encryptedPwd;

ou comme mentionné ci-dessus en l' ceekayannotant avec @JsonPropertyoù l'attribut d'accès est défini pour écrire uniquement

@JsonProperty( value = "password", access = JsonProperty.Access.WRITE_ONLY)
private String encryptedPwd;

Ne créerait pas un UserJsonResponse classe et le peuplement des champs voulus ne serait-elle pas une solution plus propre?

Renvoyer directement un JSON semble une excellente solution lorsque vous souhaitez rendre tout le modèle. Sinon, ça devient juste compliqué.

À l'avenir, par exemple, vous voudrez peut-être avoir un champ JSON qui ne correspond à aucun champ de modèle et vous aurez alors un plus gros problème.

Ceci est un outil utilitaire propre pour la réponse ci-dessus :

@GetMapping(value = "/my-url")
public @ResponseBody
MappingJacksonValue getMyBean() {
    List<MyBean> myBeans = Service.findAll();
    MappingJacksonValue mappingValue = MappingFilterUtils.applyFilter(myBeans, MappingFilterUtils.JsonFilterMode.EXCLUDE_FIELD_MODE, "MyFilterName", "myBiggerObject.mySmallerObject.mySmallestObject");
    return mappingValue;
}

//AND THE UTILITY CLASS
public class MappingFilterUtils {

    public enum JsonFilterMode {
        INCLUDE_FIELD_MODE, EXCLUDE_FIELD_MODE
    }
    public static MappingJacksonValue applyFilter(Object object, final JsonFilterMode mode, final String filterName, final String... fields) {
        if (fields == null || fields.length == 0) {
            throw new IllegalArgumentException("You should pass at least one field");
        }
        return applyFilter(object, mode, filterName, new HashSet<>(Arrays.asList(fields)));
    }

    public static MappingJacksonValue applyFilter(Object object, final JsonFilterMode mode, final String filterName, final Set<String> fields) {
        if (fields == null || fields.isEmpty()) {
            throw new IllegalArgumentException("You should pass at least one field");
        }

        SimpleBeanPropertyFilter filter = null;
        switch (mode) {
            case EXCLUDE_FIELD_MODE:
                filter = SimpleBeanPropertyFilter.serializeAllExcept(fields);
                break;
            case INCLUDE_FIELD_MODE:
                filter = SimpleBeanPropertyFilter.filterOutAllExcept(fields);
                break;
        }

        FilterProvider filters = new SimpleFilterProvider().addFilter(filterName, filter);
        MappingJacksonValue mapping = new MappingJacksonValue(object);
        mapping.setFilters(filters);
        return mapping;
    }
}

Dans votre classe d'entité, ajoutez une @JsonInclude(JsonInclude.Include.NON_NULL)annotation pour résoudre le problème

ça ressemblera à

@Entity
@JsonInclude(JsonInclude.Include.NON_NULL)