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 将数据读/写为标记，称为 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 文件夹中。

设置 Gson 环境

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

设置 CLASSPATH 变量

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

Gson - 第一个应用

在深入了解 Google Gson 库的细节之前，让我们先看看一个正在运行的应用程序。在此示例中，我们创建了一个 Student 类。我们将创建一个包含学生详细信息的 JSON 字符串，并将其反序列化为 student 对象，然后将其序列化为 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 库的主要参与者类。它提供了将 Java 对象转换为匹配的 JSON 结构以及反之的功能。Gson 最初是使用 GsonBuilder 构造的，然后使用 toJson(Object) 或 fromJson(String, Class) 方法来读取/写入 JSON 结构。

类声明

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

public final class Gson 
   extends Object 

构造函数

类方法

继承的方法

此类继承自以下类：

• 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 对象）并从 POJO 转换。它有两种类型。

• 基本数据绑定 - 将 JSON 转换为 Java Map、List、String、Number、Boolean 和 NULL 对象，以及从这些类型转换。

• 对象数据绑定 - 将 JSON 转换为任何 JAVA 类型，以及从任何 JAVA 类型转换。

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

基本数据绑定

基本数据绑定指的是将 JSON 映射到 JAVA 核心数据类型和内置集合。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 - 流处理

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

它是三种处理 JSON 方法中最强大的方法。它具有最低的开销，并且在读/写操作中非常快。它类似于 XML 的 Stax 解析器。

在本章中，我们将展示使用 GSON 流式 API 读取 JSON 数据的用法。流式 API 使用令牌的概念，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类并传递目标对象的类型来创建自定义适配器。覆盖read和write方法分别执行自定义反序列化和序列化。

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，后来我们添加了verified作为新变量。使用 @Since，我们将rollNo和name定义为版本 1.0，将 verified 定义为版本 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 会从序列化/反序列化过程中排除 transient 和 static 字段。让我们看看下面的例子。

示例

在 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}

使用 excludeFieldsWithModifiers

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

示例

在 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"}