Android 数据转 JSON 完全指南：JSONObject、Gson、kotlinx.serialization 与 Moshi

前言#

在 Android 开发中，JSON 是数据交换的绝对主角——接口请求要发 JSON、本地存储要存 JSON、组件间通信可能也要传 JSON。一个高频的需求就是：如何把 Kotlin/Java 中的各种数据（int、String、List、对象）转成 JSON 字符串？

本文将带你逐一掌握 Android 生态中四种主流 JSON 序列化方案，从原生的 org.json 到现代的 kotlinx.serialization，帮你彻底吃透「数据转 JSON」这件事。

Note

本文所有示例使用 Kotlin 编写。JSON 解析（反序列化）虽不在本文范围，但每种方案的解析也同样简单，文中会简要提及。

1. 四种方案速览#

方案	来源	原理	依赖量
`org.json`	Android SDK 内置	手动逐字段拼装	0
Gson	Google 出品	反射自动映射	1 个库
kotlinx.serialization	JetBrains 出品	编译期生成序列化器	2 个库（核心 + 插件）
Moshi	Square 出品	注解 + 代码生成	2 个库（核心 + 代码生成）

2. org.json：Android 内置方案#

Android SDK 自带了 org.json 包，零依赖，适合简单场景。

2.1 基本类型转 JSON#

1
import org.json.JSONArray
2
import org.json.JSONObject
3

4
// int → JSON
5
val intValue = 42
6
val jsonInt = JSONObject().apply {
7
    put("age", intValue)
8
}
9
// 输出: {"age":42}
10

11
// String → JSON
12
val name = "张三"
13
val jsonString = JSONObject().apply {
14
    put("name", name)
15
}
16
// 输出: {"name":"张三"}
17

18
// Boolean → JSON
19
val isVip = true
20
val jsonBoolean = JSONObject().apply {
21
    put("isVip", isVip)
22
}
23
// 输出: {"isVip":true}
24

25
// Double → JSON
26
val price = 19.99
27
val jsonDouble = JSONObject().apply {
28
    put("price", price)
29
}
30
// 输出: {"price":19.99}
31

32
// null → JSON（会变成 JSONObject.NULL）
33
val nullable: String? = null
34
val jsonNull = JSONObject().apply {
35
    put("nickname", nullable ?: JSONObject.NULL)
36
}
37
// 输出: {"nickname":null}

2.2 复合类型转 JSON#

1
// List → JSONArray
2
val tags = listOf("Android", "Kotlin", "JSON")
3
val jsonArray = JSONArray(tags)
4
// 输出: ["Android","Kotlin","JSON"]
5

6
// Map → JSONObject
7
val config = mapOf(
8
    "timeout" to 30,
9
    "retry" to 3,
10
    "baseUrl" to "https://api.example.com"
11
)
12
val jsonMap = JSONObject(config)
13
// 输出: {"timeout":30,"retry":3,"baseUrl":"https://api.example.com"}
14

15
// 嵌套 JSON
16
val address = JSONObject().apply {
17
    put("province", "广东省")
18
    put("city", "广州市")
19
    put("district", "天河区")
20
}
21

22
val userJson = JSONObject().apply {
23
    put("id", 1001)
24
    put("name", "张三")
25
    put("age", 28)
26
    put("address", address)
27
    put("hobbies", JSONArray(listOf("篮球", "阅读", "编程")))
28
}
29
// 输出（格式化后）:
30
// {
31
//   "id": 1001,
32
//   "name": "张三",
33
//   "age": 28,
34
//   "address": {"province":"广东省","city":"广州市","district":"天河区"},
35
//   "hobbies": ["篮球","阅读","编程"]
36
// }

2.3 自定义对象手动转 JSON#

1
data class User(
2
    val id: Long,
3
    val name: String,
4
    val age: Int,
5
    val email: String?,
6
    val tags: List<String>
7
)
8

9
fun User.toJson(): JSONObject {
10
    return JSONObject().apply {
11
        put("id", id)
12
        put("name", name)
13
        put("age", age)
14
        put("email", email ?: JSONObject.NULL)
15
        put("tags", JSONArray(tags))
16
    }
17
}
18

19
val user = User(
20
    id = 1001,
21
    name = "张三",
22
    age = 28,
23
    email = "zhangsan@example.com",
24
    tags = listOf("Android", "Kotlin")
25
)
26
val userJson = user.toJson()
27
println(userJson.toString())

2.4 格式化输出#

1
val obj = JSONObject().apply {
2
    put("name", "张三")
3
    put("age", 28)
4
}
5

6
// 紧凑输出
7
println(obj.toString())
8
// {"name":"张三","age":28}
9

10
// 格式化输出（缩进 2 空格）
11
println(obj.toString(2))
12
// {
13
//   "name": "张三",
14
//   "age": 28
15
// }

2.5 org.json 优缺点#

优点	缺点
零依赖，Android SDK 内置	每个字段都要手动 `put`，代码冗余
无编译期开销	不支持自动对象映射
适合简单/动态 JSON	嵌套对象多时极易出错

3. Gson：Google 的经典之选#

Gson 是 Google 出品的 Java JSON 库，通过反射自动完成对象与 JSON 的双向转换，是 Android 社区多年来的事实标准。

3.1 添加依赖#

1
dependencies {
2
    implementation("com.google.code.gson:gson:2.10.1")
3
}

3.2 基本类型转 JSON#

1
import com.google.gson.Gson
2
import com.google.gson.GsonBuilder
3

4
val gson = Gson()
5

6
// int → JSON
7
val intJson = gson.toJson(42)
8
// 输出: 42
9

10
// String → JSON
11
val strJson = gson.toJson("Hello World")
12
// 输出: "Hello World"
13

14
// Boolean → JSON
15
val boolJson = gson.toJson(true)
16
// 输出: true
17

18
// Array → JSON
19
val arrJson = gson.toJson(arrayOf(1, 2, 3))
20
// 输出: [1,2,3]
21

22
// List → JSON
23
val listJson = gson.toJson(listOf("A", "B", "C"))
24
// 输出: ["A","B","C"]
25

26
// Map → JSON
27
val mapJson = gson.toJson(mapOf("key1" to "value1", "key2" to 2))
28
// 输出: {"key1":"value1","key2":2}

3.3 自定义对象一键转 JSON#

1
data class User(
2
    val id: Long,
3
    val name: String,
4
    val age: Int,
5
    val email: String?,
6
    val tags: List<String>
7
)
8

9
data class Order(
10
    val orderId: String,
11
    val user: User,
12
    val amount: Double,
13
    val items: List<OrderItem>,
14
    val paid: Boolean
15
)
16

17
data class OrderItem(
18
    val productId: Long,
19
    val productName: String,
20
    val quantity: Int,
21
    val price: Double
22
)
23

24
val order = Order(
25
    orderId = "ORD-2024-001",
26
    user = User(1001, "张三", 28, null, listOf("VIP")),
27
    amount = 299.99,
28
    items = listOf(
29
        OrderItem(1, "机械键盘", 1, 199.99),
30
        OrderItem(2, "鼠标垫", 2, 50.00)
31
    ),
32
    paid = true
33
)
34

35
val gson = Gson()
36
val orderJson = gson.toJson(order)
37
println(orderJson)

输出（一个完整嵌套的 JSON 字符串）：

1
{"orderId":"ORD-2024-001","user":{"id":1001,"name":"张三","age":28,"tags":["VIP"]},"amount":299.99,"items":[{"productId":1,"productName":"机械键盘","quantity":1,"price":199.99},{"productId":2,"productName":"鼠标垫","quantity":2,"price":50.0}],"paid":true}

注意：email 为 null 时 Gson 默认直接省略该字段，不会输出 "email": null。

3.4 Gson 高级配置#

1
val gson = GsonBuilder()
2
    .setPrettyPrinting()              // 格式化输出
3
    .serializeNulls()                 // 不忽略 null 字段
4
    .setDateFormat("yyyy-MM-dd HH:mm:ss") // 日期格式
5
    .setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES) // 字段命名策略
6
    .excludeFieldsWithoutExposeAnnotation() // 只序列化 @Expose 标记的字段
7
    .create()
8

9
// 使用
10
val json = gson.toJson(order)

3.5 自定义字段名#

1
// 用 @SerializedName 注解映射不规则的 JSON key
2
data class ApiResponse(
3
    @SerializedName("status_code")
4
    val statusCode: Int,
5

6
    @SerializedName("error_msg")
7
    val errorMsg: String?
8
)
9

10
val response = ApiResponse(200, null)
11
val json = gson.toJson(response)
12
// 输出: {"status_code":200}

3.6 自定义序列化器#

1
import com.google.gson.JsonElement
2
import com.google.gson.JsonPrimitive
3
import com.google.gson.JsonSerializationContext
4
import com.google.gson.JsonSerializer
5
import java.lang.reflect.Type
6

7
// 自定义枚举序列化
8
enum class OrderStatus {
9
    PENDING, PROCESSING, SHIPPED, DELIVERED
10
}
11

12
class OrderStatusSerializer : JsonSerializer<OrderStatus> {
13
    override fun serialize(
14
        src: OrderStatus?,
15
        typeOfSrc: Type?,
16
        context: JsonSerializationContext?
17
    ): JsonElement {
18
        return when (src) {
19
            OrderStatus.PENDING -> JsonPrimitive("待处理")
20
            OrderStatus.PROCESSING -> JsonPrimitive("处理中")
21
            OrderStatus.SHIPPED -> JsonPrimitive("已发货")
22
            OrderStatus.DELIVERED -> JsonPrimitive("已送达")
23
            null -> JsonPrimitive("未知")
24
        }
25
    }
26
}
27

28
val gson = GsonBuilder()
29
    .registerTypeAdapter(OrderStatus::class.java, OrderStatusSerializer())
30
    .create()
31

32
val json = gson.toJson(OrderStatus.PROCESSING)
33
// 输出: "处理中"

3.7 Gson 优缺点#

优点	缺点
API 极简，`toJson()` 一行搞定	依赖反射，性能有轻微损耗
社区成熟，资料丰富	对 Kotlin 默认值、非空类型支持不完美
配置灵活，可插拔序列化器	不做编译期校验，拼写错误运行时才发现

4. kotlinx.serialization：Kotlin 原生方案#

kotlinx.serialization 是 JetBrains 出品的 Kotlin 原生序列化库，通过编译期生成序列化器消除反射开销，是 Kotlin 生态的推荐方案。

4.1 添加依赖#

1
// 项目级 build.gradle.kts
2
plugins {
3
    id("org.jetbrains.kotlin.plugin.serialization") version "1.9.22"
4
}
5

6
// 模块级 build.gradle.kts
7
dependencies {
8
    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.6.2")
9
}

4.2 基本类型转 JSON#

1
import kotlinx.serialization.encodeToString
2
import kotlinx.serialization.json.*
3

4
val json = Json { prettyPrint = true }
5

6
// int → JSON
7
val intJson = json.encodeToString(JsonPrimitive(42))
8
// 输出: 42
9

10
// String → JSON
11
val strJson = json.encodeToString(JsonPrimitive("Hello"))
12
// 输出: "Hello"
13

14
// Boolean → JSON
15
val boolJson = json.encodeToString(JsonPrimitive(true))
16
// 输出: true
17

18
// null → JSON
19
val nullJson = json.encodeToString(JsonNull)
20
// 输出: null
21

22
// List → JSON
23
val listJson = json.encodeToString(JsonArray(listOf(
24
    JsonPrimitive("Android"),
25
    JsonPrimitive("Kotlin"),
26
    JsonPrimitive("JSON")
27
)))
28
// 输出: ["Android","Kotlin","JSON"]

4.3 自定义对象转 JSON#

1
import kotlinx.serialization.Serializable
2
import kotlinx.serialization.encodeToString
3

4
@Serializable
5
data class User(
6
    val id: Long,
7
    val name: String,
8
    val age: Int,
9
    val email: String? = null,
10
    val tags: List<String> = emptyList()
11
)
12

13
@Serializable
14
data class Order(
15
    val orderId: String,
16
    val user: User,
17
    val amount: Double,
18
    val items: List<OrderItem>,
19
    val paid: Boolean
20
)
21

22
@Serializable
23
data class OrderItem(
24
    val productId: Long,
25
    val productName: String,
26
    val quantity: Int,
27
    val price: Double
28
)
29

30
val order = Order(
31
    orderId = "ORD-2024-001",
32
    user = User(1001, "张三", 28, tags = listOf("VIP")),
33
    amount = 299.99,
34
    items = listOf(
35
        OrderItem(1, "机械键盘", 1, 199.99),
36
        OrderItem(2, "鼠标垫", 2, 50.0)
37
    ),
38
    paid = true
39
)
40

41
val json = Json { prettyPrint = true }
42
val orderJson = json.encodeToString(order)
43
println(orderJson)

输出：

1
{
2
    "orderId": "ORD-2024-001",
3
    "user": {
4
        "id": 1001,
5
        "name": "张三",
6
        "age": 28,
7
        "tags": [
8
            "VIP"
9
        ]
10
    },
11
    "amount": 299.99,
12
    "items": [
13
        {
14
            "productId": 1,
15
            "productName": "机械键盘",
16
            "quantity": 1,
17
            "price": 199.99
18
        },
19
        {
20
            "productId": 2,
21
            "productName": "鼠标垫",
22
            "quantity": 2,
23
            "price": 50.0
24
        }
25
    ],
26
    "paid": true
27
}

4.4 自定义字段名#

1
@Serializable
2
data class ApiResponse(
3
    @SerialName("status_code")
4
    val statusCode: Int,
5

6
    @SerialName("error_msg")
7
    val errorMsg: String? = null
8
)

4.5 自定义序列化器#

1
import kotlinx.serialization.KSerializer
2
import kotlinx.serialization.descriptors.PrimitiveKind
3
import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
4
import kotlinx.serialization.encoding.Decoder
5
import kotlinx.serialization.encoding.Encoder
6
import java.time.LocalDateTime
7
import java.time.format.DateTimeFormatter
8

9
// 为 LocalDateTime 编写自定义序列化器
10
object LocalDateTimeSerializer : KSerializer<LocalDateTime> {
11
    private val formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME
12

13
    override val descriptor = PrimitiveSerialDescriptor("LocalDateTime", PrimitiveKind.STRING)
14

15
    override fun serialize(encoder: Encoder, value: LocalDateTime) {
16
        encoder.encodeString(value.format(formatter))
17
    }
18

19
    override fun deserialize(decoder: Decoder): LocalDateTime {
20
        return LocalDateTime.parse(decoder.decodeString(), formatter)
21
    }
22
}
23

24
@Serializable
25
data class Event(
26
    val name: String,
27
    @Serializable(with = LocalDateTimeSerializer::class)
28
    val createdAt: LocalDateTime
29
)
30

31
val event = Event("发布新版本", LocalDateTime.now())
32
val json = Json { prettyPrint = true }
33
println(json.encodeToString(event))

4.6 灵活配置#

1
val json = Json {
2
    prettyPrint = true                     // 格式化输出
3
    encodeDefaults = true                  // 序列化默认值
4
    explicitNulls = true                   // 不忽略 null 字段
5
    ignoreUnknownKeys = true               // 反序列化时忽略未知字段
6
    coerceInputValues = true               // 输入值自动转换（如 null → 默认值）
7
    classDiscriminator = "type"            // 多态类型标识字段名
8
    allowStructuredMapKeys = true          // 允许复合类型做 Map 的 key
9
}

4.7 动态构建 JSON（JsonObjectBuilder）#

1
val dynamicJson = buildJsonObject {
2
    put("name", "张三")
3
    put("age", 28)
4
    putJsonArray("hobbies") {
5
        add("篮球")
6
        add("阅读")
7
    }
8
    putJsonObject("address") {
9
        put("city", "广州")
10
        put("district", "天河")
11
    }
12
}
13

14
println(json.encodeToString(dynamicJson))

4.8 kotlinx.serialization 优缺点#

优点	缺点
编译期生成代码，零反射开销	需要 Gradle 插件
完美支持 Kotlin 特性（默认值、非空等）	对 Java 类的支持需额外适配
跨平台（JVM/JS/Native 通用）	社区资料比 Gson 少
可搭配 Ktor、KMM 无缝使用	—

5. Moshi：Square 的现代方案#

Moshi 是 Square 出品的现代 JSON 库，专为 Kotlin 优化，通过注解处理器生成适配器。

5.1 添加依赖#

1
plugins {
2
    id("com.google.devtools.ksp") version "1.9.22-1.0.17" // 或 kapt
3
}
4

5
dependencies {
6
    implementation("com.squareup.moshi:moshi:1.15.1")
7
    implementation("com.squareup.moshi:moshi-kotlin:1.15.1")
8
    ksp("com.squareup.moshi:moshi-kotlin-codegen:1.15.1") // 或 kapt
9
}

5.2 基本类型转 JSON#

1
import com.squareup.moshi.Moshi
2
import com.squareup.moshi.kotlin.reflect.KotlinJsonAdapterFactory
3
import com.squareup.moshi.adapter
4

5
val moshi = Moshi.Builder()
6
    .addLast(KotlinJsonAdapterFactory())
7
    .build()
8

9
val jsonAdapter = moshi.adapter<Map<String, Any>>()
10

11
// int → JSON
12
val intMap = mapOf("age" to 42)
13
println(jsonAdapter.toJson(intMap))
14
// 输出: {"age":42}
15

16
// String → JSON
17
val strMap = mapOf("name" to "张三")
18
println(jsonAdapter.toJson(strMap))
19
// 输出: {"name":"张三"}
20

21
// List → JSON
22
val listAdapter = moshi.adapter<List<Any>>()
23
println(listAdapter.toJson(listOf("A", "B", "C")))
24
// 输出: ["A","B","C"]

5.3 自定义对象转 JSON#

1
import com.squareup.moshi.JsonClass
2

3
@JsonClass(generateAdapter = true)
4
data class User(
5
    val id: Long,
6
    val name: String,
7
    val age: Int,
8
    val email: String? = null,
9
    val tags: List<String> = emptyList()
10
)
11

12
@JsonClass(generateAdapter = true)
13
data class Order(
14
    val orderId: String,
15
    val user: User,
16
    val amount: Double,
17
    val items: List<OrderItem>,
18
    val paid: Boolean
19
)
20

21
@JsonClass(generateAdapter = true)
22
data class OrderItem(
23
    val productId: Long,
24
    val productName: String,
25
    val quantity: Int,
26
    val price: Double
27
)
28

29
val order = Order(
30
    orderId = "ORD-2024-001",
31
    user = User(1001, "张三", 28, tags = listOf("VIP")),
32
    amount = 299.99,
33
    items = listOf(
34
        OrderItem(1, "机械键盘", 1, 199.99),
35
        OrderItem(2, "鼠标垫", 2, 50.0)
36
    ),
37
    paid = true
38
)
39

40
val adapter = moshi.adapter<Order>()
41
val orderJson = adapter.toJson(order)
42
println(orderJson)

5.4 自定义字段名#

1
@JsonClass(generateAdapter = true)
2
data class ApiResponse(
3
    @Json(name = "status_code")
4
    val statusCode: Int,
5

6
    @Json(name = "error_msg")
7
    val errorMsg: String? = null
8
)

5.5 自定义适配器#

1
import com.squareup.moshi.FromJson
2
import com.squareup.moshi.ToJson
3
import java.time.LocalDateTime
4
import java.time.format.DateTimeFormatter
5

6
class LocalDateTimeAdapter {
7
    private val formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME
8

9
    @ToJson
10
    fun toJson(value: LocalDateTime): String {
11
        return value.format(formatter)
12
    }
13

14
    @FromJson
15
    fun fromJson(json: String): LocalDateTime {
16
        return LocalDateTime.parse(json, formatter)
17
    }
18
}
19

20
val moshi = Moshi.Builder()
21
    .add(LocalDateTimeAdapter())
22
    .addLast(KotlinJsonAdapterFactory())
23
    .build()

5.6 Moshi 优缺点#

优点	缺点
对 Kotlin 支持优秀	依赖 KSP/KAPT 代码生成
比 Gson 更轻量、更安全	社区规模小于 Gson
无反射，编译期生成适配器	需注解标记数据类

6. 实用场景示例#

6.1 表单数据转 JSON 提交#

1
// 用 Gson 把 EditText 的输入打包成 JSON
2
fun buildLoginJson(
3
    username: String,
4
    password: String,
5
    rememberMe: Boolean
6
): String {
7
    val loginData = mapOf(
8
        "username" to username,
9
        "password" to password,
10
        "remember_me" to rememberMe
11
    )
12
    return Gson().toJson(loginData)
13
}
14

15
// 输出: {"username":"admin","password":"123456","remember_me":true}

6.2 Room 数据库的 TypeConverter#

1
// 把 List<String> 存为 JSON 字符串
2
class Converters {
3
    private val gson = Gson()
4

5
    @TypeConverter
6
    fun fromStringList(value: List<String>): String {
7
        return gson.toJson(value)
8
    }
9

10
    @TypeConverter
11
    fun toStringList(value: String): List<String> {
12
        val listType = object : TypeToken<List<String>>() {}.type
13
        return gson.fromJson(value, listType)
14
    }
15
}

6.3 SharedPreferences 存储对象#

1
fun saveUserToPrefs(context: Context, user: User) {
2
    val json = Gson().toJson(user)
3
    context.getSharedPreferences("app_prefs", Context.MODE_PRIVATE)
4
        .edit()
5
        .putString("current_user", json)
6
        .apply()
7
}
8

9
fun getUserFromPrefs(context: Context): User? {
10
    val json = context.getSharedPreferences("app_prefs", Context.MODE_PRIVATE)
11
        .getString("current_user", null) ?: return null
12
    return Gson().fromJson(json, User::class.java)
13
}

6.4 用 kotlinx.serialization 处理动态 key#

1
@Serializable
2
data class Translations(
3
    val data: Map<String, String>
4
)
5

6
val translations = Translations(
7
    mapOf(
8
        "hello" to "你好",
9
        "world" to "世界",
10
        "kotlin" to "科特林"
11
    )
12
)
13

14
val json = Json { prettyPrint = true }
15
println(json.encodeToString(translations))
16
// 输出:
17
// {
18
//     "data": {
19
//         "hello": "你好",
20
//         "world": "世界",
21
//         "kotlin": "科特林"
22
//     }
23
// }

7. 方案对比总结#

维度	org.json	Gson	kotlinx.serialization	Moshi
依赖量	0	1	2	2
对象自动映射	❌	✅	✅	✅
反射	—	是	否（编译期生成）	否（编译期生成）
Kotlin 特性支持	手动处理	一般	⭐⭐⭐⭐⭐	⭐⭐⭐⭐
学习曲线	低	低	中	中
跨平台	仅 Android JVM	JVM	JVM/JS/Native	JVM
性能	一般	良好	优秀	优秀
社区成熟度	SDK 自带	⭐⭐⭐⭐⭐	⭐⭐⭐	⭐⭐⭐

8. 选型建议#

1
你的项目是什么样的？
2
│
3
├── 极简场景 / 只传几个字段
4
│   └── org.json（零依赖，写完即走）
5
│
6
├── 传统 Android 项目（Java + Kotlin 混编）
7
│   └── Gson（成熟稳定，一行业务代码搞定）
8
│
9
├── 纯 Kotlin 新项目
10
│   └── kotlinx.serialization（原生支持，编译期安全）
11
│
12
├── Kotlin Multiplatform / KMM
13
│   └── kotlinx.serialization（唯一跨平台选择）
14
│
15
├── 追求极致性能 + 类型安全
16
│   └── kotlinx.serialization 或 Moshi
17
│
18
└── 与 Retrofit 配合
19
    └── Gson 或 Moshi（Retrofit 有对应 Converter）

Tip

如果你只能记住一个结论：纯 Kotlin 新项目用 kotlinx.serialization，混编或老项目用 Gson，简单场景用 org.json。

音乐

Android 数据转 JSON 完全指南：JSONObject、Gson、kotlinx.serialization 与 Moshi

前言#

1. 四种方案速览#

2. org.json：Android 内置方案#

2.1 基本类型转 JSON#

2.2 复合类型转 JSON#

2.3 自定义对象手动转 JSON#

2.4 格式化输出#

2.5 org.json 优缺点#

3. Gson：Google 的经典之选#

3.1 添加依赖#

3.2 基本类型转 JSON#

3.3 自定义对象一键转 JSON#

3.4 Gson 高级配置#

3.5 自定义字段名#

3.6 自定义序列化器#

3.7 Gson 优缺点#

4. kotlinx.serialization：Kotlin 原生方案#

4.1 添加依赖#

4.2 基本类型转 JSON#

4.3 自定义对象转 JSON#

4.4 自定义字段名#

4.5 自定义序列化器#

4.6 灵活配置#

4.7 动态构建 JSON（JsonObjectBuilder）#

4.8 kotlinx.serialization 优缺点#

5. Moshi：Square 的现代方案#

5.1 添加依赖#

5.2 基本类型转 JSON#

5.3 自定义对象转 JSON#

5.4 自定义字段名#

5.5 自定义适配器#

5.6 Moshi 优缺点#

6. 实用场景示例#

6.1 表单数据转 JSON 提交#

6.2 Room 数据库的 TypeConverter#

6.3 SharedPreferences 存储对象#

6.4 用 kotlinx.serialization 处理动态 key#

7. 方案对比总结#

8. 选型建议#

参考资料#

文章分享

评论区