streamalism.org

1. Overzicht

Deze tutorial laat zien hoe negeer bepaalde velden bij het serialiseren van een object naar JSON met behulp van Jackson 2.x.

Dit is erg handig als de Jackson-standaardinstellingen niet voldoende zijn en we precies moeten bepalen wat er naar JSON wordt geserialiseerd - en er zijn verschillende manieren om eigenschappen te negeren.

Als je dieper wilt graven en andere coole dingen wilt leren die je met de Jackson kunt doen, ga dan naar de belangrijkste Jackson-tutorial.

2. Negeer velden op klassenniveau

We kunnen specifieke velden op klassenniveau negeren met de @JsonIgnoreProperties annotatie en specificeren van de velden op naam:

@JsonIgnoreProperties (waarde = {"intValue"}) openbare klasse MyDto {privé String stringValue; privé int intValue; privé boolean booleanValue; openbare MyDto () {super (); } // standaard setters en getters worden niet weergegeven}

We kunnen nu testen dat, nadat het object naar JSON is geschreven, het veld inderdaad geen deel uitmaakt van de output:

@Test openbare leegte gegevenFieldIsIgnoredByName_whenDtoIsSerialized_thenCorrect () gooit JsonParseException, IOException {ObjectMapper mapper = new ObjectMapper (); MyDto dtoObject = nieuwe MyDto (); String dtoAsString = mapper.writeValueAsString (dtoObject); assertThat (dtoAsString, not (containsString ("intValue"))); }

3. Negeer veld op veldniveau

We kunnen een veld ook direct negeren via de @JsonIgnore annotatie direct op het veld:

openbare klasse MyDto {private String stringValue; @JsonIgnore privé int intValue; privé boolean booleanValue; openbare MyDto () {super (); } // standaard setters en getters worden niet weergegeven}

We kunnen nu testen of het intValue veld maakt inderdaad geen deel uit van de geserialiseerde JSON-uitvoer:

@Test openbare leegte gegevenFieldIsIgnoredDirectly_whenDtoIsSerialized_thenCorrect () gooit JsonParseException, IOException {ObjectMapper mapper = new ObjectMapper (); MyDto dtoObject = nieuwe MyDto (); String dtoAsString = mapper.writeValueAsString (dtoObject); assertThat (dtoAsString, not (containsString ("intValue"))); }

4. Negeer alle velden op type

Eindelijk kunnen we negeer alle velden van een bepaald type met de @JsonIgnoreType annotatie. Als we het type beheersen, kunnen we de klasse rechtstreeks annoteren:

@JsonIgnoreType openbare klasse SomeType {...}

Vaker wel dan niet hebben we echter geen controle over de klas zelf; in dit geval, we kunnen goed gebruik maken van Jackson-mixins.

Eerst definiëren we een MixIn voor het type dat we willen negeren, en we annoteren dat met @JsonIgnoreType in plaats daarvan:

@JsonIgnoreType openbare klasse MyMixInForIgnoreType {}

Vervolgens registreren we die mixin om alles te vervangen (en te negeren) Draad[] types tijdens het rangeren:

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

Op dit punt worden alle String-arrays genegeerd in plaats van gemarshaled naar JSON:

@Test openbare definitieve ongeldige gegevenFieldTypeIsIgnored_whenDtoIsSerialized_thenCorrect () gooit JsonParseException, IOException {ObjectMapper mapper = new ObjectMapper (); mapper.addMixIn (String []. class, MyMixInForIgnoreType.class); MyDtoWithSpecialField dtoObject = nieuwe MyDtoWithSpecialField (); dtoObject.setBooleanValue (true); String dtoAsString = mapper.writeValueAsString (dtoObject); assertThat (dtoAsString, bevatString ("intValue")); assertThat (dtoAsString, bevatString ("booleanValue")); assertThat (dtoAsString, not (containsString ("stringValue"))); }

en hier is onze DTO:

openbare klasse MyDtoWithSpecialField {privé String [] stringValue; privé int intValue; privé boolean booleanValue; }

Opmerking: sinds versie 2.5 - het lijkt erop dat we deze methode niet kunnen gebruiken om primitieve datatypes te negeren, maar we kunnen het gebruiken voor aangepaste datatypes en arrays.

5. Negeer velden met behulp van filters

Tenslotte, we kunnen ook filters gebruiken om specifieke velden te negeren in Jackson. Eerst moeten we het filter op het Java-object definiëren:

@JsonFilter ("myFilter") openbare klasse MyDtoWithFilter {...}

Vervolgens definiëren we een eenvoudig filter dat het intValue veld:

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

Nu kunnen we het object serialiseren en ervoor zorgen dat de intValue veld is niet aanwezig in de JSON-uitvoer:

@Test openbare definitieve ongeldig gegevenTypeHasFilterThatIgnoresFieldByName_whenDtoIsSerialized_thenCorrect () gooit JsonParseException, IOException {ObjectMapper mapper = new ObjectMapper (); SimpleBeanPropertyFilter theFilter = SimpleBeanPropertyFilter .serializeAllExcept ("intValue"); FilterProvider filters = nieuwe SimpleFilterProvider () .addFilter ("myFilter", theFilter); MyDtoWithFilter dtoObject = nieuwe MyDtoWithFilter (); String dtoAsString = mapper.writer (filters) .writeValueAsString (dtoObject); assertThat (dtoAsString, not (containsString ("intValue"))); assertThat (dtoAsString, bevatString ("booleanValue")); assertThat (dtoAsString, bevatString ("stringValue")); System.out.println (dtoAsString); }

6. Conclusie

Het artikel illustreerde hoe velden bij serialisatie kunnen worden genegeerd - eerst op naam, dan direct en ten slotte - we negeerden het hele Java-type met MixIns en we gebruiken filters voor meer controle over de uitvoer.

De implementatie van al deze voorbeelden en codefragmenten is te vinden in mijn GitHub-project.