參考：

1. https://github.com/yole/jkid

預(yù)備知識

• Kotlin 反射搓蚪；
• Kotlin 注解；
• Koltin 泛型煌茴；

說明

Json 序列化是將一個對象埋合，轉(zhuǎn)換成Json形式的字符串卧须；反序列化是將json格式字符串轉(zhuǎn)成相應(yīng)的對象；

1. 分析

如下：代碼

// 數(shù)據(jù)類
data class Person(val name: String, val age: Int, val likes: List<String>)

// 測試代碼
val p = Person("better", 30, listOf("Java", "Kotlin", "Python"))
println(serialize(p)) 

輸出為：

{"age": 30, "likes": ["Java", "Kotlin", "Python"], "name": "better"}

將類的每個屬性作為 json 的 key，value 為 key 對象的值衷掷，如果value 為 List 形式，即對應(yīng)json的數(shù)組形式[];

我們可通過反射獲取類的所有屬性，然后遍歷汁针，分別將每個屬性，映射成json對應(yīng)的 key 砚尽、value施无；

2. kotlin 代碼實(shí)現(xiàn)

會有大量字符串拼接，所以為StringBuilder添加擴(kuò)展函數(shù)來整體拼接

整體步驟：

1. 獲取類的所有KProperty;
2. 遍歷 KProperty 集合必孤，獲取每個 KProperty猾骡；
3. 每個KProperty都有他的名字與值，對應(yīng)json的 key敷搪，value兴想，value 處理時，需進(jìn)行類型判斷赡勘；

// 對外全局方法
fun serialize(obj: Any) = buildString { serializeObj(obj) }

private inline fun StringBuilder.serializeObj(o: Any) {
    // ==== 1. 獲取類的所有`KProperty`
    o.javaClass.kotlin.memberProperties.joinToStringBuilder(this, separator = ",", prefix = "{", postfix = "}") {
        // ==== 2.遍歷 `KProperty` 集合嫂便，獲取每個 `KProperty`，進(jìn)行類型判斷闸与，并處理毙替；
        serializeProperty(it, o)
    }
}

private inline fun StringBuilder.serializeProperty(property: KProperty1<Any, *>, receiver: Any) {
    // ====3. 每個`KProperty`都有他的名字與值岸售，對應(yīng)json的 key，value厂画，value 處理時凸丸，需進(jìn)行類型判斷；
    val key = property.name
    // 處理key
    serializeString(key)
    append(": ")

    // 處理value
    val value = property.get(receiver)
    serializePropertyValue(value)
}

// 處理屬性值
private fun StringBuilder.serializePropertyValue(value: Any?) {
    when (value) {
        null -> append("null")
        is String -> serializeString(value)
        is Boolean, is Number -> append(value.toString())
        is List<*> -> serializeList(value)
        else -> serializeObj(value)
    }
}

/**
 * 處理list
 */
private fun StringBuilder.serializeList(data: List<Any?>) {
    data.joinToStringBuilder(this,  separator = ", " ,prefix = "[", postfix = "]") {
        serializePropertyValue(it)
    }
}

// 屬性名稱
private inline fun StringBuilder.serializeString(name: String) {
    // like "better"
    append('\"').append("$name").append('\"')
}

// 這里對joinToString 進(jìn)行了改寫袱院，使其支持 ((T) -> Unit)
fun <T> Iterable<T>.joinToStringBuilder(sb: StringBuilder, separator: CharSequence = ", ",
                                        prefix: CharSequence = "",
                                        postfix: CharSequence = "",
                                        limit: Int = -1,
                                        truncated: CharSequence = "...",
                                        transform: ((T) -> Unit)? = null): StringBuilder {
    return joinTo(sb, separator, prefix, postfix, limit, truncated) {
        if (transform == null) {    // 包裝器模式
            return@joinTo it.toString()
        }
        transform.invoke(it)
        ""
    }
}

3. 測試1 :

// 數(shù)據(jù)類
data class Person(val name: String, val age: Int, val likes: List<String>)

// 測試代碼
val p = Person("better", 30, listOf("Java", "Kotlin", "Python"))
println(serialize(p))  // 沒問題

4. 測試2 屎慢，新增類

// 縣
data class County(val name: String, val peopleCount: Int)
// 市
data class City(val name: String, val counties: List<County>)
// 省
data class Province(val name: String, val size: Int, val cities: List<City>?)

val c1 = County("湘潭縣", 20_000)
val c2 = County("株洲縣", 30_000)
val c4 = County("攸縣", 40_000)

val ci1 = City("湘潭市", listOf(c1))
val ci2 = City("株洲市", listOf(c2, c4))

val p1 = Province("湖南省", 780, listOf(ci1, ci2))
println(serialize(p1))

格式化為：

{
    "cities": [{
        "counties": [{
            "name": "湘潭縣",
            "peopleCount": 20000
        }],
        "name": "湘潭市"
    }, {
        "counties": [{
            "name": "株洲縣",
            "peopleCount": 30000
        }, {
            "name": "攸縣",
            "peopleCount": 40000
        }],
        "name": "株洲市"
    }],
    "name": "湖南省",
    "size": 780
}