Exemplos e tutoriais do Google Gson para Android.

Gson (também conhecido como Google Gson) é uma pequena biblioteca baseada em Java para analisar e criar objetos JSON.

É uma biblioteca de serialização/desserialização para converter objetos Java em JSON e vice-versa.

O Google desenvolveu o Gson para seus próprios projetos, mas depois disponibilizou o Gson publicamente, começando com a versão 1.0.

O Gson é muito poderoso e é capaz de trabalhar com objetos Java arbitrários, incluindo objetos pré-existentes dos quais você não possui código-fonte.

Usos de Gson

  1. Conversão de objetos Java em JSON e vice-versa.
  2. Conversão de uma string JSON em um objeto Java equivalente.

Por que Gson foi criado

Aqui estão as razões para a criação do Gson:

  1. Para facilitar o trabalho com JSON, fornecendo métodos simples toJson() e fromJson(). Esses métodos nos permitem converter objetos Java para JSON e vice-versa.
  2. Para permitir que objetos não modificáveis ​​pré-existentes sejam convertidos de e para JSON.
  3. Para fornecer suporte extensivo de Java Generics.
  4. Para permitir representações personalizadas para objetos
  5. Para fornecer suporte para objetos arbitrariamente complexos (com hierarquias de herança profundas e uso extensivo de tipos genéricos)

Instalação do Gson

Gson tem como alvo projetos baseados em Java, incluindo android. Isso significa que temos pelo menos várias maneiras de instalá-lo, dependendo do nosso sistema de compilação.

(a) Gradle

Por exemplo, se você estiver usando o Android, provavelmente está usando o Android Studio e o gradle.

Nesse caso, você adiciona o seguinte nas dependências do build.gradle no nível do aplicativo:

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

(b) Especialista

Se você estiver criando um projeto java geral, provavelmente usará o Maven:

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

(c) Jarra

A última opção é usar jar diretamente. Você os baixa do Maven Central e os adiciona ao seu projeto.

Baixe o Jar aqui.

Aulas importantes

(a) Gson

Gson é uma classe encontrada no pacote com.google.gson e é a classe principal que precisamos para usar a biblioteca Gson.

Normalmente nós o usamos primeiro construindo uma instância Gson e então invocando métodos toJson(Object) ou fromJson(String, Class) nela.

(b). JsonElementName

JsonElement é uma classe encontrada no pacote com.google.gson que representa um elemento de Json.

Aqui estão os objetos JsonElement:

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

JsonObject é uma classe encontrada no pacote com.google.gson que representa um tipo de objeto em Json.

Este objeto pode incluir pares nome-valor onde nomes são strings e valores são qualquer outro tipo de JsonElement.

Com isso podemos construir uma árvore de JsonElements. Esses elementos são mantidos na ordem em que foram adicionados.

(d) JsonParser

JsonParser é uma classe encontrada no pacote com.google.gson que é usada para analisar Json em uma árvore de análise de JsonElements

Criando Gson

1. Gson()

A primeira maneira de criar ou construir um objeto Gson é usar o construtor defalu: Gson().

Isso nos construirá um objeto Gson com configuração padrão.

Essa configuração padrão tem as seguintes configurações:

  1. O JSON gerado pelos métodos toJson está em representação compacta. Isso significa que todos os espaços em branco desnecessários são removidos. Você pode alterar esse comportamento com GsonBuilder#setPrettyPrinting().
  2. O JSON gerado omite todos os campos que são nulos. Observe que os nulos em arrays são mantidos como estão, já que um array é uma lista ordenada. Além disso, se um campo não for nulo, mas seu JSON gerado estiver vazio, o campo será mantido. Você pode configurar o Gson para serializar valores nulos definindo GsonBuilder#serializeNulls().
  3. O Gson fornece serialização e desserialização padrão para as classes Enums, Map, java.net.URL, java.net.URI, java.util.Locale, java.util.Date, java.math.BigDecimal e java.math.BigInteger .
2. GsonBuilder

O GsonBuilder pode ser usado para instanciar o Gson com várias configurações.

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

O GsonBuilder segue o padrão do construtor e normalmente é usado primeiro invocando vários métodos de configuração para definir as opções desejadas e, finalmente, chamando o método create().

Métodos Gson importantes

(uma). toJson()

Esse método serializa o objeto especificado, incluindo os de tipos genéricos, em sua representação Json equivalente.

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

Deve ser usado se o objeto especificado for um tipo genérico. Para objetos não genéricos, use toJson(Object,Appendable).

(b). de Json

Esse método desserializa o Json especificado em um objeto do tipo especificado. Este método é útil se o objeto especificado for um tipo genérico. Para objetos não genéricos, use fromJson(String,Class).

Se você tiver o Json em um Reader em vez de uma String, use fromJson(Reader,Type).

(c). toJsonTree

Esse método serializa o objeto especificado, incluindo os de tipos genéricos, em sua representação equivalente como uma árvore de JsonElements. Este método deve ser usado se o objeto especificado for um tipo genérico. Para objetos não genéricos, use toJsonTree(Object).

(d). getAdaptador

Retorna o adaptador de tipo para o tipo.

Exemplo completo de Gson Hello World

Vamos ver um exemplo completo do Gson hello world. Você pode copiar e colar este exemplo em seu IDE, desde que tenha o Gson instalado e executado.

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

Exemplos rápidos de GSON e instruções

Nestes exemplos, estamos usando o Google Gson.

1. Como converter mapa para JSON

Suponha que eu dê a você um mapa com uma chave String e um valor T. E eu digo para você mapeá-lo ou convertê-lo em uma string JSON.

Como você faria?

Bem, você pode simplesmente usar o método toJson() da classe Gson. Você primeiro tem que instanciar essa classe Gson e então invocar esse método.

    public static <T> String mapToJsonStr(Map<String, T> map) {
        Gson gson = new Gson();
        return gson.toJson(map);
    }
2. Como converter JSON em mapa

E se você tiver JSON String e pedirmos que você a converta em uma estrutura de dados Map em java.

Bem, então você usaria o método fromJson() do Gson.

No entanto, desta vez você deve instanciar um TypeToken com esse Map como um parâmetro genérico. Em seguida, passe a string json como nosso primeiro parâmetro no método fromJson(). E a instância Type como nosso 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. Como converter JSON em objeto

Tudo bem, você tem uma string JSON e é solicitado a convertê-la em um objeto de determinado tipo.

Bem, novamente você passa a string json e o tipo para o método fromJson().

    public static <T> T jsonToObj(String jsonStr, Class<T> classOfT) {
        return new Gson().fromJson(jsonStr, classOfT);
    }
4. Como converter JSON para ArrayList

Um cenário comum em muitos projetos é converter uma string json em um ArrayList, a coleção mais usada.

Começamos usando o método TextUtils' isEmpty() para verificar valores vazios.

Em seguida, obtemos nossa instância TypeToken com ArrayList de JSONObjects passados ​​como nosso tipo genérico.

Em seguida, use o método fromJson() para obter nosso ArrayList de JSONObjects.

Então agora podemos fazer um loop por ele e preencher o ArrayList que queremos preencher.

    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. Como converter lista para JSON

Outra coisa comum é converter uma Lista em uma string json. Talvez você queira serializar essa lista e enviá-la para onde ou uma maneira básica de expô-la como uma API.

Novamente, o método toJson() facilmente faz isso por nós.

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

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

    }
6. Como converter objeto em JSON

Você tem um objeto e deve convertê-lo para JSON, bem, basta invocar o método toJson() com o objeto passado como parâmetro.

    public static <T> String object2Json(T t) {
        Gson gson = new Gson();
        return gson.toJson(t);
    }
7. Como excluir campos específicos da serialização sem anotações

Normalmente você controla os campos a serem incluídos por meio de anotações no Gson. No entanto, podemos fazê-lo sem anotações.

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

Referência

8. Como imprimir bonito com Gson

PrettyPrinting significa adicionar espaço em branco para tornar nossos dados JSON mais legíveis. Você pode usar GsonBuilder#setPrettyPrinting().

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

Referência

9. Como escrever JSON usando TreeModel

Aqui está o método importante. Temos dois métodos para ler e gravar dados json.

Segue a aula 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. Como converter string em objeto

Gson myGson = new GsonBuilder().setPrettyPrinting().create();
myGson.fromJson(jsonString, Person.class)
11. String JSON de impressão bonita

private static String pretty(String json) {
  JsonElement gson = new JsonParser().parse(json);
  return new GsonBuilder().setPrettyPrinting().serializeNulls().create().toJson(gson);
 }
}
12. API de streaming de leitura e gravação usando Gson

Este é um exemplo de leitura e gravação da API JSON Streaming. Usaremos as classes JsonReader, JsonToken e JsonWriter.

Temos três métodos, nosso método main(), um método readJSON() e o 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. Classe de utilitário Gson reutilizável completo

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

Categorized in: