Jackson Ignore Propriétés sur le Marshalling

Jackson ignore les propriétés sur le Marshalling

1. Vue d'ensemble

Ce tutoriel montrera commentignore certain fields when serializing an object to JSON en utilisant Jackson 2.x.

Ceci est très utile lorsque les valeurs par défaut de Jackson ne sont pas suffisantes et que nous devons contrôler exactement ce qui est sérialisé en JSON - et il existe plusieurs façons d'ignorer les propriétés.

Si vous voulez creuser plus profondément et apprendre d'autres choses intéressantes que vous pouvez faire avec le Jackson, rendez-vous surthe main Jackson tutorial.

Lectures complémentaires:

Introduction à l'ObjectMapper de Jackson

L'article traite de la classe ObjectMapper centrale de Jackson, de la sérialisation et de la désérialisation de base, ainsi que de la configuration des deux processus.

Jackson Streaming API

Un aperçu rapide de l'API Streaming de Jackson pour le traitement de JSON, y compris les exemples

Guide de @JsonFormat à Jackson

Guide rapide et pratique sur l'annotation @JsonFormat dans Jackson.

2. Ignorer les champs au niveau de la classe

Nous pouvons ignorer des champs spécifiques au niveau de la classe, en utilisantthe @JsonIgnoreProperties annotation and specifying the fields by name:

@JsonIgnoreProperties(value = { "intValue" })
public class MyDto {

    private String stringValue;
    private int intValue;
    private boolean booleanValue;

    public MyDto() {
        super();
    }

    // standard setters and getters are not shown
}

Nous pouvons maintenant tester qu'après l'écriture de l'objet dans JSON, le champ ne fait en effet pas partie de la sortie:

@Test
public void givenFieldIsIgnoredByName_whenDtoIsSerialized_thenCorrect()
  throws JsonParseException, IOException {

    ObjectMapper mapper = new ObjectMapper();
    MyDto dtoObject = new MyDto();

    String dtoAsString = mapper.writeValueAsString(dtoObject);

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

3. Ignorer le champ au niveau du champ

On peut aussi ignorer un champ directement viathe @JsonIgnore annotation directly on the field:

public class MyDto {

    private String stringValue;
    @JsonIgnore
    private int intValue;
    private boolean booleanValue;

    public MyDto() {
        super();
    }

    // standard setters and getters are not shown
}

Nous pouvons maintenant tester que le champintValue ne fait effectivement pas partie de la sortie JSON sérialisée:

@Test
public void givenFieldIsIgnoredDirectly_whenDtoIsSerialized_thenCorrect()
  throws JsonParseException, IOException {

    ObjectMapper mapper = new ObjectMapper();
    MyDto dtoObject = new MyDto();

    String dtoAsString = mapper.writeValueAsString(dtoObject);

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

4. Ignorer tous les champs par type

Enfin, nous pouvonsignore all fields of a specified type, using the @JsonIgnoreType annotation. Si nous contrôlons le type, nous pouvons directement annoter la classe:

@JsonIgnoreType
public class SomeType { ... }

Le plus souvent, cependant, nous n’avons pas le contrôle de la classe elle-même; dans ce cas,we can make good use of Jackson mixins.

Tout d'abord, nous définissons un MixIn pour le type que nous aimerions ignorer, et annotons cela avec@JsonIgnoreType à la place:

@JsonIgnoreType
public class MyMixInForIgnoreType {}

Ensuite, nous enregistrons ce mixin pour remplacer (et ignorer) tous les typesString[] pendant le marshaling:

mapper.addMixInAnnotations(String[].class, MyMixInForIgnoreType.class);

À ce stade, tous les tableaux de chaînes seront ignorés au lieu d'être marshalés en JSON:

@Test
public final void givenFieldTypeIsIgnored_whenDtoIsSerialized_thenCorrect()
  throws JsonParseException, IOException {

    ObjectMapper mapper = new ObjectMapper();
    mapper.addMixIn(String[].class, MyMixInForIgnoreType.class);
    MyDtoWithSpecialField dtoObject = new MyDtoWithSpecialField();
    dtoObject.setBooleanValue(true);

    String dtoAsString = mapper.writeValueAsString(dtoObject);

    assertThat(dtoAsString, containsString("intValue"));
    assertThat(dtoAsString, containsString("booleanValue"));
    assertThat(dtoAsString, not(containsString("stringValue")));
}

et voici notre DTO:

public class MyDtoWithSpecialField {
    private String[] stringValue;
    private int intValue;
    private boolean booleanValue;
}

Remarque: Depuis la version 2.5 - il semble que nous ne pouvons pas utiliser cette méthode pour ignorer les types de données primitifs, mais nous pouvons l’utiliser pour les types de données et les tableaux personnalisés.

5. Ignorer les champs à l'aide de filtres

Enfin,we can also use filters to ignore specific fields dans Jackson. Tout d'abord, nous devons définir le filtre sur l'objet Java:

@JsonFilter("myFilter")
public class MyDtoWithFilter { ... }

Ensuite, nous définissons un filtre simple qui ignorera le champintValue:

SimpleBeanPropertyFilter theFilter = SimpleBeanPropertyFilter
  .serializeAllExcept("intValue");
FilterProvider filters = new SimpleFilterProvider()
  .addFilter("myFilter", theFilter);

Nous pouvons maintenant sérialiser l'objet et nous assurer que le champintValue n'est pas présent dans la sortie JSON:

@Test
public final void givenTypeHasFilterThatIgnoresFieldByName_whenDtoIsSerialized_thenCorrect()
  throws JsonParseException, IOException {

    ObjectMapper mapper = new ObjectMapper();
    SimpleBeanPropertyFilter theFilter = SimpleBeanPropertyFilter
      .serializeAllExcept("intValue");
    FilterProvider filters = new SimpleFilterProvider()
      .addFilter("myFilter", theFilter);

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

    assertThat(dtoAsString, not(containsString("intValue")));
    assertThat(dtoAsString, containsString("booleanValue"));
    assertThat(dtoAsString, containsString("stringValue"));
    System.out.println(dtoAsString);
}

6. Conclusion

L'article expliquait comment ignorer les champs de la sérialisation - d'abord par son nom, puis directement, et enfin - nous avons ignoré le type entier de Java avec MixIns et nous utilisons des filtres pour un meilleur contrôle de la sortie.

L'implémentation de tous ces exemples et extraits de code se trouve dansmy GitHub project.

TOC