引入

  1.  implementation 'com.google.code.gson:gson:2.8.6'

方法

  1. //GsonKtx内方法
  2. getGson        ：获取gson
  3. toJson        :任意对象转成json
  4. toAny        :将json数据转成任意bean类
  5. toMap        :将json数据转成Map
  6. toList        :将json数据转成任意集合bean类
  7. toList2        :将json数据转成任意集合bean类,遇到解析不了的，就使用这个
  8. toListType    :将json数据转成任意集合bean类，需要自己定义好Type
  9. toListMap    :将json数据转成任意集合Map类
  10. //扩展方法
  11. toJson        :任意对象转成json
  12. toAny        :将json数据转成任意bean类
  13. toMap        :将json数据转成Map
  14. toList        :将json数据转成任意集合bean类
  15. toList2        :将json数据转成任意集合bean类
  16. toListType    :将json数据转成任意集合bean类，需要自定义Type
  17. toListMap    :将json数据转成任意集合Map类

使用示例

  • 对象转json

    1. val testBean = TestBean(true, "alice")
    2. //工具类
    3. val json1 = GsonKtx.toJson(testBean)
    4. //扩展函数
    5. val json2 = testBean.toJson()

  • json转对象

    1. val jsonTest = "{\"isSuccess\":\"true\",\"name\":alice}"
    2. val test = GsonKtx.toAny<TestBean>(jsonTest)
    3. val test2 = jsonTest.toAny<TestBean>()

  • json转map

    1. val jsonTest = "{\"isSuccess\":\"true\",\"name\":alice}"
    2. val map = GsonKtx.toMap<Any>(jsonTest)

  • json转list

    • 方法一，自己定义好Type，调用toListType

      1. val jsonList = "[{\"isSuccess\":false,\"name\":\"a\"},{\"isSuccess\":true,\"name\":\"b\"}]"
      2. val typeToken: TypeToken<List<TestBean>> = object : TypeToken<List<TestBean>>() {}
      3. val list = jsonList.toListType<TestBean>(typeToken.type)
      4. list?.forEach {
      5. println(it.name)
      6. }

    • 方法二、调用toList

      1. val list22 = jsonList.toList(Array<TestBean>::class.java)
      2. list22?.forEach {
      3. println(it.name)
      4. }

    • 方法三、调用toList2

      1. val list4 = GsonKtx.toList2<TestBean>(jsonList)
      2. println(list4)
      3. list4.forEach {
      4. println(it.name)
      5. }

  • json转listMap

    1. val list3 = GsonKtx.toListMap<String>(jsonList)
    2. println(list3)
    3. list3?.forEach {
    4.   println(it?.get("name"))
    5. }

完整代码

  1. /**
  2.  * 任意对象转成json
  3.  */
  4. fun Any?.toJson() = GsonKtx.toJson(this)
  5. fun Any?.toJson(gson: Gson) = GsonKtx.toJson(gson, this)
  7. /**
  8.  *将json数据转成任意bean类
  9.  */
  10. inline fun <reified T> String?.toAny() = GsonKtx.toAny<T>(this)
  11. fun <T> String?.toAny(clazz: Class<T>) = GsonKtx.toAny(this, clazz)
  12. fun <T> String?.toAny(gson: Gson, clazz: Class<T>) = GsonKtx.toAny(gson, this, clazz)
  14. /**
  15.  *将json数据转成Map
  16.  */
  17. inline fun <reified T> String?.toMap() = GsonKtx.toMap<T>(this)
  18. fun <T> String?.toMap(clz: Class<T>?) = GsonKtx.toMap(this, clz)
  20. /**
  21.  *将json数据转成任意集合bean类
  22.  */
  23. fun <T> String?.toList(clz: Class<Array<T>>?) = GsonKtx.toList(this, clz)
  24. fun <T> String?.toList(gson: Gson, clz: Class<Array<T>>?) = GsonKtx.toList(gson, this, clz)
  26. /**
  27.  *将json数据转成任意集合bean类
  28.  */
  29. inline fun <reified T> String?.toList2() = GsonKtx.toList2<T>(this)
  30. fun <T> String?.toList2(clz: Class<T>?) = GsonKtx.toList2(this, clz)
  32. /**
  33.  *将json数据转成任意集合bean类，需要自定义Type
  34.  */
  35. fun <T> String?.toListType(type: Type) = GsonKtx.toListType<T>(this, type)
  37. /**
  38.  *将json数据转成任意集合Map类
  39.  */
  40. inline fun <reified T> String?.toListMap() = GsonKtx.toListMap<T>(this)
  41. fun <T> String?.toListMap(clazz: Class<T>) = GsonKtx.toListMap(this, clazz)
  44. object GsonKtx {
  46.     private val gson = Gson()
  48.     /**
  49.      *获取 gson
  50.      */
  51.     fun getGson() = gson
  53.     /**
  54.      * 任意对象转成json
  55.      */
  56.     fun toJson(any: Any?): String? {
  57.         return toJson(gson, any)
  58.     }
  60.     fun toJson(gson: Gson, any: Any?): String? {
  61.         return try {
  62.             gson.toJson(any)
  63.         } catch (e: Exception) {
  64.             null
  65.         }
  66.     }
  68.     /**
  69.      *将json数据转成任意bean类
  70.      */
  71.     inline fun <reified T> toAny(json: String?): T? {
  72.         return toAny(json, T::class.java)
  73.     }
  75.     fun <T> toAny(json: String?, clazz: Class<T>): T? {
  76.         return toAny(gson, json, clazz)
  77.     }
  79.     fun <T> toAny(gson: Gson, json: String?, clazz: Class<T>): T? {
  80.         return try {
  81.             gson.fromJson(json, clazz)
  82.         } catch (e: Exception) {
  83.             null
  84.         }
  85.     }
  87.     /**
  88.      *将json数据转成任意集合bean类
  89.      */
  90.     fun <T> toList(json: String?, clz: Class<Array<T>>?): List<T>? {
  91.         return toList(gson, json, clz)
  92.     }
  94.     fun <T> toList(gson: Gson, json: String?, clz: Class<Array<T>>?): List<T>? {
  95.         return try {
  96.             val ts: Array<T> = gson.fromJson(json, clz)
  97.             mutableListOf(*ts)
  98.         } catch (e: Exception) {
  99.             null
  100.         }
  101.     }
  103.     /**
  104.      *将json数据转成任意集合bean类，需要自己定义好Type
  105.      *   val typeToken: TypeToken<List<TestBean>> = object : TypeToken<List<TestBean>>() {}
  106.      */
  107.     fun <T> toListType(json: String?, type: Type): List<T>? {
  108.         return toListType(gson, json, type)
  109.     }
  111.     fun <T> toListType(gson: Gson, json: String?, type: Type): List<T>? {
  112.         return try {
  113.             gson.fromJson(json, type)
  114.         } catch (e: Exception) {
  115.             null
  116.         }
  117.     }
  119.     /**
  120.      * Json转List集合,遇到解析不了的，就使用这个
  121.      */
  122.     inline fun <reified T> toList2(json: String?): List<T> {
  123.         return toList2(json, T::class.java)
  124.     }
  126.     fun <T> toList2(json: String?, cls: Class<T>?): List<T> {
  127.         val mList: MutableList<T> = ArrayList()
  128.         try {
  129.             val array = JsonParser().parse(json).asJsonArray
  130.             for (elem in array) {
  131.                 mList.add(gson.fromJson(elem, cls))
  132.             }
  133.         } catch (e: Exception) {
  134.         }
  135.         return mList
  136.     }
  138.     /**
  139.      * Json转换成Map的List集合对象
  140.      */
  141.     inline fun <reified T> toListMap(json: String?): List<Map<String?, T>?>? {
  142.         return toListMap(json, T::class.java)
  143.     }
  145.     fun <T> toListMap(json: String?, clz: Class<T>?): List<Map<String?, T>?>? {
  146.         return toListMap(gson, json, clz)
  147.     }
  149.     fun <T> toListMap(gson: Gson, json: String?, clz: Class<T>?): List<Map<String?, T>?>? {
  150.         return try {
  151.             val type: Type = object : TypeToken<List<Map<String?, T>?>?>() {}.type
  152.             gson.fromJson(json, type)
  153.         } catch (e: Exception) {
  154.             null
  155.         }
  156.     }
  158.     /**
  159.      * Json转Map对象
  160.      */
  161.     inline fun <reified T> toMap(json: String?): Map<String?, T>? {
  162.         return toMap(json, T::class.java)
  163.     }
  165.     fun <T> toMap(json: String?, clz: Class<T>?): Map<String?, T>? {
  166.         return toMap(gson, json, clz)
  167.     }
  169.     fun <T> toMap(gson: Gson, json: String?, clazz: Class<T>?): Map<String?, T>? {
  170.         return try {
  171.             val type = object : TypeToken<Map<String?, T>?>() {}.type
  172.             return gson.fromJson(json, type)
  173.         } catch (e: Exception) {
  174.             null
  175.         }
  176.     }
  179. }