Gson Deserialization Cookbook

In diesem Kochbuch untersuchen wir die verschiedenen Möglichkeiten fürunmarshall JSON into Java objects unter Verwendung der beliebtenGson library.

1. Deserialisieren Sie JSON in ein einzelnes Basisobjekt

Fangen wir einfach an - wir gehen zuunmarshall a simple json to a Java object – Foo:

public class Foo {
    public int intValue;
    public String stringValue;

    // + standard equals and hashCode implementations
}

Und die Lösung:

@Test
public void whenDeserializingToSimpleObject_thenCorrect() {
    String json = "{"intValue":1,"stringValue":"one"}";

    Foo targetObject = new Gson().fromJson(json, Foo.class);

    assertEquals(targetObject.intValue, 1);
    assertEquals(targetObject.stringValue, "one");
}

Weitere Lektüre:

Felder von der Serialisierung in Gson ausschließen

Informieren Sie sich über die verfügbaren Optionen zum Ausschließen von Feldern von der Serialisierung in Gson.

Gson Serialization Cookbook

Erfahren Sie, wie Sie Entitäten mithilfe der Gson-Bibliothek serialisieren.

Jackson gegen Gson

Schnelle und praktische Anleitung zur Serialisierung mit Jackson und Gson.

2. Deserialisieren Sie JSON in ein generisches Objekt

Weiter - Definieren wir ein Objekt mithilfe von Generika:

public class GenericFoo {
    public T theValue;
}

Und einige Json in diese Art von Objekt unmarshall:

@Test
public void whenDeserializingToGenericObject_thenCorrect() {
    Type typeToken = new TypeToken>() { }.getType();
    String json = "{"theValue":1}";

    GenericFoo targetObject = new Gson().fromJson(json, typeToken);

    assertEquals(targetObject.theValue, new Integer(1));
}

3. Deserialisieren Sie JSON mit zusätzlichen unbekannten Feldern für das Objekt

Weiter - Lassen Sie uns einige komplexe JSON deserialisieren, die zusätzlicheunknown fields enthalten:

@Test
public void givenJsonHasExtraValues_whenDeserializing_thenCorrect() {
    String json =
      "{"intValue":1,"stringValue":"one","extraString":"two","extraFloat":2.2}";
    Foo targetObject = new Gson().fromJson(json, Foo.class);

    assertEquals(targetObject.intValue, 1);
    assertEquals(targetObject.stringValue, "one");
}

Wie Sie sehen können, geben SieGson will ignore the unknown fieldsan und stimmen Sie einfach mit den Feldern überein, die es können.

4. Deserialisieren Sie JSON mit nicht übereinstimmenden Feldnamen für das Objekt

Lassen Sie uns nun sehen, wie Gson mit einer JSON-Zeichenfolge umgeht, die Felder enthält, die einfach nicht mit den Feldern unseresFoo-Objekts übereinstimmen:

@Test
public void givenJsonHasNonMatchingFields_whenDeserializingWithCustomDeserializer_thenCorrect() {
    String json = "{"valueInt":7,"valueString":"seven"}";

    GsonBuilder gsonBldr = new GsonBuilder();
    gsonBldr.registerTypeAdapter(Foo.class, new FooDeserializerFromJsonWithDifferentFields());
    Foo targetObject = gsonBldr.create().fromJson(json, Foo.class);

    assertEquals(targetObject.intValue, 7);
    assertEquals(targetObject.stringValue, "seven");
}

Beachten Sie, dass wira custom deserializer registriert haben. Dadurch konnten die Felder aus der JSON-Zeichenfolge korrekt analysiert und unserenFoo zugeordnet werden:

public class FooDeserializerFromJsonWithDifferentFields implements JsonDeserializer {

    @Override
    public Foo deserialize
      (JsonElement jElement, Type typeOfT, JsonDeserializationContext context)
      throws JsonParseException {
        JsonObject jObject = jElement.getAsJsonObject();
        int intValue = jObject.get("valueInt").getAsInt();
        String stringValue = jObject.get("valueString").getAsString();
        return new Foo(intValue, stringValue);
    }
}

5. Deserialisieren Sie das JSON-Array in ein Java-Array von Objekten

Als Nächstes deserialisieren wira json array into a Java array vonFoo Objekten:

@Test
public void givenJsonArrayOfFoos_whenDeserializingToArray_thenCorrect() {
    String json = "[{"intValue":1,"stringValue":"one"}," +
      "{"intValue":2,"stringValue":"two"}]";
    Foo[] targetArray = new GsonBuilder().create().fromJson(json, Foo[].class);

    assertThat(Lists.newArrayList(targetArray), hasItem(new Foo(1, "one")));
    assertThat(Lists.newArrayList(targetArray), hasItem(new Foo(2, "two")));
    assertThat(Lists.newArrayList(targetArray), not(hasItem(new Foo(1, "two"))));
}

6. Deserialisieren Sie das JSON-Array in die Java-Sammlung

Als nächstes ein JSON-Arraydirectly into a Java Collection:

@Test
public void givenJsonArrayOfFoos_whenDeserializingCollection_thenCorrect() {
    String json =
      "[{"intValue":1,"stringValue":"one"},{"intValue":2,"stringValue":"two"}]";
    Type targetClassType = new TypeToken>() { }.getType();

    Collection targetCollection = new Gson().fromJson(json, targetClassType);
    assertThat(targetCollection, instanceOf(ArrayList.class));
}

7. Deserialisieren Sie JSON in verschachtelte Objekte

Als nächstes definieren wir unser verschachteltes Objekt -FooWithInner:

public class FooWithInner {
    public int intValue;
    public String stringValue;
    public InnerFoo innerFoo;

    public class InnerFoo {
        public String name;
    }
}

Und so deserialisieren Sie eine Eingabe, die dieses verschachtelte Objekt enthält:

@Test
public void whenDeserializingToNestedObjects_thenCorrect() {
    String json = "{\"intValue\":1,\"stringValue\":\"one\",\"innerFoo\":{\"name\":\"inner\"}}";

    FooWithInner targetObject = new Gson().fromJson(json, FooWithInner.class);

    assertEquals(targetObject.intValue, 1);
    assertEquals(targetObject.stringValue, "one");
    assertEquals(targetObject.innerFoo.name, "inner");
}

8. Deserialisieren Sie JSON mit dem benutzerdefinierten Konstruktor

Lassen Sie uns abschließend sehen, wie Sie die Verwendung eines bestimmten Konstruktors während der Deserialisierung anstelle von Standard - Konstruktor ohne Argumente - mitInstanceCreator erzwingen:

public class FooInstanceCreator implements InstanceCreator {

    @Override
    public Foo createInstance(Type type) {
        return new Foo("sample");
    }
}

Und so verwenden Sie unsereFooInstanceCreator bei der Deserialisierung:

@Test
public void whenDeserializingUsingInstanceCreator_thenCorrect() {
    String json = "{\"intValue\":1}";

    GsonBuilder gsonBldr = new GsonBuilder();
    gsonBldr.registerTypeAdapter(Foo.class, new FooInstanceCreator());
    Foo targetObject = gsonBldr.create().fromJson(json, Foo.class);

    assertEquals(targetObject.intValue, 1);
    assertEquals(targetObject.stringValue, "sample");
}

Beachten Sie, dassFoo.stringValue anstelle von null gleichsample ist, da wir den folgenden Konstruktor verwendet haben:

public Foo(String stringValue) {
    this.stringValue = stringValue;
}

9. Fazit

In diesem Artikel wird gezeigt, wie Sie die Gson-Bibliothek aufparse JSON input nutzen können. Dabei werden die häufigsten Anwendungsfälle für einzelne und mehrere Objekte behandelt.

Die Implementierung all dieser Beispiele und Codefragmentecan be found in my github project - dies ist ein Eclipse-basiertes Projekt, daher sollte es einfach zu importieren und auszuführen sein, wie es ist.

TOC

Gson Deserialization Cookbook