Gson - Kurzanleitung
Google Gson ist eine einfache Java-basierte Bibliothek zum Serialisieren von Java-Objekten in JSON und umgekehrt. Es ist eine Open-Source-Bibliothek, die von Google entwickelt wurde.
Die folgenden Punkte verdeutlichen, warum Sie diese Bibliothek verwenden sollten -
Standardized - Gson ist eine standardisierte Bibliothek, die von Google verwaltet wird.
Efficient - Es ist eine zuverlässige, schnelle und effiziente Erweiterung der Java-Standardbibliothek.
Optimized - Die Bibliothek ist stark optimiert.
Support Generics - Es bietet umfassende Unterstützung für Generika.
Supports complex inner classes - Es unterstützt komplexe Objekte mit tiefen Vererbungshierarchien.
Eigenschaften von Gson
Hier ist eine Liste der wichtigsten Merkmale von Gson -
Easy to use - Die Gson-API bietet eine Fassade auf hoher Ebene, um häufig verwendete Anwendungsfälle zu vereinfachen.
No need to create mapping - Die Gson-API bietet eine Standardzuordnung für die meisten zu serialisierenden Objekte.
Performance- Gson ist ziemlich schnell und hat einen geringen Speicherbedarf. Es eignet sich für große Objektgraphen oder -systeme.
Clean JSON - Gson erstellt ein sauberes und kompaktes JSON-Ergebnis, das leicht zu lesen ist.
No Dependency - Für die Gson-Bibliothek ist außer JDK keine andere Bibliothek erforderlich.
Open Source- Die Gson-Bibliothek ist Open Source. es ist frei verfügbar.
Drei Arten der Verarbeitung von JSON
Gson bietet drei alternative Möglichkeiten zur Verarbeitung von JSON:
Streaming-API
Es liest und schreibt JSON-Inhalte als diskrete Ereignisse. JsonReader und JsonWriter Lesen / Schreiben der Daten als Token, bezeichnet als JsonToken.
Dies ist der leistungsstärkste Ansatz unter den drei Ansätzen zur Verarbeitung von JSON. Es hat den geringsten Overhead und ist bei Lese- / Schreibvorgängen recht schnell. Es ist analog zum Stax-Parser für XML.
Baummodell
Es erstellt eine speicherinterne Baumdarstellung des JSON-Dokuments. Es wird ein Baum von JsonObject-Knoten erstellt. Es ist ein flexibler Ansatz und entspricht dem DOM-Parser für XML.
Datenbindung
Es konvertiert JSON mithilfe von Property Accessor zu und von POJO (Plain Old Java Object). Gson liest / schreibt JSON mithilfe von Datentypadaptern. Es ist analog zum JAXB-Parser für XML.
Einrichtung der lokalen Umgebung
Wenn Sie dennoch eine lokale Umgebung für die Programmiersprache Java einrichten möchten, finden Sie in diesem Abschnitt Anleitungen zum Herunterladen und Einrichten von Java auf Ihrem Computer. Führen Sie die folgenden Schritte aus, um die Umgebung einzurichten.
Java SE ist frei verfügbar über den Link Java herunterladen . Sie laden also eine Version herunter, die auf Ihrem Betriebssystem basiert.
Befolgen Sie die Anweisungen, um Java herunterzuladen und auszuführen .exeum Java auf Ihrem Computer zu installieren. Sobald Sie Java auf Ihrem Computer installiert haben, müssen Sie die Umgebungsvariablen so einstellen, dass sie auf die richtigen Installationsverzeichnisse verweisen.
Einrichten des Pfads in Windows 2000 / XP
Angenommen, Sie haben Java im Verzeichnis c: \ Programme \ java \ jdk installiert -
Klicken Sie mit der rechten Maustaste auf "Arbeitsplatz" und wählen Sie "Eigenschaften".
Klicken Sie auf der Registerkarte "Erweitert" auf die Schaltfläche "Umgebungsvariablen".
Ändern Sie als Nächstes die Variable 'Path' so, dass sie auch den Pfad zur ausführbaren Java-Datei enthält. Wenn der Pfad derzeit auf "C: \ WINDOWS \ SYSTEM32" festgelegt ist, ändern Sie Ihren Pfad in "C: \ WINDOWS \ SYSTEM32; c: \ Programme \ java \ jdk \ bin".
Einrichten des Pfads in Windows 95/98 / ME
Angenommen, Sie haben Java im Verzeichnis c: \ Programme \ java \ jdk installiert -
Bearbeiten Sie die Datei 'C: \ autoexec.bat' und fügen Sie am Ende die folgende Zeile hinzu: 'SET PATH =% PATH%; C: \ Programme \ java \ jdk \ bin'
Einrichten des Pfads für Linux, UNIX, Solaris, FreeBSD
Die Umgebungsvariable PATHsollte so eingestellt werden, dass es darauf verweist, wo die Java-Binärdateien installiert wurden. Informationen hierzu finden Sie in Ihrer Shell-Dokumentation.
Wenn Sie beispielsweise bash als Shell verwenden, fügen Sie die folgende Zeile am Ende Ihrer '.bashrc: export PATH = / path / to / java: $ PATH' hinzu.
Beliebte Java-Editoren
Zum Schreiben Ihrer Java-Programme benötigen Sie einen Texteditor. Es gibt einige hoch entwickelte IDEs auf dem Markt. Im Moment können Sie jedoch eine der folgenden Möglichkeiten in Betracht ziehen:
Notepad - Unter Windows können Sie einen einfachen Texteditor wie Notepad (für dieses Tutorial empfohlen) oder TextPad verwenden.
Netbeans - Es handelt sich um eine Open-Source-Java-IDE, die kostenlos heruntergeladen werden kann https://netbeans.org/index.html.
Eclipse - Es ist auch eine Java-IDE, die von der Open-Source-Community von Eclipse entwickelt wurde und von heruntergeladen werden kann https://www.eclipse.org/.
Laden Sie das Gson-Archiv herunter
Laden Sie die neueste Version der Gson-JAR-Datei von herunter gson-2.3.1.jar. Zum Zeitpunkt des Schreibens dieses Tutorials haben wir gson-2.3.1.jar heruntergeladen und in den Ordner C: \> gson kopiert.
| Betriebssystem | Archivname |
|---|---|
| Windows | gson-2.3.1.jar |
| Linux | gson-2.3.1.jar |
| Mac | gson-2.3.1.jar |
Stellen Sie die Gson-Umgebung ein
Stellen Sie die GSON_HOME Umgebungsvariable, die auf den Speicherort des Basisverzeichnisses verweist, in dem Gson jar auf Ihrem Computer gespeichert ist.
| Betriebssystem | Ausgabe |
|---|---|
| Windows | Setzen Sie die Umgebungsvariable GSON_HOME auf C: \ gson |
| Linux | exportiere GSON_HOME = / usr / local / gson |
| Mac | export GSON_HOME = / Library / gson |
Setzen Sie die Variable CLASSPATH
Stellen Sie die CLASSPATH Umgebungsvariable, die auf den Speicherort des Gson-JARs verweist.
| Betriebssystem | Ausgabe |
|---|---|
| Windows | Setzen Sie die Umgebungsvariable CLASSPATH auf% 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:. |
Bevor wir uns mit den Details der Google Gson-Bibliothek befassen, sehen wir uns eine Anwendung in Aktion an. In diesem Beispiel haben wir eine erstelltStudentKlasse. Wir erstellen eine JSON-Zeichenfolge mit Schülerdetails und deserialisieren sie aufstudent Objekt und serialisieren Sie es dann zu einem JSON-String.
Beispiel
Erstellen Sie eine Java-Klassendatei mit dem Namen 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+ " ]";
}
}Überprüfen Sie das Ergebnis
Kompilieren Sie die Klassen mit javac Compiler wie folgt -
C:\GSON_WORKSPACE>javac GsonTester.javaFühren Sie nun den GsonTester aus, um das Ergebnis anzuzeigen -
C:\GSON_WORKSPACE>java GsonTesterÜberprüfen Sie die Ausgabe.
Student [ name: Mahesh, age: 21 ]
{
"name" : "Mahesh",
"age" : 21
}Schritte zum Erinnern
Im Folgenden sind die wichtigen Schritte aufgeführt, die hier zu berücksichtigen sind.
Schritt 1 - Erstellen Sie ein Gson-Objekt mit GsonBuilder
Erstellen Sie ein Gson-Objekt. Es ist ein wiederverwendbares Objekt.
GsonBuilder builder = new GsonBuilder();
builder.setPrettyPrinting();
Gson gson = builder.create();Schritt 2 - JSON in Objekt deserialisieren
Verwenden Sie die fromJson () -Methode, um das Objekt aus dem JSON abzurufen. Übergeben Sie die Json-Zeichenfolge / Quelle der Json-Zeichenfolge und den Objekttyp als Parameter.
//Object to JSON Conversion
Student student = gson.fromJson(jsonString, Student.class);Schritt 3 - Objekt in JSON serialisieren
Verwenden Sie die toJson () -Methode, um die JSON-Zeichenfolgendarstellung eines Objekts abzurufen.
//Object to JSON Conversion
jsonString = gson.toJson(student);Gson ist die Hauptdarstellerklasse der Google Gson-Bibliothek. Es bietet Funktionen zum Konvertieren von Java-Objekten in übereinstimmende JSON-Konstrukte und umgekehrt. Gson wird zuerst mit GsonBuilder erstellt. Anschließend werden die Methoden toJson (Object) oder fromJson (String, Class) zum Lesen / Schreiben von JSON-Konstrukten verwendet.
Klassenerklärung
Es folgt die Erklärung für com.google.gson.Gson Klasse -
public final class Gson
extends ObjectKonstruktoren
| Sr.Nr. | Konstruktor & Beschreibung |
|---|---|
| 1 | Gson() Erstellt ein Gson-Objekt mit Standardkonfiguration. |
Klassenmethoden
| Sr.Nr. | Methode & Beschreibung |
|---|---|
| 1 | <T> T fromJson(JsonElement json, Class<T> classOfT) Diese Methode deserialisiert den aus dem angegebenen Analysebaum gelesenen Json in ein Objekt des angegebenen Typs. |
| 2 | <T> T fromJson(JsonElement json, Type typeOfT) Diese Methode deserialisiert den aus dem angegebenen Analysebaum gelesenen Json in ein Objekt des angegebenen Typs. |
| 3 | <T> T fromJson(JsonReader reader, Type typeOfT) Liest den nächsten JSON-Wert vom Reader und konvertiert ihn in ein Objekt vom Typ typeOfT. |
| 4 | <T> T fromJson(Reader json, Class<T> classOfT) Diese Methode deserialisiert den vom angegebenen Reader gelesenen Json in ein Objekt der angegebenen Klasse. |
| 5 | <T> T fromJson(Reader json, Type typeOfT) Diese Methode deserialisiert den vom angegebenen Reader gelesenen Json in ein Objekt des angegebenen Typs. |
| 6 | <T> T fromJson(String json, Class<T> classOfT) Diese Methode deserialisiert den angegebenen Json in ein Objekt der angegebenen Klasse. |
| 7 | <T> T fromJson(String json, Type typeOfT) Diese Methode deserialisiert den angegebenen Json in ein Objekt des angegebenen Typs. |
| 8 | <T> TypeAdapter<T> getAdapter(Class<T> type) Gibt den Typadapter für Typ zurück. |
| 9 | <T> TypeAdapter<T> getAdapter(TypeToken<T> type) Gibt den Typadapter für Typ zurück. |
| 10 | <T> TypeAdapter<T> getDelegateAdapter(TypeAdapterFactory skipPast, TypeToken<T> type) Diese Methode wird verwendet, um einen alternativen Typadapter für den angegebenen Typ abzurufen. |
| 11 | String toJson(JsonElement jsonElement) Konvertiert einen Baum von JsonElements in seine entsprechende JSON-Darstellung. |
| 12 | void toJson(JsonElement jsonElement, Appendable writer) Schreibt den entsprechenden JSON für einen Baum von JsonElements aus. |
| 13 | void toJson(JsonElement jsonElement, JsonWriter writer) Schreibt den JSON für jsonElement an den Writer. |
| 14 | String toJson(Object src) Diese Methode serialisiert das angegebene Objekt in seine entsprechende Json-Darstellung. |
| 15 | void toJson(Object src, Appendable writer) Diese Methode serialisiert das angegebene Objekt in seine entsprechende Json-Darstellung. |
| 16 | String toJson(Object src, Type typeOfSrc) Diese Methode serialisiert das angegebene Objekt, einschließlich der Objekte generischer Typen, in seine entsprechende Json-Darstellung. |
| 17 | void toJson(Object src, Type typeOfSrc, Appendable writer) Diese Methode serialisiert das angegebene Objekt, einschließlich der Objekte generischer Typen, in seine entsprechende Json-Darstellung. |
| 18 | void toJson(Object src, Type typeOfSrc, JsonWriter writer) Schreibt die JSON-Darstellung von src vom Typ typeOfSrc in den Writer. |
| 19 | JsonElement toJsonTree(Object src) Diese Methode serialisiert das angegebene Objekt in seine entsprechende Darstellung als Baum von JsonElements. |
| 20 | JsonElement toJsonTree(Object src, Type typeOfSrc) Diese Methode serialisiert das angegebene Objekt, einschließlich der Objekte generischer Typen, in seine entsprechende Darstellung als Baum von JsonElements. |
| 21 | String toString() |
Methoden geerbt
Diese Klasse erbt Methoden von der folgenden Klasse:
- java.lang.Object
Beispiel
Erstellen Sie das folgende Java-Programm mit einem beliebigen Editor Ihrer Wahl und speichern Sie es beispielsweise unter 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+ " ]";
}
}Überprüfen Sie das Ergebnis
Kompilieren Sie die Klassen mit javac Compiler wie folgt -
C:\GSON_WORKSPACE>javac GsonTester.javaFühren Sie nun den GsonTester aus, um das Ergebnis anzuzeigen -
C:\GSON_WORKSPACE>java GsonTesterÜberprüfen Sie die Ausgabe
Student [ name: Mahesh, age: 21 ]
{
"name" : "Mahesh",
"age" : 21
}Lassen Sie uns ein Java-Objekt in eine Json-Datei serialisieren und dann diese Json-Datei lesen, um das Objekt zurückzubekommen. In diesem Beispiel haben wir eine erstelltStudentKlasse. Wir werden eine erstellenstudent.json Datei, die eine haben wird json Darstellung von Student Objekt.
Beispiel
Erstellen Sie eine Java-Klassendatei mit dem Namen GsonTester im C:\>GSON_WORKSPACE.
Datei - 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+ " ]";
}
}Überprüfen Sie das Ergebnis
Kompilieren Sie die Klassen mit javac Compiler wie folgt -
C:\GSON_WORKSPACE>javac GsonTester.javaFühren Sie nun den GsonTester aus, um das Ergebnis anzuzeigen -
C:\GSON_WORKSPACE>java GsonTesterÜberprüfen Sie die Ausgabe
Student [ name: Mahesh, age: 10 ]Die Datenbindungs-API wird verwendet, um JSON mithilfe des Eigenschaftenzugriffs oder mithilfe von Anmerkungen in und von POJO (Plain Old Java Object) zu konvertieren. Es gibt zwei Arten.
Primitives Data Binding - Konvertiert JSON in und von Java Maps, Listen, Strings, Numbers, Booleans und NULL-Objekten.
Objects Data Binding - Konvertiert JSON in und von einem beliebigen JAVA-Typ.
Gson liest / schreibt JSON für beide Arten von Datenbindungen. Die Datenbindung erfolgt analog zum JAXB-Parser für XML.
Primitive Datenbindung
Die primitive Datenbindung bezieht sich auf die Zuordnung von JSON zu JAVA Core-Datentypen und integrierten Sammlungen. Gson bietet verschiedene eingebaute Adapter, mit denen primitive Datentypen serialisiert / deserialisiert werden können.
Beispiel
Lassen Sie uns die Bindung primitiver Daten in Aktion sehen. Hier ordnen wir JAVA-Basistypen direkt JSON zu und umgekehrt.
Erstellen Sie eine Java-Klassendatei mit dem Namen GsonTester im 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));
}
}Überprüfen Sie das Ergebnis
Kompilieren Sie die Klassen mit javac Compiler wie folgt -
C:\GSON_WORKSPACE>javac GsonTester.javaFühren Sie nun die aus GsonTester um das Ergebnis zu sehen -
C:\GSON_WORKSPACE>java GsonTesterÜberprüfen Sie die Ausgabe.
{
name: "Mahesh Kumar",
rollNo: 1,
verified: false,
marks:[100,90,85]
}
name: Mahesh Kumar
rollNo: 1
verified: false
marks:[100, 90, 85]Die Objektdatenbindung bezieht sich auf die Zuordnung von JSON zu einem beliebigen JAVA-Objekt.
//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);Beispiel
Lassen Sie uns die Objektdatenbindung in Aktion sehen. Hier ordnen wir JAVA Object direkt JSON zu und umgekehrt.
Erstellen Sie eine Java-Klassendatei mit dem Namen GsonTester in C: \> GSON_WORKSPACE.
Datei - 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+ " ]";
}
}Überprüfen Sie das Ergebnis
Kompilieren Sie die Klassen mit javac Compiler wie folgt -
C:\GSON_WORKSPACE>javac GsonTester.javaFühren Sie nun die aus GsonTester um das Ergebnis zu sehen -
C:\GSON_WORKSPACE>java GsonTesterÜberprüfen Sie die Ausgabe.
{"name":"Mahesh","age":10}
Student [ name: Mahesh, age: 10 ]Das Baummodell erstellt eine speicherinterne Baumdarstellung des JSON-Dokuments. Es wird ein Baum von JsonObject-Knoten erstellt. Es ist ein flexibler Ansatz und entspricht dem DOM-Parser für XML.
Erstellen Sie einen Baum aus JSON
JsonParser stellt nach dem Lesen des JSON einen Zeiger auf den Stammknoten des Baums bereit. Der Wurzelknoten kann verwendet werden, um den gesamten Baum zu durchlaufen. Betrachten Sie das folgende Codeausschnitt, um den Stammknoten einer bereitgestellten JSON-Zeichenfolge abzurufen.
//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);Baummodell durchqueren
Rufen Sie jeden Knoten mithilfe des relativen Pfads zum Stammknoten ab, während Sie den Baum durchlaufen, und verarbeiten Sie die Daten. Das folgende Codefragment zeigt, wie Sie einen Baum durchlaufen können.
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());Beispiel
Erstellen Sie eine Java-Klassendatei mit dem Namen 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() + " ");
}
}
}
}Überprüfen Sie das Ergebnis
Kompilieren Sie die Klassen mit javac Compiler wie folgt -
C:\GSON_WORKSPACE>javac GsonTester.javaFühren Sie nun die aus GsonTester um das Ergebnis zu sehen -
C:\GSON_WORKSPACE>java GsonTesterÜberprüfen Sie die Ausgabe.
Name: Mahesh Kumar
Age: 21
Verified: No
100 90 85Die Streaming-API wird verwendet, um JSON-Token für Token zu lesen. Es liest und schreibt JSON-Inhalte als diskrete Ereignisse.JsonReader und JsonWriter Lesen / Schreiben der Daten als Token, bezeichnet als JsonToken.
Dies ist der leistungsstärkste Ansatz unter den drei Ansätzen zur Verarbeitung von JSON. Es hat den geringsten Overhead und ist bei Lese- / Schreibvorgängen recht schnell. Es ist analog zum Stax-Parser für XML.
In diesem Kapitel wird die Verwendung von GSON-Streaming-APIs zum Lesen von JSON-Daten vorgestellt. Die Streaming-API arbeitet mit dem Konzept des Tokens und alle Details von Json müssen sorgfältig behandelt werden.
//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();
}Beispiel
Wir werden sehen JsonReaderin Aktion. Erstellen Sie eine Java-Klassendatei mit dem NamenGsonTester in C: \> GSON_WORKSPACE.
Datei - 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() + " ");
}
}
}
}Überprüfen Sie das Ergebnis
Kompilieren Sie die Klassen mit javac Compiler wie folgt -
C:\GSON_WORKSPACE>javac GsonTester.javaFühren Sie nun die aus GsonTester um das Ergebnis zu sehen -
C:\GSON_WORKSPACE>java GsonTesterÜberprüfen Sie die Ausgabe.
Name: Mahesh Kumar
Age:21
Verified:false
Marks [ 100 90 85 ]In diesem Kapitel werden wir die Serialisierung / Deserialisierung von Arrays, Sammlungen und Generika diskutieren.
Array-Beispiel
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));Beispiel
Lassen Sie uns die Array-Serialisierung / De-Serialisierung in Aktion sehen. Erstellen Sie eine Java-Klassendatei mit dem NamenGsonTester 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));
}
}Überprüfen Sie das Ergebnis
Kompilieren Sie die Klassen mit javac Compiler wie folgt -
C:\GSON_WORKSPACE>javac GsonTester.javaFühren Sie nun den GsonTester aus, um das Ergebnis anzuzeigen -
C:\GSON_WORKSPACE>java GsonTesterÜberprüfen Sie die Ausgabe.
{marks:[100,90,85],names:["Ram","Shyam","Mohan"]}
marks:[100, 90, 85]
names:[Ram, Shyam, Mohan]Sammlungsbeispiel
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>Beispiel
Lassen Sie uns die Serialisierung / De-Serialisierung der Sammlung in Aktion sehen. Erstellen Sie eine Java-Klassendatei mit dem NamenGsonTester 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);
}
}Überprüfen Sie das Ergebnis
Kompilieren Sie die Klassen mit javac Compiler wie folgt -
C:\GSON_WORKSPACE>javac GsonTester.javaFühren Sie nun die aus GsonTester um das Ergebnis zu sehen -
C:\GSON_WORKSPACE>java GsonTesterÜberprüfen Sie die Ausgabe.
{marks:[100,90,85]}
marks:[100, 90, 85]Beispiel für Generika
Gson verwendet die Java Reflection API, um den Typ des Objekts abzurufen, dem ein Json-Text zugeordnet werden soll. Bei Generika gehen diese Informationen jedoch während der Serialisierung verloren. Um diesem Problem entgegenzuwirken, stellt Gson eine Klasse zur Verfügungcom.google.gson.reflect.TypeToken um den Typ des generischen Objekts zu speichern.
Beispiel
Lassen Sie uns die Serialisierung / De-Serialisierung von Generika in Aktion sehen. Erstellen Sie eine Java-Klassendatei mit dem NamenGsonTester 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);
}
}Überprüfen Sie das Ergebnis
Kompilieren Sie die Klassen mit javac Compiler wie folgt -
C:\GSON_WORKSPACE>javac GsonTester.javaFühren Sie nun die aus GsonTester um das Ergebnis zu sehen -
C:\GSON_WORKSPACE>java GsonTesterÜberprüfen Sie die Ausgabe.
{"shape":{"radius":5.0}}
class com.google.gson.internal.LinkedTreeMap
{radius = 5.0}
0.0
class Circle
Circle
78.5In diesem Kapitel erklären wir die Serialisierung / Deserialisierung von Klassen mit inneren Klassen.
Beispiel für eine verschachtelte innere Klasse
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());Beispiel
Sehen wir uns ein Beispiel für die Serialisierung / De-Serialisierung einer Klasse mit einer inneren Klasse in Aktion an. Erstellen Sie eine Java-Klassendatei mit dem NamenGsonTester 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;
}
}Überprüfen Sie das Ergebnis
Kompilieren Sie die Klassen mit javac Compiler wie folgt -
C:\GSON_WORKSPACE>javac GsonTester.javaFühren Sie nun den GsonTester aus, um das Ergebnis anzuzeigen -
C:\GSON_WORKSPACE>java GsonTesterÜberprüfen Sie die Ausgabe.
{"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: KumarBeispiel für eine verschachtelte statische innere Klasse
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());Beispiel
Sehen wir uns ein Beispiel für die Serialisierung / De-Serialisierung einer Klasse mit einer statischen inneren Klasse in Aktion an. Erstellen Sie eine Java-Klassendatei mit dem Namen 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;
}
}Überprüfen Sie das Ergebnis
Kompilieren Sie die Klassen mit javac Compiler wie folgt -
C:\GSON_WORKSPACE>javac GsonTester.javaFühren Sie nun die aus GsonTester um das Ergebnis zu sehen -
C:\GSON_WORKSPACE>java GsonTesterÜberprüfen Sie die Ausgabe.
{"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: KumarGson führt die Serialisierung / Deserialisierung von Objekten mithilfe seiner eingebauten Adapter durch. Es werden auch benutzerdefinierte Adapter unterstützt. Lassen Sie uns diskutieren, wie Sie einen benutzerdefinierten Adapter erstellen und wie Sie ihn verwenden können.
Erstellen Sie einen benutzerdefinierten Adapter
Erstellen Sie einen benutzerdefinierten Adapter, indem Sie die Option erweitern TypeAdapterKlasse und übergeben Sie ihm den Typ des Zielobjekts. Überschreiben Sie dieread und write Methoden zur Durchführung einer benutzerdefinierten Deserialisierung bzw. Serialisierung.
class StudentAdapter extends TypeAdapter<Student> {
@Override
public Student read(JsonReader reader) throws IOException {
...
}
@Override
public void write(JsonWriter writer, Student student) throws IOException {
}
}Registrieren Sie den benutzerdefinierten Adapter
Registrieren Sie den benutzerdefinierten Adapter mit GsonBuilder und erstellen Sie eine Gson-Instanz mit GsonBuilder.
GsonBuilder builder = new GsonBuilder();
builder.registerTypeAdapter(Student.class, new StudentAdapter());
Gson gson = builder.create();Verwenden Sie den Adapter
Gson verwendet jetzt den benutzerdefinierten Adapter, um Json-Text in Objekt zu konvertieren und umgekehrt.
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);Beispiel
Sehen wir uns ein Beispiel für einen benutzerdefinierten Typadapter in Aktion an. Erstellen Sie eine Java-Klassendatei mit dem NamenGsonTester 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+ "]";
}
}Überprüfen Sie das Ergebnis
Kompilieren Sie die Klassen mit javac Compiler wie folgt -
C:\GSON_WORKSPACE>javac GsonTester.javaFühren Sie nun die aus GsonTester um das Ergebnis zu sehen -
C:\GSON_WORKSPACE>java GsonTesterÜberprüfen Sie die Ausgabe.
Student[ name = Mahesh, roll no: 1]
{
"name": "Mahesh",
"rollNo": 1
}Gson generiert standardmäßig optimierten Json-Inhalt, wobei die NULL-Werte ignoriert werden. GsonBuilder bietet jedoch Flags, um NULL-Werte in der Json-Ausgabe mithilfe von anzuzeigenGsonBuilder.serializeNulls() Methode.
GsonBuilder builder = new GsonBuilder();
builder.serializeNulls();
Gson gson = builder.create();Beispiel ohne serializeNulls Call
Erstellen Sie eine Java-Klassendatei mit dem Namen GsonTester in C: \> GSON_WORKSPACE.
Datei - 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+ "]";
}
}Überprüfen Sie das Ergebnis
Kompilieren Sie die Klassen mit javac Compiler wie folgt -
C:\GSON_WORKSPACE>javac GsonTester.javaFühren Sie nun den GsonTester aus, um das Ergebnis anzuzeigen -
C:\GSON_WORKSPACE>java GsonTesterÜberprüfen Sie die Ausgabe.
{"rollNo": 1}
Student[ name = null, roll no: 1]Beispiel mit serializeNulls-Aufruf
Erstellen Sie eine Java-Klassendatei mit dem Namen GsonTester in C: \> GSON_WORKSPACE.
Datei - 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+ "]";
}
}Überprüfen Sie das Ergebnis
Kompilieren Sie die Klassen mit javac Compiler wie folgt -
C:\GSON_WORKSPACE>javac GsonTester.javaFühren Sie nun die aus GsonTester um das Ergebnis zu sehen -
C:\GSON_WORKSPACE>java GsonTesterÜberprüfen Sie die Ausgabe.
{
"rollNo": 1,
"name": null
}
Student[ name = null, roll no: 1]Gson bietet @SinceAnmerkung zur Steuerung der Json-Serialisierung / Deserialisierung einer Klasse basierend auf ihren verschiedenen Versionen. Betrachten Sie die folgende Klasse mit Versionsunterstützung. In dieser Klasse haben wir zunächst zwei Variablen definiertrollNo und name und später fügten wir hinzu verifiedals neue Variable. Mit @Since haben wir definiertrollNo und name ab Version 1.0 und als Version 1.1 verifiziert.
class Student {
@Since(1.0)
private int rollNo;
@Since(1.0)
private String name;
@Since(1.1)
private boolean verified;
}GsonBuilder bietet die setVersion() Methode zum Serialisieren einer solchen versionierten Klasse.
GsonBuilder builder = new GsonBuilder();
builder.setVersion(1.0);
Gson gson = builder.create();Beispiel
Sehen wir uns ein Beispiel für die Versionsunterstützung in Aktion an. Erstellen Sie eine Java-Klassendatei mit dem NamenGsonTester in C: \> GSON_WORKSPACE.
Datei - 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;
}
}Überprüfen Sie das Ergebnis
Kompilieren Sie die Klassen mit javac Compiler wie folgt -
C:\GSON_WORKSPACE>javac GsonTester.javaFühren Sie nun den GsonTester aus, um das Ergebnis anzuzeigen -
C:\GSON_WORKSPACE>java GsonTesterÜberprüfen Sie die Ausgabe.
{"rollNo":1,"name":"Mahesh Kumar"}
{"rollNo":1,"name":"Mahesh Kumar","verified":true}Standardmäßig schließt GSON transiente und statische Felder vom Serialisierungs- / Deserialisierungsprozess aus. Schauen wir uns das folgende Beispiel an.
Beispiel
Erstellen Sie eine Java-Klassendatei mit dem Namen 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;
}
}Überprüfen Sie das Ergebnis
Kompilieren Sie die Klassen mit javac Compiler wie folgt -
C:\GSON_WORKSPACE>javac GsonTester.javaFühren Sie nun die aus GsonTester um das Ergebnis zu sehen -
C:\GSON_WORKSPACE>java GsonTesterÜberprüfen Sie die Ausgabe
{"rollNo":1,"name":"Mahesh Kumar","verified":true}Verwenden von excludeFieldsWithModifiers
GsonBuilder bietet die Kontrolle über das Ausschließen von Feldern mit einem bestimmten Modifikator mithilfe der Methode excludeFieldsWithModifiers () aus dem Serialisierungs- / Deserialisierungsprozess. Siehe folgendes Beispiel.
Beispiel
Erstellen Sie eine Java-Klassendatei mit dem Namen 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;
}
}Überprüfen Sie das Ergebnis
Kompilieren Sie die Klassen mit javac Compiler wie folgt -
C:\GSON_WORKSPACE>javac GsonTester.javaFühren Sie nun die aus GsonTester um das Ergebnis zu sehen -
C:\GSON_WORKSPACE>java GsonTesterÜberprüfen Sie die Ausgabe
{"rollNo":1,"name":"Mahesh Kumar","verified":true,"className":"VI"}Verwenden von @Expose Annotation
Gson bietet @ExposeAnmerkung zur Steuerung der Json-Serialisierung / Deserialisierung einer Klasse basierend auf ihrem Umfang. Betrachten Sie die folgende Klasse mit einer Variablen mit@ExposeUnterstützung. In dieser Klasse,name und rollnoVariablen sollen zur Serialisierung verfügbar gemacht werden. Dann haben wir das benutztGsonBuilder.excludeFieldsWithoutExposeAnnotation()Methode, um anzuzeigen, dass nur exponierte Variablen serialisiert / deserialisiert werden sollen. Siehe folgendes Beispiel.
Beispiel
Erstellen Sie eine Java-Klassendatei mit dem Namen 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;
}
}Überprüfen Sie das Ergebnis
Kompilieren Sie die Klassen mit javac Compiler wie folgt -
C:\GSON_WORKSPACE>javac GsonTester.javaFühren Sie nun die aus GsonTester um das Ergebnis zu sehen -
C:\GSON_WORKSPACE>java GsonTesterÜberprüfen Sie die Ausgabe
{"rollNo":1,"name":"Mahesh Kumar"}