一、Gson

导包：implementation ‘com.google.code.gson:gson:2.8.6’

  2. /**
  3.  * 任意对象转成json
  4.  */
  5. fun Any?.toJson() = GsonUtils.any2Json(this)
  6. fun Any?.toJson(gson: Gson) = GsonUtils.any2Json(gson, this)
  8. /**
  9.  *将json数据转成任意bean类
  10.  */
  11. fun <T> String?.toAny(clazz: Class<T>) = GsonUtils.json2Any(this, clazz)
  12. fun <T> String?.toAny(gson: Gson, clazz: Class<T>) = GsonUtils.json2Any(gson, this, clazz)
  13. fun <T> String?.toMap(clz: Class<T>?) = GsonUtils.json2Map(this,clz)
  15. /**
  16.  *将json数据转成任意集合bean类
  17.  */
  18. fun <T> String?.toList(clazz: Class<T>) = GsonUtils.json2List(this, clazz)
  19. fun <T> String?.toList(gson: Gson, clazz: Class<T>) = GsonUtils.json2List(gson, this, clazz)
  20. fun <T> String?.toListMap(clazz: Class<T>) = GsonUtils.json2ListMap(this, clazz)
  23. object GsonUtils {
  25.     private val gson = Gson()
  27.     /**
  28.      *获取 gson
  29.      */
  30.     fun getGson() = gson
  31.     /**
  32.      *将json数据转成任意bean类
  33.      */
  34.     fun <T> json2Any(json: String?, clazz: Class<T>): T? {
  35.         return json2Any(gson, json, clazz)
  36.     }
  38.     fun <T> json2Any(gson: Gson, json: String?, clazz: Class<T>): T? {
  39.         return try {
  40.             gson.fromJson(json, clazz)
  41.         } catch (e: Exception) {
  42.             null
  43.         }
  44.     }
  46.     /**
  47.      * 任意对象转成json
  48.      */
  49.     fun any2Json(any: Any?): String? {
  50.         return any2Json(gson, any)
  51.     }
  53.     fun any2Json(gson: Gson, any: Any?): String? {
  54.         return try {
  55.             gson.toJson(any)
  56.         } catch (e: Exception) {
  57.             null
  58.         }
  59.     }
  61.     /**
  62.      *将json数据转成任意集合bean类
  63.      */
  64.     fun <T> json2List(json: String?, clazz: Class<T>): List<T>? {
  65.         val typeToken: TypeToken<List<T>> = object : TypeToken<List<T>>() {}
  66.         return json2List(gson, json, clazz)
  67.     }
  69.     fun <T> json2List(gson: Gson, json: String?, clazz: Class<T>): List<T>? {
  70.         val typeToken: TypeToken<List<T>> = object : TypeToken<List<T>>() {}
  71.         return try {
  72.             gson.fromJson(json, typeToken.type)
  73.         } catch (e: Exception) {
  74.             null
  75.         }
  76.     }
  78.     /**
  79.      * Json转List集合,遇到解析不了的，就使用这个
  80.      */
  81.     fun <T> json2List2(json: String?, cls: Class<T>?): List<T>? {
  82.         val mList: MutableList<T> = ArrayList()
  83.         val array = JsonParser().parse(json).asJsonArray
  84.         for (elem in array) {
  85.             mList.add(gson.fromJson(elem, cls))
  86.         }
  87.         return mList
  88.     }
  90.     /**
  91.      * Json转换成Map的List集合对象
  92.      */
  93.     fun <T> json2ListMap(json: String?, clz: Class<T>?): List<Map<String?, T>?>? {
  94.         return try {
  95.             val type: Type = object : TypeToken<List<Map<String?, T>?>?>() {}.type
  96.             gson.fromJson(json, type)
  97.         } catch (e: Exception) {
  98.             null
  99.         }
  100.     }
  102.     /**
  103.      * Json转Map对象
  104.      */
  105.     fun <T> json2Map(json: String?, clz: Class<T>?): Map<String?, T>? {
  106.         val type = object : TypeToken<Map<String?, T>?>() {}.type
  107.         return gson.fromJson(json, type)
  108.     }
  110. }

二、Fastjson

implementation ‘com.alibaba:fastjson:1.2.48’

  1. //json -> any
  2. fun <T>String?.toAny(tClass: Class<T>?) = FastUtils.json2Class(this,tClass)
  3. //json -> map
  4. fun <T>String?.toMap() = FastUtils.json2Map<Map<String,T>>(this)
  5. //json -> list
  6. fun <T>String?.toList(tClass: Class<T>?) = FastUtils.json2List(this,tClass)
  7. //any -> json
  8. fun Any?.toJsonFast() = FastUtils.any2Json(this)
  11. object FastUtils {
  13.     /**
  14.      *json  ----->  T
  15.      * @param T
  16.      * @param json
  17.      * @param tClass
  18.      * @return
  19.      */
  20.     fun <T> json2Class(json: String?, tClass: Class<T>?): T? {
  21.         if (TextUtils.isEmpty(json)) {
  22.             return null
  23.         }
  24.         try {
  25.             return JSON.parseObject(json, tClass)
  26.         } catch (e: Exception) {
  27.         }
  28.         return null
  29.     }
  31.     /**
  32.      *json ---->  map
  33.      * @param T
  34.      * @param json
  35.      * @return
  36.      */
  37.     fun <T>json2Map(json: String?): Map<String, T>? {
  38.         if (TextUtils.isEmpty(json)) {
  39.             return null
  40.         }
  41.         try {
  42.             return JSON.parseObject<Map<String, T>>(json, MutableMap::class.java)
  43.         } catch (e: Exception) {
  44.         }
  45.         return null
  46.     }
  48.     /**
  49.      *json ----->  list
  50.      * @param T
  51.      * @param json
  52.      * @param tClass
  53.      * @return
  54.      */
  55.     fun <T> json2List(json: String?, tClass: Class<T>?): List<T>? {
  56.         if (TextUtils.isEmpty(json)) {
  57.             return null
  58.         }
  59.         try {
  60.             return JSON.parseArray(json, tClass)
  61.         } catch (e: Exception) {
  62.         }
  63.         return null
  64.     }
  66.     /**
  67.      *any -----> json
  68.      * @param any
  69.      * @return
  70.      */
  71.     fun any2Json(any: Any?): String?{
  72.         return try {
  73.             JSON.toJSONString(any)
  74.         }catch (e: Exception){
  75.             null
  76.         }
  77.     }
  78. }