Gson - Guida rapida

Google Gson è una semplice libreria basata su Java per serializzare oggetti Java in JSON e viceversa. È una libreria open source sviluppata da Google.

I seguenti punti evidenziano il motivo per cui dovresti utilizzare questa libreria:

• Standardized - Gson è una libreria standardizzata gestita da Google.

• Efficient - È un'estensione affidabile, veloce ed efficiente della libreria standard Java.

• Optimized - La libreria è altamente ottimizzata.

• Support Generics - Fornisce un ampio supporto per i generici.

• Supports complex inner classes - Supporta oggetti complessi con gerarchie di ereditarietà profonde.

Caratteristiche di Gson

Ecco un elenco di alcune delle caratteristiche più importanti di Gson:

• Easy to use - Gson API fornisce una facciata di alto livello per semplificare i casi d'uso comunemente usati.

• No need to create mapping - Gson API fornisce la mappatura predefinita per la maggior parte degli oggetti da serializzare.

• Performance- Gson è abbastanza veloce e ha un ingombro di memoria ridotto. È adatto per sistemi o grafici a oggetti di grandi dimensioni.

• Clean JSON - Gson crea un risultato JSON pulito e compatto che è facile da leggere.

• No Dependency - La libreria Gson non richiede altre librerie oltre a JDK.

• Open Source- La libreria Gson è open source; è disponibile gratuitamente.

Tre modi di elaborazione di JSON

Gson offre tre modi alternativi per elaborare JSON:

Streaming API

Legge e scrive contenuto JSON come eventi discreti. JsonReader e JsonWriter leggere / scrivere i dati come token, denominato JsonToken.

È l'approccio più potente tra i tre approcci per elaborare JSON. Ha l'overhead più basso ed è abbastanza veloce nelle operazioni di lettura / scrittura. È analogo al parser Stax per XML.

Modello di albero

Prepara una rappresentazione ad albero in memoria del documento JSON. Costruisce un albero di nodi JsonObject. È un approccio flessibile ed è analogo al parser DOM per XML.

Associazione dati

Converte JSON in e da POJO (Plain Old Java Object) utilizzando la funzione di accesso alle proprietà. Gson legge / scrive JSON utilizzando adattatori del tipo di dati. È analogo al parser JAXB per XML.

Configurazione dell'ambiente locale

Se desideri ancora configurare un ambiente locale per il linguaggio di programmazione Java, questa sezione ti guiderà su come scaricare e configurare Java sulla tua macchina. Si prega di seguire i passaggi indicati di seguito, per configurare l'ambiente.

Java SE è disponibile gratuitamente dal collegamento Scarica Java . Quindi scarichi una versione basata sul tuo sistema operativo.

Segui le istruzioni per scaricare Java ed eseguire il file .exeper installare Java sulla tua macchina. Dopo aver installato Java sulla macchina, è necessario impostare le variabili di ambiente in modo che puntino alle directory di installazione corrette.

Impostazione del percorso in Windows 2000 / XP

Supponendo che tu abbia installato Java nella directory c: \ Program Files \ java \ jdk -

• Fare clic con il tasto destro del mouse su "Risorse del computer" e selezionare "Proprietà".

• Fare clic sul pulsante "Variabili d'ambiente" nella scheda "Avanzate".

• Successivamente, modifica la variabile "Path" in modo che contenga anche il percorso dell'eseguibile Java. Ad esempio, se il percorso è attualmente impostato su "C: \ WINDOWS \ SYSTEM32", modificare il percorso in "C: \ WINDOWS \ SYSTEM32; c: \ Program Files \ java \ jdk \ bin".

Impostazione del percorso in Windows 95/98 / ME

Supponendo che tu abbia installato Java nella directory c: \ Program Files \ java \ jdk -

• Modifica il file "C: \ autoexec.bat" e aggiungi la seguente riga alla fine: "SET PATH =% PATH%; C: \ Program Files \ java \ jdk \ bin"

Configurazione del percorso per Linux, UNIX, Solaris, FreeBSD

La variabile d'ambiente PATHdovrebbe essere impostato in modo che punti a dove sono stati installati i binari Java. Fare riferimento alla documentazione della shell se si hanno problemi a farlo.

Ad esempio, se usi bash come shell, aggiungi la seguente riga alla fine di '.bashrc: export PATH = / path / to / java: $ PATH'

Editor Java popolari

Per scrivere i tuoi programmi Java, avrai bisogno di un editor di testo. Ci sono alcuni IDE sofisticati disponibili sul mercato. Ma per ora, puoi considerare uno dei seguenti:

• Notepad - Su Windows, puoi utilizzare qualsiasi semplice editor di testo come Blocco note (consigliato per questo tutorial) o TextPad.

• Netbeans - È un IDE Java open-source e gratuito da cui è possibile scaricare https://netbeans.org/index.html.

• Eclipse - È anche un IDE Java sviluppato dalla comunità open source di Eclipse e può essere scaricato da https://www.eclipse.org/.

Scarica Gson Archive

Scarica l'ultima versione del file jar Gson da gson-2.3.1.jar. Al momento della stesura di questo tutorial, abbiamo scaricato gson-2.3.1.jar e lo abbiamo copiato nella cartella C: \> gson.

OS	Nome dell'archivio
finestre	gson-2.3.1.jar
Linux	gson-2.3.1.jar
Mac	gson-2.3.1.jar

Imposta l'ambiente Gson

Impostare il GSON_HOME variabile di ambiente in modo che punti alla posizione della directory di base in cui è archiviato il jar Gson sulla macchina.

OS	Produzione
finestre	Imposta la variabile d'ambiente GSON_HOME su C: \ gson
Linux	esporta GSON_HOME = / usr / local / gson
Mac	export GSON_HOME = / Library / gson

Imposta la variabile CLASSPATH

Impostare il CLASSPATH variabile di ambiente in modo che punti alla posizione del jar Gson.

OS	Produzione
finestre	Imposta la variabile d'ambiente CLASSPATH su% 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 :.

Prima di entrare nei dettagli della libreria Google Gson, vediamo un'applicazione in azione. In questo esempio, abbiamo creato un fileStudentclasse. Creeremo una stringa JSON con i dettagli dello studente e la deserializzeremo instudent oggetto e quindi serializzarlo in una stringa JSON.

Esempio

Crea un file di classe Java denominato GsonTester in 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 il risultato

Compila le classi usando javac compilatore come segue -

C:\GSON_WORKSPACE>javac GsonTester.java

Ora esegui GsonTester per vedere il risultato -

C:\GSON_WORKSPACE>java GsonTester

Verifica l'output.

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

Passi da ricordare

Di seguito sono riportati i passaggi importanti da considerare qui.

Passaggio 1: creare un oggetto Gson utilizzando GsonBuilder

Crea un oggetto Gson. È un oggetto riutilizzabile.

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

Passaggio 2: deserializza JSON in Object

Usa il metodo fromJson () per ottenere l'oggetto da JSON. Passa la stringa / origine Json della stringa Json e il tipo di oggetto come parametro.

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

Passaggio 3: serializzare l'oggetto in JSON

Utilizzare il metodo toJson () per ottenere la rappresentazione di stringa JSON di un oggetto.

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

Gson è la principale classe di attori della libreria Google Gson. Fornisce funzionalità per convertire oggetti Java in costrutti JSON corrispondenti e viceversa. Gson viene prima costruito utilizzando GsonBuilder, quindi i metodi toJson (Object) o fromJson (String, Class) vengono utilizzati per leggere / scrivere costrutti JSON.

Dichiarazione di classe

Di seguito è riportata la dichiarazione per com.google.gson.Gson classe -

public final class Gson 
   extends Object

Costruttori

Suor n	Costruttore e descrizione
1	Gson() Costruisce un oggetto Gson con la configurazione predefinita.

Metodi di classe

Suor n	Metodo e descrizione
1	<T> T fromJson(JsonElement json, Class<T> classOfT) Questo metodo deserializza la lettura Json dall'albero di analisi specificato in un oggetto del tipo specificato.
2	<T> T fromJson(JsonElement json, Type typeOfT) Questo metodo deserializza la lettura Json dall'albero di analisi specificato in un oggetto del tipo specificato.
3	<T> T fromJson(JsonReader reader, Type typeOfT) Legge il valore JSON successivo dal lettore e lo converte in un oggetto di tipo typeOfT.
4	<T> T fromJson(Reader json, Class<T> classOfT) Questo metodo deserializza la lettura Json dal lettore specificato in un oggetto della classe specificata.
5	<T> T fromJson(Reader json, Type typeOfT) Questo metodo deserializza la lettura Json dal lettore specificato in un oggetto del tipo specificato.
6	<T> T fromJson(String json, Class<T> classOfT) Questo metodo deserializza il Json specificato in un oggetto della classe specificata.
7	<T> T fromJson(String json, Type typeOfT) Questo metodo deserializza il Json specificato in un oggetto del tipo specificato.
8	<T> TypeAdapter<T> getAdapter(Class<T> type) Restituisce l'adattatore di tipo per il tipo.
9	<T> TypeAdapter<T> getAdapter(TypeToken<T> type) Restituisce l'adattatore di tipo per il tipo.
10	<T> TypeAdapter<T> getDelegateAdapter(TypeAdapterFactory skipPast, TypeToken<T> type) Questo metodo viene utilizzato per ottenere un adattatore di tipo alternativo per il tipo specificato.
11	String toJson(JsonElement jsonElement) Converte un albero di JsonElements nella sua rappresentazione JSON equivalente.
12	void toJson(JsonElement jsonElement, Appendable writer) Scrive il JSON equivalente per un albero di JsonElements.
13	void toJson(JsonElement jsonElement, JsonWriter writer) Scrive il JSON per jsonElement nel writer.
14	String toJson(Object src) Questo metodo serializza l'oggetto specificato nella sua rappresentazione Json equivalente.
15	void toJson(Object src, Appendable writer) Questo metodo serializza l'oggetto specificato nella sua rappresentazione Json equivalente.
16	String toJson(Object src, Type typeOfSrc) Questo metodo serializza l'oggetto specificato, inclusi quelli di tipi generici, nella sua rappresentazione Json equivalente.
17	void toJson(Object src, Type typeOfSrc, Appendable writer) Questo metodo serializza l'oggetto specificato, inclusi quelli di tipi generici, nella sua rappresentazione Json equivalente.
18	void toJson(Object src, Type typeOfSrc, JsonWriter writer) Scrive la rappresentazione JSON di src di tipo typeOfSrc nel writer.
19	JsonElement toJsonTree(Object src) Questo metodo serializza l'oggetto specificato nella sua rappresentazione equivalente come un albero di JsonElements.
20	JsonElement toJsonTree(Object src, Type typeOfSrc) Questo metodo serializza l'oggetto specificato, inclusi quelli di tipi generici, nella sua rappresentazione equivalente come un albero di JsonElements.
21	String toString()

Metodi ereditati

Questa classe eredita i metodi dalla classe seguente:

• java.lang.Object

Esempio

Crea il seguente programma Java utilizzando qualsiasi editor di tua scelta e salvalo, ad esempio, in 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 il risultato

Compila le classi usando javac compilatore come segue -

C:\GSON_WORKSPACE>javac GsonTester.java

Ora esegui GsonTester per vedere il risultato -

C:\GSON_WORKSPACE>java GsonTester

Verifica l'output

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

Serializziamo un oggetto Java in un file Json e poi leggiamo quel file Json per recuperare l'oggetto. In questo esempio, abbiamo creato un fileStudentclasse. Creeremo un filestudent.json file che avrà l'estensione json rappresentazione di Student oggetto.

Esempio

Crea un file di classe Java denominato GsonTester in C:\>GSON_WORKSPACE.

File: 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 il risultato

Compila le classi usando javac compilatore come segue -

C:\GSON_WORKSPACE>javac GsonTester.java

Ora esegui GsonTester per vedere il risultato -

C:\GSON_WORKSPACE>java GsonTester

Verifica l'output

Student [ name: Mahesh, age: 10 ]

L'API di associazione dati viene utilizzata per convertire JSON in e da POJO (Plain Old Java Object) utilizzando la funzione di accesso alle proprietà o utilizzando le annotazioni. È di due tipi.

• Primitives Data Binding - Converte JSON in e da Java Maps, elenchi, stringhe, numeri, booleani e oggetti NULL.

• Objects Data Binding - Converte JSON in e da qualsiasi tipo JAVA.

Gson legge / scrive JSON per entrambi i tipi di associazioni di dati. Il data binding è analogo al parser JAXB per XML.

Primitive Data Binding

Il data binding delle primitive si riferisce alla mappatura di JSON ai tipi di dati JAVA Core e alle raccolte integrate. Gson fornisce vari adattatori integrati che possono essere utilizzati per serializzare / deserializzare i tipi di dati primitivi.

Esempio

Vediamo il primitivo data binding in azione. Qui mapperemo i tipi di base JAVA direttamente in JSON e viceversa.

Crea un file di classe Java denominato GsonTester in 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 il risultato

Compila le classi usando javac compilatore come segue -

C:\GSON_WORKSPACE>javac GsonTester.java

Ora esegui il file GsonTester per vedere il risultato -

C:\GSON_WORKSPACE>java GsonTester

Verifica l'output.

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

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

L'associazione dati oggetto si riferisce alla mappatura di JSON a qualsiasi oggetto 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);

Esempio

Vediamo l'associazione dei dati degli oggetti in azione. Qui mapperemo l'oggetto JAVA direttamente su JSON e viceversa.

Crea un file di classe Java denominato GsonTester in C: \> GSON_WORKSPACE.

File: 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 il risultato

Compila le classi usando javac compilatore come segue -

C:\GSON_WORKSPACE>javac GsonTester.java

Ora esegui il file GsonTester per vedere il risultato -

C:\GSON_WORKSPACE>java GsonTester

Verifica l'output.

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

Tree Model prepara una rappresentazione ad albero in memoria del documento JSON. Costruisce un albero di nodi JsonObject. È un approccio flessibile ed è analogo al parser DOM per XML.

Crea albero da JSON

JsonParser fornisce un puntatore al nodo radice dell'albero dopo aver letto il JSON. Il nodo radice può essere utilizzato per attraversare l'intero albero. Considera il seguente frammento di codice per ottenere il nodo radice di una stringa JSON fornita.

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

Modello di albero trasversale

Ottieni ogni nodo utilizzando il percorso relativo al nodo radice mentre attraversi l'albero ed elabora i dati. Il frammento di codice seguente mostra come attraversare un albero.

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

Esempio

Crea un file di classe Java denominato GsonTester in 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 il risultato

Compila le classi usando javac compilatore come segue -

C:\GSON_WORKSPACE>javac GsonTester.java

Ora esegui il file GsonTester per vedere il risultato -

C:\GSON_WORKSPACE>java GsonTester

Verifica l'output.

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

L'API di streaming viene utilizzata per leggere il token JSON per token. Legge e scrive contenuto JSON come eventi discreti.JsonReader e JsonWriter leggere / scrivere i dati come token, denominato JsonToken.

È l'approccio più potente tra i tre approcci per elaborare JSON. Ha l'overhead più basso ed è abbastanza veloce nelle operazioni di lettura / scrittura. È analogo al parser Stax per XML.

In questo capitolo, mostreremo l'utilizzo delle API di streaming GSON per leggere i dati JSON. L'API di streaming funziona con il concetto di token e ogni dettaglio di Json deve essere gestito con attenzione.

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

Esempio

Vediamo JsonReaderin azione. Crea un file di classe Java denominatoGsonTester in C: \> GSON_WORKSPACE.

File: 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 il risultato

Compila le classi usando javac compilatore come segue -

C:\GSON_WORKSPACE>javac GsonTester.java

Ora esegui il file GsonTester per vedere il risultato -

C:\GSON_WORKSPACE>java GsonTester

Verifica l'output.

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

In questo capitolo, discuteremo la serializzazione / deserializzazione di array, raccolte e generici.

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

Esempio

Vediamo la serializzazione / deserializzazione di array in azione. Crea un file di classe Java denominatoGsonTester in 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 il risultato

Compila le classi usando javac compilatore come segue -

C:\GSON_WORKSPACE>javac GsonTester.java

Ora esegui GsonTester per vedere il risultato -

C:\GSON_WORKSPACE>java GsonTester

Verifica l'output.

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

Esempio di collezioni

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>

Esempio

Vediamo la serializzazione / deserializzazione delle raccolte in azione. Crea un file di classe Java denominatoGsonTester in 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 il risultato

Compila le classi usando javac compilatore come segue -

C:\GSON_WORKSPACE>javac GsonTester.java

Ora esegui il file GsonTester per vedere il risultato -

C:\GSON_WORKSPACE>java GsonTester

Verifica l'output.

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

Esempio di farmaci generici

Gson utilizza l'API di riflessione Java per ottenere il tipo di oggetto a cui deve essere mappato un testo Json. Ma con i generici, queste informazioni vengono perse durante la serializzazione. Per contrastare questo problema, Gson fornisce una classecom.google.gson.reflect.TypeToken per memorizzare il tipo di oggetto generico.

Esempio

Vediamo la serializzazione / deserializzazione Generics in azione. Crea un file di classe Java denominatoGsonTester in 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 il risultato

Compila le classi usando javac compilatore come segue -

C:\GSON_WORKSPACE>javac GsonTester.java

Ora esegui il file GsonTester per vedere il risultato -

C:\GSON_WORKSPACE>java GsonTester

Verifica l'output.

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

In questo capitolo, spiegheremo la serializzazione / deserializzazione di classi con classi interne.

Esempio di classe interna annidata

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

Esempio

Vediamo un esempio di serializzazione / deserializzazione di una classe con una classe interna in azione. Crea un file di classe Java denominatoGsonTester in 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 il risultato

Compila le classi usando javac compilatore come segue -

C:\GSON_WORKSPACE>javac GsonTester.java

Ora esegui GsonTester per vedere il risultato -

C:\GSON_WORKSPACE>java GsonTester

Verifica l'output.

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

Esempio di classe interna statica annidata

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

Esempio

Vediamo un esempio di serializzazione / deserializzazione di una classe con una classe interna statica in azione. Crea un file di classe Java denominato GsonTester in 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 il risultato

Compila le classi usando javac compilatore come segue -

C:\GSON_WORKSPACE>javac GsonTester.java

Ora esegui il file GsonTester per vedere il risultato -

C:\GSON_WORKSPACE>java GsonTester

Verifica l'output.

{"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 esegue la serializzazione / deserializzazione degli oggetti utilizzando i suoi adattatori incorporati. Supporta anche adattatori personalizzati. Parliamo di come puoi creare un adattatore personalizzato e come puoi usarlo.

Crea un adattatore personalizzato

Crea un adattatore personalizzato estendendo il file TypeAdapterclass e passandogli il tipo di oggetto targetizzato. Sostituisci ilread e write metodi per eseguire rispettivamente la deserializzazione e la serializzazione personalizzate.

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

Registra l'adattatore personalizzato

Registrare l'adattatore personalizzato utilizzando GsonBuilder e creare un'istanza di Gson utilizzando GsonBuilder.

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

Usa l'adattatore

Gson ora utilizzerà l'adattatore personalizzato per convertire il testo Json in oggetto e 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);

Esempio

Vediamo un esempio di adattatore di tipo personalizzato in azione. Crea un file di classe Java denominatoGsonTester in 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 il risultato

Compila le classi usando javac compilatore come segue -

C:\GSON_WORKSPACE>javac GsonTester.java

Ora esegui il file GsonTester per vedere il risultato -

C:\GSON_WORKSPACE>java GsonTester

Verifica l'output.

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

Gson per impostazione predefinita genera contenuto Json ottimizzato ignorando i valori NULL. Ma GsonBuilder fornisce flag per mostrare i valori NULL nell'output Json utilizzando ilGsonBuilder.serializeNulls() metodo.

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

Esempio senza serializeNulls Call

Crea un file di classe Java denominato GsonTester in C: \> GSON_WORKSPACE.

File: 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 il risultato

Compila le classi usando javac compilatore come segue -

C:\GSON_WORKSPACE>javac GsonTester.java

Ora esegui GsonTester per vedere il risultato -

C:\GSON_WORKSPACE>java GsonTester

Verifica l'output.

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

Esempio con chiamata serializeNulls

Crea un file di classe Java denominato GsonTester in 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(); 
      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 il risultato

Compila le classi usando javac compilatore come segue -

C:\GSON_WORKSPACE>javac GsonTester.java

Ora esegui il file GsonTester per vedere il risultato -

C:\GSON_WORKSPACE>java GsonTester

Verifica l'output.

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

Gson fornisce @Sinceannotazione per controllare la serializzazione / deserializzazione Json di una classe in base alle sue varie versioni. Considera la seguente classe con supporto per il controllo delle versioni. In questa classe, abbiamo inizialmente definito due variabilirollNo e name e in seguito, abbiamo aggiunto verifiedcome nuova variabile. Usando @Since, abbiamo definitorollNo e name a partire dalla versione 1.0 e verificato come versione 1.1.

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

GsonBuilder fornisce il setVersion() metodo per serializzare tale classe con versione.

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

Esempio

Vediamo un esempio di supporto al controllo delle versioni in azione. Crea un file di classe Java denominatoGsonTester in C: \> GSON_WORKSPACE.

File: 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 il risultato

Compila le classi usando javac compilatore come segue -

C:\GSON_WORKSPACE>javac GsonTester.java

Ora esegui GsonTester per vedere il risultato -

C:\GSON_WORKSPACE>java GsonTester

Verifica l'output.

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

Per impostazione predefinita, GSON esclude i campi temporanei e statici dal processo di serializzazione / deserializzazione. Diamo un'occhiata al seguente esempio.

Esempio

Crea un file di classe Java denominato GsonTester in 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 il risultato

Compila le classi usando javac compilatore come segue -

C:\GSON_WORKSPACE>javac GsonTester.java

Ora esegui il file GsonTester per vedere il risultato -

C:\GSON_WORKSPACE>java GsonTester

Verifica l'output

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

Utilizzo di excludeFieldsWithModifiers

GsonBuilder fornisce il controllo sull'esclusione di campi con un particolare modificatore utilizzando il metodo excludeFieldsWithModifiers () dal processo di serializzazione / deserializzazione. Vedi il seguente esempio.

Esempio

Crea un file di classe Java denominato GsonTester in 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 il risultato

Compila le classi usando javac compilatore come segue -

C:\GSON_WORKSPACE>javac GsonTester.java

Ora esegui il file GsonTester per vedere il risultato -

C:\GSON_WORKSPACE>java GsonTester

Verifica l'output

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

Utilizzo di @Expose Annotation

Gson fornisce @Exposeannotazione per controllare la serializzazione / deserializzazione Json di una classe in base al suo ambito. Considera la seguente classe con una variabile avente@Exposesupporto. In questa classe,name e rollnole variabili devono essere esposte per la serializzazione. Quindi abbiamo usato il fileGsonBuilder.excludeFieldsWithoutExposeAnnotation()metodo per indicare che solo le variabili esposte devono essere serializzate / deserializzate. Vedi il seguente esempio.

Esempio

Crea un file di classe Java denominato GsonTester in 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 il risultato

Compila le classi usando javac compilatore come segue -

C:\GSON_WORKSPACE>javac GsonTester.java

Ora esegui il file GsonTester per vedere il risultato -

C:\GSON_WORKSPACE>java GsonTester

Verifica l'output

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