本文将重点介绍如何使用 Gson 序列化嵌套类，包括内部类。

什么是嵌套类？

在 Java 中，嵌套类是指在一个类的内部定义的另一个类。嵌套类可以分为两种类型：静态嵌套类（也称为静态内部类）和非静态嵌套类（也称为成员内部类）。静态嵌套类与外部类之间没有直接的引用关系，而非静态嵌套类则与外部类实例相关联。

Gson序列化嵌套类的基本用法

Gson 可以很容易地序列化和反序列化静态嵌套类。

要使用 Gson 序列化嵌套类，我们首先需要确保 Gson 库已添加到项目中。可以通过 Maven、Gradle 或手动下载 jar 包的方式导入 Gson 库。

例如，如果使用 Maven，在 pom.xml 文件中添加以下依赖项：

1
2
3
4
5
6
<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.10.1</version>
    <scope>compile</scope>
</dependency>

下面的示例，展示了如何使用 Gson 序列化和反序列化嵌套类：

OuterClass 类：

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
package com.johnson.gson;

/**
 * @author johnson lin
 * @date 2023/8/1 06:27
 */
public class OuterClass {
    private String outerField;

    public String getOuterField() {
        return outerField;
    }

    public void setOuterField(String outerField) {
        this.outerField = outerField;
    }

    public static class StaticNestedClass {
        private String staticNestedClassField;

        public String getStaticNestedClassField() {
            return staticNestedClassField;
        }

        public void setStaticNestedClassField(String staticNestedClassField) {
            this.staticNestedClassField = staticNestedClassField;
        }
    }

    public class InnerClass {
        private int value;

        public int getValue() {
            return value;
        }

        public void setValue(int value) {
            this.value = value;
        }
    }
}

OuterClassExample 类：

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
package com.johnson.gson;

import com.google.gson.Gson;

/**
 * @author johnson lin
 * @date 2023/8/1 06:30
 */
public class OuterClassExample {
    public static void main(String[] args) {
        Gson gson = new Gson();

        // 序列化静态嵌套类
        OuterClass.StaticNestedClass staticNestedClass = new OuterClass.StaticNestedClass();
        staticNestedClass.setStaticNestedClassField("John and Jack");
        String json1 = gson.toJson(staticNestedClass);
        System.out.println(json1);

        // 反序列化静态嵌套类
        OuterClass.StaticNestedClass deserializedStaticNestedClass = gson.fromJson(json1, OuterClass.StaticNestedClass.class);
        System.out.println(deserializedStaticNestedClass.getStaticNestedClassField());

        // 序列化非静态嵌套类
        OuterClass.InnerClass t = new OuterClass().new InnerClass();
        t.setValue(8080);

        String json2 = gson.toJson(t);
        System.out.println(json2);

        // 反序列化非静态嵌套类
        OuterClass.InnerClass deserializedInnerClass = gson.fromJson(json2, OuterClass.InnerClass.class);
        System.out.println(deserializedInnerClass.getValue());
    }
}
/*
此代码示例执行结果如下：

{"staticNestedClassField":"John and Jack"}
John and Jack
{"value":8080}
8080

*/

在上述示例中，我们首先创建了一个静态嵌套类 StaticNestedClass 和一个非静态嵌套类 InnerClass，它们分别包含了不同的成员变量。然后，我们使用 Gson 库将这两个类序列化为 JSON 字符串，并将其打印出来。接着，我们使用 Gson 库将 JSON 字符串反序列化回原始对象，并将其中的成员变量值打印出来。

小结

通过使用 Gson 库，我们可以方便地将嵌套类（包括静态嵌套类和非静态嵌套类）序列化为 JSON 字符串，并在需要时反序列化回原始对象。这为我们在 Java 应用程序中处理复杂对象结构提供了便利。

然而，需要注意的是，即使 Gson 可以处理嵌套类的序列化和反序列化，但在某些情况下，由于内部类与外部类的引用关系，可能会导致一些潜在的问题。因此，在实际开发中，我们需要仔细考虑嵌套类的使用场景，并确保它们符合我们的需求。

希望本文对您了解如何使用 Gson 序列化嵌套类提供了一些帮助。

参考资料：

（END）