Gson - Guía rápida

Google Gson es una biblioteca simple basada en Java para serializar objetos Java en JSON y viceversa. Es una biblioteca de código abierto desarrollada por Google.

Los siguientes puntos destacan por qué debería utilizar esta biblioteca:

• Standardized - Gson es una biblioteca estandarizada administrada por Google.

• Efficient - Es una extensión confiable, rápida y eficiente de la biblioteca estándar de Java.

• Optimized - La biblioteca está altamente optimizada.

• Support Generics - Proporciona un amplio soporte para genéricos.

• Supports complex inner classes - Admite objetos complejos con jerarquías de herencia profundas.

Características de Gson

Aquí hay una lista de algunas de las características más destacadas de Gson:

• Easy to use - La API de Gson proporciona una fachada de alto nivel para simplificar los casos de uso de uso común.

• No need to create mapping - La API de Gson proporciona un mapeo predeterminado para la mayoría de los objetos que se serializarán.

• Performance- Gson es bastante rápido y ocupa poco espacio en la memoria. Es adecuado para sistemas o gráficos de objetos grandes.

• Clean JSON - Gson crea un resultado JSON limpio y compacto que es fácil de leer.

• No Dependency - La biblioteca Gson no requiere ninguna otra biblioteca aparte de JDK.

• Open Source- La biblioteca Gson es de código abierto; está disponible gratuitamente.

Tres formas de procesar JSON

Gson proporciona tres formas alternativas de procesar JSON:

API de transmisión

Lee y escribe contenido JSON como eventos discretos. JsonReader y JsonWriter leer / escribir los datos como token, denominado JsonToken.

Es el enfoque más poderoso entre los tres enfoques para procesar JSON. Tiene la sobrecarga más baja y es bastante rápido en operaciones de lectura / escritura. Es análogo al analizador Stax para XML.

Modelo de árbol

Prepara una representación de árbol en memoria del documento JSON. Construye un árbol de nodos JsonObject. Es un enfoque flexible y es análogo al analizador DOM para XML.

El enlace de datos

Convierte JSON hacia y desde POJO (Plain Old Java Object) mediante el acceso de propiedad. Gson lee / escribe JSON usando adaptadores de tipo de datos. Es análogo al analizador JAXB para XML.

Configuración del entorno local

Si aún desea configurar un entorno local para el lenguaje de programación Java, esta sección lo guiará sobre cómo descargar y configurar Java en su máquina. Siga los pasos que se indican a continuación para configurar el entorno.

Java SE está disponible gratuitamente desde el enlace Descargar Java . Entonces descargas una versión basada en tu sistema operativo.

Siga las instrucciones para descargar Java y ejecutar el .exepara instalar Java en su máquina. Una vez que haya instalado Java en su máquina, deberá configurar las variables de entorno para que apunten a sus directorios de instalación correctos.

Configuración de la ruta en Windows 2000 / XP

Suponiendo que haya instalado Java en el directorio c: \ Archivos de programa \ java \ jdk -

• Haga clic derecho en 'Mi PC' y seleccione 'Propiedades'.

• Haga clic en el botón 'Variables de entorno' en la pestaña 'Avanzado'.

• A continuación, modifique la variable 'Ruta' para que también contenga la ruta al ejecutable de Java. Por ejemplo, si la ruta está configurada actualmente en 'C: \ WINDOWS \ SYSTEM32', cambie su ruta para que lea 'C: \ WINDOWS \ SYSTEM32; c: \ Archivos de programa \ java \ jdk \ bin'.

Configuración de la ruta en Windows 95/98 / ME

Suponiendo que haya instalado Java en el directorio c: \ Archivos de programa \ java \ jdk -

• Edite el archivo 'C: \ autoexec.bat' y agregue la siguiente línea al final: 'SET PATH =% PATH%; C: \ Program Files \ java \ jdk \ bin'

Configuración de la ruta para Linux, UNIX, Solaris, FreeBSD

La variable de entorno PATHdebe establecerse para que apunte a donde se han instalado los binarios de Java. Consulte la documentación de su shell si tiene problemas para hacer esto.

Por ejemplo, si usa bash como su shell, entonces agregaría la siguiente línea al final de su '.bashrc: export PATH = / path / to / java: $ PATH'

Editores populares de Java

Para escribir sus programas Java, necesitará un editor de texto. Hay bastantes IDE sofisticados disponibles en el mercado. Pero por ahora, puede considerar uno de los siguientes:

• Notepad - En Windows, puede usar cualquier editor de texto simple como el Bloc de notas (recomendado para este tutorial) o TextPad.

• Netbeans - Es un IDE de Java que es de código abierto y gratuito que se puede descargar desde https://netbeans.org/index.html.

• Eclipse - También es un IDE de Java desarrollado por la comunidad de código abierto Eclipse y se puede descargar desde https://www.eclipse.org/.

Descarga Gson Archive

Descargue la última versión del archivo jar de Gson de gson-2.3.1.jar. En el momento de escribir este tutorial, descargamos gson-2.3.1.jar y lo copiamos en la carpeta C: \> gson.

SO	Nombre de archivo
Ventanas	gson-2.3.1.jar
Linux	gson-2.3.1.jar
Mac	gson-2.3.1.jar

Establecer entorno Gson

Selecciona el GSON_HOME variable de entorno para apuntar a la ubicación del directorio base donde se almacena Gson jar en su máquina.

SO	Salida
Ventanas	Establezca la variable de entorno GSON_HOME en C: \ gson
Linux	exportar GSON_HOME = / usr / local / gson
Mac	exportar GSON_HOME = / Library / gson

Establecer la variable CLASSPATH

Selecciona el CLASSPATH variable de entorno para apuntar a la ubicación del jar de Gson.

SO	Salida
Ventanas	Establezca la variable de entorno CLASSPATH en% 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 en los detalles de la biblioteca de Google Gson, veamos una aplicación en acción. En este ejemplo, hemos creado unStudentclase. Crearemos una cadena JSON con los detalles del estudiante y la deserializaremos parastudent objeto y luego serialícelo en una cadena JSON.

Ejemplo

Cree un archivo de clase Java llamado GsonTester en 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+ " ]"; 
   }  
}

Verifica el resultado

Compila las clases usando javac compilador de la siguiente manera:

C:\GSON_WORKSPACE>javac GsonTester.java

Ahora ejecute GsonTester para ver el resultado:

C:\GSON_WORKSPACE>java GsonTester

Verifique la salida.

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

Pasos para recordar

Los siguientes son los pasos importantes que se deben considerar aquí.

Paso 1: crea un objeto Gson usando GsonBuilder

Crea un objeto Gson. Es un objeto reutilizable.

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

Paso 2: deserializar JSON en un objeto

Utilice el método fromJson () para obtener el objeto del JSON. Pase la cadena Json / fuente de la cadena Json y el tipo de objeto como parámetro.

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

Paso 3: serializar el objeto en JSON

Utilice el método toJson () para obtener la representación de cadena JSON de un objeto.

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

Gson es la clase de actor principal de la biblioteca de Google Gson. Proporciona funcionalidades para convertir objetos Java en construcciones JSON coincidentes y viceversa. Gson se construye primero usando GsonBuilder y luego, los métodos toJson (Object) o fromJson (String, Class) se usan para leer / escribir construcciones JSON.

Declaración de clase

A continuación se muestra la declaración de com.google.gson.Gson clase -

public final class Gson 
   extends Object

Constructores

No Señor	Constructor y descripción
1	Gson() Construye un objeto Gson con la configuración predeterminada.

Métodos de clase

No Señor	Método y descripción
1	<T> T fromJson(JsonElement json, Class<T> classOfT) Este método deserializa la lectura de Json del árbol de análisis especificado en un objeto del tipo especificado.
2	<T> T fromJson(JsonElement json, Type typeOfT) Este método deserializa la lectura de Json del árbol de análisis especificado en un objeto del tipo especificado.
3	<T> T fromJson(JsonReader reader, Type typeOfT) Lee el siguiente valor JSON del lector y lo convierte en un objeto de tipo typeOfT.
4	<T> T fromJson(Reader json, Class<T> classOfT) Este método deserializa la lectura de Json del lector especificado en un objeto de la clase especificada.
5	<T> T fromJson(Reader json, Type typeOfT) Este método deserializa la lectura de Json del lector especificado en un objeto del tipo especificado.
6	<T> T fromJson(String json, Class<T> classOfT) Este método deserializa el Json especificado en un objeto de la clase especificada.
7	<T> T fromJson(String json, Type typeOfT) Este método deserializa el Json especificado en un objeto del tipo especificado.
8	<T> TypeAdapter<T> getAdapter(Class<T> type) Devuelve el adaptador de tipo para el tipo.
9	<T> TypeAdapter<T> getAdapter(TypeToken<T> type) Devuelve el adaptador de tipo para el tipo.
10	<T> TypeAdapter<T> getDelegateAdapter(TypeAdapterFactory skipPast, TypeToken<T> type) Este método se utiliza para obtener un adaptador de tipo alternativo para el tipo especificado.
11	String toJson(JsonElement jsonElement) Convierte un árbol de JsonElements en su representación JSON equivalente.
12	void toJson(JsonElement jsonElement, Appendable writer) Escribe el JSON equivalente para un árbol de JsonElements.
13	void toJson(JsonElement jsonElement, JsonWriter writer) Escribe el JSON para jsonElement en el escritor.
14	String toJson(Object src) Este método serializa el objeto especificado en su representación Json equivalente.
15	void toJson(Object src, Appendable writer) Este método serializa el objeto especificado en su representación Json equivalente.
dieciséis	String toJson(Object src, Type typeOfSrc) Este método serializa el objeto especificado, incluidos los de tipos genéricos, en su representación Json equivalente.
17	void toJson(Object src, Type typeOfSrc, Appendable writer) Este método serializa el objeto especificado, incluidos los de tipos genéricos, en su representación Json equivalente.
18	void toJson(Object src, Type typeOfSrc, JsonWriter writer) Escribe la representación JSON de src de tipo typeOfSrc en el escritor.
19	JsonElement toJsonTree(Object src) Este método serializa el objeto especificado en su representación equivalente como un árbol de JsonElements.
20	JsonElement toJsonTree(Object src, Type typeOfSrc) Este método serializa el objeto especificado, incluidos los de tipos genéricos, en su representación equivalente como un árbol de JsonElements.
21	String toString()

Métodos heredados

Esta clase hereda métodos de la siguiente clase:

• java.lang.Object

Ejemplo

Cree el siguiente programa Java utilizando cualquier editor de su elección y guárdelo en, 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+ " ]"; 
   }  
}

Verifica el resultado

Compila las clases usando javac compilador de la siguiente manera:

C:\GSON_WORKSPACE>javac GsonTester.java

Ahora ejecute GsonTester para ver el resultado:

C:\GSON_WORKSPACE>java GsonTester

Verificar la salida

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

Serialicemos un objeto Java en un archivo Json y luego leamos ese archivo Json para recuperar el objeto. En este ejemplo, hemos creado unStudentclase. Crearemos unstudent.json archivo que tendrá un json representacion de Student objeto.

Ejemplo

Cree un archivo de clase Java llamado GsonTester en C:\>GSON_WORKSPACE.

Archivo - 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+ " ]";
   }  
}

Verifica el resultado

Compila las clases usando javac compilador de la siguiente manera:

C:\GSON_WORKSPACE>javac GsonTester.java

Ahora ejecute GsonTester para ver el resultado:

C:\GSON_WORKSPACE>java GsonTester

Verificar la salida

Student [ name: Mahesh, age: 10 ]

La API de enlace de datos se utiliza para convertir JSON hacia y desde POJO (Objeto Java antiguo simple) mediante el acceso de propiedad o mediante anotaciones. Es de dos tipos.

• Primitives Data Binding - Convierte JSON hacia y desde Java Maps, Lists, Strings, Numbers, Booleanos y objetos NULL.

• Objects Data Binding - Convierte JSON hacia y desde cualquier tipo de JAVA.

Gson lee / escribe JSON para ambos tipos de enlaces de datos. El enlace de datos es análogo al analizador JAXB para XML.

Enlace de datos primitivos

El enlace de datos primitivos se refiere al mapeo de JSON a tipos de datos JAVA Core y colecciones incorporadas. Gson proporciona varios adaptadores incorporados que se pueden usar para serializar / deserializar tipos de datos primitivos.

Ejemplo

Veamos el enlace de datos primitivos en acción. Aquí asignaremos los tipos básicos de JAVA directamente a JSON y viceversa.

Cree un archivo de clase Java llamado GsonTester en 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)); 
   } 
}

Verifica el resultado

Compila las clases usando javac compilador de la siguiente manera:

C:\GSON_WORKSPACE>javac GsonTester.java

Ahora ejecuta el GsonTester para ver el resultado -

C:\GSON_WORKSPACE>java GsonTester

Verifique la salida.

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

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

El enlace de datos de objetos se refiere al mapeo de JSON a cualquier 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);

Ejemplo

Veamos el enlace de datos de objetos en acción. Aquí asignaremos el objeto JAVA directamente a JSON y viceversa.

Cree un archivo de clase Java llamado GsonTester en C: \> GSON_WORKSPACE.

Archivo - 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+ " ]"; 
   }  
}

Verifica el resultado

Compila las clases usando javac compilador de la siguiente manera:

C:\GSON_WORKSPACE>javac GsonTester.java

Ahora ejecuta el GsonTester para ver el resultado -

C:\GSON_WORKSPACE>java GsonTester

Verifique la salida.

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

Tree Model prepara una representación de árbol en memoria del documento JSON. Construye un árbol de nodos JsonObject. Es un enfoque flexible y es análogo al analizador DOM para XML.

Crear árbol desde JSON

JsonParser proporciona un puntero al nodo raíz del árbol después de leer el JSON. El nodo raíz se puede utilizar para recorrer el árbol completo. Considere el siguiente fragmento de código para obtener el nodo raíz de una cadena JSON proporcionada.

//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 árbol transversal

Obtenga cada nodo usando la ruta relativa al nodo raíz mientras atraviesa el árbol y procesa los datos. El siguiente fragmento de código muestra cómo atravesar un árbol.

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

Ejemplo

Cree un archivo de clase Java llamado GsonTester en 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() + " ");  
         } 
      } 
   }   
}

Verifica el resultado

Compila las clases usando javac compilador de la siguiente manera:

C:\GSON_WORKSPACE>javac GsonTester.java

Ahora ejecuta el GsonTester para ver el resultado -

C:\GSON_WORKSPACE>java GsonTester

Verifique la salida.

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

La API de transmisión se utiliza para leer token JSON por token. Lee y escribe contenido JSON como eventos discretos.JsonReader y JsonWriter leer / escribir los datos como token, denominado JsonToken.

Es el enfoque más poderoso entre los tres enfoques para procesar JSON. Tiene la sobrecarga más baja y es bastante rápido en operaciones de lectura / escritura. Es análogo al analizador Stax para XML.

En este capítulo, mostraremos el uso de las API de transmisión GSON para leer datos JSON. La API de transmisión funciona con el concepto de token y todos los detalles de Json deben manejarse con 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(); 
}

Ejemplo

Veamos JsonReaderen acción. Cree un archivo de clase Java llamadoGsonTester en C: \> GSON_WORKSPACE.

Archivo - 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() + " ");            
         } 
      } 
   } 
}

Verifica el resultado

Compila las clases usando javac compilador de la siguiente manera:

C:\GSON_WORKSPACE>javac GsonTester.java

Ahora ejecuta el GsonTester para ver el resultado -

C:\GSON_WORKSPACE>java GsonTester

Verifique la salida.

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

En este capítulo, discutiremos la serialización / deserialización de matrices, colecciones y genéricos.

Ejemplo de matriz

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

Ejemplo

Veamos la serialización / deserialización de matrices en acción. Cree un archivo de clase Java llamadoGsonTester en 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));     
   }      
}

Verifica el resultado

Compila las clases usando javac compilador de la siguiente manera:

C:\GSON_WORKSPACE>javac GsonTester.java

Ahora ejecute GsonTester para ver el resultado:

C:\GSON_WORKSPACE>java GsonTester

Verifique la salida.

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

Ejemplo de colecciones

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>

Ejemplo

Veamos la serialización / deserialización de colecciones en acción. Cree un archivo de clase Java llamadoGsonTester en 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);     
   }      
}

Verifica el resultado

Compila las clases usando javac compilador de la siguiente manera:

C:\GSON_WORKSPACE>javac GsonTester.java

Ahora ejecuta el GsonTester para ver el resultado -

C:\GSON_WORKSPACE>java GsonTester

Verifique la salida.

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

Ejemplo de genéricos

Gson utiliza la API de reflexión de Java para obtener el tipo de objeto al que se asignará un texto Json. Pero con los genéricos, esta información se pierde durante la serialización. Para contrarrestar este problema, Gson ofrece una clasecom.google.gson.reflect.TypeToken para almacenar el tipo de objeto genérico.

Ejemplo

Veamos la serialización / deserialización de Generics en acción. Cree un archivo de clase Java llamadoGsonTester en 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); 
   } 
}

Verifica el resultado

Compila las clases usando javac compilador de la siguiente manera:

C:\GSON_WORKSPACE>javac GsonTester.java

Ahora ejecuta el GsonTester para ver el resultado -

C:\GSON_WORKSPACE>java GsonTester

Verifique la salida.

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

En este capítulo, explicaremos la serialización / deserialización de clases que tienen clases internas.

Ejemplo de clase interna anidada

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

Ejemplo

Veamos un ejemplo de serialización / deserialización de una clase con una clase interna en acción. Cree un archivo de clase Java llamadoGsonTester en 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; 
   } 
}

Verifica el resultado

Compila las clases usando javac compilador de la siguiente manera:

C:\GSON_WORKSPACE>javac GsonTester.java

Ahora ejecute GsonTester para ver el resultado:

C:\GSON_WORKSPACE>java GsonTester

Verifique la salida.

{"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

Ejemplo de clase interna estática anidada

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

Ejemplo

Veamos un ejemplo de serialización / deserialización de una clase con una clase interna estática en acción. Cree un archivo de clase Java llamado GsonTester en 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; 
   } 
}

Verifica el resultado

Compila las clases usando javac compilador de la siguiente manera:

C:\GSON_WORKSPACE>javac GsonTester.java

Ahora ejecuta el GsonTester para ver el resultado -

C:\GSON_WORKSPACE>java GsonTester

Verifique la salida.

{"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 la serialización / deserialización de objetos utilizando sus adaptadores incorporados. También admite adaptadores personalizados. Analicemos cómo puede crear un adaptador personalizado y cómo puede usarlo.

Crear un adaptador personalizado

Cree un adaptador personalizado ampliando el TypeAdapterclass y pasándole el tipo de objeto objetivo. Anular elread y write métodos para realizar deserialización y serialización 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 { 
   } 
}

Registrar el adaptador personalizado

Registre el adaptador personalizado usando GsonBuilder y cree una instancia de Gson usando GsonBuilder.

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

Utilice el adaptador

Gson ahora usará el adaptador personalizado para convertir texto Json en objeto y viceversa.

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

Ejemplo

Veamos un ejemplo de adaptador de tipo personalizado en acción. Cree un archivo de clase Java llamadoGsonTester en 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+ "]"; 
   } 
}

Verifica el resultado

Compila las clases usando javac compilador de la siguiente manera:

C:\GSON_WORKSPACE>javac GsonTester.java

Ahora ejecuta el GsonTester para ver el resultado -

C:\GSON_WORKSPACE>java GsonTester

Verifique la salida.

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

De forma predeterminada, Gson genera contenido Json optimizado ignorando los valores NULL. Pero GsonBuilder proporciona indicadores para mostrar valores NULL en la salida de Json usando elGsonBuilder.serializeNulls() método.

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

Ejemplo sin llamada serializeNulls

Cree un archivo de clase Java llamado GsonTester en C: \> GSON_WORKSPACE.

Archivo - 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+ "]"; 
   } 
}

Verifica el resultado

Compila las clases usando javac compilador de la siguiente manera:

C:\GSON_WORKSPACE>javac GsonTester.java

Ahora ejecute GsonTester para ver el resultado:

C:\GSON_WORKSPACE>java GsonTester

Verifique la salida.

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

Ejemplo con llamada serializeNulls

Cree un archivo de clase Java llamado GsonTester en C: \> GSON_WORKSPACE.

Archivo - 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+ "]"; 
   } 
}

Verifica el resultado

Compila las clases usando javac compilador de la siguiente manera:

C:\GSON_WORKSPACE>javac GsonTester.java

Ahora ejecuta el GsonTester para ver el resultado -

C:\GSON_WORKSPACE>java GsonTester

Verifique la salida.

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

Gson proporciona @Sinceanotación para controlar la serialización / deserialización de Json de una clase en función de sus diversas versiones. Considere la siguiente clase con soporte de versiones. En esta clase, inicialmente hemos definido dos variablesrollNo y name y luego agregamos verifiedcomo una nueva variable. Usando @Desde, hemos definidorollNo y name a partir de la versión 1.0 y verificado que es de la versión 1.1.

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

GsonBuilder proporciona setVersion() método para serializar dicha clase versionada.

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

Ejemplo

Veamos un ejemplo de soporte de versiones en acción. Cree un archivo de clase Java llamadoGsonTester en C: \> GSON_WORKSPACE.

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

Verifica el resultado

Compila las clases usando javac compilador de la siguiente manera:

C:\GSON_WORKSPACE>javac GsonTester.java

Ahora ejecute GsonTester para ver el resultado:

C:\GSON_WORKSPACE>java GsonTester

Verifique la salida.

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

De forma predeterminada, GSON excluye los campos estáticos y transitorios del proceso de serialización / deserialización. Echemos un vistazo al siguiente ejemplo.

Ejemplo

Cree un archivo de clase Java llamado GsonTester en 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; 
   } 
}

Verifica el resultado

Compila las clases usando javac compilador de la siguiente manera:

C:\GSON_WORKSPACE>javac GsonTester.java

Ahora ejecuta el GsonTester para ver el resultado -

C:\GSON_WORKSPACE>java GsonTester

Verificar la salida

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

Uso de excludeFieldsWithModifiers

GsonBuilder proporciona control sobre la exclusión de campos con un modificador particular utilizando el método excludeFieldsWithModifiers () del proceso de serialización / deserialización. Vea el siguiente ejemplo.

Ejemplo

Cree un archivo de clase Java llamado GsonTester en 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; 
   } 
}

Verifica el resultado

Compila las clases usando javac compilador de la siguiente manera:

C:\GSON_WORKSPACE>javac GsonTester.java

Ahora ejecuta el GsonTester para ver el resultado -

C:\GSON_WORKSPACE>java GsonTester

Verificar la salida

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

Uso de la anotación @Expose

Gson proporciona @Exposeanotación para controlar la serialización / deserialización de Json de una clase en función de su alcance. Considere la siguiente clase con una variable que tiene@Exposeapoyo. En esta clase,name y rollnolas variables deben exponerse para su serialización. Entonces usamos elGsonBuilder.excludeFieldsWithoutExposeAnnotation()método para indicar que solo las variables expuestas deben ser serializadas / deserializadas. Vea el siguiente ejemplo.

Ejemplo

Cree un archivo de clase Java llamado GsonTester en 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; 
   } 
}

Verifica el resultado

Compila las clases usando javac compilador de la siguiente manera:

C:\GSON_WORKSPACE>javac GsonTester.java

Ahora ejecuta el GsonTester para ver el resultado -

C:\GSON_WORKSPACE>java GsonTester

Verificar la salida

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