Ejemplos y tutoriales de Google Gson para Android

Gson (también conocido como Google Gson) es una pequeña biblioteca basada en Java para analizar y crear objetos JSON.

Es una biblioteca de serialización/deserialización para convertir objetos Java en JSON y viceversa.

Google desarrolló Gson para sus propios proyectos, pero más tarde puso Gson a disposición del público, a partir de la versión 1.0.

Gson es muy potente y es capaz de trabajar con objetos Java arbitrarios, incluyendo objetos preexistentes de los que no se tiene el código fuente.

Usos de Gson

  1. Conversión de objetos Java a JSON y viceversa.
  2. Conversión de una cadena JSON a un objeto Java equivalente.

Por qué se creó Gson

Aquí están las razones para la creación de Gson:

  1. Para facilitar el trabajo con JSON proporcionando métodos simples toJson() y fromJson(). Estos métodos nos permiten convertir objetos Java a JSON y viceversa.
  2. Permitir convertir objetos preexistentes no modificables a y desde JSON.
  3. Proporcionar un amplio soporte de Java Generics.
  4. Permitir representaciones personalizadas para los objetos.
  5. Proporcionar soporte para objetos arbitrariamente complejos (con profundas jerarquías de herencia y amplio uso de tipos genéricos)

Instalación de Gson

Gson se dirige a proyectos basados en Java, incluyendo android. Esto significa que tenemos al menos varias formas de instalarlo dependiendo de nuestro sistema de construcción.

(a) Gradle

Por ejemplo, si estás usando android, lo más probable es que estés usando android studio y gradle.

En ese caso agregas lo siguiente en las dependencias de tu app level build.gradle:

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

(b) Maven

Si estás creando un proyecto java general entonces lo más probable es que uses Maven:

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

(c) Jar

La última opción es usar jar directamente. Los descargas desde Maven Central y los añades a tu proyecto.

Descarga el Jar aquí.

Clases importantes

(a) Gson

Gson es una clase que se encuentra en el paquete com.google.gson y es la clase principal que necesitamos para utilizar la librería Gson.

Normalmente la usamos primero construyendo una instancia de Gson y luego invocando los métodos toJson(Object) o fromJson(String, Class) sobre ella.

(b). JsonElement

JsonElement es una clase que se encuentra en el paquete com.google.gson que representa un elemento de Json.

Aquí están los objetos JsonElement:

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

JsonObject es una clase del paquete com.google.gson que representa un tipo de objeto en Json.

Este objeto puede comprender pares nombre-valor donde los nombres son cadenas, y los valores son cualquier otro tipo de JsonElement.

Con esto entonces podemos construir un árbol de JsonElements. Estos elementos se mantienen en el orden en que fueron añadidos.

(d) JsonParser

JsonParser es una clase que se encuentra en el paquete com.google.gson` que se utiliza para parsear Json en un árbol de JsonElements

Creación de Gson

1. Gson()

La primera forma de crear o construir un objeto Gson es utilizar el constructor defalu: Gson().

Esto nos construirá un objeto Gson con la configuración por defecto.

Esa configuración por defecto tiene los siguientes ajustes:

  1. El JSON generado por los métodos toJson está en representación compacta. Esto significa que se eliminan todos los espacios en blanco innecesarios. Puedes cambiar este comportamiento con GsonBuilder#setPrettyPrinting().
  2. El JSON generado omite todos los campos que son nulos. Tenga en cuenta que los nulos en los arrays se mantienen tal cual, ya que un array es una lista ordenada. Además, si un campo no es nulo, pero su JSON generado está vacío, el campo se mantiene. Puedes configurar Gson para que serialice los valores nulos estableciendo GsonBuilder#serializeNulls().
  3. Gson proporciona una serialización y deserialización por defecto para las clases Enums, Map, java.net.URL, java.net.URI, java.util.Locale, java.util.Date, java.math.BigDecimal y java.math.BigInteger.
2. GsonBuilder

El GsonBuilder se puede utilizar para instanciar Gson con varios ajustes de configuración.

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

GsonBuilder sigue el patrón constructor, y se suele utilizar invocando primero varios métodos de configuración para establecer las opciones deseadas, y finalmente llamando al método create().

Métodos importantes de Gson

toJson()

Este método serializa el objeto especificado, incluyendo los de tipo genérico, en su representación Json equivalente.

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

Debe utilizarse si el objeto especificado es de tipo genérico. Para objetos no genéricos, utilice toJson(Object,Appendable) en su lugar.

(b). fromJson

Este método deserializa el Json especificado en un objeto del tipo especificado. Este método es útil si el objeto especificado es de tipo genérico. Para objetos no genéricos, utilice fromJson(String,Class) en su lugar.

Si tiene el Json en un Reader en lugar de un String, utilice fromJson(Reader,Type) en su lugar.

toJsonTree

Este método serializa el objeto especificado, incluyendo los de tipo genérico, en su representación equivalente como un árbol de JsonElements. Este método debe utilizarse si el objeto especificado es de tipo genérico. Para objetos no genéricos, utilice toJsonTree(Object) en su lugar.

getAdapter

Devuelve el adaptador de tipo para el tipo.

Ejemplo completo de Gson Hello World

Veamos un ejemplo completo de Gson Hello World. Puedes copiar y pegar este ejemplo en tu IDE siempre que tengas instalado Gson y lo ejecutes.

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

Ejemplos rápidos de GSON y cómo hacerlo

En estos ejemplos estamos usando Google Gson.

1. Cómo convertir un mapa en JSON

Supongamos que te doy un mapa con una clave String y un valor T. Y te digo que lo mapees o conviertas a una cadena JSON.

¿Cómo lo harías?

Pues simplemente puedes usar el método toJson() de la clase Gson. Primero tienes que instanciar esa clase Gson y luego invocar ese método.

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

Que pasa si tienes una cadena JSON y te pedimos que la conviertas en una estructura de datos Map en java.

Bien, entonces usarías el método fromJson() de Gson.

Sin embargo esta vez debes instanciar un TypeToken con ese Map como parámetro genérico. Entonces pasa la cadena json como nuestro primer parámetro en el método fromJson(). Y la instancia de Type como nuestro segundo parámetro.

    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. Cómo convertir JSON en objeto

Muy bien, tienes una cadena JSON y te dicen que la conviertas en un objeto de un tipo determinado.

Bien, de nuevo pasas la cadena json y el tipo al método fromJson().

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

Un escenario común en muchos proyectos es convertir una cadena json a un ArrayList, la colección más utilizada.

Comenzamos utilizando el método TextUtils isEmpty() para comprobar si hay valores vacíos.

Luego obtenemos nuestra instancia TypeToken con ArrayList de JSONObjects pasada como nuestro tipo genérico.

Luego usamos el método fromJson() para obtener nuestro ArrayList de JSONObjects.

Ahora podemos hacer un bucle a través de él y llenar el ArrayList que queremos rellenar.

    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. Cómo convertir una lista en JSON

Otra cosa común es convertir una Lista a una cadena json. Tal vez quieras serializar esa lista y enviarla por el donde o una forma básica de exponerla como una API.

De nuevo, el método toJson() hace eso fácilmente por nosotros.

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

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

    }
6. Cómo convertir un objeto en JSON

Tienes un objeto y debes convertirlo a JSON, pues simplemente invocas el método toJson() con el objeto pasado como parámetro.

    public static <T> String object2Json(T t) {
        Gson gson = new Gson();
        return gson.toJson(t);
    }
7. Cómo excluir campos específicos de la serialización sin anotaciones

Normalmente se controlan los campos a incluir mediante anotaciones en Gson. Sin embargo, podemos hacerlo sin anotaciones.

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

Referencia

8. Cómo hacer Pretty Print con Gson

PrettyPrinting significa añadir espacios en blanco para que nuestros datos JSON sean más legibles. Puedes usar GsonBuilder#setPrettyPrinting().

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

Referencia

9. Cómo escribir JSON usando TreeModel

Aquí está el método importante. Tenemos dos métodos para leer y escribir datos json.

Aquí está la clase completa:


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. Cómo convertir una cadena en un objeto

Gson myGson = new GsonBuilder().setPrettyPrinting().create();
myGson.fromJson(jsonString, Person.class)
11. Impresión bonita de una cadena JSON

private static String pretty(String json) {
  JsonElement gson = new JsonParser().parse(json);
  return new GsonBuilder().setPrettyPrinting().serializeNulls().create().toJson(gson);
 }
}
12. Streaming API de lectura y escritura usando Gson

Este es un ejemplo de lectura y escritura de la API de Streaming JSON. Utilizaremos las clases JsonReader, JsonToken y JsonWriter.

Tenemos tres métodos, nuestro método main(), un método readJSON() y un método 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. Clase de utilidad Gson completamente reutilizable

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

Categorizado en: