Java中Gson的使用详解

Gson是Google提供的一种Java序列化/反序列化库，可让Java对象与JSON序列进行转换。Gson可以从 JSON 中读取 Java 对象，也可以将 Java 对象转换到 JSON 中。因此，Gson可以轻松地将Java对象序列化为JSON格式的字符串，也可以将JSON格式的字符串反序列化为Java对象。

Gson基础使用

添加依赖

首先，我们需要将Gson添加到我们的项目中。你可以通过以下Maven坐标引入：

<dependency>
  <groupId>com.google.code.gson</groupId>
  <artifactId>gson</artifactId>
  <version>2.8.7</version>
</dependency>

或者将以下Gradle代码添加到你的项目中：

dependencies {
    implementation 'com.google.code.gson:gson:2.8.7'
}

Java对象转JSON格式字符串

我们可以使用toJson()方法将Java对象转换为JSON格式字符串：

User user = new User("张三", 18);
Gson gson = new Gson();
String json = gson.toJson(user);
System.out.println(json); //输出 {"name":"张三","age":18}

在上面的示例中，我们创建了一个名为user的Java对象，并使用toJson()方法将其转换为JSON格式字符串。在这里，我们使用了gson.toJson()方法将对象转换为JSON格式字符串，该对象提供以下公共方法：

class User {
    private String name;
    private int age;

    // 构造函数、getter和setter方法等（省略）
}

JSON格式字符串转Java对象

我们可以使用fromJson()方法将JSON格式字符串转换为Java对象：

String json = "{\"name\":\"张三\",\"age\":18}";
Gson gson = new Gson();
User user = gson.fromJson(json, User.class);
System.out.println(user.toString()); // 输出 User{name='张三', age=18}

在上面的示例中，我们创建了一个JSON格式字符串，并使用Gson的fromJson()方法将其转换为Java对象。fromJson()方法具有以下签名：public <T> T fromJson(String json, Class<T> classOfT) throws JsonSyntaxException。JsonSyntaxException是Gson提供的异常类，如果JSON格式不正确，则会引发该异常。classOfT参数用于指定要转换的对象的类型。

Gson的高级用法

除了上面的基本用法，Gson还提供了许多高级用法。在这里，我们将介绍Gson的两个高级用法：自定义JSON序列化和反序列化规则以及处理JSON嵌套。

自定义JSON序列化和反序列化规则

我们可以通过实现JsonSerializer和JsonDeserializer接口来自定义JSON序列化和反序列化规则。

自定义序列化规则

接下来，我们将从对象中获取年龄，并将其转换为数字字符串格式。代码如下所示：

public class UserAgeJsonSerializer implements JsonSerializer<User> {

    @Override
    public JsonElement serialize(User src, Type typeOfSrc, JsonSerializationContext context) {
        JsonObject jsonObject = new JsonObject();
        jsonObject.addProperty("name", src.getName());
        jsonObject.addProperty("age", String.valueOf(src.getAge())); // 将age转为字符串
        return jsonObject;
    }
}

在上面的示例中，我们创建一个UserAgeJsonSerializer类并实现JsonSerializer接口。在serialize()方法中，我们使用JsonOjbect对象创建一个新的JSON对象，并使用addProperty方法将name和age字段添加到该对象中。

现在，我们已经实现了UserAgeJsonSerializer序列化器，我们可以在Gson对象的builder中使用registerTypeAdapter方法将其注册为User类的序列化程序，如下所示：

Gson gson = new GsonBuilder()
        .registerTypeAdapter(User.class, new UserAgeJsonSerializer())
        .create();

User user = new User("张三", 18);
String json = gson.toJson(user);
System.out.println(json); // 输出 {"name":"张三","age":"18"}

自定义反序列化规则

我们可以通过实现JsonDeserializer接口来自定义反序列化规则。代码如下所示：

public class UserAgeJsonDeserializer implements JsonDeserializer<User> {

    @Override
    public User deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
        JsonObject jsonObject = json.getAsJsonObject();
        String name = jsonObject.get("name").getAsString();
        int age = Integer.parseInt(jsonObject.get("age").getAsString());
        return new User(name, age);
    }
}

在上面的示例中，我们创建一个UserAgeJsonDeserializer类并实现JsonDeserializer接口。在deserialize()方法中，我们从JsonElement对象中获取JSON数据，并将其转换为User对象。我们使用getAsJsonObject()方法获取包含数据的JSON对象。接下来，我们使用getAsString()或getAsInt()等JsonElement对象的方法从JSONObject中获取数据，并将其转换为适当的数据类型。

现在，我们已经实现了UserAgeJsonDeserializer序列化器，我们可以在Gson对象的builder中使用registerTypeAdapter方法将其注册为User类的反序列化程序，如下所示：

Gson gson = new GsonBuilder()
        .registerTypeAdapter(User.class, new UserAgeJsonDeserializer())
        .create();

String json = "{\"name\":\"张三\",\"age\":\"18\"}";
User user = gson.fromJson(json, User.class);
System.out.println(user.toString()); // 输出 User{name='张三', age=18}

处理JSON嵌套

如果我们的Java对象具有复杂的结构，包含嵌套的对象，我们可以使用Gson处理嵌套的JSON数据。

嵌套对象

让我们考虑一种情况，我们的User类包含Address对象。我们将使用Gson来序列化此结构，如下所示：

class User {
    private String name;
    private int age;
    private Address address;

    // 构造函数、getter和setter方法等（省略）
}

class Address {
    private String province;
    private String city;

    // 构造函数、getter和setter方法等（省略）
}

我们可以使用以下语法将User的address字段序列化到JSON对象中：

Gson gson = new Gson();
User user = new User("张三", 18);
Address address = new Address();
address.setProvince("北京市");
address.setCity("北京市");
user.setAddress(address);

String json = gson.toJson(user);
System.out.println(json); 
// 输出 {"name":"张三","age":18,"address":{"province":"北京市","city":"北京市"}}

嵌套集合

如果我们的Java对象包含嵌套的集合，我们可以使用以下语法将集合序列化为JSON。例如，如果我们的User类包含一个List

字段：

class User {
    private String name;
    private int age;
    private List<Address> addressList;

    // 构造函数、getter和setter方法等（省略）
}

我们可以使用以下语法将addressList序列化到JSON对象中：

Gson gson = new Gson();
User user = new User("张三", 18);

List<Address> addressList = new ArrayList<>();
Address address1 = new Address();
address1.setProvince("北京市");
address1.setCity("北京市");

Address address2 = new Address();
address2.setProvince("上海市");
address2.setCity("上海市");

addressList.add(address1);
addressList.add(address2);

user.setAddressList(addressList);

String json = gson.toJson(user);
System.out.println(json); 
// 输出 {"name":"张三","age":18,"addressList":[{"province":"北京市","city":"北京市"},{"province":"上海市","city":"上海市"}]}

解析这样的嵌套集合也很简单。要将JSON数据解析到嵌套集合中，我们只需要提供合适的对象：

String json = "{\"name\":\"张三\",\"age\":18,\"addressList\":[{\"province\":\"北京市\",\"city\":\"北京市\"},{\"province\":\"上海市\",\"city\":\"上海市\"}]}";
Gson gson = new Gson();
User user = gson.fromJson(json, User.class);
System.out.println(user.toString()); 
// 输出 User{name='张三', age=18, addressList=[Address{province='北京市', city='北京市'}, Address{province='上海市', city='上海市'}]}

总结

Gson是一个轻量级、开源、易于使用的Java库，可用于将Java对象序列化为JSON格式字符串，以及将JSON格式字符串反序列化为Java对象。上述攻略中，我们简要介绍了Gson的基础和高级用法，并提供了自定义JSON规则序列化、反序列化和嵌套对象和集合的示例。Gson可以轻松地处理复杂结构的Java对象，并将其转换为JSON格式，这使得它成为现代Java开发中必不可少的工具之一。