Jackson JSON Ansichten

Jackson Top

Ich habe gerade den neuen Learn Spring- Kurs angekündigt , der sich auf die Grundlagen von Spring 5 und Spring Boot 2 konzentriert:

>> Überprüfen Sie den Kurs

1. Übersicht

In diesem Tutorial erfahren Sie, wie Sie mit Jackson JSON-Ansichten Objekte serialisieren / deserialisieren, die Ansichten anpassen und schließlich mit der Integration in Spring beginnen.

2. Serialisieren mit JSON-Ansichten

Lassen Sie uns zunächst ein einfaches Beispiel durchgehen und ein Objekt mit @JsonView serialisieren .

Hier ist unsere Ansicht:

public class Views { public static class Public { } }

Und die Entität " Benutzer ":

public class User { public int id; @JsonView(Views.Public.class) public String name; }

Lassen Sie uns nun eine " Benutzer " -Instanz mithilfe unserer Ansicht serialisieren :

@Test public void whenUseJsonViewToSerialize_thenCorrect() throws JsonProcessingException { User user = new User(1, "John"); ObjectMapper mapper = new ObjectMapper(); mapper.disable(MapperFeature.DEFAULT_VIEW_INCLUSION); String result = mapper .writerWithView(Views.Public.class) .writeValueAsString(user); assertThat(result, containsString("John")); assertThat(result, not(containsString("1"))); }

Beachten Sie, dass beim Serialisieren mit einer bestimmten aktiven Ansicht nur die richtigen Felder serialisiert werden .

Es ist auch wichtig zu verstehen, dass standardmäßig alle Eigenschaften, die nicht explizit als Teil einer Ansicht markiert sind, serialisiert werden. Wir deaktivieren dieses Verhalten mit der praktischen Funktion DEFAULT_VIEW_INCLUSION .

3. Verwenden Sie mehrere JSON-Ansichten

Weiter - sehen wir uns an, wie mehrere JSON-Ansichten verwendet werden - jede hat unterschiedliche Felder wie im folgenden Beispiel:

Hier müssen wir Ansichten sehen, in denen Intern die Öffentlichkeit erweitert , wobei die interne Ansicht die Öffentlichkeit erweitert:

public class Views { public static class Public { } public static class Internal extends Public { } }

Und hier ist unsere Entität " Element ", in der nur die Felder ID und Name in der öffentlichen Ansicht enthalten sind:

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

Wenn wir die öffentliche Ansicht zum Serialisieren verwenden, werden nur ID und Name in JSON serialisiert:

@Test public void whenUsePublicView_thenOnlyPublicSerialized() throws JsonProcessingException { Item item = new Item(2, "book", "John"); ObjectMapper mapper = new ObjectMapper(); String result = mapper .writerWithView(Views.Public.class) .writeValueAsString(item); assertThat(result, containsString("book")); assertThat(result, containsString("2")); assertThat(result, not(containsString("John"))); }

Wenn wir jedoch die interne Ansicht verwenden, um die Serialisierung durchzuführen, sind alle Felder Teil der JSON-Ausgabe:

@Test public void whenUseInternalView_thenAllSerialized() throws JsonProcessingException { Item item = new Item(2, "book", "John"); ObjectMapper mapper = new ObjectMapper(); String result = mapper .writerWithView(Views.Internal.class) .writeValueAsString(item); assertThat(result, containsString("book")); assertThat(result, containsString("2")); assertThat(result, containsString("John")); }

4. Deserialisieren mit JSON-Ansichten

Lassen Sie uns nun sehen, wie JSON-Ansichten zum Deserialisieren von Objekten verwendet werden - insbesondere eine Benutzerinstanz :

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

Beachten Sie, wie wir die readerWithView () - API verwenden, um einen ObjectReader mit der angegebenen Ansicht zu erstellen .

5. Passen Sie JSON-Ansichten an

Weiter - sehen wir uns an, wie Sie JSON-Ansichten anpassen. Im nächsten Beispiel - wollen wir das machen BenutzerNamen “ Uppercase in der Serialisierung Ergebnis.

Wir werden BeanPropertyWriter und BeanSerializerModifier verwenden , um unsere JSON-Ansicht anzupassen. Erstens - hier ist die BeanPropertyWriter UpperCasingWriter die zu transformieren Benutzernamen in Großbuchstaben:

public class UpperCasingWriter extends BeanPropertyWriter { BeanPropertyWriter _writer; public UpperCasingWriter(BeanPropertyWriter w) { super(w); _writer = w; } @Override public void serializeAsField(Object bean, JsonGenerator gen, SerializerProvider prov) throws Exception { String value = ((User) bean).name; value = (value == null) ? "" : value.toUpperCase(); gen.writeStringField("name", value); } }

Und hier ist der BeanSerializerModifier des festlegen Benutzername BeanPropertyWriter mit unserem kundenspezifischen UpperCasingWriter :

public class MyBeanSerializerModifier extends BeanSerializerModifier{ @Override public List changeProperties( SerializationConfig config, BeanDescription beanDesc, List beanProperties) { for (int i = 0; i < beanProperties.size(); i++) { BeanPropertyWriter writer = beanProperties.get(i); if (writer.getName() == "name") { beanProperties.set(i, new UpperCasingWriter(writer)); } } return beanProperties; } }

Lassen Sie uns nun eine Benutzerinstanz mit dem geänderten Serializer serialisieren:

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

6. Verwenden von JSON-Ansichten mit Spring

Lassen Sie uns zum Schluss einen kurzen Blick auf die Verwendung von JSON-Ansichten mit dem Spring Framework werfen . Wir können die Annotation @JsonView nutzen , um unsere JSON-Antwort auf API-Ebene anzupassen.

Im folgenden Beispiel haben wir die öffentliche Ansicht verwendet, um zu antworten:

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

Die Antwort lautet:

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

Und als wir die interne Ansicht wie folgt verwendeten:

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

Das war die Antwort:

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

Wenn Sie tiefer in die Verwendung der Ansichten mit Spring 4.1 eintauchen möchten, sollten Sie sich die Jackson-Verbesserungen in Spring 4.1 ansehen.

7. Fazit

In diesem kurzen Tutorial haben wir uns die Jackson JSON-Ansichten und die @ JsonView-Annotation angesehen. Wir haben gezeigt, wie JSON-Ansichten verwendet werden, um eine präzise Kontrolle über unseren Serialisierungs- / Deserialisierungsprozess zu erhalten - mithilfe einer einzelnen oder mehrerer Ansichten.

Den vollständigen Code für dieses Tutorial finden Sie auf GitHub.

Jackson unten

Ich habe gerade den neuen Learn Spring- Kurs angekündigt , der sich auf die Grundlagen von Spring 5 und Spring Boot 2 konzentriert:

>> Überprüfen Sie den Kurs