Premiers pas avec gson

Tableaux

JSON :

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

Personne.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) + " ]";
    }
}

Usage:

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

Production:

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

Exemple simple

La bibliothèque Gson fournit Gson.class qui gère toutes les conversions entre les objets Java et JSON. Une instance de cette classe peut être créée en appelant le constructeur par défaut. Vous aimeriez généralement avoir une instance Gson pour la plupart des opérations de votre programme.

Gson gson = new Gson();

Tout d’abord, nous devons créer la classe de notre objet avec lequel nous allons travailler

class Person {
   public String name;
   public int age;

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

La classe Gson fournit les méthodes toJson et fromJson qui sont les principaux points d’entrée pour les objets JSON et Java

Essayons de convertir l’objet Java en JSON et de revenir à l’objet Java

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}

Et maintenant de retour

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"

Installation

Pour utiliser Gson, vous devez l’inclure dans votre projet. Vous pouvez le faire en ajoutant la dépendance suivante de la version Gson disponible dans Maven Central :

Maven

Ajouter à pom.xml

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

Gradle :

Ajouter à build.gradle

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

Convertir String en JsonObject sans 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();

Sérialisation et désérialisation

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

Utilisation de GSON avec héritage

GSON ne prend pas en charge l’héritage de la boîte. Disons que nous avons la hiérarchie de classes suivante :

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;
    }
}

Et maintenant, nous voulons sérialiser une instance de DerivedClass1 en une chaîne json

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

Maintenant, à un autre endroit, nous recevons cette chaîne json et voulons la désérialiser - mais au moment de la compilation, nous savons seulement qu’elle est censée être une instance de BaseClass :

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

Mais GSON ne sait pas que derivedClass1Json était à l’origine une instance de DerivedClass1, donc cela affichera 10.

Comment résoudre ce problème ?

Vous devez créer votre propre JsonDeserializer, qui gère de tels cas. La solution n’est pas parfaitement propre, mais je n’ai pas pu en trouver une meilleure.

Tout d’abord, ajoutez le champ suivant à votre classe de base

@SerializedName("type")
private String typeName;

Et initialisez-le dans le constructeur de la classe de base

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

Ajoutez maintenant la classe suivante :

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);
 }
}

Il ne reste plus qu’à tout brancher -

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

Et maintenant, en exécutant le code suivant-

 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());

Imprime 5.