Sérialiser uniquement les champs qui répondent à un critère personnalisé avec Jackson

1. Vue d'ensemble

Ce tutoriel va illustrer comment nous pouvonsuse Jackson to only serialize a field if it meets a specific, custom criteria.

Par exemple, disons que nous ne voulons sérialiser une valeur entière que si elle est positive - et que nous voulons l’ignorer complètement si ce n’est pas le cas.

Si vous voulez creuser plus profondément et apprendreother cool things you can do with the Jackson 2 - allez àthe main Jackson tutorial.

2. Utilisez Jackson Filter pour contrôler le processus de sérialisation

Tout d'abord, nous devons définir le filtre sur notre entité, en utilisant l'annotation@JsonFilter:

@JsonFilter("myFilter")
public class MyDto {
    private int intValue;

    public MyDto() {
        super();
    }

    public int getIntValue() {
        return intValue;
    }

    public void setIntValue(int intValue) {
        this.intValue = intValue;
    }
}

Ensuite, nous devons définir nosPropertyFilter personnalisés:

PropertyFilter theFilter = new SimpleBeanPropertyFilter() {
   @Override
   public void serializeAsField
    (Object pojo, JsonGenerator jgen, SerializerProvider provider, PropertyWriter writer)
     throws Exception {
      if (include(writer)) {
         if (!writer.getName().equals("intValue")) {
            writer.serializeAsField(pojo, jgen, provider);
            return;
         }
         int intValue = ((MyDtoWithFilter) pojo).getIntValue();
         if (intValue >= 0) {
            writer.serializeAsField(pojo, jgen, provider);
         }
      } else if (!jgen.canOmitFields()) { // since 2.3
         writer.serializeAsOmittedField(pojo, jgen, provider);
      }
   }
   @Override
   protected boolean include(BeanPropertyWriter writer) {
      return true;
   }
   @Override
   protected boolean include(PropertyWriter writer) {
      return true;
   }
};

Ce filtre contient la logique réelle déterminant si le champintValue va êtreserialized or not, en fonction de sa valeur.

Ensuite, nous raccordons ce filtre auxObjectMapper et nous sérialisons une entité:

FilterProvider filters = new SimpleFilterProvider().addFilter("myFilter", theFilter);
MyDto dtoObject = new MyDto();
dtoObject.setIntValue(-1);

ObjectMapper mapper = new ObjectMapper();
String dtoAsString = mapper.writer(filters).writeValueAsString(dtoObject);

Et enfin, on peut vérifier que le champintValue est biennot part of the marshalled JSON output:

assertThat(dtoAsString, not(containsString("intValue")));

3. Ignorer les objets de manière conditionnelle

Voyons maintenant comment ignorer des objets lors de la sérialisation en fonction de la propriétévalue. Nous ignorerons tous les objets où la propriétéhidden esttrue:

3.1. Classes masquables

Tout d'abord, jetons un œil à notre interfaceHidable:

@JsonIgnoreProperties("hidden")
public interface Hidable {
    boolean isHidden();
}

Et nous avons deux classes simples implémentant cette interfacePerson,Address:

ClassePerson:

public class Person implements Hidable {
    private String name;
    private Address address;
    private boolean hidden;
}

Et la classeAddress:

public class Address implements Hidable {
    private String city;
    private String country;
    private boolean hidden;
}

Remarque: nous avons utilisé@JsonIgnoreProperties(“hidden”) pour nous assurer que la propriétéhidden elle-même n'est pas incluse dans JSON

3.2. Sérialiseur personnalisé

Suivant - voici notre sérialiseur personnalisé:

public class HidableSerializer extends JsonSerializer {

    private JsonSerializer

TOC

Sérialiser uniquement les champs qui répondent à un critère personnalisé avec Jackson