Jackson JSON-weergaven

Jackson Top

Ik heb zojuist het nieuwe aangekondigd Leer de lente natuurlijk, gericht op de basisprincipes van Spring 5 en Spring Boot 2:

>> BEKIJK DE CURSUS

1. Overzicht

In deze zelfstudie bespreken we hoe u Jackson JSON-weergaven kunt gebruiken om objecten te serialiseren / deserialiseren, de weergaven aan te passen en tot slot - hoe u de integratie met Spring kunt beginnen.

2. Serialiseren met behulp van JSON-weergaven

Laten we eerst een eenvoudig voorbeeld bekijken - serialiseer een object met @JsonView.

Hier is onze mening:

public class Views {public static class Public {}}

En de "Gebruiker" entiteit:

openbare klasse Gebruiker {openbare int id; @JsonView (Views.Public.class) public String naam; }

Laten we nu een "Gebruiker”Instantie met behulp van onze visie:

@Test public void whenUseJsonViewToSerialize_thenCorrect () gooit JsonProcessingException {User user = new User (1, "John"); ObjectMapper-mapper = nieuwe ObjectMapper (); mapper.disable (MapperFeature.DEFAULT_VIEW_INCLUSION); String resultaat = mapper .writerWithView (Views.Public.class) .writeValueAsString (gebruiker); assertThat (resultaat, bevatString ("John")); assertThat (resultaat, niet (bevatString ("1"))); }

Merk op hoe, omdat we serialiseren met een specifieke actieve weergave, we zien alleen de juiste velden worden geserialiseerd.

Het is ook belangrijk om te begrijpen dat - standaard - alle eigenschappen die niet expliciet zijn gemarkeerd als onderdeel van een weergave, geserialiseerd zijn. We schakelen dat gedrag uit met het handige DEFAULT_VIEW_INCLUSION voorzien zijn van.

3. Gebruik meerdere JSON-weergaven

Vervolgens - laten we eens kijken hoe we meerdere JSON-weergaven kunnen gebruiken - elk heeft verschillende velden, zoals in het volgende voorbeeld:

Hier moeten we zien waar Intern strekt zich uit Openbaar, waarbij de interne weergave de openbare uitbreidt:

openbare klasse Weergaven {openbare statische klasse Openbaar {} openbare statische klasse Intern breidt openbaar uit {}}

En hier is onze entiteit "Item”Waar alleen de velden ID kaart en naam zijn opgenomen in de Openbaar visie:

public class Item {@JsonView (Views.Public.class) public int id; @JsonView (Views.Public.class) public String itemName; @JsonView (Views.Internal.class) public String ownerName; }

Als we de Openbaar weergave om te serialiseren - alleen ID kaart en naam wordt geserialiseerd naar JSON:

@Test public void whenUsePublicView_thenOnlyPublicSerialized () gooit JsonProcessingException {Item item = new Item (2, "book", "John"); ObjectMapper-mapper = nieuwe ObjectMapper (); String resultaat = mapper .writerWithView (Views.Public.class) .writeValueAsString (item); assertThat (resultaat, bevatString ("boek")); assertThat (resultaat, bevatString ("2")); assertThat (resultaat, niet (bevatString ("John"))); }

Maar als we de Intern weergave om de serialisatie uit te voeren, zullen alle velden deel uitmaken van de JSON-uitvoer:

@Test public void whenUseInternalView_thenAllSerialized () gooit JsonProcessingException {Item item = new Item (2, "book", "John"); ObjectMapper-mapper = nieuwe ObjectMapper (); String resultaat = mapper .writerWithView (Views.Internal.class) .writeValueAsString (item); assertThat (resultaat, bevatString ("boek")); assertThat (resultaat, bevatString ("2")); assertThat (resultaat, bevatString ("John")); }

4. Deserialiseer met behulp van JSON-weergaven

Laten we nu eens kijken hoe we JSON-weergaven kunnen gebruiken om objecten te deserialiseren - met name een Gebruiker voorbeeld:

@Test public void whenUseJsonViewToDeserialize_thenCorrect () gooit IOException {String json = "{" id ": 1," name ":" John "}"; ObjectMapper-mapper = nieuwe ObjectMapper (); Gebruiker user = mapper .readerWithView (Views.Public.class) .forType (User.class) .readValue (json); assertEquals (1, user.getId ()); assertEquals ("John", user.getName ()); }

Merk op hoe we de readerWithView () API om een ObjectReader met behulp van de gegeven weergave.

5. Pas JSON-weergaven aan

Vervolgens - laten we eens kijken hoe we JSON-weergaven kunnen aanpassen. In het volgende voorbeeld willen we de Gebruikernaam”UpperCase in het serialisatieresultaat.

We zullen gebruiken BeanPropertyWriter en BeanSerializerModifier om onze JSON-weergave aan te passen. Ten eerste - hier is de BeanPropertyWriterUpperCasingWriter om het Gebruikernaam naar hoofdletters:

openbare klasse UpperCasingWriter breidt BeanPropertyWriter {BeanPropertyWriter _writer uit; openbare UpperCasingWriter (BeanPropertyWriter w) {super (w); _writer = w; } @Override public void serializeAsField (Object bean, JsonGenerator gen, SerializerProvider prov) genereert uitzondering {String value = ((User) bean) .name; waarde = (waarde == null)? "": waarde.toUpperCase (); gen.writeStringField ("naam", waarde); }}

En hier is de BeanSerializerModifier om de Gebruiker naam BeanPropertyWriter met onze gewoonte UpperCasingWriter:

openbare klasse MyBeanSerializerModifier breidt BeanSerializerModifier uit {@Override public List changeProperties (configuratie SerializationConfig, BeanDescription beanDesc, List beanProperties) {voor (int i = 0; i <beanProperties.size (); i ++) {BeanPropget writer = i ++ () beanPropertyWriteries; if (writer.getName () == "name") {beanProperties.set (i, nieuwe UpperCasingWriter (schrijver)); }} geef beanProperties terug; }}

Laten we nu een Gebruiker instantie met behulp van de gemodificeerde Serializer:

@Test public void whenUseCustomJsonViewToSerialize_thenCorrect () gooit JsonProcessingException {User user = new User (1, "John"); SerializerFactory serializerFactory = BeanSerializerFactory.instance .withSerializerModifier (nieuwe MyBeanSerializerModifier ()); ObjectMapper-mapper = nieuwe ObjectMapper (); mapper.setSerializerFactory (serializerFactory); String resultaat = mapper .writerWithView (Views.Public.class) .writeValueAsString (gebruiker); assertThat (resultaat, bevatString ("JOHN")); assertThat (resultaat, bevatString ("1")); }

6. JSON-weergaven gebruiken met Spring

Tot slot - laten we eens kijken naar het gebruik van JSON-weergaven met de Spring Framework. We kunnen gebruikmaken van de @JsonView annotatie om onze JSON-reactie op API-niveau aan te passen.

In het volgende voorbeeld hebben we de Openbaar kijk om te reageren:

@JsonView (Views.Public.class) @RequestMapping ("/ items / {id}") openbaar item getItemPublic (@PathVariable int id) {return ItemManager.getById (id); }

Het antwoord is:

{"id": 2, "itemName": "boek"}

En toen we de Intern bekijk als volgt:

@JsonView (Views.Internal.class) @RequestMapping ("/ items / internal / {id}") openbaar item getItemInternal (@PathVariable int id) {return ItemManager.getById (id); }

Dat was het antwoord:

{"id": 2, "itemName": "book", "ownerName": "John"}

Als je dieper in het gebruik van de weergaven met Spring 4.1 wilt duiken, moet je de Jackson-verbeteringen in Spring 4.1 eens bekijken.

7. Conclusie

In deze korte tutorial hebben we de Jackson JSON-weergaven en de @JsonView-annotatie bekeken. We hebben laten zien hoe je JSON-weergaven kunt gebruiken om fijnmazige controle te hebben over ons serialiserings- / deserialiseringsproces - met behulp van een enkele of meerdere weergaven.

De volledige code voor deze tutorial is te vinden op GitHub.

Jackson onderkant

Ik heb zojuist het nieuwe aangekondigd Leer de lente natuurlijk, gericht op de basisprincipes van Spring 5 en Spring Boot 2:

>> BEKIJK DE CURSUS