Exemples et tutoriels Google Gson pour Android.

Gson (également connu sous le nom de Google Gson) est une petite bibliothèque basée sur Java pour analyser et créer des objets JSON.

Il s'agit d'une bibliothèque de sérialisation/désérialisation permettant de convertir des objets Java en JSON et inversement.

Google a développé Gson pour ses propres projets, mais a ensuite mis Gson à la disposition du public, à partir de la version 1.0.

Gson est très puissant et est capable de travailler avec des objets Java arbitraires, y compris des objets préexistants dont vous n'avez pas le code source.

Utilisations de Gson

  1. Conversion d'objets Java en JSON et inversement.
  2. Conversion d'une chaîne JSON en un objet Java équivalent.

Pourquoi Gson a été créé

Voici les raisons de la création de Gson :

  1. Pour faciliter le travail avec JSON en fournissant des méthodes simples toJson() et fromJson(). Ces méthodes nous permettent de convertir des objets Java en JSON et vice-versa.
  2. Permettre aux objets non modifiables préexistants d'être convertis en JSON et vice-versa.
  3. Fournir un support étendu de Java Generics.
  4. Permettre des représentations personnalisées des objets
  5. Fournir un support pour des objets arbitrairement complexes (avec des hiérarchies d'héritage profondes et une utilisation étendue des types génériques).

Installation de Gson

Gson vise les projets basés sur Java, y compris android. Cela signifie que nous avons au moins plusieurs façons de l'installer en fonction de notre système de construction.

(a) Gradle

Par exemple, si vous utilisez android, il est fort probable que vous utilisiez android studio et gradle.

Dans ce cas, vous ajoutez ce qui suit dans les dépendances de votre build.gradle au niveau de l'application :

implementation 'com.google.code.gson:gson:2.8.5'

(b) Maven

Si vous créez un projet java général alors très probablement vous utiliserez Maven :

<dependency>
  <groupId>com.google.code.gson</groupId>
  <artifactId>gson</artifactId>
  <version>2.8.5</version>
</dependency>

(c) Jar

La dernière option consiste à utiliser directement les jar. Vous les téléchargez depuis Maven Central et les ajoutez à votre projet.

Télécharger Jar ici.

Classes importantes

(a) Gson

Gson est une classe trouvée dans le paquet com.google.gson et est la classe principale dont nous avons besoin pour utiliser la bibliothèque Gson.

Normalement, nous l'utilisons d'abord en construisant une instance Gson, puis en invoquant les méthodes toJson(Object) ou fromJson(String, Class) sur celle-ci.

(b). JsonElement

JsonElement est une classe du paquet com.google.gson qui représente un élément de Json.

Voici les objets de JsonElement :

  1. JsonObject
  2. JsonArray
  3. JsonPrimitive
  4. JsonNull.
(c) JsonObject

JsonObject est une classe du paquetage com.google.gson qui représente un type d'objet en Json.

Cet objet peut comprendre des paires nom-valeur où les noms sont des chaînes de caractères et les valeurs tout autre type de JsonElement.

Avec cela, nous pouvons construire un arbre de JsonElements. Ces éléments sont maintenus dans l'ordre où ils ont été ajoutés.

(d) JsonParser

JsonParser est une classe trouvée dans le paquet com.google.gson qui est utilisée pour analyser Json dans un arbre de JsonElements.

Création de Gson

1. Gson()

La première façon de créer ou de construire un objet Gson est d'utiliser le constructeur defalu : Gson().

Cela va nous construire un objet Gson avec une configuration par défaut.

Cette configuration par défaut a les paramètres suivants :

  1. Le JSON généré par les méthodes toJson est en représentation compacte. Cela signifie que tous les espaces blancs inutiles sont supprimés. Vous pouvez changer ce comportement avec GsonBuilder#setPrettyPrinting().
  2. Le JSON généré omet tous les champs qui sont nuls. Notez que les champs nuls dans les tableaux sont conservés tels quels puisqu'un tableau est une liste ordonnée. De plus, si un champ n'est pas nul, mais que son JSON généré est vide, le champ est conservé. Vous pouvez configurer Gson pour qu'il sérialise les valeurs nulles en définissant GsonBuilder#serializeNulls().
  3. Gson fournit une sérialisation et une désérialisation par défaut pour les classes Enums, Map, java.net.URL, java.net.URI, java.util.Locale, java.util.Date, java.math.BigDecimal et java.math.BigInteger.
2. GsonBuilder

GsonBuilder peut être utilisé pour instancier Gson avec divers paramètres de configuration.

Gson gson = new GsonBuilder().setPrettyPrinting().create();

GsonBuilder suit le modèle du constructeur, et il est typiquement utilisé en invoquant d'abord diverses méthodes de configuration pour définir les options souhaitées, et enfin en appelant la méthode create().

Méthodes Gson importantes

(a). toJson()

Cette méthode sérialise l'objet spécifié, y compris ceux de types génériques, dans sa représentation Json équivalente.

Gson gson = new Gson();
gson.toJson(map);

Elle doit être utilisée si l'objet spécifié est un type générique. Pour les objets non génériques, utilisez plutôt toJson(Object,Appendable).

(b). fromJson

Cette méthode désérialise le Json spécifié en un objet du type spécifié. Cette méthode est utile si l'objet spécifié est un type générique. Pour les objets non génériques, utilisez plutôt fromJson(String,Class).

Si vous avez le Json dans un Reader au lieu d'un String, utilisez fromJson(Reader,Type) à la place.

(c). toJsonTree

Cette méthode sérialise l'objet spécifié, y compris ceux de type générique, en sa représentation équivalente sous forme d'un arbre de JsonElements. Cette méthode doit être utilisée si l'objet spécifié est un type générique. Pour les objets non génériques, utilisez plutôt toJsonTree(Object).

(d). getAdapter

Renvoie l'adaptateur de type pour le type.

Exemple complet de Gson Hello World

Voyons un exemple complet de Gson Hello World. Vous pouvez copier-coller cet exemple dans votre IDE tant que vous avez Gson installé et exécuté.

import com.google.gson.Gson;

/**
 *  Gson Hello World
 *
  */
public class GsonHelloWorld {

    public static void main(String[] args) {
        // init class
        Place place = new Place();
        place.setName("World");

        Human human = new Human();
        human.setMessage("Hi");
        human.setPlace(place);

        // convert to json
        Gson gson = new Gson();
        String jsonString = gson.toJson(human);
        System.out.println("json " + jsonString); // print "json {"message":"Hi","place":{"name":"World"}}"

        // convert from json
        Human newHuman = gson.fromJson(jsonString, Human.class);
        newHuman.say(); // print "Hi , World!"
    }

    private static class Human {
        private String message;
        private Place place;

        public String getMessage() {
            return message;
        }

        public void setMessage(String message) {
            this.message = message;
        }

        public Place getPlace() {
            return place;
        }

        public void setPlace(Place place) {
            this.place = place;
        }

        public void say() {
            System.out.println();
            System.out.println(getMessage() + " , " + getPlace().getName() + "!");
        }
    }

    private static class Place {
        private String name;

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }
    }
}

Exemples rapides de Gson et mode d'emploi

Dans ces exemples, nous utilisons Google Gson.

1. Comment convertir une carte en JSON

Supposons que je vous donne une carte avec une clé String et une valeur T. Et je vous demande de la convertir en une chaîne JSON.

Comment allez-vous faire ?

Eh bien, vous pouvez simplement utiliser la méthode toJson() de la classe Gson. Vous devez d'abord instancier cette classe Gson puis invoquer cette méthode.

    public static <T> String mapToJsonStr(Map<String, T> map) {
        Gson gson = new Gson();
        return gson.toJson(map);
    }
2. Comment convertir JSON en Map

Qu'en est-il si vous avez JSON String et nous vous demandons de le convertir en une structure de données Map en java.

Dans ce cas, vous utiliserez la méthode fromJson() de Gson.

Cependant, cette fois, vous devez instancier un TypeToken avec ce Map comme paramètre générique. Puis passez la chaîne json comme premier paramètre dans la méthode fromJson(). Et l'instance Type comme second paramètre.

    public static <T> Map<String, T> jsonStrToMap(String jsonStr) {
        Gson gson = new Gson();
        Type type = new TypeToken<Map<String, T>>() {
        }.getType();
        return gson.fromJson(jsonStr, type);
    }
3. Comment convertir JSON en objet

Très bien, vous avez une chaîne JSON et on vous dit de la convertir en un objet de type donné.

Eh bien, encore une fois vous passez la chaîne json et le type à la méthode fromJson().

    public static <T> T jsonToObj(String jsonStr, Class<T> classOfT) {
        return new Gson().fromJson(jsonStr, classOfT);
    }
4. Comment convertir JSON en ArrayList ?

Un scénario courant dans de nombreux projets est de convertir une chaîne json en ArrayList, la collection la plus couramment utilisée.

Nous commençons par utiliser la méthode isEmpty() de TextUtils pour vérifier les valeurs vides.

Ensuite, nous obtenons notre instance TypeToken avec ArrayList de JSONObjects passés comme notre type générique.

Utilisez ensuite la méthode fromJson() pour obtenir notre ArrayList de JSONObjects.

Puis maintenant, nous pouvons boucler à travers elle et de remplir le ArrayList que nous voulons remplir.

    public static <T> ArrayList<T> jsonToArrayList(String json, Class<T> clazz) {
        if (TextUtils.isEmpty(json)) {
            return null;
        }
        Type type = new TypeToken<ArrayList<JsonObject>>() {
        }.getType();
        ArrayList<JsonObject> jsonObjects = new Gson().fromJson(json, type);

        ArrayList<T> arrayList = new ArrayList<>();
        for (JsonObject jsonObject : jsonObjects) {
            arrayList.add(new Gson().fromJson(jsonObject, clazz));
        }
        return arrayList;
    }
5. Comment convertir une liste en JSON

Une autre chose courante est de convertir une Liste en une chaîne json. Peut-être que vous voulez sérialiser cette liste et l'envoyer sur l'où ou un moyen de base de l'exposer comme une API.

Encore une fois, la méthode toJson() fait facilement cela pour nous.

    public static <T> String listToJson(List<T> list) {

        Gson gson = new Gson();
        String jsonstring = gson.toJson(list);
        return jsonstring;

    }
6. Comment convertir un objet en JSON

Vous avez un objet et vous devez le convertir en JSON, et bien vous invoquez simplement la méthode toJson() avec l'objet passé en paramètre.

    public static <T> String object2Json(T t) {
        Gson gson = new Gson();
        return gson.toJson(t);
    }
7. Comment exclure des champs spécifiques de la sérialisation sans annotations ?

Normalement, on contrôle les champs à inclure via les annotations dans Gson. Cependant, peut-on le faire sans annotations.

Gson gson = new GsonBuilder()
   .setExclusionStrategies(new TestExclStrat())
   //.serializeNulls() <-- uncomment to serialize NULL fields as well
   .create();
 Student src = new Student();
 String json = gson.toJson(src);
 System.out.println(json);

Référence

8. Comment faire de la PrettyPrinting avec Gson

PrettyPrinting signifie ajouter des espaces blancs pour rendre nos données JSON plus lisibles. Vous pouvez utiliser GsonBuilder#setPrettyPrinting().

Gson gson = new GsonBuilder().setPrettyPrinting().create();
JsonParser jp = new JsonParser();
JsonElement je = jp.parse(uglyJSONString);
String prettyJsonString = gson.toJson(je);

Référence

9. Comment écrire JSON en utilisant TreeModel

Voici la méthode importante. Nous avons deux méthodes pour lire et écrire des données json.

Voici la classe complète :


import com.google.gson.Gson;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;

import java.io.IOException;

public class TreeModel {
    public static void main(String[] args) throws IOException {
        System.out.print("readJson: ");
        readJson();
        System.out.println();
        System.out.print("writeJson: ");
        writeJson();
    }

    /**
     *  Example to readJson using TreeModel
     */
    private static void readJson() throws IOException {
        JsonParser parser = new JsonParser();
        JsonElement jsonElement = parser.parse("{"message":"Hi","place":{"name":"World!"}}");
        JsonObject rootObject = jsonElement.getAsJsonObject();
        String message = rootObject.get("message").getAsString(); // get property "message"
        JsonObject childObject = rootObject.getAsJsonObject("place"); // get place object
        String place = childObject.get("name").getAsString(); // get property "name"
        System.out.println(message + " " + place); // print "Hi World!"*/
    }

    /**
     * Example to writeJson using TreeModel
     */
    private static void writeJson() throws IOException {
        JsonObject rootObject = new JsonObject();
        rootObject.addProperty("message", "Hi");
        JsonObject childObject = new JsonObject();
        childObject.addProperty("name", "World!");
        rootObject.add("place", childObject);

        Gson gson = new Gson();
        String json = gson.toJson(rootObject);
        System.out.println(json); // print "{"message":"Hi","place":{"name":"World!"}}"
    }
}
10. Comment convertir une chaîne en objet

Gson myGson = new GsonBuilder().setPrettyPrinting().create();
myGson.fromJson(jsonString, Person.class)
11. Impression jolie d'une chaîne JSON

private static String pretty(String json) {
  JsonElement gson = new JsonParser().parse(json);
  return new GsonBuilder().setPrettyPrinting().serializeNulls().create().toJson(gson);
 }
}
12. Lecture et écriture d'API en continu à l'aide de Gson

Il s'agit d'un exemple de lecture et d'écriture de l'API Streaming JSON. Nous allons utiliser les classes JsonReader, JsonToken et JsonWriter.

Nous avons trois méthodes, notre méthode main(), une méthode readJSON() et une méthode writeJson().

import com.google.gson.stream.JsonReader;
import com.google.gson.stream.JsonToken;
import com.google.gson.stream.JsonWriter;

import java.io.*;
import java.nio.charset.Charset;

public class StreamingAPI {
    public static void main(String[] args) throws IOException {
        System.out.print("readJson: ");
        readJson();
        System.out.println();
        System.out.print("writeJson: ");
        writeJson();
    }

    /**
     *  Example to readJson using StreamingAPI
     */
    private static void readJson() throws IOException {
        String str = "{"message":"Hi","place":{"name":"World!"}}";
        InputStream in = new ByteArrayInputStream(str.getBytes(Charset.forName("UTF-8")));
        JsonReader reader = new JsonReader(new InputStreamReader(in, "UTF-8"));
        while (reader.hasNext()) {
            JsonToken jsonToken = reader.peek();
            if(jsonToken == JsonToken.BEGIN_OBJECT) {
                reader.beginObject();
            } else if(jsonToken == JsonToken.END_OBJECT) {
                reader.endObject();
            } if(jsonToken == JsonToken.STRING) {
                System.out.print(reader.nextString() + " "); // print Hi World!
            } else {
                reader.skipValue();
            }
        }
        reader.close();
    }

    /**
     * Example to writeJson using StreamingAPI
     */
    private static void writeJson() throws IOException {
        OutputStream outputStream = new ByteArrayOutputStream();
        JsonWriter writer = new JsonWriter(new OutputStreamWriter(outputStream, "UTF-8"));
        writer.beginObject(); // main object
        writer.name("message");
        writer.value("Hi");
        writer.name("place"); // save object Place
        writer.beginObject();
        writer.name("name");
        writer.value("World!");
        writer.endObject();
        writer.endObject();
        writer.close();
        System.out.println(outputStream.toString()); // print "{"message":"Hi","place":{"name":"World!"}}"
    }
}
13. Classe utilitaire Gson complète et réutilisable

ublic class GsonUtils {

    privatestaticfinaldoubleVERSION=1.0f;
    private static final Gson sGson = createGson(true, false);

    private static final Gson sGsonExpose = createGson(true, true);

    private GsonUtils () {
        thrownewAssertionError();
    }

    /**
     * Create the standard {@link Gson} configuration
     *
     * @return created gson, never null
     */
    public static Gson createGson() {
        return createGson(true, false);
    }

    /**
     * Create the standard {@link Gson} configuration
     *
     * @param serializeNulls whether nulls should be serialized
     * @return created gson, never null
     */
    private static Gson createGson(final boolean serializeNulls,
                                   final boolean exposeEnable ) {
        final GsonBuilder builder = new GsonBuilder ();
        if (serializeNulls) {
            builder.serializeNulls();
        }
        builder . setVersion ( VERSION );
        // json format
        // builder.setPrettyPrinting();
        if (exposeEnable) {
            builder.excludeFieldsWithoutExposeAnnotation();
        }
        return builder.create();
    }

    /**
     * Get reusable pre-configured {@link Gson} instance
     *
     * @return Gson instance
     */
    public static Gson getGson() {
        return sGson;
    }

    /**
     * Get reusable pre-configured {@link Gson} instance
     *
     * @return Gson instance
     */
    public static Gson getGson(final boolean exposeEnable) {
        return exposeEnable ? sGsonExpose : sGson;
    }

    /**
     * Convert object to json, only exports attributes that have been annotated with @Expose
     *
     * @param object
     * @return json string
     */
    public static String toJson(final Object object) {
        return toJson(object, true);
    }

    /**
     * Convert object to json
     *
     * @param object
     * @param exposeEnable Whether to export only @Expose annotated properties, true is only exported by @Expose
     * @return json string
     */
    public static String toJson(final Object object,
                                final boolean exposeEnable ) {
        return exposeEnable ? sGsonExpose.toJson(object) : sGson.toJson(object);
    }

    /**
     * Convert string to given type
     *
     * @param json
     * @param type
     * @return instance of type
     */
    public static <V> V fromJson(String json, Class<V> type) {
        return sGson.fromJson(json, type);
    }

    /**
     * Convert string to given type
     *
     * @param json
     * @param type
     * @return instance of type
     */
    public static <V> V fromJson(String json, Type type) {
        returnsGson.fromJson(json,type);
    }

    /**
     * Convert content of reader to given type
     *
     * @param reader
     * @param type
     * @return instance of type
     */
    public static <V> V fromJson(Reader reader, Class<V> type) {
        return sGson.fromJson(reader, type);
    }

    /**
     * Convert content of reader to given type
     *
     * @param reader
     * @param type
     * @return instance of type
     */
    public static <V> V fromJson(Reader reader, Type type) {
        returnsGson.fromJson(reader,type);
    }

    /**
     * Convert object object to map only supports basic types
     *
     * @param src
     * @param exposeEnable
     * @return
     */
    public static HashMap<String, String> toMap(Object src, boolean exposeEnable) {
        Gson gson = exposeEnable ? sGsonExpose : sGson;
        HashMap<String, String> params = new HashMap<String, String>();
        try {
            if (src == null) {
                return null;
            }
            JsonElement jsonTree = gson . toJsonTree ( src );
            JsonObject jsonObj = jsonTree.getAsJsonObject();
            Iterator<Entry<String, JsonElement>> iterator = jsonObj.entrySet().iterator();
            String curKey;
            JsonElement curVal ;
            while (iterator.hasNext()) {
                Entry<String, JsonElement> entry = iterator.next();
                curKey = entry.getKey();
                curVal = entry.getValue();
                if (!curVal.isJsonNull()) {
                    params.put(curKey, curVal.getAsString());
                }
            }
            return params;
        } Catch ( Exception e ) {
            e . printStackTrace ();
        }
        returnparams;
    }

    public static <T> String mapToJson(Map<String, T> map) {
        Gson gson =  new  Gson ();
        return gson . toJson (folder);
    }
}

Catégorisé: