在本文中，我们将学习如何使用 Gson 进行序列化和反序列化操作。
在Maven中使用Gson
要在 Maven 中使用 Gson，可以通过添加以下依赖关系，使用 Maven Central 中的 Gson 版本：
1
2
3
4
5
6
7
8
9
| <dependencies>
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.10.1</version>
<scope>compile</scope>
</dependency>
</dependencies>
|
现在，我们的 Maven 项目已经成功地集成了 Gson。
序列化与反序列化原始类型
以下代码演示了使用 Gson 库对基本数据类型进行序列化和反序列化的示例。
首先，在 main 方法中创建一个 Gson 对象，通过 gson.toJson() 方法可以将基本数据类型和字符串对象序列化为 JSON 格式的字符串，并使用 System.out.println() 打印出来。例如，System.out.println("INT类型：" + gson.toJson(8080)); 将整数 8080 序列化为 JSON 字符串并打印出来。
接下来，将整数数组 intArray 序列化为JSON字符串：System.out.println(gson.toJson(intArray));。
然后，通过 gson.fromJson() 方法可以将 JSON 字符串反序列化为相应的基本数据类型或对象，并将其打印出来。例如，int i = gson.fromJson("8080", int.class); 将字符串 "8080" 反序列化为整数并赋值给变量 i，然后将其打印出来。
其他的反序列化示例包括将字符串反序列化为 Integer 对象、Long 对象、Boolean 对象、字符串对象、字符串数组等，并将它们打印出来。
示例代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
| package com.johnson.gson;
import com.google.gson.Gson;
import java.util.Arrays;
public class PrimitiveExample {
public static void main(String[] args) {
Gson gson = new Gson();
System.out.println("基本数据类型序列化：");
System.out.println("INT类型：" + gson.toJson(8080));
System.out.println("Long类型：" + gson.toJson(Long.MAX_VALUE));
System.out.println("String类型：" + gson.toJson("Daddy finger daddy finger where are you"));
System.out.println();
System.out.println("整数数组序列化：");
int[] intArray = {8080, 8081, 8090};
System.out.println(gson.toJson(intArray));
System.out.println();
System.out.println("基本数据类型反序列化：");
int i = gson.fromJson("8080", int.class);
Integer intObj = gson.fromJson("8081", Integer.class);
Long longObj = gson.fromJson("10000", Long.class);
Boolean boolObj = gson.fromJson("true", Boolean.class);
String str = gson.fromJson("\"abc\"", String.class);
String[] strArray = gson.fromJson("[\"abc\",\"plain text\"]", String[].class);
System.out.println("int: " + i);
System.out.println("Integer: " + intObj);
System.out.println("Long: " + longObj);
System.out.println("Boolean: " + boolObj);
System.out.println("String: " + str);
System.out.println("String[]: " + Arrays.toString(strArray));
}
}
|
对Java对象进行序列化
使用 Gson 进行序列化非常简单。以下是一个示例，我们将使用实体类 PrimitiveBundle：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
| package com.johnson.gson;
public class PrimitiveBundle {
public byte byteValue;
public short shortValue;
public int intValue;
public long longValue;
public float floatValue;
public double doubleValue;
public boolean booleanValue;
public char charValue;
public byte getByteValue() {
return byteValue;
}
public void setByteValue(byte byteValue) {
this.byteValue = byteValue;
}
public short getShortValue() {
return shortValue;
}
public void setShortValue(short shortValue) {
this.shortValue = shortValue;
}
public int getIntValue() {
return intValue;
}
public void setIntValue(int intValue) {
this.intValue = intValue;
}
public long getLongValue() {
return longValue;
}
public void setLongValue(long longValue) {
this.longValue = longValue;
}
public float getFloatValue() {
return floatValue;
}
public void setFloatValue(float floatValue) {
this.floatValue = floatValue;
}
public double getDoubleValue() {
return doubleValue;
}
public void setDoubleValue(double doubleValue) {
this.doubleValue = doubleValue;
}
public boolean isBooleanValue() {
return booleanValue;
}
public void setBooleanValue(boolean booleanValue) {
this.booleanValue = booleanValue;
}
public char getCharValue() {
return charValue;
}
public void setCharValue(char charValue) {
this.charValue = charValue;
}
}
|
首先，我们使用一些测试值来初始化一个实例：
1
2
3
4
5
6
7
8
9
| PrimitiveBundle bundle = new PrimitiveBundle();
bundle.setByteValue((byte) 0x00000011);
bundle.setShortValue((short) 125);
bundle.setIntValue(125);
bundle.setLongValue(125L);
bundle.setFloatValue(3.14159F);
bundle.setDoubleValue(3.14159);
bundle.setBooleanValue(true);
bundle.setCharValue('X');
|
接下来，对其进行序列化：
1
2
| Gson gson = new Gson();
String json = gson.toJson(bundle);
|
格式化后的输出结果如下：
1
2
3
4
5
6
7
8
9
10
| {
"byteValue":17,
"shortValue":125,
"intValue":125,
"longValue":125,
"floatValue":3.14159,
"doubleValue":3.14159,
"booleanValue":true,
"charValue":"X"
}
|
完整的代码如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
| package com.johnson.gson;
import com.google.gson.Gson;
public class ObjectExample {
public static void main(String[] args) {
PrimitiveBundle bundle = new PrimitiveBundle();
bundle.setByteValue((byte) 0x00000011);
bundle.setShortValue((short) 125);
bundle.setIntValue(125);
bundle.setLongValue(125L);
bundle.setFloatValue(3.14159F);
bundle.setDoubleValue(3.14159);
bundle.setBooleanValue(true);
bundle.setCharValue('X');
Gson gson = new Gson();
String json = gson.toJson(bundle);
System.out.println(json);
}
}
|
在示例中，我们应该注意一些细节。首先，byte 值不会像实例中定义一样被序列化为一串位。此外，short、int 和 long 之间没有区别。同样，浮点数和双精度数之间也没有区别。
另一个需要注意的是，使用字符串来表示字符值。
实际上，这些细节与 Gson 无关，而是由 JSON 的定义方式决定的。
对JSON字符串进行反序列化
现在让我们来看看如何对上一个示例中获取的 JSON 字符串进行反序列化。
反序列化和序列化一样简单：
1
2
| Gson gson = new Gson();
PrimitiveBundle model = gson.fromJson(json, PrimitiveBundle.class);
|
最后，我们可以打印输出该对象 model，验证是否包含所需的值：
1
| System.out.println(model);
|
输出结果如下：
1
| PrimitiveBundle{byteValue=17, shortValue=125, intValue=125, longValue=125, floatValue=3.14159, doubleValue=3.14159, booleanValue=true, charValue=X}
|
小结
本文介绍了如何使用 Gson 库进行序列化和反序列化操作。
首先，使用 Maven 中央仓库中的 Gson 版本，在 Maven 项目中添加相关依赖。然后，通过创建 Gson 对象，可以将基本数据类型和字符串对象序列化为 JSON 格式的字符串。示例代码还演示了将整数数组序列化为 JSON 字符串的方法。
接下来，通过使用 gson.fromJson() 方法，可以将 JSON 字符串反序列化为相应的基本数据类型或对象。示例还包括将字符串反序列化为 Integer、Long、Boolean、字符串对象和字符串数组的示例。
另外，文章还展示了如何使用 Gson 将 Java 对象进行序列化和反序列化操作。通过创建一个实体类，设置属性的值，然后使用 Gson 将对象序列化为 JSON 字符串。反序列化操作与序列化类似，只需使用 gson.fromJson() 方法将 JSON 字符串反序列化为相应的对象。
（END）
