• Gson：
  这是Gson的核心类，它可以将对象转换为JSON字符串，或者将JSON字符串转换为对象。它使用反射机制来自动匹配对象的字段和JSON的属性，不需要额外的配置或注解。它适合处理简单和稳定的数据结构，例如用户信息、商品列表等。使用方法是创建一个Gson对象，然后调用其toJson()和fromJson()方法。

// 创建一个Gson对象
val gson = Gson()

// 创建一个表示用户的类User
data class User(
    val id: Int,
    val name: String,
    val email: String,
    val phone: String
)

// 创建一个User对象
val user = User(1, "Alice", "alice@gmail.com", "1234567890")

// 使用Gson对象的toJson()方法将User对象转换为JSON字符串
val json = gson.toJson(user) // {"id":1,"name":"Alice","email":"alice@gmail.com","phone":"1234567890"}

// 使用Gson对象的fromJson()方法将JSON字符串转换为User对象
val user2 = gson.fromJson(json, User::class.java) // User(id=1, name=Alice, email=alice@gmail.com, phone=1234567890)

• GsonBuilder：
  这是一个辅助类，它可以让您定制Gson的行为和特性，例如设置日期格式、排除策略、版本控制、自定义序列化和反序列化等。它适合处理复杂和灵活的数据结构，例如泛型、循环引用、动态类型等。使用方法是创建一个GsonBuilder对象，然后调用其各种设置方法，最后调用其create()方法来生成一个Gson对象。

// 创建一个GsonBuilder对象
val gsonBuilder = GsonBuilder()

//省略配置代码

// 使用GsonBuilder对象的create()方法来生成一个Gson对象
val gson2 = gsonBuilder.create()

• JsonReader：
  这是一个读取JSON数据的类，它可以让您以流式的方式读取JSON数据，而不需要将整个JSON文档加载到内存中。它适合处理大型和未知的JSON数据，例如网络响应、日志文件等。使用方法是创建一个JsonReader对象，然后调用其各种读取方法，如beginObject()、endObject()、nextName()、nextString()等。

// 创建一个JsonReader对象，用于读取JSON数据
val jsonReader = JsonReader(FileReader("test.json")) // 从文件中读取JSON数据

// 使用JsonReader对象的各种读取方法，以流式的方式读取JSON数据，而不需要将整个JSON文档加载到内存中
jsonReader.beginObject() // 开始读取一个JSON对象
while (jsonReader.hasNext()) { // 循环读取每个键值对
    val name = jsonReader.nextName() // 读取键名
    when (name) { // 根据键名判断值的类型和处理逻辑
        "id" -> {
            val id = jsonReader.nextInt() // 读取整数值
            println("id: $id")
        }
        "name" -> {
            val name = jsonReader.nextString() // 读取字符串值
            println("name: $name")
        }
        "email" -> {
            val email = jsonReader.nextString() // 读取字符串值
            println("email: $email")
        }
        "phone" -> {
            val phone = jsonReader.nextString() // 读取字符串值
            println("phone: $phone")
        }
        else -> {
            jsonReader.skipValue() // 跳过其他值
        }
    }
}
jsonReader.endObject() // 结束读取一个JSON对象

• JsonWriter：
  这是一个写入JSON数据的类，它可以让您以流式的方式写入JSON数据，而不需要创建一个完整的JSON对象。它适合处理大型和未知的JSON数据，例如网络请求、日志文件等。使用方法是创建一个JsonWriter对象，然后调用其各种写入方法，如beginObject()、endObject()、name()、value()等。

// 创建一个JsonWriter对象，用于写入JSON数据
val jsonWriter = JsonWriter(FileWriter("test.json")) // 写入JSON数据到文件中

// 使用JsonWriter对象的各种写入方法，以流式的方式写入JSON数据，而不需要创建一个完整的JSON对象
jsonWriter.beginObject() // 开始写入一个JSON对象
jsonWriter.name("id").value(1) // 写入一个键值对，键名为id，值为1
jsonWriter.name("name").value("Alice") // 写入一个键值对，键名为name，值为Alice
jsonWriter.name("email").value("alice@gmail.com") // 写入一个键值对，键名为email，值为alice@gmail.com
jsonWriter.name("phone").value("1234567890") // 写入一个键值对，键名为phone，值为1234567890
jsonWriter.endObject() // 结束写

• JsonParser：
  这是一个解析JSON数据的类，它可以让您将JSON数据表示为一棵树状的结构，每个节点都是一个JsonElement对象，可以是JsonObject、JsonArray、JsonPrimitive或JsonNull。它适合处理动态和不规则的JSON数据，例如用户输入、配置文件等。使用方法是创建一个JsonParser对象，然后调用其parse()方法来解析JSON字符串为一个JsonElement对象 。

// 创建一个JsonParser对象，用于解析JSON数据
val jsonParser = JsonParser()

// 使用JsonParser对象的parse()方法来解析JSON字符串为一个JsonElement对象
val jsonElement = jsonParser.parse(json) // 解析JSON字符串为一个JsonElement对象

• JsonElement：
  这是一个抽象类，它是所有JSON元素的基类。它提供了一些通用的方法，如isJsonObject()、isJsonArray()、isJsonPrimitive()、isJsonNull()等来判断元素的类型，以及getAsJsonObject()、getAsJsonArray()、getAsJsonPrimitive()、getAsJsonNull()等来获取元素的具体类型。

// 使用JsonParser对象的parse()方法来解析JSON字符串为一个JsonElement对象
val jsonElement = jsonParser.parse(json) // 解析JSON字符串为一个JsonElement对象

// 使用JsonElement对象的各种方法，将JSON数据表示为一棵树状的结构，每个节点都是一个JsonElement对象，可以是JsonObject、JsonArray、JsonPrimitive或JsonNull
if (jsonElement.isJsonObject) { // 判断是否是一个JSON对象
    val jsonObject = jsonElement.asJsonObject // 获取JSON对象
    if (jsonObject.has("id")) { // 判断是否有id属性
        val id = jsonObject.get("id").asInt // 获取id属性的值
        println("id: $id")
    }
    if (jsonObject.has("name")) { // 判断是否有name属性
        val name = jsonObject.get("name").asString // 获取name属性的值
        println("name: $name")
    }
    if (jsonObject.has("email")) { // 判断是否有email属性
        val email = jsonObject.get("email").asString // 获取email属性的值
        println("email: $email")
    }
    if (jsonObject.has("phone")) { // 判断是否有phone属性
        val phone = jsonObject.get("phone").asString // 获取phone属性的值
        println("phone: $phone")
    }
}

• JsonObject：
  这是一个继承自JsonElement的类，它表示一个JSON对象。它提供了一些操作键值对的方法，如add()、remove()、get()、has()等。

gsonBuilder.registerTypeAdapter(Book::class.java, object : JsonSerializer<Book> { // 注册自定义序列化器
    override fun serialize(src: Book, typeOfSrc: Type, context: JsonSerializationContext): JsonElement {
        val jsonObject = JsonObject()
        jsonObject.addProperty("id", src.id)
        jsonObject.addProperty("title", src.title.toUpperCase()) // 将标题转换为大写
        jsonObject.addProperty("author", src.author)
        return jsonObject
    }
})

• JsonArray：
  这是一个继承自JsonElement的类，它表示一个JSON数组。它提供了一些操作元素的方法，如add()、remove()、get()、size()等。

• JsonPrimitive：
  这是一个继承自JsonElement的类，它表示一个JSON原始值。它可以是一个字符串、数字、布尔值或空值。它提供了一些获取值的方法，如getAsString()、getAsInt()、getAsBoolean()等。

• JsonNull：
  这是一个继承自JsonElement的类，它表示一个JSON空值。它是一个单例类，只有一个实例。

• InstanceCreator：
  这是一个创建对象实例的接口，它可以让您为特定的类型提供自定义的构造方法。它适合处理没有无参构造器或有特殊初始化逻辑的类，例如抽象类、接口、内部类等。使用方法是实现这个接口，并重写createInstance()方法，然后注册到GsonBuilder中。

• JsonSerializer：
  这是一个自定义序列化的接口，它可以让您为特定的类型提供自定义的序列化方法。它适合处理复杂的泛型、循环引用、动态类型等情况，或者需要修改或增加JSON属性等情况。使用方法是实现这个接口，并重写serialize()方法，然后注册到GsonBuilder中。

gsonBuilder.registerTypeAdapter(Book::class.java, object : JsonSerializer<Book> { // 注册自定义序列化器
    override fun serialize(src: Book, typeOfSrc: Type, context: JsonSerializationContext): JsonElement {
        val jsonObject = JsonObject()
        jsonObject.addProperty("id", src.id)
        jsonObject.addProperty("title", src.title.toUpperCase()) // 将标题转换为大写
        jsonObject.addProperty("author", src.author)
        return jsonObject
    }
})

• JsonDeserializer：
  这是一个自定义反序列化的接口，它可以让您为特定的类型提供自定义的反序列化方法。它适合处理复杂的泛型、循环引用、动态类型等情况，或者需要验证或转换JSON属性等情况。使用方法是实现这个接口，并重写deserialize()方法，然后注册到GsonBuilder中。

gsonBuilder.registerTypeAdapter(Book::class.java, object : JsonDeserializer<Book> { // 注册自定义反序列化器
    override fun deserialize(json: JsonElement, typeOfT: Type, context: JsonDeserializationContext): Book {
        val jsonObject = json.asJsonObject
        val id = jsonObject.get("id").asInt
        val title = jsonObject.get("title").asString.toLowerCase() // 将标题转换为小写
        val author = jsonObject.get("author").asString
        return Book(id, title, author)
    }
})

• TypeAdapter：
  这是一个抽象类，它可以让您完全控制对象和JSON之间的转换过程。它适合处理日期格式、枚举类型、自定义类型等情况，或者需要优化性能或内存消耗等情况。使用方法是继承这个类，并重写write()和read()方法，然后注册到GsonBuilder中。

// 创建一个表示颜色的枚举类Color，并使用@TypeAdapter注解来指定自定义的TypeAdapter类
enum class Color {
    @TypeAdapter(ColorTypeAdapter::class)
    RED,
    GREEN,
    BLUE
}

// 创建一个自定义的TypeAdapter类，用于控制Color枚举类和JSON之间的转换过程
class ColorTypeAdapter : TypeAdapter<Color>() {
    override fun write(out: JsonWriter, value: Color) {
        out.value(value.ordinal) // 将枚举值转换为整数值写入JSON中
    }

    override fun read(`in`: JsonReader): Color {
        return Color.values()[`in`.nextInt()] // 将整数值从JSON中读取并转换为枚举值
    }
}

// 创建一个表示画笔的类Pen，并使用@TypeAdapter注解来指定自定义的TypeAdapter类
data class Pen(
    val brand: String,
    val color: Color,
    val price: Double
) {
    @TypeAdapter(PenTypeAdapter::class)
    constructor(json: String) : this("", Color.RED, 0.0) // 使用一个带有JSON字符串参数的构造器，并使用@TypeAdapter注解来指定




// 创建一个表示颜色的枚举类Color，并使用@TypeAdapter注解来指定自定义的TypeAdapter类
enum class Color {
    @TypeAdapter(ColorTypeAdapter::class)
    RED,
    GREEN,
    BLUE
}

// 创建一个自定义的TypeAdapter类，用于控制Color枚举类和JSON之间的转换过程
class ColorTypeAdapter : TypeAdapter<Color>() {
    override fun write(out: JsonWriter, value: Color) {
        out.value(value.ordinal) // 将枚举值转换为整数值写入JSON中
    }

    override fun read(`in`: JsonReader): Color {
        return Color.values()[`in`.nextInt()] // 将整数值从JSON中读取并转换为枚举值
    }
}

// 创建一个表示画笔的类Pen，并使用@TypeAdapter注解来指定自定义的TypeAdapter类
data class Pen(
    val brand: String,
    val color: Color,
    val price: Double
) {
    @TypeAdapter(PenTypeAdapter::class)
    constructor(json: String) : this("", Color.RED, 0.0) // 使用一个带有JSON字符串参数的构造器，并使用@TypeAdapter注解来指定自定义的TypeAdapter类
}

// 创建一个自定义的TypeAdapter类，用于控制Pen类和JSON之间的转换过程
class PenTypeAdapter : TypeAdapter<Pen>() {
    override fun write(out: JsonWriter, value: Pen) {
        out.beginObject() // 开始写入一个JSON对象
        out.name("brand").value(value.brand) // 写入一个键值对，键名为brand，值为画笔品牌
        out.name("color").value(value.color.ordinal) // 写入一个键值对，键名为color，值为画笔颜色对应的整数值
        out.name("price").value(value.price) // 写入一个键值对，键名为price，值为画笔价格
        out.endObject() // 结束写入一个JSON对象
    }

    override fun read(`in`: JsonReader): Pen {
        var brand = ""
        var color = Color.RED
        var price = 0.0
        `in`.beginObject() // 开始读取一个JSON对象
        while (`in`.hasNext()) { // 循环读取每个键值对
            val name = `in`.nextName() // 读取键名
            when (name) { // 根据键名判断值的类型和处理逻辑
                "brand" -> {
                    brand = `in`.nextString() // 读取字符串值作为画笔品牌
                }
                "color" -> {
                    color = Color.values()[`in`.nextInt()] // 读取整数值并转换为画笔颜色对应的枚举值
                }
                "price" -> {
                    price = `in`.nextDouble() // 读取浮点数值作为画笔价格
                }
                else -> {
                    `in`.skipValue() // 跳过其他值
                }
            }
        }
        `in`.endObject() // 结束读取一个JSON对象
        return Pen(brand, color, price) // 返回一个Pen对象
    }
}

// 创建一个Pen对象
val pen = Pen("Pilot", Color.BLUE, 10.0)

// 使用生成的Gson对象的toJson()方法将Pen对象转换为JSON字符串，根据@TypeAdapter注解和自定义的TypeAdapter类来控制转换过程
val json7 = gson2.toJson(pen) // {"brand":"Pilot","color":2,"price":10.0}

// 使用生成的Gson对象的fromJson()方法将JSON字符串转换为Pen对象，根据@TypeAdapter注解和自定义的TypeAdapter类来控制转换过程
val pen2 = gson2.fromJson(json7, Pen::class.java) // Pen(brand=Pilot, color=BLUE, price=10.0)

// 使用带有JSON字符串参数的构造器来创建一个Pen对象，根据@TypeAdapter注解和自定义的TypeAdapter类来控制转换过程
val pen3 = Pen(json7) // Pen(brand=Pilot, color=BLUE, price=10.0)

• ExclusionStrategy：
  这是一个排除策略的接口，它可以让您根据一些条件来排除某些字段或类不参与序列化或反序列化。它适合处理不需要暴露或转换的敏感或无关的数据，例如带有特定注解、修饰符、名称等的字段或类。使用方法是实现这个接口，并重写shouldSkipField()和shouldSkipClass()方法，然后注册到GsonBuilder中。

gsonBuilder.setExclusionStrategies(object : ExclusionStrategy { // 设置排除策略
    override fun shouldSkipField(f: FieldAttributes): Boolean {
        return f.getAnnotation(Exclude::class.java) != null // 排除带有@Exclude注解的字段
    }

    override fun shouldSkipClass(clazz: Class<*>): Boolean {
        return false // 不排除任何类
    }
})

• @SerializedName：这是一个用于指定字段在JSON中的名称的注解，它可以让您在序列化和反序列化时使用不同于字段名的JSON属性名。它适合处理字段名和JSON属性名不一致的情况，例如使用下划线或驼峰命名法等。使用方法是在字段上添加@SerializedName注解，并指定一个或多个JSON属性名。例如：

data class User(
    @SerializedName("user_id") val id: Int, // 在JSON中使用user_id而不是id
    @SerializedName("user_name", alternate = ["name", "username"]) val name: String // 在JSON中使用user_name，也可以接受name或username作为备选
)

• @Expose：这是一个用于指定字段是否参与序列化和反序列化的注解，它可以让您在转换对象和JSON时忽略某些字段。它适合处理不需要暴露或转换的敏感或无关的数据，例如密码、日志、缓存等。使用方法是在字段上添加@Expose注解，并指定serialize和deserialize属性为true或false。例如：

data class User(
    @Expose(serialize = true, deserialize = true) val id: Int, // 参与序列化和反序列化
    @Expose(serialize = false, deserialize = false) val password: String, // 不参与序列化和反序列化
    @Expose(serialize = true, deserialize = false) val token: String // 只参与序列化
)

• @Since：这是一个用于指定字段的版本号的注解，它可以让您根据不同的版本号来选择性地转换对象和JSON。它适合处理数据结构随着版本变化而变化的情况，例如添加、删除、修改字段等。使用方法是在字段上添加@Since注解，并指定一个double类型的版本号。例如：

data class User(
    @Since(1.0) val id: Int, // 从1.0版本开始存在
    @Since(1.1) val name: String, // 从1.1版本开始存在
    @Since(2.0) val email: String // 从2.0版本开始存在
)

• @Until：这是一个用于指定字段的过期版本号的注解，它可以让您根据不同的版本号来选择性地转换对象和JSON。它适合处理数据结构随着版本变化而变化的情况，例如添加、删除、修改字段等。使用方法是在字段上添加@Until注解，并指定一个double类型的版本号。例如：

data class User(
    @Until(2.0) val id: Int, // 直到2.0版本之前存在
    @Until(3.0) val name: String, // 直到3.0版本之前存在
    val email: String // 没有过期版本号
)

整体代码

// 创建一个Gson对象
val gson = Gson()

// 创建一个表示用户的类User
data class User(
    val id: Int,
    val name: String,
    val email: String,
    val phone: String
)

// 创建一个User对象
val user = User(1, "Alice", "alice@gmail.com", "1234567890")

// 使用Gson对象的toJson()方法将User对象转换为JSON字符串
val json = gson.toJson(user) // {"id":1,"name":"Alice","email":"alice@gmail.com","phone":"1234567890"}

// 使用Gson对象的fromJson()方法将JSON字符串转换为User对象
val user2 = gson.fromJson(json, User::class.java) // User(id=1, name=Alice, email=alice@gmail.com, phone=1234567890)

// 创建一个GsonBuilder对象
val gsonBuilder = GsonBuilder()

// 使用GsonBuilder对象的各种设置方法来定制Gson的行为和特性，例如设置日期格式、排除策略、版本控制、自定义序列化和反序列化等
gsonBuilder.setDateFormat("yyyy-MM-dd") // 设置日期格式
gsonBuilder.setExclusionStrategies(object : ExclusionStrategy { // 设置排除策略
    override fun shouldSkipField(f: FieldAttributes): Boolean {
        return f.getAnnotation(Exclude::class.java) != null // 排除带有@Exclude注解的字段
    }

    override fun shouldSkipClass(clazz: Class<*>): Boolean {
        return false // 不排除任何类
    }
})
gsonBuilder.setVersion(2.0) // 设置版本控制
gsonBuilder.registerTypeAdapter(Book::class.java, object : JsonSerializer<Book> { // 注册自定义序列化器
    override fun serialize(src: Book, typeOfSrc: Type, context: JsonSerializationContext): JsonElement {
        val jsonObject = JsonObject()
        jsonObject.addProperty("id", src.id)
        jsonObject.addProperty("title", src.title.toUpperCase()) // 将标题转换为大写
        jsonObject.addProperty("author", src.author)
        return jsonObject
    }
})
gsonBuilder.registerTypeAdapter(Book::class.java, object : JsonDeserializer<Book> { // 注册自定义反序列化器
    override fun deserialize(json: JsonElement, typeOfT: Type, context: JsonDeserializationContext): Book {
        val jsonObject = json.asJsonObject
        val id = jsonObject.get("id").asInt
        val title = jsonObject.get("title").asString.toLowerCase() // 将标题转换为小写
        val author = jsonObject.get("author").asString
        return Book(id, title, author)
    }
})

// 使用GsonBuilder对象的create()方法来生成一个Gson对象
val gson2 = gsonBuilder.create()

// 使用生成的Gson对象来转换对象和JSON，根据定制的行为和特性进行转换

// 创建一个表示书籍的类Book，并使用@Since和@Until注解来指定版本号
data class Book(
    @Since(1.0) @Until(2.0) val id: Int,
    @Since(1.1) @Until(3.0) val title: String,
    val author: String
)

// 创建一个Book对象
val book = Book(1, "Kotlin in Action", "Dmitry Jemerov")

// 使用生成的Gson对象的toJson()方法将Book对象转换为JSON字符串，根据版本号来选择性地转换字段
val json2 = gson2.toJson(book) // {"title":"KOTLIN IN ACTION","author":"Dmitry Jemerov"}

// 使用生成的Gson对象的fromJson()方法将JSON字符串转换为Book对象，根据版本号和自定义反序列化器来选择性地转换属性
val book2 = gson2.fromJson(json2, Book::class.java) // Book(id=0, title=kotlin in action, author=Dmitry Jemerov)

// 创建一个表示日期的Date对象
val date = Date()

// 使用生成的Gson对象的toJson()方法将Date对象转换为JSON字符串，根据日期格式来转换值
val json3 = gson2.toJson(date) // "2023-04-15"

// 使用生成的Gson对象的fromJson()方法将JSON字符串转换为Date对象，根据日期格式来转换值
val date2 = gson2.fromJson(json3, Date::class.java) // Sat Apr 15 00:00:00 GMT+08:00 2023

// 创建一个表示学生的类Student，并使用@SerializedName注解来指定字段在JSON中的名称
data class Student(
    @SerializedName("student_id") val id: Int,
    @SerializedName("student_name") val name: String,
    val age: Int
)

// 创建一个Student对象
val student = Student(1, "Bob", 18)

// 使用生成的Gson对象的toJson()方法将Student对象转换为JSON字符串，根据@SerializedName注解来使用不同于字段名的JSON属性名
val json4 = gson2.toJson(student) // {"student_id":1,"student_name":"Bob","age":18}

// 使用生成的Gson对象的fromJson()方法将JSON字符串转换为Student对象，根据@SerializedName注解来使用不同于字段名的JSON属性名
val student2 = gson2.fromJson(json4, Student::class.java) // Student(id=1, name=Bob, age=18)

// 创建一个表示员工的类Employee，并使用@Expose注解来指定字段是否参与序列化和反序列化
data class Employee(
    @Expose(serialize = true, deserialize = true) val id: Int,
    @Expose(serialize = false, deserialize = false) val password: String,
    @Expose(serialize = true, deserialize = false) val token: String
)

// 创建一个Employee对象
val employee = Employee(1, "123456", "abcdef")

// 使用生成的Gson对象的toJson()方法将Employee对象转换为JSON字符串，根据@Expose注解来忽略某些字段
val json5 = gson2.toJson(employee) // {"id":1,"token":"abcdef"}

// 使用生成的Gson对象的fromJson()方法将JSON字符串转换为Employee对象，根据@Expose注解来忽略某些字段
val employee2 = gson2.fromJson(json5, Employee::class.java) // Employee(id=1, password=null, token=null)

// 创建一个JsonReader对象，用于读取JSON数据
val jsonReader = JsonReader(FileReader("test.json")) // 从文件中读取JSON数据

// 使用JsonReader对象的各种读取方法，以流式的方式读取JSON数据，而不需要将整个JSON文档加载到内存中
jsonReader.beginObject() // 开始读取一个JSON对象
while (jsonReader.hasNext()) { // 循环读取每个键值对
    val name = jsonReader.nextName() // 读取键名
    when (name) { // 根据键名判断值的类型和处理逻辑
        "id" -> {
            val id = jsonReader.nextInt() // 读取整数值
            println("id: $id")
        }
        "name" -> {
            val name = jsonReader.nextString() // 读取字符串值
            println("name: $name")
        }
        "email" -> {
            val email = jsonReader.nextString() // 读取字符串值
            println("email: $email")
        }
        "phone" -> {
            val phone = jsonReader.nextString() // 读取字符串值
            println("phone: $phone")
        }
        else -> {
            jsonReader.skipValue() // 跳过其他值
        }
    }
}
jsonReader.endObject() // 结束读取一个JSON对象

// 创建一个JsonWriter对象，用于写入JSON数据
val jsonWriter = JsonWriter(FileWriter("test.json")) // 写入JSON数据到文件中

// 使用JsonWriter对象的各种写入方法，以流式的方式写入JSON数据，而不需要创建一个完整的JSON对象
jsonWriter.beginObject() // 开始写入一个JSON对象
jsonWriter.name("id").value(1) // 写入一个键值对，键名为id，值为1
jsonWriter.name("name").value("Alice") // 写入一个键值对，键名为name，值为Alice
jsonWriter.name("email").value("alice@gmail.com") // 写入一个键值对，键名为email，值为alice@gmail.com
jsonWriter.name("phone").value("1234567890") // 写入一个键值对，键名为phone，值为1234567890
jsonWriter.endObject() // 结束写



// 创建一个表示学生的类Student，并使用@SerializedName注解来指定字段在JSON中的名称
data class Student(
    @SerializedName("student_id") val id: Int,
    @SerializedName("student_name") val name: String,
    val age: Int
)

// 创建一个Student对象
val student = Student(1, "Bob", 18)

// 使用生成的Gson对象的toJson()方法将Student对象转换为JSON字符串，根据@SerializedName注解来使用不同于字段名的JSON属性名
val json4 = gson2.toJson(student) // {"student_id":1,"student_name":"Bob","age":18}

// 使用生成的Gson对象的fromJson()方法将JSON字符串转换为Student对象，根据@SerializedName注解来使用不同于字段名的JSON属性名
val student2 = gson2.fromJson(json4, Student::class.java) // Student(id=1, name=Bob, age=18)

// 创建一个表示员工的类Employee，并使用@Expose注解来指定字段是否参与序列化和反序列化
data class Employee(
    @Expose(serialize = true, deserialize = true) val id: Int,
    @Expose(serialize = false, deserialize = false) val password: String,
    @Expose(serialize = true, deserialize = false) val token: String
)

// 创建一个Employee对象
val employee = Employee(1, "123456", "abcdef")

// 使用生成的Gson对象的toJson()方法将Employee对象转换为JSON字符串，根据@Expose注解来忽略某些字段
val json5 = gson2.toJson(employee) // {"id":1,"token":"abcdef"}

// 使用生成的Gson对象的fromJson()方法将JSON字符串转换为Employee对象，根据@Expose注解来忽略某些字段
val employee2 = gson2.fromJson(json5, Employee::class.java) // Employee(id=1, password=null, token=null)

// 创建一个JsonReader对象，用于读取JSON数据
val jsonReader = JsonReader(FileReader("test.json")) // 从文件中读取JSON数据

// 使用JsonReader对象的各种读取方法，以流式的方式读取JSON数据，而不需要将整个JSON文档加载到内存中
jsonReader.beginObject() // 开始读取一个JSON对象
while (jsonReader.hasNext()) { // 循环读取每个键值对
    val name = jsonReader.nextName() // 读取键名
    when (name) { // 根据键名判断值的类型和处理逻辑
        "id" -> {
            val id = jsonReader.nextInt() // 读取整数值
            println("id: $id")
        }
        "name" -> {
            val name = jsonReader.nextString() // 读取字符串值
            println("name: $name")
        }
        "email" -> {
            val email = jsonReader.nextString() // 读取字符串值
            println("email: $email")
        }
        "phone" -> {
            val phone = jsonReader.nextString() // 读取字符串值
            println("phone: $phone")
        }
        else -> {
            jsonReader.skipValue() // 跳过其他值
        }
    }
}
jsonReader.endObject() // 结束读取一个JSON对象

// 创建一个JsonWriter对象，用于写入JSON数据
val jsonWriter = JsonWriter(FileWriter("test.json")) // 写入JSON数据到文件中

// 使用JsonWriter对象的各种写入方法，以流式的方式写入JSON数据，而不需要创建一个完整的JSON对象
jsonWriter.beginObject() // 开始写入一个JSON对象
jsonWriter.name("id").value(1) // 写入一个键值对，键名为id，值为1
jsonWriter.name("name").value("Alice") // 写入一个键值对，键名为name，值为Alice
jsonWriter.name("email").value("alice@gmail.com") // 写入一个键值对，键名为email，值为alice@gmail.com
jsonWriter.name("phone").value("1234567890") // 写入一个键值对，键名为phone，值为1234567890
jsonWriter.endObject() // 结束写入一个JSON对象

// 创建一个JsonParser对象，用于解析JSON数据
val jsonParser = JsonParser()

// 使用JsonParser对象的parse()方法来解析JSON字符串为一个JsonElement对象
val jsonElement = jsonParser.parse(json) // 解析JSON字符串为一个JsonElement对象

// 使用JsonElement对象的各种方法，将JSON数据表示为一棵树状的结构，每个节点都是一个JsonElement对象，可以是JsonObject、JsonArray、JsonPrimitive或JsonNull
if (jsonElement.isJsonObject) { // 判断是否是一个JSON对象
    val jsonObject = jsonElement.asJsonObject // 获取JSON对象
    if (jsonObject.has("id")) { // 判断是否有id属性
        val id = jsonObject.get("id").asInt // 获取id属性的值
        println("id: $id")
    }
    if (jsonObject.has("name")) { // 判断是否有name属性
        val name = jsonObject.get("name").asString // 获取name属性的值
        println("name: $name")
    }
    if (jsonObject.has("email")) { // 判断是否有email属性
        val email = jsonObject.get("email").asString // 获取email属性的值
        println("email: $email")
    }
    if (jsonObject.has("phone")) { // 判断是否有phone属性
        val phone = jsonObject.get("phone").asString // 获取phone属性的值
        println("phone: $phone")
    }
}

// 创建一个表示图书馆的类Library，并使用@Expose注解来指定字段是否参与序列化和反序列化，使用@SerializedName注解来指定字段在JSON中的名称，使用@Since和@Until注解来指定字段的版本号
data class Library(
    @Expose(serialize = true, deserialize = true) @SerializedName("library_id") @Since(1.0) @Until(2.0) val id: Int,
    @Expose(serialize = true, deserialize = true) @SerializedName("library_name") @Since(1.1) @Until(3.0) val name: String,
    @Expose(serialize = false, deserialize = false) @SerializedName("library_password") val password: String,
    @Expose(serialize = true, deserialize = false) @SerializedName("library_token") val token: String,
    val books: List<Book>
)

// 创建一个Library对象
val library = Library(1, "My Library", "123456", "abcdef", listOf(book, book2))

// 使用生成的Gson对象的toJson()方法将Library对象转换为JSON字符串，根据各种注解来定制转换过程
val json6 = gson2.toJson(library) // {"library_name":"MY LIBRARY","library_token":"abcdef","books":[{"title":"KOTLIN IN ACTION","author":"Dmitry Jemerov"}]}

// 使用生成的Gson对象的fromJson()方法将JSON字符串转换为Library对象，根据各种注解来定制转换过程
val library2 = gson2.fromJson(json6, Library::class.java) // Library(id=0, name=MY LIBRARY, password=null, token=null, books=[Book(id=0, title=kotlin in action, author=Dmitry Jemerov)])

// 创建一个表示颜色的枚举类Color，并使用@TypeAdapter注解来指定自定义的TypeAdapter类
enum class Color {
    @TypeAdapter(ColorTypeAdapter::class)
    RED,
    GREEN,
    BLUE
}

// 创建一个自定义的TypeAdapter类，用于控制Color枚举类和JSON之间的转换过程
class ColorTypeAdapter : TypeAdapter<Color>() {
    override fun write(out: JsonWriter, value: Color) {
        out.value(value.ordinal) // 将枚举值转换为整数值写入JSON中
    }

    override fun read(`in`: JsonReader): Color {
        return Color.values()[`in`.nextInt()] // 将整数值从JSON中读取并转换为枚举值
    }
}

// 创建一个表示画笔的类Pen，并使用@TypeAdapter注解来指定自定义的TypeAdapter类
data class Pen(
    val brand: String,
    val color: Color,
    val price: Double
) {
    @TypeAdapter(PenTypeAdapter::class)
    constructor(json: String) : this("", Color.RED, 0.0) // 使用一个带有JSON字符串参数的构造器，并使用@TypeAdapter注解来指定




// 创建一个表示颜色的枚举类Color，并使用@TypeAdapter注解来指定自定义的TypeAdapter类
enum class Color {
    @TypeAdapter(ColorTypeAdapter::class)
    RED,
    GREEN,
    BLUE
}

// 创建一个自定义的TypeAdapter类，用于控制Color枚举类和JSON之间的转换过程
class ColorTypeAdapter : TypeAdapter<Color>() {
    override fun write(out: JsonWriter, value: Color) {
        out.value(value.ordinal) // 将枚举值转换为整数值写入JSON中
    }

    override fun read(`in`: JsonReader): Color {
        return Color.values()[`in`.nextInt()] // 将整数值从JSON中读取并转换为枚举值
    }
}

// 创建一个表示画笔的类Pen，并使用@TypeAdapter注解来指定自定义的TypeAdapter类
data class Pen(
    val brand: String,
    val color: Color,
    val price: Double
) {
    @TypeAdapter(PenTypeAdapter::class)
    constructor(json: String) : this("", Color.RED, 0.0) // 使用一个带有JSON字符串参数的构造器，并使用@TypeAdapter注解来指定自定义的TypeAdapter类
}

// 创建一个自定义的TypeAdapter类，用于控制Pen类和JSON之间的转换过程
class PenTypeAdapter : TypeAdapter<Pen>() {
    override fun write(out: JsonWriter, value: Pen) {
        out.beginObject() // 开始写入一个JSON对象
        out.name("brand").value(value.brand) // 写入一个键值对，键名为brand，值为画笔品牌
        out.name("color").value(value.color.ordinal) // 写入一个键值对，键名为color，值为画笔颜色对应的整数值
        out.name("price").value(value.price) // 写入一个键值对，键名为price，值为画笔价格
        out.endObject() // 结束写入一个JSON对象
    }

    override fun read(`in`: JsonReader): Pen {
        var brand = ""
        var color = Color.RED
        var price = 0.0
        `in`.beginObject() // 开始读取一个JSON对象
        while (`in`.hasNext()) { // 循环读取每个键值对
            val name = `in`.nextName() // 读取键名
            when (name) { // 根据键名判断值的类型和处理逻辑
                "brand" -> {
                    brand = `in`.nextString() // 读取字符串值作为画笔品牌
                }
                "color" -> {
                    color = Color.values()[`in`.nextInt()] // 读取整数值并转换为画笔颜色对应的枚举值
                }
                "price" -> {
                    price = `in`.nextDouble() // 读取浮点数值作为画笔价格
                }
                else -> {
                    `in`.skipValue() // 跳过其他值
                }
            }
        }
        `in`.endObject() // 结束读取一个JSON对象
        return Pen(brand, color, price) // 返回一个Pen对象
    }
}

// 创建一个Pen对象
val pen = Pen("Pilot", Color.BLUE, 10.0)

// 使用生成的Gson对象的toJson()方法将Pen对象转换为JSON字符串，根据@TypeAdapter注解和自定义的TypeAdapter类来控制转换过程
val json7 = gson2.toJson(pen) // {"brand":"Pilot","color":2,"price":10.0}

// 使用生成的Gson对象的fromJson()方法将JSON字符串转换为Pen对象，根据@TypeAdapter注解和自定义的TypeAdapter类来控制转换过程
val pen2 = gson2.fromJson(json7, Pen::class.java) // Pen(brand=Pilot, color=BLUE, price=10.0)

// 使用带有JSON字符串参数的构造器来创建一个Pen对象，根据@TypeAdapter注解和自定义的TypeAdapter类来控制转换过程
val pen3 = Pen(json7) // Pen(brand=Pilot, color=BLUE, price=10.0)