Gson - 快速指南

Gson - 概述

Google Gson 是一个简单的基于 Java 的库，用于将 Java 对象序列化为 JSON，反之亦然。它是由 Google 开发的开源库。

以下几点强调了为什么您应该使用这个库 -

标准化- Gson 是一个由 Google 管理的标准化库。
高效- 它是 Java 标准库的可靠、快速且高效的扩展。
优化- 该库经过高度优化。
支持泛型- 它为泛型提供广泛的支持。
支持复杂的内部类- 它支持具有深层继承层次结构的复杂对象。

Gson的特点

以下是 Gson 一些最突出的功能的列表 -

易于使用- Gson API 提供了一个高级外观来简化常用的用例。
无需创建映射- Gson API 为大多数要序列化的对象提供默认映射。
性能- Gson 速度相当快且内存占用低。它适用于大型对象图或系统。
干净的 JSON - Gson 创建一个干净紧凑的 JSON 结果，易于阅读。
无依赖关系- Gson 库不需要除 JDK 之外的任何其他库。
开源- Gson 库是开源的；它是免费提供的。

处理 JSON 的三种方式

Gson 提供了三种处理 JSON 的替代方法 -

流媒体API

它将 JSON 内容作为离散事件读取和写入。JsonReader和JsonWriter以 token 的形式读写数据，简称JsonToken。

它是处理 JSON 的三种方法中最强大的方法。它的开销最低，并且读/写操作速度相当快。它类似于 XML 的 Stax 解析器。

树模型

它准备 JSON 文档的内存中树表示。它构建了一棵 JsonObject 节点树。这是一种灵活的方法，类似于 XML 的 DOM 解析器。

数据绑定

它使用属性访问器将 JSON 与 POJO（普通旧 Java 对象）相互转换。Gson 使用数据类型适配器读取/写入 JSON。它类似于 XML 的 JAXB 解析器。

Gson - 环境设置

本地环境设置

如果您仍然想为 Java 编程语言设置本地环境，那么本节将指导您如何在计算机上下载和设置 Java。请按照以下步骤设置环境。

Java SE 可以通过下载 Java链接免费获得。因此，您可以根据您的操作系统下载一个版本。

按照说明下载 Java 并运行 .exe以在您的计算机上安装 Java。在计算机上安装 Java 后，您需要设置环境变量以指向其正确的安装目录。

在 Windows 2000/XP 中设置路径

假设您已将 Java 安装在c:\Program Files\java\jdk目录中 -

右键单击“我的电脑”并选择“属性”。
单击“高级”选项卡下的“环境变量”按钮。
接下来，更改“Path”变量，使其也包含 Java 可执行文件的路径。例如，如果路径当前设置为“C:\WINDOWS\SYSTEM32”，则将路径更改为“C:\WINDOWS\SYSTEM32;c:\Program Files\java\jdk\bin”。

在 Windows 95 / 98 / ME 中设置路径

假设您已将 Java 安装在c:\Program Files\java\jdk目录中 -

编辑“C:\autoexec.bat”文件并在末尾添加以下行：“SET PATH=%PATH%;C:\Program Files\java\jdk\bin”

设置 Linux、UNIX、Solaris、FreeBSD 的路径

环境变量PATH应设置为指向 Java 二进制文件的安装位置。如果您在执行此操作时遇到问题，请参阅您的 shell 文档。

例如，如果您使用 bash 作为 shell，那么您可以将以下行添加到 '.bashrc: export PATH=/path/to/java:$PATH' 的末尾

流行的 Java 编辑器

要编写 Java 程序，您需要一个文本编辑器。市场上有很多复杂的 IDE。但现在，您可以考虑以下其中一项 -

记事本- 在 Windows 上，您可以使用任何简单的文本编辑器，例如记事本（本教程推荐）或 TextPad。
Netbeans - 它是一个开源且免费的 Java IDE，可以从https://netbeans.org/index.html下载。
Eclipse - 它也是由 Eclipse 开源社区开发的 Java IDE，可以从https://www.eclipse.org/下载。

下载 Gson 存档

从gson-2.3.1.jar下载最新版本的 Gson jar 文件。在编写本教程时，我们下载了 gson-2.3.1.jar 并将其复制到 C:\>gson 文件夹中。

操作系统	档案名称
Windows	gson-2.3.1.jar
Linux	gson-2.3.1.jar
苹果	gson-2.3.1.jar

设置Gson环境

设置GSON_HOME环境变量以指向计算机上存储 Gson jar 的基本目录位置。

操作系统	输出
Windows	设置环境变量 GSON_HOME 为 C:\gson
Linux	导出 GSON_HOME=/usr/local/gson
苹果	导出 GSON_HOME=/库/gson

设置 CLASSPATH 变量

设置CLASSPATH环境变量以指向 Gson jar 位置。

操作系统	输出
Windows	设置环境变量CLASSPATH为%CLASSPATH%;%GSON_HOME%\gson-2.3.1.jar;.;
Linux	导出 CLASSPATH=$CLASSPATH:$GSON_HOME/gson-2.3.1.jar:。
苹果	导出 CLASSPATH=$CLASSPATH:$GSON_HOME/gson-2.3.1.jar:。

Gson - 第一次应用

在详细介绍 Google Gson 库之前，让我们先看看一个正在运行的应用程序。在此示例中，我们创建了一个Student类。我们将创建一个包含学生详细信息的 JSON 字符串，并将其反序列化为学生对象，然后将其序列化为 JSON 字符串。

例子

在 C:\>GSON_WORKSPACE 中创建名为 GsonTester 的 Java 类文件。

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

验证结果

使用javac编译器编译类，如下所示 -

C:\GSON_WORKSPACE>javac GsonTester.java

现在运行 GsonTester 查看结果 -

C:\GSON_WORKSPACE>java GsonTester

验证输出。

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

需要记住的步骤

以下是此处需要考虑的重要步骤。

步骤 1 - 使用 GsonBuilder 创建 Gson 对象

创建一个 Gson 对象。它是一个可重复使用的对象。

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

步骤 2 - 将 JSON 反序列化为对象

使用 fromJson() 方法从 JSON 中获取对象。将 Json 字符串/Json 字符串的来源和对象类型作为参数传递。

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

步骤 3 - 将对象序列化为 JSON

使用 toJson() 方法获取对象的 JSON 字符串表示形式。

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

Gson-类

Gson 是 Google Gson 库的主要 Actor 类。它提供了将 Java 对象转换为匹配的 JSON 结构的功能，反之亦然。Gson 首先使用 GsonBuilder 构建，然后使用 toJson(Object) 或 fromJson(String, Class) 方法读取/写入 JSON 构造。

类别声明

以下是com.google.gson.Gson类的声明-

public final class Gson 
   extends Object

构造函数

先生编号	构造函数及描述
1	格森() 使用默认配置构造一个 Gson 对象。

类方法

先生编号	方法及说明
1	<T> T fromJson(JsonElement json, Class<T> classOfT) 该方法将从指定解析树读取的Json反序列化为指定类型的对象。
2	<T> T fromJson(JsonElement json, 类型 typeOfT) 该方法将从指定解析树读取的Json反序列化为指定类型的对象。
3	<T> T fromJson(JsonReader reader, Type typeOfT) 从 reader 读取下一个 JSON 值并将其转换为 typeOfT 类型的对象。
4	<T> T fromJson(Reader json, Class<T> classOfT) 该方法将从指定读取器读取的 Json 反序列化为指定类的对象。
5	<T> T fromJson(阅读器 json, 类型 typeOfT) 该方法将从指定读取器读取的 Json 反序列化为指定类型的对象。
6	<T> T fromJson(String json, Class<T> classOfT) 该方法将指定的Json反序列化为指定类的对象。
7	<T> T fromJson(字符串 json, 类型 typeOfT) 该方法将指定的Json反序列化为指定类型的对象。
8	<T> TypeAdapter<T> getAdapter(Class<T> 类型) 返回类型的类型适配器。
9	<T> TypeAdapter<T> getAdapter(TypeToken<T> 类型) 返回类型的类型适配器。
10	<T> TypeAdapter<T> getDelegateAdapter(TypeAdapterFactory skipPast, TypeToken<T> 类型) 此方法用于获取指定类型的替代类型适配器。
11	字符串 toJson(JsonElement jsonElement) 将 JsonElements 树转换为其等效的 JSON 表示形式。
12	void toJson(JsonElement jsonElement，可附加写入器) 写出 JsonElements 树的等效 JSON。
13	void toJson(JsonElement jsonElement, JsonWriter writer) 将 jsonElement 的 JSON 写入 writer。
14	字符串 toJson(对象 src) 此方法将指定的对象序列化为其等效的 Json 表示形式。
15	void toJson（对象 src，可附加写入器）此方法将指定的对象序列化为其等效的 Json 表示形式。
16	字符串 toJson(对象 src, 类型 typeOfSrc) 此方法将指定的对象（包括泛型类型的对象）序列化为其等效的 Json 表示形式。
17 号	void toJson（对象 src，类型 typeOfSrc，可附加写入器）此方法将指定的对象（包括泛型类型的对象）序列化为其等效的 Json 表示形式。
18	void toJson(对象 src, 类型 typeOfSrc, JsonWriter writer) 将 typeOfSrc 类型的 src 的 JSON 表示形式写入 writer。
19	JsonElement toJsonTree(对象 src) 此方法将指定对象序列化为等效的 JsonElements 树表示形式。
20	JsonElement toJsonTree(对象 src, 类型 typeOfSrc) 此方法将指定的对象（包括泛型类型的对象）序列化为其等效的 JsonElements 树表示形式。
21	字符串转字符串()

继承的方法

该类继承了以下类的方法 -

java.lang.Object

例子

使用您选择的任何编辑器创建以下 Java 程序，并将其保存在 C:/> GSON_WORKSPACE

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

验证结果

使用javac编译器编译类，如下所示 -

C:\GSON_WORKSPACE>javac GsonTester.java

现在运行 GsonTester 查看结果 -

C:\GSON_WORKSPACE>java GsonTester

验证输出

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

Gson - 对象序列化

让我们将 Java 对象序列化为 Json 文件，然后读取该 Json 文件以获取该对象。在此示例中，我们创建了一个Student类。我们将创建一个Student.json文件，其中包含Student对象的json表示形式。

例子

在C:\>GSON_WORKSPACE中创建一个名为GsonTester的 Java 类文件。

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

验证结果

使用javac编译器编译类，如下所示 -

C:\GSON_WORKSPACE>javac GsonTester.java

现在运行 GsonTester 查看结果 -

C:\GSON_WORKSPACE>java GsonTester

验证输出

Student [ name: Mahesh, age: 10 ]

Gson - 数据绑定

数据绑定 API 用于使用属性访问器或使用注释将 JSON 与 POJO（普通旧 Java 对象）相互转换。它有两种类型。

基元数据绑定- 将 JSON 与 Java 映射、列表、字符串、数字、布尔值和 NULL 对象相互转换。
对象数据绑定- 将 JSON 与任何 JAVA 类型相互转换。

Gson 读取/写入两种类型数据绑定的 JSON。数据绑定类似于 XML 的 JAXB 解析器。

基元数据绑定

基元数据绑定是指 JSON 到 JAVA Core 数据类型和内置集合的映射。Gson 提供了各种内置适配器，可用于序列化/反序列化原始数据类型。

例子

让我们看看原始数据绑定的实际应用。在这里，我们将 JAVA 基本类型直接映射到 JSON，反之亦然。

在C:\>Gson_WORKSPACE中创建名为GsonTester的 Java 类文件。

文件 - 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)); 
   } 
}

验证结果

使用javac编译器编译类，如下所示 -

C:\GSON_WORKSPACE>javac GsonTester.java

现在运行GsonTester查看结果 -

C:\GSON_WORKSPACE>java GsonTester

验证输出。

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

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

Gson - 对象数据绑定

对象数据绑定是指将 JSON 映射到任何 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);

例子

让我们看看对象数据绑定的实际应用。在这里，我们将 JAVA 对象直接映射到 JSON，反之亦然。

在 C:\>GSON_WORKSPACE 中创建名为GsonTester的 Java 类文件。

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

验证结果

使用javac编译器编译类，如下所示 -

C:\GSON_WORKSPACE>javac GsonTester.java

现在运行GsonTester查看结果 -

C:\GSON_WORKSPACE>java GsonTester

验证输出。

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

Gson - 树模型

树模型准备 JSON 文档的内存中树表示。它构建了一棵 JsonObject 节点树。这是一种灵活的方法，类似于 XML 的 DOM 解析器。

从 JSON 创建树

JsonParser 在读取 JSON 后提供指向树的根节点的指针。根节点可以用来遍历完整的树。考虑以下代码片段来获取所提供的 JSON 字符串的根节点。

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

遍历树模型

遍历树时使用到根节点的相对路径获取每个节点并处理数据。下面的代码片段展示了如何遍历一棵树。

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

例子

在 C:\>GSON_WORKSPACE 中创建名为GsonTester的 Java 类文件。

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

验证结果

使用javac编译器编译类，如下所示 -

C:\GSON_WORKSPACE>javac GsonTester.java

现在运行GsonTester查看结果 -

C:\GSON_WORKSPACE>java GsonTester

验证输出。

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

Gson - 流媒体

Streaming API 用于逐个读取 JSON 令牌。它将 JSON 内容作为离散事件读取和写入。JsonReader和JsonWriter以 token 的形式读写数据，简称JsonToken。

它是处理 JSON 的三种方法中最强大的方法。它的开销最低，并且读/写操作速度相当快。它类似于 XML 的 Stax 解析器。

在本章中，我们将展示如何使用 GSON 流 API 来读取 JSON 数据。Streaming API使用token的概念，Json的每一个细节都要小心处理。

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

例子

让我们看看JsonReader 的实际应用。在 C:\>GSON_WORKSPACE 中创建名为GsonTester的 Java 类文件。

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

验证结果

使用javac编译器编译类，如下所示 -

C:\GSON_WORKSPACE>javac GsonTester.java

现在运行GsonTester查看结果 -

C:\GSON_WORKSPACE>java GsonTester

验证输出。

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

Gson - 序列化示例

在本章中，我们将讨论数组、集合和泛型的序列化/反序列化。

数组示例

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

例子

让我们看看数组序列化/反序列化的实际效果。在 C:\>GSON_WORKSPACE 中创建名为GsonTester的 Java 类文件。

文件 - 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));     
   }      
}

验证结果

使用javac编译器编译类，如下所示 -

C:\GSON_WORKSPACE>javac GsonTester.java

现在运行 GsonTester 查看结果 -

C:\GSON_WORKSPACE>java GsonTester

验证输出。

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

集合示例

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>

例子

让我们看看集合序列化/反序列化的实际效果。在 C:\>GSON_WORKSPACE 中创建名为GsonTester的 Java 类文件。

文件 - 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);     
   }      
}

验证结果

使用javac编译器编译类，如下所示 -

C:\GSON_WORKSPACE>javac GsonTester.java

现在运行GsonTester查看结果 -

C:\GSON_WORKSPACE>java GsonTester

验证输出。

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

泛型示例

Gson 使用 Java 反射 API 来获取 Json 文本要映射到的对象的类型。但对于泛型，这些信息在序列化过程中会丢失。为了解决这个问题，Gson 提供了一个类com.google.gson.reflect.TypeToken来存储通用对象的类型。

例子

让我们看看泛型序列化/反序列化的实际效果。在 C:\>GSON_WORKSPACE 中创建名为GsonTester的 Java 类文件。

文件 - 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); 
   } 
}

验证结果

使用javac编译器编译类，如下所示 -

C:\GSON_WORKSPACE>javac GsonTester.java

现在运行GsonTester查看结果 -

C:\GSON_WORKSPACE>java GsonTester

验证输出。

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

Gson - 序列化内部类

在本章中，我们将解释具有内部类的类的序列化/反序列化。

嵌套内部类示例

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

例子

让我们看一个带有内部类的类序列化/反序列化的示例。在 C:\>GSON_WORKSPACE 中创建名为GsonTester的 Java 类文件。

文件 - 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; 
   } 
}

验证结果

使用javac编译器编译类，如下所示 -

C:\GSON_WORKSPACE>javac GsonTester.java

现在运行 GsonTester 查看结果 -

C:\GSON_WORKSPACE>java GsonTester

验证输出。

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

嵌套静态内部类示例

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

例子

让我们看一下使用静态内部类进行类的序列化/反序列化的示例。在 C:\>GSON_WORKSPACE 中创建名为 GsonTester 的 Java 类文件。

文件 - 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; 
   } 
}

验证结果

使用javac编译器编译类，如下所示 -

C:\GSON_WORKSPACE>javac GsonTester.java

现在运行GsonTester查看结果 -

C:\GSON_WORKSPACE>java GsonTester

验证输出。

{"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 - 自定义类型适配器

Gson 使用其内置适配器执行对象的序列化/反序列化。它还支持自定义适配器。让我们讨论如何创建自定义适配器以及如何使用它。

创建自定义适配器

通过扩展TypeAdapter类并向其传递目标对象的类型来创建自定义适配器。重写读取和写入方法以分别执行自定义反序列化和序列化。

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

注册自定义适配器

使用 GsonBuilder 注册自定义适配器并使用GsonBuilder创建 Gson 实例。

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

使用适配器

Gson 现在将使用自定义适配器将 Json 文本转换为对象，反之亦然。

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

例子

让我们看看自定义类型适配器的实际应用示例。在 C:\>GSON_WORKSPACE 中创建名为GsonTester的 Java 类文件。

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

验证结果

使用javac编译器编译类，如下所示 -

C:\GSON_WORKSPACE>javac GsonTester.java

现在运行GsonTester查看结果 -

C:\GSON_WORKSPACE>java GsonTester

验证输出。

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

Gson - 空对象支持

Gson 默认生成优化的 Json 内容，忽略 NULL 值。但 GsonBuilder 提供了使用GsonBuilder.serializeNulls()方法在 Json 输出中显示 NULL 值的标志。

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

没有serializeNulls调用的示例

在 C:\>GSON_WORKSPACE 中创建名为GsonTester的 Java 类文件。

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

验证结果

使用javac编译器编译类，如下所示 -

C:\GSON_WORKSPACE>javac GsonTester.java

现在运行 GsonTester 查看结果 -

C:\GSON_WORKSPACE>java GsonTester

验证输出。

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

SerializeNulls 调用示例

在 C:\>GSON_WORKSPACE 中创建名为 GsonTester 的 Java 类文件。

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

验证结果

使用javac编译器编译类，如下所示 -

C:\GSON_WORKSPACE>javac GsonTester.java

现在运行GsonTester查看结果 -

C:\GSON_WORKSPACE>java GsonTester

验证输出。

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

Gson - 版本控制支持

Gson提供了@Since注解来根据类的各个版本来控制类的Json序列化/反序列化。考虑以下具有版本控制支持的类。在这个类中，我们最初定义了两个变量rollNo和name，后来我们添加了verify作为新变量。使用@Since，我们从版本 1.0 开始定义了rollNo和name，并验证为版本 1.1。

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

GsonBuilder 提供了setVersion()方法来序列化此类版本化类。

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

例子

让我们看一下版本控制支持的实际示例。在 C:\>GSON_WORKSPACE 中创建名为GsonTester的 Java 类文件。

文件 - 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; 
   } 
}

验证结果

使用javac编译器编译类，如下所示 -

C:\GSON_WORKSPACE>javac GsonTester.java

现在运行 GsonTester 查看结果 -

C:\GSON_WORKSPACE>java GsonTester

验证输出。

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

Gson - 从序列化中排除字段

默认情况下，GSON 从序列化/反序列化过程中排除瞬态和静态字段。让我们看一下下面的例子。

例子

在 C:\>GSON_WORKSPACE 中创建名为GsonTester的 Java 类文件。

文件 - 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; 
   } 
}

验证结果

使用javac编译器编译类，如下所示 -

C:\GSON_WORKSPACE>javac GsonTester.java

现在运行GsonTester查看结果 -

C:\GSON_WORKSPACE>java GsonTester

验证输出

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

使用带有修饰符的排除字段

GsonBuilder 使用从序列化/反序列化过程中排除的 FieldsWithModifiers() 方法提供对排除具有特定修饰符的字段的控制。请参阅以下示例。

例子

在 C:\>GSON_WORKSPACE 中创建名为 GsonTester 的 Java 类文件。

文件 - 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; 
   } 
}

验证结果

使用javac编译器编译类，如下所示 -

C:\GSON_WORKSPACE>javac GsonTester.java

现在运行GsonTester查看结果 -

C:\GSON_WORKSPACE>java GsonTester

验证输出

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

使用@Expose注解

Gson 提供了@Expose注解来根据类的作用域来控制类的 Json 序列化/反序列化。考虑以下类，其中的变量具有@Expose支持。在此类中，将公开name和rollno变量以进行序列化。然后我们使用GsonBuilder.excludeFieldsWithoutExposeAnnotation()方法来指示仅公开的变量要被序列化/反序列化。请参阅以下示例。

例子

在 C:\>GSON_WORKSPACE 中创建名为GsonTester的 Java 类文件。

文件 - 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; 
   } 
}

验证结果

使用javac编译器编译类，如下所示 -

C:\GSON_WORKSPACE>javac GsonTester.java

现在运行GsonTester查看结果 -

C:\GSON_WORKSPACE>java GsonTester

验证输出

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