gson

1.引入依赖：

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

2.创建gson：

1）直接New:多个实例

Gson gson = new Gson();

2）通过构建器：

GsonBuilder builder = new GsonBuilder();
Gson gson = builder.create();

// 简化为一行也可以new GsonBuilder().create()

构建器可以设置null值也需要序列化：

GsonBuilder().serializeNulls().create()

3）单例模式，工厂方法（推荐）：

import java.io.Serializable;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

public class GsonFactory implements Serializable {

    private GsonFactory() {
        super();
    }

    private static class GsonHolder {
        public static Gson gson = new GsonBuilder().serializeNulls().create();
    }

    public static Gson getInstance() {
        return GsonHolder.gson;
    }
}

使用不同的 Gson 实例：适用于需要不同配置的情况，提供灵活性但增加资源消耗和复杂性。
共享一个 Gson 实例：适用于需要相同配置的情况，节省资源并确保一致性。
GsonBuilder().serializeNulls().create()：配置 Gson 在序列化时包含 null 值，并创建一个 Gson 实例。

对象转json：

People P1=new People("菠萝吹雪",15,"黑龙江");
People P2=new People("橙留香",16,"上海");
Gson gson=new GsonBuilder()
             .setPrettyPrinting()
             .create();
String P11=gson.toJson(P1);
String P21=gson.toJson(P2);
System.out.println(P11);
System.out.println(P21);

json转对象：

            String jsonP1="{\n" +
                    "  \"name\": \"菠萝吹雪\",\n" +
                    "  \"age\": 15,\n" +
                    "  \"city\": \"黑龙江\"\n" +
                    "}";
            String jsonP2="{\n" +
                    "  \"name\": \"橙留香\",\n" +
                    "  \"age\": 16,\n" +
                    "  \"city\": \"上海\"\n" +
                    "}";
            Gson gson=new Gson();
            People people1 = gson.fromJson(jsonP1, People.class);
            People people2 = gson.fromJson(jsonP2, People.class);
            System.out.println(people1);
            System.out.println(people2);

一般这样定义一个用来序列化的javabean：

package com.ecarx.sumatra.data.entity.device;

import java.io.Serializable;

import com.ecarx.sumatra.data.common.GsonFactory;
import com.ecarx.sumatra.data.entity.vehicle.VehicleEntity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class DeviceEntity implements Serializable {
    private String id;
    private String device_id;
    private String device_name;
    private String device_type;
    private String manufacture_id;
    private String brand_id;
    private String model_id;
    private String ecarx_id;
    private String source;
    private String device_status;
    private String upgrade_status;
    private String platform;
    private String release_date;
    private String feature;
    private String remark;
    private String status;
    private String batch_no;
    private String custom_feature;
    private String last_user;
    private String gmt_created;
    private String gmt_modified;

    @Override
    public String toString() {
        return GsonFactory.getInstance().toJson(this);
    }
}

`JsonObject` 是 `Gson` 库中的一个类，用于表示 JSON 对象。它允许你创建、操作和解析 JSON 数据结构。`JsonObject` 是 `com.google.gson.JsonElement` 的一个子类，这意味着它可以与其他 `JsonElement` 类型（如 `JsonArray`, `JsonPrimitive`, 和 `JsonNull`）一起使用。

### 主要特点

1. **键值对存储**：`JsonObject` 本质上是一个键值对的集合，其中键是字符串类型，值是 `JsonElement` 类型。
2. **嵌套结构**：可以包含其他 `JsonObject` 或 `JsonArray` 实例，从而构建复杂的 JSON 结构。
3. **动态添加/移除元素**：你可以随时向 `JsonObject` 添加或移除键值对。
4. **序列化和反序列化**：支持将 Java 对象转换为 JSON (`JsonObject`) 和从 JSON 转换回 Java 对象。

### 常用方法

- **add(String memberName, JsonElement value)**: 向 `JsonObject` 添加一个新的成员。如果成员已存在，则会替换其值。
- **addProperty(String property, String value)**, **addProperty(String property, Number value)**, **addProperty(String property, Boolean value)**, **addProperty(String property, Character value)**: 直接添加基本类型的属性到 `JsonObject`。
- **get(String memberName)**: 获取指定名称的成员。返回的是 `JsonElement` 类型，因此你需要根据实际情况进行类型转换。
- **has(String memberName)**: 检查 `JsonObject` 是否包含指定名称的成员。
- **remove(String memberName)**: 移除指定名称的成员。
- **entrySet()**: 返回一个包含所有成员条目的集合视图。
- **keySet()**: 返回一个包含所有成员名称的集合视图。
- **getAsJsonObject(String memberName)**: 获取指定名称的成员并尝试将其转换为 `JsonObject`。
- **getAsJsonArray(String memberName)**: 获取指定名称的成员并尝试将其转换为 `JsonArray`。
- **getAsJsonPrimitive(String memberName)**: 获取指定名称的成员并尝试将其转换为 `JsonPrimitive`。
- **getAsBoolean(String memberName)**, **getAsDouble(String memberName)**, **getAsFloat(String memberName)**, **getAsInt(String memberName)**, **getAsLong(String memberName)**, **getAsString(String memberName)**: 获取指定名称的成员并尝试将其转换为相应的基础数据类型。
- **toString()**: 返回该对象的 JSON 表示形式的字符串。

### 示例代码

#### 创建和操作 `JsonObject`

```java
import com.google.gson.JsonObject;

public class JsonObjectExample {
public static void main(String[] args) {
// 创建一个新的 JsonObject
JsonObject jsonObject = new JsonObject();

// 添加一些属性
jsonObject.addProperty("name", "John Doe");
jsonObject.addProperty("age", 30);
jsonObject.addProperty("isEmployed", true);

// 创建一个嵌套的 JsonObject 并添加到主对象中
JsonObject address = new JsonObject();
address.addProperty("street", "123 Main St");
address.addProperty("city", "Anytown");
address.addProperty("state", "CA");

jsonObject.add("address", address);

// 打印整个 JSON 对象
System.out.println(jsonObject.toString());
}
}
```

输出结果将是：

```json
{
"name": "John Doe",
"age": 30,
"isEmployed": true,
"address": {
"street": "123 Main St",
"city": "Anytown",
"state": "CA"
}
}
```

#### 解析 JSON 字符串为 `JsonObject`

```java
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;

public class ParseJsonExample {
public static void main(String[] args) {
String jsonString = "{ \"name\": \"Jane Doe\", \"age\": 25, \"isEmployed\": false }";

// 使用 JsonParser 解析 JSON 字符串
JsonObject jsonObject = JsonParser.parseString(jsonString).getAsJsonObject();

// 访问 JSON 对象的属性
System.out.println("Name: " + jsonObject.get("name").getAsString());
System.out.println("Age: " + jsonObject.get("age").getAsInt());
System.out.println("Is Employed: " + jsonObject.get("isEmployed").getAsBoolean());
}
}
```

输出结果将是：

```plaintext
Name: Jane Doe
Age: 25
Is Employed: false
```

### 总结

`JsonObject` 提供了一种强大而灵活的方式来处理 JSON 数据，无论是创建新的 JSON 对象还是解析现有的 JSON 数据。通过它的丰富 API，你可以轻松地构建、修改、查询和遍历 JSON 数据结构。如果你需要更高级的功能，比如自定义序列化和反序列化逻辑，`Gson` 库也提供了相应的接口和抽象类来满足这些需求。