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 Kurs1. Ü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 Benutzer „ Namen “ 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