Gson - Guia Rápido

Google Gson é uma biblioteca simples baseada em Java para serializar objetos Java para JSON e vice-versa. É uma biblioteca de código aberto desenvolvida pelo Google.

Os pontos a seguir destacam por que você deve usar esta biblioteca -

• Standardized - Gson é uma biblioteca padronizada gerenciada pelo Google.

• Efficient - É uma extensão confiável, rápida e eficiente da biblioteca padrão Java.

• Optimized - A biblioteca é altamente otimizada.

• Support Generics - Fornece amplo suporte para genéricos.

• Supports complex inner classes - Suporta objetos complexos com hierarquias de herança profundas.

Características do Gson

Aqui está uma lista de alguns dos recursos mais importantes do Gson -

• Easy to use - A API Gson fornece uma fachada de alto nível para simplificar os casos de uso comumente usados.

• No need to create mapping - Gson API fornece mapeamento padrão para a maioria dos objetos a serem serializados.

• Performance- Gson é bastante rápido e consome pouca memória. É adequado para sistemas ou gráficos de objetos grandes.

• Clean JSON - Gson cria um resultado JSON limpo e compacto que é fácil de ler.

• No Dependency - A biblioteca Gson não requer nenhuma outra biblioteca além do JDK.

• Open Source- A biblioteca Gson é de código aberto; está disponível gratuitamente.

Três maneiras de processar JSON

Gson fornece três maneiras alternativas de processar JSON -

API de streaming

Ele lê e grava conteúdo JSON como eventos discretos. JsonReader e JsonWriter ler / escrever os dados como token, referido como JsonToken.

É a abordagem mais poderosa entre as três abordagens para processar JSON. Tem a menor sobrecarga e é bastante rápido em operações de leitura / gravação. É análogo ao analisador Stax para XML.

Modelo de Árvore

Ele prepara uma representação em árvore na memória do documento JSON. Ele constrói uma árvore de nós JsonObject. É uma abordagem flexível e análoga ao analisador DOM para XML.

Ligação de dados

Ele converte JSON de e para POJO (Plain Old Java Object) usando o acessador de propriedade. Gson lê / grava JSON usando adaptadores de tipo de dados. É análogo ao analisador JAXB para XML.

Configuração de ambiente local

Se você ainda deseja configurar um ambiente local para a linguagem de programação Java, esta seção irá guiá-lo sobre como baixar e configurar o Java em sua máquina. Siga as etapas abaixo para configurar o ambiente.

Java SE está disponível gratuitamente no link Download Java . Então você baixa uma versão com base em seu sistema operacional.

Siga as instruções para baixar o Java e executar o .exepara instalar o Java em sua máquina. Depois de instalar o Java em sua máquina, você precisará definir as variáveis ​​de ambiente para apontar para seus diretórios de instalação corretos.

Configurando o caminho no Windows 2000 / XP

Supondo que você tenha instalado o Java no diretório c: \ Arquivos de programas \ java \ jdk -

• Clique com o botão direito em 'Meu Computador' e selecione 'Propriedades'.

• Clique no botão 'Variáveis ​​de ambiente' na guia 'Avançado'.

• Em seguida, altere a variável 'Path' para que também contenha o caminho para o executável Java. Por exemplo, se o caminho estiver definido atualmente para 'C: \ WINDOWS \ SYSTEM32', altere seu caminho para 'C: \ WINDOWS \ SYSTEM32; c: \ Arquivos de programas \ java \ jdk \ bin'.

Configurando o Caminho no Windows 95/98 / ME

Supondo que você tenha instalado o Java no diretório c: \ Arquivos de programas \ java \ jdk -

• Edite o arquivo 'C: \ autoexec.bat' e adicione a seguinte linha no final: 'SET PATH =% PATH%; C: \ Arquivos de programas \ java \ jdk \ bin'

Configurando o caminho para Linux, UNIX, Solaris, FreeBSD

A variável de ambiente PATHdeve ser definido para apontar para onde os binários Java foram instalados. Consulte a documentação do shell se tiver problemas para fazer isso.

Por exemplo, se você usar bash como seu shell, então você adicionaria a seguinte linha ao final de seu '.bashrc: export PATH = / path / to / java: $ PATH'

Editores Java populares

Para escrever seus programas Java, você precisará de um editor de texto. Existem alguns IDEs sofisticados disponíveis no mercado. Mas, por enquanto, você pode considerar um dos seguintes -

• Notepad - No Windows, você pode usar qualquer editor de texto simples como o Notepad (recomendado para este tutorial) ou TextPad.

• Netbeans - É um IDE Java de código aberto e gratuito que pode ser baixado de https://netbeans.org/index.html.

• Eclipse - Também é um IDE Java desenvolvido pela comunidade de código aberto Eclipse e pode ser baixado de https://www.eclipse.org/.

Baixar Arquivo Gson

Baixe a versão mais recente do arquivo jar Gson em gson-2.3.1.jar. No momento em que este tutorial foi escrito, baixamos gson-2.3.1.jar e o copiamos para a pasta C: \> gson.

SO	Nome do arquivo
janelas	gson-2.3.1.jar
Linux	gson-2.3.1.jar
Mac	gson-2.3.1.jar

Definir ambiente Gson

Colocou o GSON_HOME variável de ambiente para apontar para o local do diretório base onde o jar Gson está armazenado em sua máquina.

SO	Resultado
janelas	Defina a variável de ambiente GSON_HOME para C: \ gson
Linux	export GSON_HOME = / usr / local / gson
Mac	export GSON_HOME = / Library / gson

Definir variável CLASSPATH

Colocou o CLASSPATH variável de ambiente para apontar para o local do jar Gson.

SO	Resultado
janelas	Defina a variável de ambiente CLASSPATH como% CLASSPATH%;% GSON_HOME% \ gson-2.3.1.jar;.;
Linux	export CLASSPATH = $ CLASSPATH: $ GSON_HOME / gson-2.3.1.jar :.
Mac	export CLASSPATH = $ CLASSPATH: $ GSON_HOME / gson-2.3.1.jar :.

Antes de entrar nos detalhes da biblioteca Google Gson, vamos ver um aplicativo em ação. Neste exemplo, criamos umStudentclasse. Vamos criar uma string JSON com detalhes do aluno e desserializá-la parastudent objeto e serializá-lo em uma String JSON.

Exemplo

Crie um arquivo de classe Java denominado GsonTester em C: \> GSON_WORKSPACE.

File − GsonTester.java

import com.google.gson.Gson; 
import com.google.gson.GsonBuilder;  

public class GsonTester { 
   public static void main(String[] args) { 
      String jsonString = "{\"name\":\"Mahesh\", \"age\":21}"; 
      
      GsonBuilder builder = new GsonBuilder(); 
      builder.setPrettyPrinting(); 
      
      Gson gson = builder.create(); 
      Student student = gson.fromJson(jsonString, Student.class); 
      System.out.println(student);    
      
      jsonString = gson.toJson(student); 
      System.out.println(jsonString);  
   } 
} 

class Student { 
   private String name; 
   private int age; 
   public Student(){} 
   
   public String getName() { 
      return name; 
   }
   
   public void setName(String name) { 
      this.name = name; 
   } 
   
   public int getAge() { 
      return age; 
   }
   
   public void setAge(int age) { 
      this.age = age; 
   }
   
   public String toString() { 
      return "Student [ name: "+name+", age: "+ age+ " ]"; 
   }  
}

Verifique o resultado

Compile as classes usando javac compilador da seguinte forma -

C:\GSON_WORKSPACE>javac GsonTester.java

Agora execute o GsonTester para ver o resultado -

C:\GSON_WORKSPACE>java GsonTester

Verifique a saída.

Student [ name: Mahesh, age: 21 ] 
{ 
   "name" : "Mahesh", 
   "age" : 21 
}

Passos para lembrar

A seguir estão as etapas importantes a serem consideradas aqui.

Etapa 1 - Criar objeto Gson usando GsonBuilder

Crie um objeto Gson. É um objeto reutilizável.

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

Etapa 2 - desserializar JSON para objeto

Use o método fromJson () para obter o objeto do JSON. Passe a string Json / fonte da string Json e o tipo de objeto como parâmetro.

//Object to JSON Conversion 
Student student = gson.fromJson(jsonString, Student.class);

Etapa 3 - serializar objeto para JSON

Use o método toJson () para obter a representação da string JSON de um objeto.

//Object to JSON Conversion   
jsonString = gson.toJson(student);

Gson é a classe de ator principal da biblioteca Gson do Google. Ele fornece funcionalidades para converter objetos Java em construções JSON correspondentes e vice-versa. Gson é construído primeiro usando GsonBuilder e, em seguida, métodos toJson (Object) ou fromJson (String, Class) são usados ​​para ler / escrever construções JSON.

Declaração de Classe

A seguir está a declaração para com.google.gson.Gson classe -

public final class Gson 
   extends Object

Construtores

Sr. Não	Construtor e descrição
1	Gson() Constrói um objeto Gson com configuração padrão.

Métodos de aula

Sr. Não	Método e Descrição
1	<T> T fromJson(JsonElement json, Class<T> classOfT) Este método desserializa a leitura Json da árvore de análise especificada em um objeto do tipo especificado.
2	<T> T fromJson(JsonElement json, Type typeOfT) Este método desserializa a leitura Json da árvore de análise especificada em um objeto do tipo especificado.
3	<T> T fromJson(JsonReader reader, Type typeOfT) Lê o próximo valor JSON do leitor e o converte em um objeto do tipo typeOfT.
4	<T> T fromJson(Reader json, Class<T> classOfT) Este método desserializa a leitura Json do leitor especificado em um objeto da classe especificada.
5	<T> T fromJson(Reader json, Type typeOfT) Este método desserializa o Json lido do leitor especificado em um objeto do tipo especificado.
6	<T> T fromJson(String json, Class<T> classOfT) Este método desserializa o Json especificado em um objeto da classe especificada.
7	<T> T fromJson(String json, Type typeOfT) Este método desserializa o Json especificado em um objeto do tipo especificado.
8	<T> TypeAdapter<T> getAdapter(Class<T> type) Retorna o adaptador de tipo para tipo.
9	<T> TypeAdapter<T> getAdapter(TypeToken<T> type) Retorna o adaptador de tipo para tipo.
10	<T> TypeAdapter<T> getDelegateAdapter(TypeAdapterFactory skipPast, TypeToken<T> type) Este método é usado para obter um adaptador de tipo alternativo para o tipo especificado.
11	String toJson(JsonElement jsonElement) Converte uma árvore de JsonElements em sua representação JSON equivalente.
12	void toJson(JsonElement jsonElement, Appendable writer) Grava o JSON equivalente para uma árvore de JsonElements.
13	void toJson(JsonElement jsonElement, JsonWriter writer) Grava o JSON para jsonElement para o escritor.
14	String toJson(Object src) Este método serializa o objeto especificado em sua representação Json equivalente.
15	void toJson(Object src, Appendable writer) Este método serializa o objeto especificado em sua representação Json equivalente.
16	String toJson(Object src, Type typeOfSrc) Este método serializa o objeto especificado, incluindo aqueles de tipos genéricos, em sua representação Json equivalente.
17	void toJson(Object src, Type typeOfSrc, Appendable writer) Este método serializa o objeto especificado, incluindo aqueles de tipos genéricos, em sua representação Json equivalente.
18	void toJson(Object src, Type typeOfSrc, JsonWriter writer) Grava a representação JSON de src do tipo typeOfSrc para o gravador.
19	JsonElement toJsonTree(Object src) Este método serializa o objeto especificado em sua representação equivalente como uma árvore de JsonElements.
20	JsonElement toJsonTree(Object src, Type typeOfSrc) Este método serializa o objeto especificado, incluindo aqueles de tipos genéricos, em sua representação equivalente como uma árvore de JsonElements.
21	String toString()

Métodos herdados

Esta classe herda métodos da seguinte classe -

• java.lang.Object

Exemplo

Crie o seguinte programa Java usando qualquer editor de sua escolha e salve-o em, digamos, C: /> GSON_WORKSPACE

File − GsonTester.java

import com.google.gson.Gson; 
import com.google.gson.GsonBuilder;  

public class GsonTester { 
   public static void main(String[] args) { 
      String jsonString = "{\"name\":\"Mahesh\", \"age\":21}"; 
      
      GsonBuilder builder = new GsonBuilder(); 
      builder.setPrettyPrinting(); 
      
      Gson gson = builder.create(); 
      Student student = gson.fromJson(jsonString, Student.class); 
      System.out.println(student);    
      
      jsonString = gson.toJson(student); 
      System.out.println(jsonString);  
   } 
}  

class Student { 
   private String name; 
   private int age; 
   public Student(){} 
   
   public String getName() { 
      return name; 
   } 
   public void setName(String name) { 
      this.name = name; 
   } 
   public int getAge() { 
      return age;
   } 
   public void setAge(int age) { 
      this.age = age; 
   } 
   public String toString() { 
      return "Student [ name: "+name+", age: "+ age+ " ]"; 
   }  
}

Verifique o resultado

Compile as classes usando javac compilador da seguinte forma -

C:\GSON_WORKSPACE>javac GsonTester.java

Agora execute o GsonTester para ver o resultado -

C:\GSON_WORKSPACE>java GsonTester

Verifique a saída

Student [ name: Mahesh, age: 21 ] 
{ 
   "name" : "Mahesh", 
   "age" : 21 
}

Vamos serializar um objeto Java em um arquivo Json e, em seguida, ler esse arquivo Json para obter o objeto de volta. Neste exemplo, criamos umStudentclasse. Vamos criar umstudent.json arquivo que terá um json representação de Student objeto.

Exemplo

Crie um arquivo de classe Java chamado GsonTester dentro C:\>GSON_WORKSPACE.

Arquivo - GsonTester.java

import java.io.BufferedReader; 
import java.io.FileNotFoundException; 
import java.io.FileReader; 
import java.io.FileWriter; 
import java.io.IOException;  

import com.google.gson.Gson; 
import com.google.gson.GsonBuilder;  

public class GsonTester { 
   public static void main(String args[]) { 
   
      GsonTester tester = new GsonTester(); 
      try { 
         Student student = new Student(); 
         student.setAge(10); 
         student.setName("Mahesh"); 
         tester.writeJSON(student);  
         Student student1 = tester.readJSON(); 
         System.out.println(student1); 
      } 
      catch(FileNotFoundException e) { 
         e.printStackTrace(); 
      } 
      catch(IOException e) { 
         e.printStackTrace();
      } 
   } 
   
   private void writeJSON(Student student) throws IOException { 
      GsonBuilder builder = new GsonBuilder(); 
      Gson gson = builder.create(); 
      FileWriter writer = new FileWriter("student.json");   
      writer.write(gson.toJson(student));   
      writer.close(); 
   }  
   
   private Student readJSON() throws FileNotFoundException { 
      GsonBuilder builder = new GsonBuilder(); 
      Gson gson = builder.create(); 
      BufferedReader bufferedReader = new BufferedReader(
         new FileReader("student.json"));   
      
      Student student = gson.fromJson(bufferedReader, Student.class); 
      return student; 
   } 
} 

class Student { 
   private String name; 
   private int age; 
   public Student(){} 
   
   public String getName() { 
      return name; 
   } 
   
   public void setName(String name) { 
      this.name = name; 
   } 
   
   public int getAge() { 
      return age; 
   } 
   
   public void setAge(int age) { 
      this.age = age; 
   } 
   
   public String toString() { 
      return "Student [ name: "+name+", age: "+ age+ " ]";
   }  
}

Verifique o resultado

Compile as classes usando javac compilador da seguinte forma -

C:\GSON_WORKSPACE>javac GsonTester.java

Agora execute o GsonTester para ver o resultado -

C:\GSON_WORKSPACE>java GsonTester

Verifique a saída

Student [ name: Mahesh, age: 10 ]

A API Data Binding é usada para converter JSON para e de POJO (Plain Old Java Object) usando o acessador de propriedade ou usando anotações. É de dois tipos.

• Primitives Data Binding - Converte JSON para e de objetos Java Maps, Lists, Strings, Numbers, Booleans e NULL.

• Objects Data Binding - Converte JSON de e para qualquer tipo JAVA.

Gson lê / grava JSON para ambos os tipos de vinculação de dados. Data Binding é análogo ao analisador JAXB para XML.

Ligação de dados primitivos

A vinculação de dados primitivos refere-se ao mapeamento de JSON para tipos de dados JAVA Core e coleções embutidas. Gson fornece vários adaptadores embutidos que podem ser usados ​​para serializar / desserializar tipos de dados primitivos.

Exemplo

Vamos ver a vinculação de dados primitiva em ação. Aqui, mapearemos os tipos básicos JAVA diretamente para JSON e vice-versa.

Crie um arquivo de classe Java chamado GsonTester dentro C:\>Gson_WORKSPACE.

File − GsonTester.java

import java.util.Arrays; 
import com.google.gson.Gson;  

public class GsonTester { 
   public static void main(String args[]) { 
   
      Gson gson = new Gson();  
      String name = "Mahesh Kumar"; 
      long rollNo = 1; 
      boolean verified = false; 
      int[] marks = {100,90,85};  
      
      //Serialization 
      System.out.println("{"); 
      System.out.println("name: " + gson.toJson(name) +","); 
      System.out.println("rollNo: " + gson.toJson(rollNo) +","); 
      System.out.println("verified: " + gson.toJson(verified) +","); 
      System.out.println("marks:" + gson.toJson(marks)); 
      System.out.println("}");  
      
      //De-serialization 
      name = gson.fromJson("\"Mahesh Kumar\"", String.class); 
      rollNo = gson.fromJson("1", Long.class); 
      verified = gson.fromJson("false", Boolean.class); 
      marks = gson.fromJson("[100,90,85]", int[].class);  
      
      System.out.println("name: " + name); 
      System.out.println("rollNo: " + rollNo); 
      System.out.println("verified: " +verified); 
      System.out.println("marks:" + Arrays.toString(marks)); 
   } 
}

Verifique o resultado

Compile as classes usando javac compilador da seguinte forma -

C:\GSON_WORKSPACE>javac GsonTester.java

Agora execute o GsonTester para ver o resultado -

C:\GSON_WORKSPACE>java GsonTester

Verifique a saída.

{ 
   name: "Mahesh Kumar", 
   rollNo: 1, 
   verified: false, 
   marks:[100,90,85] 
} 

name: Mahesh Kumar 
rollNo: 1 
verified: false 
marks:[100, 90, 85]

A vinculação de dados do objeto se refere ao mapeamento de JSON para qualquer objeto JAVA.

//Create a Gson instance 
Gson gson = new Gson();  

//map Student object to JSON content 
String jsonString = gson.toJson(student);   

//map JSON content to Student object 
Student student1 = gson.fromJson(jsonString, Student.class);

Exemplo

Vamos ver a vinculação de dados do objeto em ação. Aqui, mapearemos o objeto JAVA diretamente para JSON e vice-versa.

Crie um arquivo de classe Java chamado GsonTester em C: \> GSON_WORKSPACE.

Arquivo - GsonTester.java

import com.google.gson.Gson;  

public class GsonTester { 
   public static void main(String args[]) { 
   
      Gson gson = new Gson(); 
      Student student = new Student(); 
      student.setAge(10); 
      student.setName("Mahesh"); 
      
      String jsonString = gson.toJson(student);          
      System.out.println(jsonString); 
      
      Student student1 = gson.fromJson(jsonString, Student.class); 
      System.out.println(student1); 
   }   
} 

class Student { 
   private String name; 
   private int age; 
   public Student(){} 
   
   public String getName() { 
      return name; 
   } 
   
   public void setName(String name) { 
      this.name = name; 
   } 
   
   public int getAge() { 
      return age; 
   } 
   
   public void setAge(int age) { 
      this.age = age; 
   } 
   
   public String toString() { 
      return "Student [ name: "+name+", age: "+ age+ " ]"; 
   }  
}

Verifique o resultado

Compile as classes usando javac compilador da seguinte forma -

C:\GSON_WORKSPACE>javac GsonTester.java

Agora execute o GsonTester para ver o resultado -

C:\GSON_WORKSPACE>java GsonTester

Verifique a saída.

{"name":"Mahesh","age":10} 
Student [ name: Mahesh, age: 10 ]

O modelo de árvore prepara uma representação em árvore na memória do documento JSON. Ele constrói uma árvore de nós JsonObject. É uma abordagem flexível e análoga ao analisador DOM para XML.

Criar árvore de JSON

JsonParser fornece um ponteiro para o nó raiz da árvore após a leitura do JSON. O nó raiz pode ser usado para percorrer a árvore completa. Considere o seguinte fragmento de código para obter o nó raiz de uma String JSON fornecida.

//Create an JsonParser instance 
JsonParser parser = new JsonParser(); 

String jsonString = 
"{\"name\":\"Mahesh Kumar\", \"age\":21,\"verified\":false,\"marks\": [100,90,85]}"; 

//create tree from JSON 
JsonElement rootNode = parser.parse(jsonString);

Modelo de árvore transversal

Obtenha cada nó usando o caminho relativo ao nó raiz enquanto atravessa a árvore e processa os dados. O trecho de código a seguir mostra como você pode atravessar uma árvore.

JsonObject details = rootNode.getAsJsonObject(); 

JsonElement nameNode = details.get("name"); 
System.out.println("Name: " +nameNode.getAsString()); 

JsonElement ageNode = details.get("age"); 
System.out.println("Age: " + ageNode.getAsInt());

Exemplo

Crie um arquivo de classe Java chamado GsonTester em C: \> GSON_WORKSPACE.

File − GsonTester.java

import com.google.gson.JsonArray; 
import com.google.gson.JsonElement; 
import com.google.gson.JsonObject; 
import com.google.gson.JsonParser;
import com.google.gson.JsonPrimitive;  

public class GsonTester { 
   public static void main(String args[]) { 
   
      String jsonString = 
         "{\"name\":\"Mahesh Kumar\", \"age\":21,\"verified\":false,\"marks\": [100,90,85]}";
      JsonParser parser = new JsonParser();  
      JsonElement rootNode = parser.parse(jsonString);  
      
      if (rootNode.isJsonObject()) { 
         JsonObject details = rootNode.getAsJsonObject();  
         JsonElement nameNode = details.get("name"); 
         System.out.println("Name: " +nameNode.getAsString());  
         
         JsonElement ageNode = details.get("age"); 
         System.out.println("Age: " + ageNode.getAsInt());  
         
         JsonElement verifiedNode = details.get("verified"); 
         System.out.println("Verified: " + (verifiedNode.getAsBoolean() ? "Yes":"No"));  
         JsonArray marks = details.getAsJsonArray("marks"); 
         
         for (int i = 0; i < marks.size(); i++) { 
            JsonPrimitive value = marks.get(i).getAsJsonPrimitive(); 
            System.out.print(value.getAsInt() + " ");  
         } 
      } 
   }   
}

Verifique o resultado

Compile as classes usando javac compilador da seguinte forma -

C:\GSON_WORKSPACE>javac GsonTester.java

Agora execute o GsonTester para ver o resultado -

C:\GSON_WORKSPACE>java GsonTester

Verifique a saída.

Name: Mahesh Kumar 
Age: 21 
Verified: No 
100 90 85

A API de streaming é usada para ler token JSON por token. Ele lê e grava conteúdo JSON como eventos discretos.JsonReader e JsonWriter ler / escrever os dados como token, referido como JsonToken.

É a abordagem mais poderosa entre as três abordagens para processar JSON. Tem a menor sobrecarga e é bastante rápido em operações de leitura / gravação. É análogo ao analisador Stax para XML.

Neste capítulo, mostraremos o uso de APIs de streaming GSON para ler dados JSON. A API de streaming funciona com o conceito de token e todos os detalhes do Json devem ser tratados com cuidado.

//create JsonReader object and pass it the json source or json text. 
JsonReader reader = new JsonReader(new StringReader(jsonString));  

//start reading json   
reader.beginObject(); 

//get the next token 
JsonToken token = reader.peek(); 

//check the type of the token 
if (token.equals(JsonToken.NAME)) {     
   //get the current token 
   fieldname = reader.nextName(); 
}

Exemplo

Vamos ver JsonReaderem ação. Crie um arquivo de classe Java chamadoGsonTester em C: \> GSON_WORKSPACE.

Arquivo - GsonTester.java

import java.io.IOException; 
import java.io.StringReader;  

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

public class GsonTester { 
   public static void main(String args[]) { 
   
      String jsonString = 
         "{\"name\":\"Mahesh Kumar\", \"age\":21,\"verified\":false,\"marks\": [100,90,85]}";  
      JsonReader reader = new JsonReader(new StringReader(jsonString));    
      try { 
         handleJsonObject(reader); 
      } 
      catch (IOException e) { 
         e.printStackTrace(); 
      } 
   } 
   
   private static void handleJsonObject(JsonReader reader) throws IOException { 
      reader.beginObject(); 
      String fieldname = null; 
      
      while (reader.hasNext()) { 
         JsonToken token = reader.peek(); 
         
         if (token.equals(JsonToken.BEGIN_ARRAY)) { 
            System.out.print("Marks [ "); 
            handleJsonArray(reader); 
            System.out.print("]"); 
         } else if (token.equals(JsonToken.END_OBJECT)) { 
            reader.endObject(); 
            return; 
         } else {            
            if (token.equals(JsonToken.NAME)) {     
               //get the current token 
               fieldname = reader.nextName(); 
            } 
            
            if ("name".equals(fieldname)) {       
               //move to next token 
               token = reader.peek(); 
               System.out.println("Name: "+reader.nextString());           
            } 
            
            if("age".equals(fieldname)) { 
               //move to next token 
               token = reader.peek(); 
               System.out.println("Age:" + reader.nextInt());       
            } 
            
            if("verified".equals(fieldname)) { 
               //move to next token 
               token = reader.peek(); 
               System.out.println("Verified:" + reader.nextBoolean());           
            }             
         } 
      } 
   }  
   
   private static void handleJsonArray(JsonReader reader) throws IOException { 
      reader.beginArray(); 
      String fieldname = null; 
      
      while (true) { 
         JsonToken token = reader.peek(); 
         
         if (token.equals(JsonToken.END_ARRAY)) { 
            reader.endArray(); 
            break; 
         } else if (token.equals(JsonToken.BEGIN_OBJECT)) { 
            handleJsonObject(reader); 
         } else if (token.equals(JsonToken.END_OBJECT)) { 
            reader.endObject(); 
         } else {            
            System.out.print(reader.nextInt() + " ");            
         } 
      } 
   } 
}

Verifique o resultado

Compile as classes usando javac compilador da seguinte forma -

C:\GSON_WORKSPACE>javac GsonTester.java

Agora execute o GsonTester para ver o resultado -

C:\GSON_WORKSPACE>java GsonTester

Verifique a saída.

Name: Mahesh Kumar 
Age:21 
Verified:false 
Marks [ 100 90 85 ]

Neste capítulo, discutiremos a serialização / desserialização de arrays, coleções e genéricos.

Exemplo de array

int[] marks = {100,90,85}; 
//Serialization 
System.out.println("marks:" + gson.toJson(marks));        

//De-serialization 
marks = gson.fromJson("[100,90,85]", int[].class); 
System.out.println("marks:" + Arrays.toString(marks));

Exemplo

Vamos ver a serialização / desserialização da matriz em ação. Crie um arquivo de classe Java chamadoGsonTester em C: \> GSON_WORKSPACE.

File − GsonTester.java

import java.util.Arrays; 
import com.google.gson.Gson;  

public class GsonTester { 
   public static void main(String args[]) { 
   
      Gson gson = new Gson(); 
      int[] marks = {100,90,85}; 
      String[] names = {"Ram","Shyam","Mohan"}; 
      
      //Serialization 
      System.out.print("{"); 
      System.out.print("marks:" + gson.toJson(marks) + ",");       
      System.out.print("names:" + gson.toJson(names));       
      System.out.println("}");  
      
      //De-serialization 
      marks = gson.fromJson("[100,90,85]", int[].class); 
      names = gson.fromJson("[\"Ram\",\"Shyam\",\"Mohan\"]", String[].class);
      System.out.println("marks:" + Arrays.toString(marks)); 
      System.out.println("names:" + Arrays.toString(names));     
   }      
}

Verifique o resultado

Compile as classes usando javac compilador da seguinte forma -

C:\GSON_WORKSPACE>javac GsonTester.java

Agora execute o GsonTester para ver o resultado -

C:\GSON_WORKSPACE>java GsonTester

Verifique a saída.

{marks:[100,90,85],names:["Ram","Shyam","Mohan"]} 
marks:[100, 90, 85] 
names:[Ram, Shyam, Mohan]

Exemplo de coleções

List marks = new ArrayList(); 
//Serialization 
System.out.println("marks:" + gson.toJson(marks));        

//De-serialization 
//get the type of the collection. 
Type listType = new TypeToken<list>(){}.getType(); 

//pass the type of collection 
marks = gson.fromJson("[100,90,85]", listType); 
System.out.println("marks:" +marks);</list>

Exemplo

Vamos ver a serialização / desserialização da coleção em ação. Crie um arquivo de classe Java chamadoGsonTester em C: \> GSON_WORKSPACE.

File − GsonTester.java

import java.lang.reflect.Type; 
import java.util.ArrayList; 
import java.util.Collection;  

import com.google.gson.Gson; 
import com.google.gson.reflect.TypeToken;  

public class GsonTester { 
   public static void main(String args[]) { 
   
      Gson gson = new Gson(); 
      Collection<Integer> marks = new ArrayList<Integer>();  
      marks.add(100); 
      marks.add(90); 
      marks.add(85);  
      
      //Serialization 
      System.out.print("{"); 
      System.out.print("marks:" + gson.toJson(marks));             
      System.out.println("}");  
      
      //De-serialization 
      Type listType = new TypeToken<Collection<Integer>>(){}.getType(); 
      marks = gson.fromJson("[100,90,85]", listType); 
      System.out.println("marks:" +marks);     
   }      
}

Verifique o resultado

Compile as classes usando javac compilador da seguinte forma -

C:\GSON_WORKSPACE>javac GsonTester.java

Agora execute o GsonTester para ver o resultado -

C:\GSON_WORKSPACE>java GsonTester

Verifique a saída.

{marks:[100,90,85]} 
marks:[100, 90, 85]

Exemplo Genérico

Gson usa a API de reflexão Java para obter o tipo de objeto para o qual um texto Json deve ser mapeado. Mas com os genéricos, essas informações são perdidas durante a serialização. Para combater esse problema, Gson oferece uma classecom.google.gson.reflect.TypeToken para armazenar o tipo do objeto genérico.

Exemplo

Vamos ver a serialização / desserialização de genéricos em ação. Crie um arquivo de classe Java chamadoGsonTester em C: \> GSON_WORKSPACE.

File − GsonTester.java

import java.lang.reflect.Type; 

import com.google.gson.Gson; 
import com.google.gson.reflect.TypeToken;  

public class GsonTester { 
   public static void main(String args[]) { 
   
      // create a shape class of type circle. 
      Shape<Circle> shape = new Shape<Circle>();  
      
      // Create a Circle object 
      Circle circle = new Circle(5.0);  
      
      //assign circle to shape 
      shape.setShape(circle);  
      Gson gson = new Gson(); 
      
      // Define a Type shapeType of type circle. 
      Type shapeType = new TypeToken<Shape<Circle>>() {}.getType();  
      
      //Serialize the json as ShapeType 
      String jsonString = gson.toJson(shape, shapeType); 
      System.out.println(jsonString);  
      Shape shape1 = gson.fromJson(jsonString, Shape.class); 
      
      System.out.println(shape1.get().getClass()); 
      System.out.println(shape1.get().toString()); 
      System.out.println(shape1.getArea());  
      Shape shape2 = gson.fromJson(jsonString, shapeType); 
      System.out.println(shape2.get().getClass()); 
      System.out.println(shape2.get().toString()); 
      System.out.println(shape2.getArea()); 
   }      
}  

class Shape <T> { 
   public T shape;  
   
   public void setShape(T shape) { 
      this.shape = shape; 
   }  
   public T get() { 
      return shape; 
   }  
   public double getArea() { 
      if(shape instanceof Circle) { 
         return ((Circle) shape).getArea(); 
      } else { 
         return 0.0; 
      } 
   } 
}  

class Circle { 
   private double radius;  
   
   public Circle(double radius){ 
      this.radius = radius; 
   }  
   public String toString() { 
      return "Circle"; 
   }  
   public double getRadius() { 
      return radius; 
   }  
   public void setRadius(double radius) { 
      this.radius = radius; 
   }  
   public double getArea() { 
      return (radius*radius*3.14); 
   } 
}

Verifique o resultado

Compile as classes usando javac compilador da seguinte forma -

C:\GSON_WORKSPACE>javac GsonTester.java

Agora execute o GsonTester para ver o resultado -

C:\GSON_WORKSPACE>java GsonTester

Verifique a saída.

{"shape":{"radius":5.0}} 
class com.google.gson.internal.LinkedTreeMap 
{radius = 5.0} 
0.0 
class Circle 
Circle 
78.5

Neste capítulo, explicaremos a serialização / desserialização de classes que possuem classes internas.

Exemplo de classe interna aninhada

Student student = new Student(); 
student.setRollNo(1); 
Student.Name name = student.new Name(); 
name.firstName = "Mahesh"; 
name.lastName = "Kumar"; 

student.setName(name); 
//serialize inner class object 
String nameString = gson.toJson(name); 
System.out.println(nameString); 

//deserialize inner class object   
name = gson.fromJson(nameString,Student.Name.class); 
System.out.println(name.getClass());

Exemplo

Vamos ver um exemplo de serialização / desserialização de classe com uma classe interna em ação. Crie um arquivo de classe Java chamadoGsonTester em C: \> GSON_WORKSPACE.

File − GsonTester.java

import com.google.gson.Gson;  

public class GsonTester { 
   public static void main(String args[]) { 
   
      Student student = new Student();  
      student.setRollNo(1); 
      Student.Name name = student.new Name(); 
      
      name.firstName = "Mahesh"; 
      name.lastName = "Kumar"; 
      student.setName(name); 
      Gson gson = new Gson(); 
      
      String jsonString = gson.toJson(student); 
      System.out.println(jsonString);  
      student = gson.fromJson(jsonString, Student.class);  
      
      System.out.println("Roll No: "+ student.getRollNo()); 
      System.out.println("First Name: "+ student.getName().firstName); 
      System.out.println("Last Name: "+ student.getName().lastName);  
      
      String nameString = gson.toJson(name); 
      System.out.println(nameString);  
      
      name = gson.fromJson(nameString,Student.Name.class); 
      System.out.println(name.getClass()); 
      System.out.println("First Name: "+ name.firstName); 
      System.out.println("Last Name: "+ name.lastName); 
   }      
}  

class Student { 
   private int rollNo; 
   private Name name;  
   
   public int getRollNo() { 
      return rollNo; 
   }
   
   public void setRollNo(int rollNo) { 
      this.rollNo = rollNo; 
   }  
   
   public Name getName() { 
      return name; 
   } 
   
   public void setName(Name name) { 
      this.name = name; 
   }
   
   class Name { 
      public String firstName; 
      public String lastName; 
   } 
}

Verifique o resultado

Compile as classes usando javac compilador da seguinte forma -

C:\GSON_WORKSPACE>javac GsonTester.java

Agora execute o GsonTester para ver o resultado -

C:\GSON_WORKSPACE>java GsonTester

Verifique a saída.

{"rollNo":1,"name":{"firstName":"Mahesh","lastName":"Kumar"}} 
Roll No: 1 
First Name: Mahesh 
Last Name: Kumar 

{"firstName":"Mahesh","lastName":"Kumar"} 
class Student$Name 
First Name: Mahesh 
Last Name: Kumar

Exemplo de classe interna estática aninhada

Student student = new Student(); 
student.setRollNo(1); 
Student.Name name = new Student.Name(); 

name.firstName = "Mahesh"; 
name.lastName = "Kumar"; 
student.setName(name); 

//serialize static inner class object 
String nameString = gson.toJson(name); 
System.out.println(nameString); 

//deserialize static inner class object   
name = gson.fromJson(nameString,Student.Name.class); 
System.out.println(name.getClass());

Exemplo

Vamos ver um exemplo de serialização / desserialização de classe com uma classe interna estática em ação. Crie um arquivo de classe Java denominado GsonTester em C: \> GSON_WORKSPACE.

File − GsonTester.java

import com.google.gson.Gson;  

public class GsonTester { 
   public static void main(String args[]) { 
   
      Student student = new Student();  
      student.setRollNo(1); 
      Student.Name name = new Student.Name(); 
      
      name.firstName = "Mahesh"; 
      name.lastName = "Kumar";  
      student.setName(name); 
      
      Gson gson = new Gson(); 
      String jsonString = gson.toJson(student); 
      System.out.println(jsonString);  
      student = gson.fromJson(jsonString, Student.class);  
      
      System.out.println("Roll No: "+ student.getRollNo()); 
      System.out.println("First Name: "+ student.getName().firstName); 
      System.out.println("Last Name: "+ student.getName().lastName);  
      String nameString = gson.toJson(name); 
      System.out.println(nameString);  
      
      name = gson.fromJson(nameString,Student.Name.class); 
      System.out.println(name.getClass()); 
      System.out.println("First Name: "+ name.firstName); 
      System.out.println("Last Name: "+ name.lastName); 
   }      
}  

class Student { 
   private int rollNo; 
   private Name name;  
   
   public int getRollNo() { 
      return rollNo; 
   }  
   
   public void setRollNo(int rollNo) { 
      this.rollNo = rollNo; 
   }  
   
   public Name getName() { 
      return name; 
   }  
   
   public void setName(Name name) { 
      this.name = name; 
   } 
   
   static class Name { 
      public String firstName; 
      public String lastName; 
   } 
}

Verifique o resultado

Compile as classes usando javac compilador da seguinte forma -

C:\GSON_WORKSPACE>javac GsonTester.java

Agora execute o GsonTester para ver o resultado -

C:\GSON_WORKSPACE>java GsonTester

Verifique a saída.

{"rollNo":1,"name":{"firstName":"Mahesh","lastName":"Kumar"}} 
Roll No: 1 
First Name: Mahesh 
Last Name: Kumar 

{"firstName":"Mahesh","lastName":"Kumar"} 
class Student$Name 
First Name: Mahesh 
Last Name: Kumar

Gson realiza a serialização / desserialização de objetos usando seus adaptadores embutidos. Ele também oferece suporte a adaptadores personalizados. Vamos discutir como você pode criar um adaptador personalizado e como usá-lo.

Crie um adaptador personalizado

Crie um adaptador personalizado estendendo o TypeAdapterclasse e passando a ela o tipo de objeto de destino. Substituir oread e write métodos para realizar a desserialização e serialização personalizadas, respectivamente.

class StudentAdapter extends TypeAdapter<Student> { 
   @Override 
   public Student read(JsonReader reader) throws IOException { 
      ... 
   } 
   
   @Override 
   public void write(JsonWriter writer, Student student) throws IOException { 
   } 
}

Registre o adaptador personalizado

Registre o adaptador personalizado usando GsonBuilder e crie uma instância Gson usando GsonBuilder.

GsonBuilder builder = new GsonBuilder(); 
builder.registerTypeAdapter(Student.class, new StudentAdapter()); 
Gson gson = builder.create();

Use o adaptador

O Gson agora usará o adaptador personalizado para converter texto Json em objeto e vice-versa.

String jsonString = "{\"name\":\"Mahesh\", \"rollNo\":1}"; 
Student student = gson.fromJson(jsonString, Student.class); 
System.out.println(student);  
jsonString = gson.toJson(student); 
System.out.println(jsonString);

Exemplo

Vamos ver um exemplo de adaptador de tipo personalizado em ação. Crie um arquivo de classe Java chamadoGsonTester em C: \> GSON_WORKSPACE.

File − GsonTester.java

import java.io.IOException;  

import com.google.gson.Gson; 
import com.google.gson.GsonBuilder; 
import com.google.gson.TypeAdapter; 
import com.google.gson.stream.JsonReader; 
import com.google.gson.stream.JsonToken; 
import com.google.gson.stream.JsonWriter;  

public class GsonTester { 
   public static void main(String args[]) { 
   
      GsonBuilder builder = new GsonBuilder(); 
      builder.registerTypeAdapter(Student.class, new StudentAdapter()); 
      builder.setPrettyPrinting(); 
      Gson gson = builder.create();  
      
      String jsonString = "{\"name\":\"Mahesh\", \"rollNo\":1}";  
      Student student = gson.fromJson(jsonString, Student.class); 
      System.out.println(student);  
      
      jsonString = gson.toJson(student); 
      System.out.println(jsonString);  
   }      
}  

class StudentAdapter extends TypeAdapter<Student> { 
   @Override 
   public Student read(JsonReader reader) throws IOException { 
      Student student = new Student(); 
      reader.beginObject(); 
      String fieldname = null; 
      
      while (reader.hasNext()) { 
         JsonToken token = reader.peek();            
         
         if (token.equals(JsonToken.NAME)) {     
            //get the current token 
            fieldname = reader.nextName(); 
         } 
         
         if ("name".equals(fieldname)) {       
            //move to next token 
            token = reader.peek(); 
            student.setName(reader.nextString()); 
         } 
         
         if("rollNo".equals(fieldname)) { 
            //move to next token 
            token = reader.peek(); 
            student.setRollNo(reader.nextInt()); 
         }               
      } 
      reader.endObject(); 
      return student; 
   }  
   
   @Override 
   public void write(JsonWriter writer, Student student) throws IOException { 
      writer.beginObject(); 
      writer.name("name"); 
      writer.value(student.getName()); 
      writer.name("rollNo"); 
      writer.value(student.getRollNo()); 
      writer.endObject(); 
   } 
}  

class Student { 
   private int rollNo; 
   private String name;  
   
   public int getRollNo() { 
      return rollNo; 
   } 
   
   public void setRollNo(int rollNo) { 
      this.rollNo = rollNo; 
   }  
   
   public String getName() { 
      return name; 
   }  
   
   public void setName(String name) { 
      this.name = name; 
   }   
   
   public String toString() { 
      return "Student[ name = "+name+", roll no: "+rollNo+ "]"; 
   } 
}

Verifique o resultado

Compile as classes usando javac compilador da seguinte forma -

C:\GSON_WORKSPACE>javac GsonTester.java

Agora execute o GsonTester para ver o resultado -

C:\GSON_WORKSPACE>java GsonTester

Verifique a saída.

Student[ name = Mahesh, roll no: 1] 
{ 
   "name": "Mahesh", 
   "rollNo": 1 
}

Gson por padrão gera conteúdo Json otimizado ignorando os valores NULL. Mas GsonBuilder fornece sinalizadores para mostrar valores NULL na saída Json usando oGsonBuilder.serializeNulls() método.

GsonBuilder builder = new GsonBuilder(); 
builder.serializeNulls(); 
Gson gson = builder.create();

Exemplo sem chamada serializeNulls

Crie um arquivo de classe Java chamado GsonTester em C: \> GSON_WORKSPACE.

Arquivo - GsonTester.java

import com.google.gson.Gson;  

public class GsonTester { 
   public static void main(String args[]) { 
   
      Gson gson = new Gson();  
      
      Student student = new Student(); 
      student.setRollNo(1);  
      String jsonString = gson.toJson(student); 
      
      System.out.println(jsonString);  
      student = gson.fromJson(jsonString, Student.class); 
      System.out.println(student); 
   }      
} 

class Student { 
   private int rollNo; 
   private String name;  
   
   public int getRollNo() { 
      return rollNo; 
   }  
   
   public void setRollNo(int rollNo) { 
      this.rollNo = rollNo; 
   } 
   
   public String getName() { 
      return name; 
   }  
   
   public void setName(String name) { 
      this.name = name; 
   } 
   
   public String toString() { 
      return "Student[ name = "+name+", roll no: "+rollNo+ "]"; 
   } 
}

Verifique o resultado

Compile as classes usando javac compilador da seguinte forma -

C:\GSON_WORKSPACE>javac GsonTester.java

Agora execute o GsonTester para ver o resultado -

C:\GSON_WORKSPACE>java GsonTester

Verifique a saída.

{"rollNo": 1} 
Student[ name = null, roll no: 1]

Exemplo com chamada serializeNulls

Crie um arquivo de classe Java denominado GsonTester em C: \> GSON_WORKSPACE.

Arquivo - GsonTester.java

import com.google.gson.Gson; 
import com.google.gson.GsonBuilder;  

public class GsonTester { 
   public static void main(String args[]) { 
   
      GsonBuilder builder = new GsonBuilder(); 
      builder.serializeNulls(); 
      builder.setPrettyPrinting(); 
      Gson gson = builder.create();  
      
      Student student = new Student(); 
      student.setRollNo(1);  
      String jsonString = gson.toJson(student); 
      
      System.out.println(jsonString);  
      student = gson.fromJson(jsonString, Student.class); 
      System.out.println(student); 
   }      
} 
class Student { 
   private int rollNo; 
   private String name;  
   
   public int getRollNo() { 
      return rollNo; 
   }  
   
   public void setRollNo(int rollNo) { 
      this.rollNo = rollNo; 
   }  
   
   public String getName() { 
      return name; 
   }  
   
   public void setName(String name) { 
      this.name = name; 
   } 
   
   public String toString() { 
      return "Student[ name = "+name+", roll no: "+rollNo+ "]"; 
   } 
}

Verifique o resultado

Compile as classes usando javac compilador da seguinte forma -

C:\GSON_WORKSPACE>javac GsonTester.java

Agora execute o GsonTester para ver o resultado -

C:\GSON_WORKSPACE>java GsonTester

Verifique a saída.

{ 
   "rollNo": 1, 
   "name": null 
} 
Student[ name = null, roll no: 1]

Gson fornece @Sinceanotação para controlar a serialização / desserialização Json de uma classe com base em suas várias versões. Considere a seguinte classe com suporte para controle de versão. Nesta aula, definimos inicialmente duas variáveisrollNo e name e mais tarde, adicionamos verifiedcomo uma nova variável. Usando @Since, definimosrollNo e name a partir da versão 1.0 e verificado para ser da versão 1.1.

class Student { 
   @Since(1.0) 
   private int rollNo; 
   
   @Since(1.0) 
   private String name; 
   
   @Since(1.1) 
   private boolean verified;  
}

GsonBuilder fornece o setVersion() método para serializar essa classe com controle de versão.

GsonBuilder builder = new GsonBuilder(); 
builder.setVersion(1.0);   
Gson gson = builder.create();

Exemplo

Vamos ver um exemplo de suporte a versionamento em ação. Crie um arquivo de classe Java chamadoGsonTester em C: \> GSON_WORKSPACE.

Arquivo - GsonTester.java

import com.google.gson.Gson; 
import com.google.gson.GsonBuilder; 
import com.google.gson.annotations.Since;  

public class GsonTester { 
   public static void main(String args[]) { 
   
      GsonBuilder builder = new GsonBuilder(); 
      builder.setVersion(1.0);   
      Gson gson = builder.create();
      
      Student student = new Student(); 
      student.setRollNo(1); 
      student.setName("Mahesh Kumar"); 
      student.setVerified(true);  
      
      String jsonString = gson.toJson(student); 
      System.out.println(jsonString);  
      
      gson = new Gson();     
      jsonString = gson.toJson(student); 
      System.out.println(jsonString); 
   }      
} 

class Student { 
   @Since(1.0) 
   private int rollNo; 
   
   @Since(1.0) 
   private String name; 
   
   @Since(1.1) 
   private boolean verified;   
   
   public int getRollNo() { 
      return rollNo; 
   }  
   
   public void setRollNo(int rollNo) { 
      this.rollNo = rollNo; 
   } 
   
   public String getName() { 
      return name; 
   } 
   
   public void setName(String name) { 
      this.name = name; 
   }
   
   public void setVerified(boolean verified) { 
      this.verified = verified; 
   }  
   
   public boolean isVerified() { 
      return verified; 
   } 
}

Verifique o resultado

Compile as classes usando javac compilador da seguinte forma -

C:\GSON_WORKSPACE>javac GsonTester.java

Agora execute o GsonTester para ver o resultado -

C:\GSON_WORKSPACE>java GsonTester

Verifique a saída.

{"rollNo":1,"name":"Mahesh Kumar"} 
{"rollNo":1,"name":"Mahesh Kumar","verified":true}

Por padrão, GSON exclui campos temporários e estáticos do processo de serialização / desserialização. Vamos dar uma olhada no exemplo a seguir.

Exemplo

Crie um arquivo de classe Java chamado GsonTester em C: \> GSON_WORKSPACE.

File − GsonTester.java

import com.google.gson.Gson; 
import com.google.gson.GsonBuilder;  

public class GsonTester { 
   public static void main(String args[]) { 
   
      GsonBuilder builder = new GsonBuilder();     
      Gson gson = builder.create();  
      
      Student student = new Student(); 
      student.setRollNo(1); 
      student.setName("Mahesh Kumar"); 
      student.setVerified(true); 
      student.setId(1); 
      student.className = "VI";  
      
      String jsonString = gson.toJson(student); 
      System.out.println(jsonString);    
   }      
} 

class Student { 
   private int rollNo; 
   private String name; 
   private boolean verified;  
   private transient int id; 
   public static String className;  
   
   public int getRollNo() {
      return rollNo; 
   }  
   
   public void setRollNo(int rollNo) { 
      this.rollNo = rollNo; 
   } 
   
   public String getName() { 
      return name; 
   } 
   
   public void setName(String name) { 
      this.name = name; 
   }  
   
   public void setVerified(boolean verified) { 
      this.verified = verified; 
   }  
   
   public boolean isVerified() { 
      return verified; 
   }  
   
   public int getId() { 
      return id; 
   } 
   
   public void setId(int id) { 
      this.id = id; 
   } 
}

Verifique o resultado

Compile as classes usando javac compilador da seguinte forma -

C:\GSON_WORKSPACE>javac GsonTester.java

Agora execute o GsonTester para ver o resultado -

C:\GSON_WORKSPACE>java GsonTester

Verifique a saída

{"rollNo":1,"name":"Mahesh Kumar","verified":true}

Usando excludeFieldsWithModifiers

GsonBuilder fornece controle sobre a exclusão de campos com um modificador específico usando o método excludeFieldsWithModifiers () do processo de serialização / desserialização. Veja o seguinte exemplo.

Exemplo

Crie um arquivo de classe Java denominado GsonTester em C: \> GSON_WORKSPACE.

File − GsonTester.java

import java.lang.reflect.Modifier; 

import com.google.gson.Gson; 
import com.google.gson.GsonBuilder;  

public class GsonTester { 
   public static void main(String args[]) { 
   
      GsonBuilder builder = new GsonBuilder(); 
      builder.excludeFieldsWithModifiers(Modifier.TRANSIENT);    
      Gson gson = builder.create();  
      
      Student student = new Student(); 
      student.setRollNo(1); 
      student.setName("Mahesh Kumar"); 
      student.setVerified(true); 
      student.setId(1); 
      student.className = "VI";  
      
      String jsonString = gson.toJson(student); 
      System.out.println(jsonString);    
   }      
} 

class Student { 
   private int rollNo; 
   private String name;
   private boolean verified;  
   private transient int id; 
   public static String className;  
   
   public int getRollNo() { 
      return rollNo; 
   }  
   
   public void setRollNo(int rollNo) { 
      this.rollNo = rollNo; 
   }  
   
   public String getName() { 
      return name; 
   }  
   
   public void setName(String name) { 
      this.name = name; 
   }  
   
   public void setVerified(boolean verified) { 
      this.verified = verified; 
   }  
   
   public boolean isVerified() { 
      return verified; 
   } 
   
   public int getId() { 
      return id; 
   } 
   
   public void setId(int id) { 
      this.id = id; 
   } 
}

Verifique o resultado

Compile as classes usando javac compilador da seguinte forma -

C:\GSON_WORKSPACE>javac GsonTester.java

Agora execute o GsonTester para ver o resultado -

C:\GSON_WORKSPACE>java GsonTester

Verifique a saída

{"rollNo":1,"name":"Mahesh Kumar","verified":true,"className":"VI"}

Usando a anotação @Expose

Gson fornece @Exposeanotação para controlar a serialização / desserialização Json de uma classe com base em seu escopo. Considere a seguinte classe com uma variável tendo@ExposeApoio, suporte. Nesta aula,name e rollnoas variáveis ​​devem ser expostas para serialização. Então nós usamos oGsonBuilder.excludeFieldsWithoutExposeAnnotation()método para indicar que apenas as variáveis ​​expostas devem ser serializadas / desserializadas. Veja o seguinte exemplo.

Exemplo

Crie um arquivo de classe Java chamado GsonTester em C: \> GSON_WORKSPACE.

File − GsonTester.java

import com.google.gson.Gson; 
import com.google.gson.GsonBuilder; 
import com.google.gson.annotations.Expose;  

public class GsonTester { 
   public static void main(String args[]) { 
   
      GsonBuilder builder = new GsonBuilder();     
      builder.excludeFieldsWithoutExposeAnnotation(); 
      Gson gson = builder.create();  
      
      Student student = new Student(); 
      student.setRollNo(1); 
      student.setName("Mahesh Kumar"); 
      student.setVerified(true); 
      student.setId(1); 
      student.className = "VI"; 
      
      String jsonString = gson.toJson(student); 
      System.out.println(jsonString);    
   }      
} 
class Student { 
   @Expose 
   private int rollNo; 
   
   @Expose 
   private String name; 
   private boolean verified;  
   private int id; 
   public static String className;  
   
   public int getRollNo() { 
      return rollNo; 
   }  
   public void setRollNo(int rollNo) { 
      this.rollNo = rollNo; 
   }  
   public String getName() { 
      return name; 
   }  
   public void setName(String name) { 
      this.name = name; 
   }  
   public void setVerified(boolean verified) { 
      this.verified = verified; 
   }  
   public boolean isVerified() { 
      return verified; 
   }  
   public int getId() { 
      return id; 
   }  
   public void setId(int id) { 
      this.id = id; 
   } 
}

Verifique o resultado

Compile as classes usando javac compilador da seguinte forma -

C:\GSON_WORKSPACE>javac GsonTester.java

Agora execute o GsonTester para ver o resultado -

C:\GSON_WORKSPACE>java GsonTester

Verifique a saída

{"rollNo":1,"name":"Mahesh Kumar"}