Gson基本使用：序列化与反序列化操作详解

在本文中，我们将学习如何使用 Gson 进行序列化和反序列化操作。

在Maven中使用Gson

要在 Maven 中使用 Gson，可以通过添加以下依赖关系，使用 Maven Central 中的 Gson 版本：

<dependencies>
    <!--  Gson: Java to JSON conversion -->
    <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 对象、字符串对象、字符串数组等，并将它们打印出来。

示例代码：

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));
    }
}
/*
此代码示例执行结果如下：

基本数据类型序列化：
INT类型：8080
Long类型：9223372036854775807
String类型："Daddy finger daddy finger where are you"

整数数组序列化：
[8080,8081,8090]

基本数据类型反序列化：
int: 8080
Integer: 8081
Long: 10000
Boolean: true
String: abc
String[]: [abc, plain text]

*/

对Java对象进行序列化

使用 Gson 进行序列化非常简单。以下是一个示例，我们将使用实体类 PrimitiveBundle：

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

首先，我们使用一些测试值来初始化一个实例：

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

格式化后的输出结果如下：

{
    "byteValue":17,
    "shortValue":125,
    "intValue":125,
    "longValue":125,
    "floatValue":3.14159,
    "doubleValue":3.14159,
    "booleanValue":true,
    "charValue":"X"
}

完整的代码如下：

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);
    }
}
/*
此代码示例执行结果如下：

{"byteValue":17,"shortValue":125,"intValue":125,"longValue":125,"floatValue":3.14159,"doubleValue":3.14159,"booleanValue":true,"charValue":"X"}

*/

在示例中，我们应该注意一些细节。首先，byte 值不会像实例中定义一样被序列化为一串位。此外，short、int 和 long 之间没有区别。同样，浮点数和双精度数之间也没有区别。

另一个需要注意的是，使用字符串来表示字符值。

实际上，这些细节与 Gson 无关，而是由 JSON 的定义方式决定的。

对JSON字符串进行反序列化

现在让我们来看看如何对上一个示例中获取的 JSON 字符串进行反序列化。

反序列化和序列化一样简单：

Gson gson = new Gson();
PrimitiveBundle model = gson.fromJson(json, PrimitiveBundle.class);

最后，我们可以打印输出该对象 model，验证是否包含所需的值：

System.out.println(model);

输出结果如下：

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）