Jackson ignora le proprietà sul marshalling

1. Panoramica

Questo tutorial mostrerà come ignorare determinati campi durante la serializzazione di un oggetto in JSON utilizzando Jackson 2.x.

Questo è molto utile quando le impostazioni predefinite di Jackson non sono sufficienti e dobbiamo controllare esattamente cosa viene serializzato in JSON e ci sono diversi modi per ignorare le proprietà.

Se vuoi approfondire e imparare altre cose interessanti che puoi fare con Jackson, vai al tutorial principale di Jackson.

2. Ignora i campi a livello di classe

Possiamo ignorare campi specifici a livello di classe, utilizzando l' annotazione @ JsonIgnoreProperties e specificando i campi per nome :

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

Ora possiamo verificare che, dopo che l'oggetto è stato scritto in JSON, il campo non fa effettivamente parte dell'output:

@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. Ignora il campo a livello di campo

Possiamo anche ignorare un campo direttamente tramite l' annotazione @ JsonIgnore direttamente sul campo :

public class MyDto { private String stringValue; @JsonIgnore private int intValue; private boolean booleanValue; public MyDto() { super(); } // standard setters and getters are not shown }

Ora possiamo verificare che il campo intValue non fa effettivamente parte dell'output JSON serializzato:

@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. Ignora tutti i campi per tipo

Infine, possiamo ignorare tutti i campi di un tipo specificato, utilizzando l' annotazione @ JsonIgnoreType . Se controlliamo il tipo, possiamo annotare direttamente la classe:

@JsonIgnoreType public class SomeType { ... }

Il più delle volte, tuttavia, non abbiamo il controllo della classe stessa; in questo caso, possiamo fare buon uso dei mixin di Jackson .

Per prima cosa, definiamo un MixIn per il tipo che vorremmo ignorare e annotiamo quello con @JsonIgnoreType invece:

@JsonIgnoreType public class MyMixInForIgnoreType {}

Quindi registriamo quel mixin per sostituire (e ignorare) tutti i tipi String [] durante il marshalling:

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

A questo punto, tutti gli array di stringhe verranno ignorati invece di essere sottoposti a marshalling in 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"))); }

ed ecco il nostro DTO:

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

Nota: dalla versione 2.5 - sembra che non possiamo usare questo metodo per ignorare i tipi di dati primitivi, ma possiamo usarlo per i tipi di dati e gli array personalizzati.

5. Ignora i campi utilizzando i filtri

Infine, possiamo anche utilizzare i filtri per ignorare campi specifici in Jackson. Innanzitutto, dobbiamo definire il filtro sull'oggetto Java:

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

Quindi, definiamo un semplice filtro che ignorerà il campo intValue :

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

Ora possiamo serializzare l'oggetto e assicurarci che il campo intValue non sia presente nell'output 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. Conclusione

L'articolo illustrava come ignorare i campi sulla serializzazione - prima per nome, poi direttamente e infine - abbiamo ignorato l'intero tipo java con MixIns e usiamo filtri per un maggiore controllo dell'output.

L'implementazione di tutti questi esempi e frammenti di codice può essere trovata nel mio progetto GitHub.