Looking for gson Keywords? Try Ask4Keywords

gsonErste Schritte mit dem Gson


Bemerkungen

Gson ist eine Open Source Java-Bibliothek, mit der Java-Objekte in ihre JSON-Darstellung konvertiert werden können. Es kann auch verwendet werden, um eine JSON-Zeichenfolge in ein entsprechendes Java-Objekt zu konvertieren.

Tore für Gson

  • Stellen Sie einfach zu verwendende Mechanismen wie toString () und Konstruktor (Factory-Methode) bereit, um Java in JSON und umgekehrt zu konvertieren

  • Zulassen, dass vorhandene, nicht veränderbare Objekte in und aus JSON konvertiert werden

  • Erlauben Sie benutzerdefinierte Darstellungen für Objekte

  • Unterstützt beliebig komplexe Objekte

  • Erzeugen Sie kompakte und lesbare JSON-Ausgaben

Der Quellcode von Gson ist auf Github verfügbar.

Benutzerhandbuch

Arrays

JSON:

[
  {
    "id": 8484,
    "name": "David",
    "height": 173.2,
    "weight": 75.42
  },
  {
    "id": 8485,
    "name": "Ronald",
    "height": 183.73,
    "weight": 83.1
  }
]
 

Person.java

public class Person {
    public int id;
    public String name;
    public double height;
    public double weight;

    @Override
    public String toString() {
        return "[ id: " + String.valueOf(id) + ", name: " + name + ", height: " + String.valueOf(height) + ", weight: " + String.valueOf(weight) + " ]";
    }
}
 

Verwendungszweck:

Gson gson = new Gson();
Person[] persons = gson.fromJson(json, Person[].class);
for(Person person : persons)
    System.out.println(person.toString());
 

Ausgabe:

[ id: 8484, name: David, height: 173.2, weight: 75.42 ]
[ id: 8485, name: Ronald, height: 183.73, weight: 83.1 ]
 

Konvertieren Sie String in JsonObject ohne POJO

String jsonStr = "{\"name\" : \"Abcd\", \"greeting\": \"Hello\", }"; //Sample Json String

Gson gson = new Gson(); // Creates new instance of Gson
JsonElement element = gson.fromJson (jsonStr, JsonElement.class); //Converts the json string to JsonElement without POJO 
JsonObject jsonObj = element.getAsJsonObject(); //Converting JsonElement to JsonObject

String name = jsonObj.get("name").getAsString(); //To fetch the values from json object
String greeting = jsonObj.get("greeting").getAsString();
 

Installation

Um Gson verwenden zu können, müssen Sie es in Ihr Projekt aufnehmen. Sie können dies tun, indem Sie die folgende Abhängigkeit der in Maven Central verfügbaren Gson-Version hinzufügen:

Maven

Fügen Sie zu pom.xml hinzu

<dependencies>
    <dependency>
      <groupId>com.google.code.gson</groupId>
      <artifactId>gson</artifactId>
      <version>2.8.0</version>
      <scope>compile</scope>
    </dependency>
</dependencies>
 

Gradle :

Zu build.gradle hinzufügen

compile 'com.google.code.gson:gson:2.8.0'
 

Serialisierung und Deserialisierung

Gson gson = new Gson(); //Create a Gson object
MyType target = new MyType(); //This is the object you want to convert to JSON   
String json = gson.toJson(target); // serializes target to Json
MyType target2 = gson.fromJson(json, MyType.class); // deserializes json into target2
 

Einfaches Beispiel

Die Gson-Bibliothek enthält Gson.class die die gesamte Konvertierung zwischen Java- und JSON-Objekten übernimmt. Eine Instanz dieser Klasse kann durch Aufrufen des Standardkonstruktors erstellt werden. In der Regel möchten Sie eine Gson-Instanz für den Großteil der Operationen in Ihrem Programm haben.

Gson gson = new Gson();
 

Zuerst müssen wir eine Klasse unseres Objekts erstellen, mit der wir arbeiten werden

class Person {
   public String name;
   public int age;

   public Person(String name, int age){
       this.name = name;
       this.age = age;
   }
}
 

Die Klasse Gson stellt für toJson und fromJson Methoden toJson die die Haupteinstiegspunkte für JSON- und Java-Objekte sind

Versuchen wir, das Java-Objekt in JSON und zurück in das Java-Objekt zu konvertieren

Person person = new Person("Jason", 29);
//using gson object which we created earlier
String json = gson.toJson(person);
System.out.println(json);
//Outputs: {"name": "Jason", "age": 29}
 

Und jetzt wieder zurück

String json = "{\"name\": \"Jason\", \"age\": 29}";
Person person = gson.fromJson(json, Person.class);
System.out.println(person.age + "yo " + person.name + " walks into a bar");
//Outputs "29 yo Jason walks into a bar"
 

Verwendung von GSON mit Vererbung

GSON unterstützt keine Vererbung der Box. Nehmen wir an, wir haben die folgende Klassenhierarchie:

public class BaseClass {
    int a;
 
    public int getInt() {
        return a;
   }
}
 
public class DerivedClass1 extends BaseClass {
     int b;
 
     @Override
     public int getInt() {
         return b;
     }
 }
 
public class DerivedClass2 extends BaseClass {
    int c;
 
    @Override
    public int getInt() {
        return c;
    }
}
 

Und jetzt möchten wir eine Instanz von DerivedClass1 zu einem DerivedClass1 String serialisieren

DerivedClass1 derivedClass1 = new DerivedClass1();
derivedClass1.b = 5;
derivedClass1.a = 10;
 
Gson gson = new Gson();
String derivedClass1Json = gson.toJson(derivedClass1);
 

Nun, an einem anderen Ort, erhalten wir diesen Json-String und möchten ihn deserialisieren - aber zur Kompilierzeit wissen wir nur, dass es sich um eine Instanz von BaseClass :

BaseClass maybeDerivedClass1 = gson.fromJson(derivedClass1Json, BaseClass.class);
System.out.println(maybeDerivedClass1.getInt());
 

Aber GSON weiß nicht, dass derivedClass1Json ursprünglich eine Instanz von DerivedClass1 , daher werden 10 DerivedClass1 .

Wie löse ich das?

Sie müssen einen eigenen JsonDeserializer , der solche Fälle behandelt. Die Lösung ist nicht perfekt sauber, aber ich könnte mir keine bessere vorstellen.

Fügen Sie zunächst der Basisklasse das folgende Feld hinzu

@SerializedName("type")
private String typeName;
 

Und initialisieren Sie es im Basisklassenkonstruktor

public BaseClass() {
    typeName = getClass().getName();
}
 

Fügen Sie nun folgende Klasse hinzu:

public class JsonDeserializerWithInheritance<T> implements JsonDeserializer<T> {
 
 @Override
 public T deserialize(
     JsonElement json, Type typeOfT, JsonDeserializationContext context)
     throws JsonParseException {
     JsonObject jsonObject = json.getAsJsonObject();
     JsonPrimitive classNamePrimitive = (JsonPrimitive) jsonObject.get("type");
 
     String className = classNamePrimitive.getAsString();
 
     Class<?> clazz;
     try {
     clazz = Class.forName(className);
     } catch (ClassNotFoundException e) {
     throw new JsonParseException(e.getMessage());
     }
     return context.deserialize(jsonObject, clazz);
 }
}
 

Jetzt bleibt nur noch alles anzuschließen -

GsonBuilder builder = new GsonBuilder();
 builder
 .registerTypeAdapter(BaseClass.class, new JsonDeserializerWithInheritance<BaseClass>());
 Gson gson = builder.create();
 

Und jetzt den folgenden Code ausführen:

 DerivedClass1 derivedClass1 = new DerivedClass1();
 derivedClass1.b = 5;
 derivedClass1.a = 10;
 String derivedClass1Json = gson.toJson(derivedClass1);
 
 BaseClass maybeDerivedClass1 = gson.fromJson(derivedClass1Json, BaseClass.class);
 System.out.println(maybeDerivedClass1.getInt());
 

Wird ausgedruckt 5.