Gson - Guide rapide

Google Gson est une bibliothèque basée sur Java simple pour sérialiser des objets Java en JSON et vice versa. C'est une bibliothèque open-source développée par Google.

Les points suivants soulignent pourquoi vous devriez utiliser cette bibliothèque -

• Standardized - Gson est une bibliothèque standardisée gérée par Google.

• Efficient - C'est une extension fiable, rapide et efficace de la bibliothèque standard Java.

• Optimized - La bibliothèque est hautement optimisée.

• Support Generics - Il fournit un support étendu pour les génériques.

• Supports complex inner classes - Il prend en charge les objets complexes avec des hiérarchies d'héritage profondes.

Caractéristiques de Gson

Voici une liste de certaines des fonctionnalités les plus importantes de Gson -

• Easy to use - L'API Gson fournit une façade de haut niveau pour simplifier les cas d'utilisation couramment utilisés.

• No need to create mapping - L'API Gson fournit un mappage par défaut pour la plupart des objets à sérialiser.

• Performance- Gson est assez rapide et son encombrement mémoire est faible. Il convient aux graphes ou systèmes d'objets volumineux.

• Clean JSON - Gson crée un résultat JSON propre et compact qui est facile à lire.

• No Dependency - La bibliothèque Gson ne nécessite aucune autre bibliothèque que JDK.

• Open Source- La bibliothèque Gson est open source; il est disponible gratuitement.

Trois façons de traiter JSON

Gson propose trois méthodes alternatives pour traiter JSON -

API de streaming

Il lit et écrit le contenu JSON sous forme d'événements discrets. JsonReader et JsonWriter lire / écrire les données sous forme de jeton, appelé JsonToken.

C'est l'approche la plus puissante parmi les trois approches pour traiter JSON. Il a la plus faible surcharge et il est assez rapide dans les opérations de lecture / écriture. Il est analogue à l'analyseur Stax pour XML.

Modèle d'arbre

Il prépare une représentation arborescente en mémoire du document JSON. Il construit une arborescence de nœuds JsonObject. Il s'agit d'une approche flexible et analogue à l'analyseur DOM pour XML.

Liaison de données

Il convertit JSON vers et depuis POJO (Plain Old Java Object) à l'aide de l'accesseur de propriété. Gson lit / écrit JSON à l'aide d'adaptateurs de type de données. Il est analogue à l'analyseur JAXB pour XML.

Configuration de l'environnement local

Si vous souhaitez toujours configurer un environnement local pour le langage de programmation Java, cette section vous guidera sur la façon de télécharger et de configurer Java sur votre machine. Veuillez suivre les étapes ci-dessous pour configurer l'environnement.

Java SE est disponible gratuitement à partir du lien Télécharger Java . Vous téléchargez donc une version basée sur votre système d'exploitation.

Suivez les instructions pour télécharger Java et exécuter le .exepour installer Java sur votre machine. Une fois que vous avez installé Java sur votre machine, vous devez définir les variables d'environnement pour qu'elles pointent vers leurs répertoires d'installation corrects.

Configuration du chemin sous Windows 2000 / XP

En supposant que vous ayez installé Java dans le répertoire c: \ Program Files \ java \ jdk -

• Cliquez avec le bouton droit sur «Poste de travail» et sélectionnez «Propriétés».

• Cliquez sur le bouton «Variables d'environnement» sous l'onglet «Avancé».

• Ensuite, modifiez la variable «Path» afin qu'elle contienne également le chemin d'accès à l'exécutable Java. Par exemple, si le chemin est actuellement défini sur 'C: \ WINDOWS \ SYSTEM32', modifiez votre chemin pour lire 'C: \ WINDOWS \ SYSTEM32; c: \ Program Files \ java \ jdk \ bin'.

Configuration du chemin dans Windows 95/98 / ME

En supposant que vous ayez installé Java dans le répertoire c: \ Program Files \ java \ jdk -

• Modifiez le fichier 'C: \ autoexec.bat' et ajoutez la ligne suivante à la fin: 'SET PATH =% PATH%; C: \ Program Files \ java \ jdk \ bin'

Configuration du chemin pour Linux, UNIX, Solaris, FreeBSD

La variable d'environnement PATHdoit être défini pour pointer vers l'endroit où les binaires Java ont été installés. Reportez-vous à la documentation de votre shell si vous avez des difficultés à faire cela.

Par exemple, si vous utilisez bash comme shell, vous ajouteriez la ligne suivante à la fin de votre '.bashrc: export PATH = / chemin / vers / java: $ PATH'

Éditeurs Java populaires

Pour écrire vos programmes Java, vous aurez besoin d'un éditeur de texte. Il existe de nombreux IDE sophistiqués disponibles sur le marché. Mais pour l'instant, vous pouvez envisager l'un des éléments suivants -

• Notepad - Sous Windows, vous pouvez utiliser n'importe quel éditeur de texte simple comme Notepad (recommandé pour ce tutoriel) ou TextPad.

• Netbeans - Il s'agit d'un IDE Java open-source et gratuit qui peut être téléchargé depuis https://netbeans.org/index.html.

• Eclipse - C'est également un IDE Java développé par la communauté open source Eclipse et peut être téléchargé depuis https://www.eclipse.org/.

Télécharger Gson Archive

Téléchargez la dernière version du fichier jar Gson à partir de gson-2.3.1.jar. Au moment de la rédaction de ce didacticiel, nous avons téléchargé gson-2.3.1.jar et l'avons copié dans le dossier C: \> gson.

OS	Nom de l'archive
les fenêtres	gson-2.3.1.jar
Linux	gson-2.3.1.jar
Mac	gson-2.3.1.jar

Définir l'environnement Gson

Met le GSON_HOME variable d'environnement pour pointer vers l'emplacement du répertoire de base où le fichier JAR Gson est stocké sur votre machine.

OS	Production
les fenêtres	Définissez la variable d'environnement GSON_HOME sur C: \ gson
Linux	export GSON_HOME = / usr / local / gson
Mac	export GSON_HOME = / Bibliothèque / gson

Définir la variable CLASSPATH

Met le CLASSPATH variable d'environnement pour pointer vers l'emplacement du jar Gson.

OS	Production
les fenêtres	Définissez la variable d'environnement CLASSPATH sur% 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 :.

Avant d'entrer dans les détails de la bibliothèque Google Gson, voyons une application en action. Dans cet exemple, nous avons créé unStudentclasse. Nous allons créer une chaîne JSON avec les détails de l'étudiant et la désérialiser enstudent objet, puis sérialisez-le en une chaîne JSON.

Exemple

Créez un fichier de classe Java nommé GsonTester dans 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+ " ]"; 
   }  
}

Vérifier le résultat

Compilez les classes en utilisant javac compilateur comme suit -

C:\GSON_WORKSPACE>javac GsonTester.java

Exécutez maintenant le GsonTester pour voir le résultat -

C:\GSON_WORKSPACE>java GsonTester

Vérifiez la sortie.

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

Étapes à retenir

Voici les étapes importantes à considérer ici.

Étape 1 - Créer un objet Gson à l'aide de GsonBuilder

Créez un objet Gson. C'est un objet réutilisable.

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

Étape 2 - Désérialiser JSON en objet

Utilisez la méthode fromJson () pour obtenir l'objet à partir du JSON. Passez la chaîne Json / la source de la chaîne Json et le type d'objet en tant que paramètre.

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

Étape 3 - Sérialiser l'objet en JSON

Utilisez la méthode toJson () pour obtenir la représentation sous forme de chaîne JSON d'un objet.

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

Gson est la principale classe d'acteurs de la bibliothèque Google Gson. Il fournit des fonctionnalités pour convertir des objets Java en constructions JSON correspondantes et vice versa. Gson est d'abord construit à l'aide de GsonBuilder, puis les méthodes toJson (Object) ou fromJson (String, Class) sont utilisées pour lire / écrire des constructions JSON.

Déclaration de classe

Voici la déclaration pour com.google.gson.Gson classe -

public final class Gson 
   extends Object

Constructeurs

Sr. Non	Constructeur et description
1	Gson() Construit un objet Gson avec la configuration par défaut.

Méthodes de classe

Sr. Non	Méthode et description
1	<T> T fromJson(JsonElement json, Class<T> classOfT) Cette méthode désérialise la lecture Json de l'arborescence d'analyse spécifiée dans un objet du type spécifié.
2	<T> T fromJson(JsonElement json, Type typeOfT) Cette méthode désérialise la lecture Json de l'arborescence d'analyse spécifiée dans un objet du type spécifié.
3	<T> T fromJson(JsonReader reader, Type typeOfT) Lit la valeur JSON suivante du lecteur et la convertit en un objet de type typeOfT.
4	<T> T fromJson(Reader json, Class<T> classOfT) Cette méthode désérialise la lecture Json du lecteur spécifié dans un objet de la classe spécifiée.
5	<T> T fromJson(Reader json, Type typeOfT) Cette méthode désérialise la lecture Json du lecteur spécifié dans un objet du type spécifié.
6	<T> T fromJson(String json, Class<T> classOfT) Cette méthode désérialise le Json spécifié en un objet de la classe spécifiée.
sept	<T> T fromJson(String json, Type typeOfT) Cette méthode désérialise le Json spécifié en un objet du type spécifié.
8	<T> TypeAdapter<T> getAdapter(Class<T> type) Renvoie l'adaptateur de type pour le type.
9	<T> TypeAdapter<T> getAdapter(TypeToken<T> type) Renvoie l'adaptateur de type pour le type.
dix	<T> TypeAdapter<T> getDelegateAdapter(TypeAdapterFactory skipPast, TypeToken<T> type) Cette méthode est utilisée pour obtenir un autre adaptateur de type pour le type spécifié.
11	String toJson(JsonElement jsonElement) Convertit une arborescence de JsonElements en sa représentation JSON équivalente.
12	void toJson(JsonElement jsonElement, Appendable writer) Écrit le JSON équivalent pour une arborescence de JsonElements.
13	void toJson(JsonElement jsonElement, JsonWriter writer) Écrit le JSON pour jsonElement dans writer.
14	String toJson(Object src) Cette méthode sérialise l'objet spécifié dans sa représentation Json équivalente.
15	void toJson(Object src, Appendable writer) Cette méthode sérialise l'objet spécifié dans sa représentation Json équivalente.
16	String toJson(Object src, Type typeOfSrc) Cette méthode sérialise l'objet spécifié, y compris ceux de types génériques, dans sa représentation Json équivalente.
17	void toJson(Object src, Type typeOfSrc, Appendable writer) Cette méthode sérialise l'objet spécifié, y compris ceux de types génériques, dans sa représentation Json équivalente.
18	void toJson(Object src, Type typeOfSrc, JsonWriter writer) Écrit la représentation JSON de src de type typeOfSrc dans writer.
19	JsonElement toJsonTree(Object src) Cette méthode sérialise l'objet spécifié dans sa représentation équivalente en tant qu'arbre de JsonElements.
20	JsonElement toJsonTree(Object src, Type typeOfSrc) Cette méthode sérialise l'objet spécifié, y compris ceux de types génériques, dans sa représentation équivalente en tant qu'arbre de JsonElements.
21	String toString()

Méthodes héritées

Cette classe hérite des méthodes de la classe suivante -

• java.lang.Object

Exemple

Créez le programme Java suivant à l'aide de n'importe quel éditeur de votre choix et enregistrez-le à, disons, 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+ " ]"; 
   }  
}

Vérifier le résultat

Compilez les classes en utilisant javac compilateur comme suit -

C:\GSON_WORKSPACE>javac GsonTester.java

Exécutez maintenant le GsonTester pour voir le résultat -

C:\GSON_WORKSPACE>java GsonTester

Vérifiez la sortie

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

Sérialisons un objet Java dans un fichier Json, puis lisons ce fichier Json pour récupérer l'objet. Dans cet exemple, nous avons créé unStudentclasse. Nous allons créer unstudent.json fichier qui aura un json la représentation de Student objet.

Exemple

Créez un fichier de classe Java nommé GsonTester dans C:\>GSON_WORKSPACE.

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

Vérifier le résultat

Compilez les classes en utilisant javac compilateur comme suit -

C:\GSON_WORKSPACE>javac GsonTester.java

Exécutez maintenant le GsonTester pour voir le résultat -

C:\GSON_WORKSPACE>java GsonTester

Vérifiez la sortie

Student [ name: Mahesh, age: 10 ]

L'API de liaison de données est utilisée pour convertir JSON vers et depuis POJO (Plain Old Java Object) à l'aide d'un accesseur de propriété ou à l'aide d'annotations. Il est de deux types.

• Primitives Data Binding - Convertit JSON vers et depuis des objets Java Maps, Lists, Strings, Numbers, Booleans et NULL.

• Objects Data Binding - Convertit JSON vers et depuis n'importe quel type JAVA.

Gson lit / écrit JSON pour les deux types de liaisons de données. La liaison de données est analogue à l'analyseur JAXB pour XML.

Liaison de données primitives

La liaison de données primitives fait référence au mappage de JSON aux types de données JAVA Core et aux collections intégrées. Gson fournit divers adaptateurs intégrés qui peuvent être utilisés pour sérialiser / désérialiser les types de données primitifs.

Exemple

Voyons la liaison de données primitive en action. Ici, nous allons mapper les types de base JAVA directement vers JSON et vice versa.

Créez un fichier de classe Java nommé GsonTester dans 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)); 
   } 
}

Vérifier le résultat

Compilez les classes en utilisant javac compilateur comme suit -

C:\GSON_WORKSPACE>javac GsonTester.java

Maintenant, exécutez le GsonTester pour voir le résultat -

C:\GSON_WORKSPACE>java GsonTester

Vérifiez la sortie.

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

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

La liaison de données d'objet fait référence au mappage de JSON à n'importe quel objet 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);

Exemple

Voyons la liaison de données d'objet en action. Ici, nous allons mapper l'objet JAVA directement à JSON et vice versa.

Créez un fichier de classe Java nommé GsonTester dans C: \> GSON_WORKSPACE.

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

Vérifier le résultat

Compilez les classes en utilisant javac compilateur comme suit -

C:\GSON_WORKSPACE>javac GsonTester.java

Maintenant, exécutez le GsonTester pour voir le résultat -

C:\GSON_WORKSPACE>java GsonTester

Vérifiez la sortie.

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

Le modèle d'arbre prépare une représentation arborescente en mémoire du document JSON. Il construit une arborescence de nœuds JsonObject. Il s'agit d'une approche flexible et analogue à l'analyseur DOM pour XML.

Créer une arborescence à partir de JSON

JsonParser fournit un pointeur vers le nœud racine de l'arborescence après avoir lu le JSON. Le nœud racine peut être utilisé pour parcourir l'arborescence complète. Considérez l'extrait de code suivant pour obtenir le nœud racine d'une chaîne JSON fournie.

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

Modèle d'arbre transversal

Obtenez chaque nœud en utilisant le chemin relatif vers le nœud racine tout en parcourant l'arborescence et traitez les données. L'extrait de code suivant montre comment parcourir une arborescence.

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

Exemple

Créez un fichier de classe Java nommé GsonTester dans 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() + " ");  
         } 
      } 
   }   
}

Vérifier le résultat

Compilez les classes en utilisant javac compilateur comme suit -

C:\GSON_WORKSPACE>javac GsonTester.java

Maintenant, exécutez le GsonTester pour voir le résultat -

C:\GSON_WORKSPACE>java GsonTester

Vérifiez la sortie.

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

L'API de streaming est utilisée pour lire le jeton JSON par jeton. Il lit et écrit le contenu JSON sous forme d'événements discrets.JsonReader et JsonWriter lire / écrire les données sous forme de jeton, appelé JsonToken.

C'est l'approche la plus puissante parmi les trois approches pour traiter JSON. Il a la plus faible surcharge et il est assez rapide dans les opérations de lecture / écriture. Il est analogue à l'analyseur Stax pour XML.

Dans ce chapitre, nous présenterons l'utilisation des API de streaming GSON pour lire les données JSON. L'API de streaming fonctionne avec le concept de jeton et tous les détails de Json doivent être traités avec soin.

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

Exemple

Voyons voir JsonReaderen action. Créez un fichier de classe Java nomméGsonTester dans C: \> GSON_WORKSPACE.

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

Vérifier le résultat

Compilez les classes en utilisant javac compilateur comme suit -

C:\GSON_WORKSPACE>javac GsonTester.java

Maintenant, exécutez le GsonTester pour voir le résultat -

C:\GSON_WORKSPACE>java GsonTester

Vérifiez la sortie.

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

Dans ce chapitre, nous aborderons la sérialisation / désérialisation des tableaux, des collections et des génériques.

Exemple de tableau

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

Exemple

Voyons la sérialisation / désérialisation de tableaux en action. Créez un fichier de classe Java nomméGsonTester dans 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));     
   }      
}

Vérifier le résultat

Compilez les classes en utilisant javac compilateur comme suit -

C:\GSON_WORKSPACE>javac GsonTester.java

Exécutez maintenant le GsonTester pour voir le résultat -

C:\GSON_WORKSPACE>java GsonTester

Vérifiez la sortie.

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

Exemple de collections

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>

Exemple

Voyons la sérialisation / désérialisation de collection en action. Créez un fichier de classe Java nomméGsonTester dans 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);     
   }      
}

Vérifier le résultat

Compilez les classes en utilisant javac compilateur comme suit -

C:\GSON_WORKSPACE>javac GsonTester.java

Maintenant, exécutez le GsonTester pour voir le résultat -

C:\GSON_WORKSPACE>java GsonTester

Vérifiez la sortie.

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

Exemple générique

Gson utilise l'API de réflexion Java pour obtenir le type de l'objet auquel un texte Json doit être mappé. Mais avec les génériques, ces informations sont perdues lors de la sérialisation. Pour contrer ce problème, Gson fournit une classecom.google.gson.reflect.TypeToken pour stocker le type de l'objet générique.

Exemple

Voyons la sérialisation / désérialisation des génériques en action. Créez un fichier de classe Java nomméGsonTester dans 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); 
   } 
}

Vérifier le résultat

Compilez les classes en utilisant javac compilateur comme suit -

C:\GSON_WORKSPACE>javac GsonTester.java

Maintenant, exécutez le GsonTester pour voir le résultat -

C:\GSON_WORKSPACE>java GsonTester

Vérifiez la sortie.

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

Dans ce chapitre, nous expliquerons la sérialisation / désérialisation des classes ayant des classes internes.

Exemple de classe interne imbriquée

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

Exemple

Voyons un exemple de sérialisation / désérialisation de classe avec une classe interne en action. Créez un fichier de classe Java nomméGsonTester dans 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; 
   } 
}

Vérifier le résultat

Compilez les classes en utilisant javac compilateur comme suit -

C:\GSON_WORKSPACE>javac GsonTester.java

Exécutez maintenant le GsonTester pour voir le résultat -

C:\GSON_WORKSPACE>java GsonTester

Vérifiez la sortie.

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

Exemple de classe interne statique imbriquée

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

Exemple

Voyons un exemple de sérialisation / désérialisation de classe avec une classe interne statique en action. Créez un fichier de classe Java nommé GsonTester dans 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; 
   } 
}

Vérifier le résultat

Compilez les classes en utilisant javac compilateur comme suit -

C:\GSON_WORKSPACE>javac GsonTester.java

Maintenant, exécutez le GsonTester pour voir le résultat -

C:\GSON_WORKSPACE>java GsonTester

Vérifiez la sortie.

{"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 effectue la sérialisation / désérialisation des objets à l'aide de ses adaptateurs intégrés. Il prend également en charge les adaptateurs personnalisés. Voyons comment vous pouvez créer un adaptateur personnalisé et comment vous pouvez l'utiliser.

Créer un adaptateur personnalisé

Créez un adaptateur personnalisé en étendant le TypeAdapterclass et en lui passant le type d'objet ciblé. Remplacer leread et write méthodes pour effectuer respectivement une désérialisation et une sérialisation personnalisées.

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

Enregistrer l'adaptateur personnalisé

Enregistrez l'adaptateur personnalisé à l'aide de GsonBuilder et créez une instance Gson à l'aide de GsonBuilder.

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

Utilisez l'adaptateur

Gson utilisera désormais l'adaptateur personnalisé pour convertir le texte Json en objet et vice versa.

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

Exemple

Voyons un exemple d'adaptateur de type personnalisé en action. Créez un fichier de classe Java nomméGsonTester dans 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+ "]"; 
   } 
}

Vérifier le résultat

Compilez les classes en utilisant javac compilateur comme suit -

C:\GSON_WORKSPACE>javac GsonTester.java

Maintenant, exécutez le GsonTester pour voir le résultat -

C:\GSON_WORKSPACE>java GsonTester

Vérifiez la sortie.

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

Gson génère par défaut un contenu Json optimisé en ignorant les valeurs NULL. Mais GsonBuilder fournit des indicateurs pour afficher les valeurs NULL dans la sortie Json en utilisant leGsonBuilder.serializeNulls() méthode.

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

Exemple sans appel serializeNulls

Créez un fichier de classe Java nommé GsonTester dans C: \> GSON_WORKSPACE.

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

Vérifier le résultat

Compilez les classes en utilisant javac compilateur comme suit -

C:\GSON_WORKSPACE>javac GsonTester.java

Exécutez maintenant le GsonTester pour voir le résultat -

C:\GSON_WORKSPACE>java GsonTester

Vérifiez la sortie.

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

Exemple avec l'appel serializeNulls

Créez un fichier de classe Java nommé GsonTester dans C: \> GSON_WORKSPACE.

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

Vérifier le résultat

Compilez les classes en utilisant javac compilateur comme suit -

C:\GSON_WORKSPACE>javac GsonTester.java

Maintenant, exécutez le GsonTester pour voir le résultat -

C:\GSON_WORKSPACE>java GsonTester

Vérifiez la sortie.

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

Gson fournit @Sinceannotation pour contrôler la sérialisation / désérialisation Json d'une classe en fonction de ses différentes versions. Considérez la classe suivante avec la prise en charge de la gestion des versions. Dans cette classe, nous avons initialement défini deux variablesrollNo et name et plus tard, nous avons ajouté verifiedcomme nouvelle variable. En utilisant @Since, nous avons définirollNo et name à partir de la version 1.0 et vérifié comme étant de la version 1.1.

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

GsonBuilder fournit le setVersion() méthode pour sérialiser une telle classe versionnée.

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

Exemple

Voyons un exemple de prise en charge du contrôle de version en action. Créez un fichier de classe Java nomméGsonTester dans C: \> GSON_WORKSPACE.

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

Vérifier le résultat

Compilez les classes en utilisant javac compilateur comme suit -

C:\GSON_WORKSPACE>javac GsonTester.java

Exécutez maintenant le GsonTester pour voir le résultat -

C:\GSON_WORKSPACE>java GsonTester

Vérifiez la sortie.

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

Par défaut, GSON exclut les champs transitoires et statiques du processus de sérialisation / désérialisation. Jetons un œil à l'exemple suivant.

Exemple

Créez un fichier de classe Java nommé GsonTester dans 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; 
   } 
}

Vérifier le résultat

Compilez les classes en utilisant javac compilateur comme suit -

C:\GSON_WORKSPACE>javac GsonTester.java

Maintenant, exécutez le GsonTester pour voir le résultat -

C:\GSON_WORKSPACE>java GsonTester

Vérifiez la sortie

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

Utilisation d'excludeFieldsWithModifiers

GsonBuilder permet de contrôler l'exclusion des champs avec un modificateur particulier à l'aide de la méthode excludeFieldsWithModifiers () du processus de sérialisation / désérialisation. Voir l'exemple suivant.

Exemple

Créez un fichier de classe Java nommé GsonTester dans 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; 
   } 
}

Vérifier le résultat

Compilez les classes en utilisant javac compilateur comme suit -

C:\GSON_WORKSPACE>javac GsonTester.java

Maintenant, exécutez le GsonTester pour voir le résultat -

C:\GSON_WORKSPACE>java GsonTester

Vérifiez la sortie

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

Utilisation de l'annotation @Expose

Gson fournit @Exposeannotation pour contrôler la sérialisation / désérialisation Json d'une classe en fonction de sa portée. Considérez la classe suivante avec une variable ayant@Exposesoutien. Dans cette classe,name et rollnoles variables doivent être exposées pour la sérialisation. Ensuite, nous avons utilisé leGsonBuilder.excludeFieldsWithoutExposeAnnotation()pour indiquer que seules les variables exposées doivent être sérialisées / désérialisées. Voir l'exemple suivant.

Exemple

Créez un fichier de classe Java nommé GsonTester dans 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; 
   } 
}

Vérifier le résultat

Compilez les classes en utilisant javac compilateur comme suit -

C:\GSON_WORKSPACE>javac GsonTester.java

Maintenant, exécutez le GsonTester pour voir le résultat -

C:\GSON_WORKSPACE>java GsonTester

Vérifiez la sortie

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