搜狐新闻客户端使用Kotlin之后对JSON解析框架的探索

本文字数： 7488 字

预计阅读时间： 45 分钟

01

引言

自2017 年Google发布Kotlin 语言之后，Android开发由原来的Java开始向Kotlin

过度，目前绝大部分Android开发岗位基本要求就是熟练使用Kotlin 。事实上，很多有着多年历史的项目一开始是Java开发的，在Kotlin日渐趋于Android开发主流的过程中，混合开发成为许多项目的首选。我们的项目也是采用混合开发，面对拥有沉重历史包袱的代码，想用Kotlin重构却不得不考虑时间成本和人力成本，但又不想放弃Kotlin开发的优势，所以新业务均采用Kotlin开发。

Json就不过多介绍了，大家耳熟能详，相信很多伙伴项目中的Json解析依旧在使用FastJson或者Gson等第三方框架进行数据解析，当我们混合开发之后，你会发现Kotlin的数据类写起来很方便，但是将Json解析为数据类对象时出现的问题会让你很头大，尤其是开启混淆之后，各种各样的问题甚至程序崩溃随之出现，随着程序的崩溃，你的内心渐渐开始崩溃，不禁发出疑问，数据类不好用吗？

02

常见Json解析框架

• FastJson：阿里巴巴公司所开发的 JSON 库，由Java语言开发，对Kotlin有一定的支持，目前FastJson1不在维护，转而维护FastJson2，称FastJson2是为未来十年打造一款高性能的Json解析框架，核心原理是反射。

• Jackson：Spring 默认的 JSON 库，GitHub上面介绍其是"the best JSON parser for Java"（最好的Java Json解析器），支持解析多种数据格式，核心原理也是反射

  Gson：Google官方开发维护的 JSON 库，目的是为Java开发提供数据解析支持，功能非常强大，核心原理依旧是反射。

  Kotlinx.serialization：Kotlin官方开发的基于Kotlin的序列化与反序列化库，它包括了用于生成代码的插件、具有核心序列化API的运行时库以及具有各种序列化格式的支持库。编译器插件为可序列化的类生成访问者和序列化器，核心原理利用了Kotlin在编译时能够生成代码的特性，从而避免了反射的使用。

03

发生了什么问题

环境：Android Kotlin FastJson1.1.56

背景：新需求初步测试完成，即将合版，所有的Case测试通过，在最后一天用Release包测试时，发现崩溃，经过好几个人三个小时的加班问题解决了。

原因：当客户端与服务器交换数据时，使用数据类作为数据存储的方式，用FastJson将Json字符串解析为对象，用于业务逻辑的使用。Release包开启了代码混淆，导致FastJson在解析时，无法利用反射反射到数据类的构造器，从而抛出异常导致解析失败。

解决方案：改变混淆规则，数据类不进行混淆，因为数据类val关键字修饰的变量不会生成对应的set方法，而FastJson在创建对象后进行赋值时需要调用set方法为其赋值，因此还得将修饰符改为var，并且需要添加默认值，否则在反射创建对象的过程中会抛出异常，导致程序崩溃。

04

FastJson要升级新版本吗

1、问题场景再现

废话不多说，首先我们看一下问题出现的异常：default constructor not found.

其中ComplexEntity是我们的数据类，由val关键字修饰，并且没有任何默认值， 代码如下：

import java.io.Serializable

data class ComplexEntity(
    val id: Int,
    val name: String,
    val score: Float,
    val userInfo: UserInfo
) : Serializable

data class UserInfo(
   val userName: String,
   val userAge: Int,
   val userFriends: List<FriendsInfo>
) : Serializable

data class FriendsInfo(
    val phoneNumber: String,
    val userTag: String,
    val groupId: Int
) : Serializable

我们的用法也很简单，就是要把一个Json字符串解析成为一个ComplexEntity类型的对象，代码如下，但是这里会抛出开头提到的异常。

val parseObject = JSON.parseObject(json, ComplexEntity::class.java)

我们来看看堆栈报错中JavaBeanInfo.build()方法中为什么会导致该错误：

public static JavaBeanInfo build(Class<?> clazz, //
                             int classModifiers, //
                             Type type, //
                             boolean fieldOnly, //
                             boolean jsonTypeSupport, //
                             boolean jsonFieldSupport, //
                             boolean fieldGenericSupport, //
                             PropertyNamingStrategy propertyNamingStrategy
) {
List<FieldInfo> fieldList = new ArrayList<FieldInfo>();

// DeserializeBeanInfo beanInfo = null;
Constructor<?> defaultConstructor = null;
if ((classModifiers & Modifier.ABSTRACT) == 0) {
    try {
        defaultConstructor = clazz.getDeclaredConstructor();
    } catch (Exception e) {
        // skip
    }

    if (defaultConstructor == null) {
        if (clazz.isMemberClass() && (classModifiers & Modifier.STATIC) == 0) { // for inner none static class
            for (Constructor<?> constructor : clazz.getDeclaredConstructors()) {
                Class<?>[] parameterTypes = constructor.getParameterTypes();
                if (parameterTypes.length == 1 && parameterTypes[0].equals(clazz.getDeclaringClass())) {
                    defaultConstructor = constructor;
                    break;
                }
            }
        }
    }
}

Constructor<?> creatorConstructor = null;
Method[] methods = fieldOnly //
    ? null //
    : clazz.getMethods();

final Field[] declaredFields = clazz.getDeclaredFields();

if (defaultConstructor == null // 
        && !(clazz.isInterface() || (classModifiers & Modifier.ABSTRACT) != 0) //
        ) {
    creatorConstructor = null;
    for (Constructor<?> constructor : clazz.getDeclaredConstructors()) {
        JSONCreator annotation = constructor.getAnnotation(JSONCreator.class);
        if (annotation != null) {
            if (creatorConstructor != null) {
                throw new JSONException("multi-json creator");
            }

            creatorConstructor = constructor;
            break;
        }
    }

    if (creatorConstructor != null) {
        ...... 此处省略构造器不为空的时候直接通过构造器创建对象
        return new JavaBeanInfo(clazz, null, creatorConstructor, null, fields, sortedFields, jsonType);
    }

    Method factoryMethod = null;
    {
        for (Method method : methods) {
            if ((!Modifier.isStatic(method.getModifiers())) //
                || !clazz.isAssignableFrom(method.getReturnType()) //
            ) {
                continue;
            }

            JSONCreator annotation = method.getAnnotation(JSONCreator.class);
            if (annotation != null) {
                if (factoryMethod != null) {
                    throw new JSONException("multi-json creator");
                }

                factoryMethod = method;
                break;
            }
        }
    }

    if (factoryMethod != null) {
        ......此处省略创建beanInfo的过程
        return beanInfo;
    }
    //抛出该异常原因是factoryMethod 没有被赋值
    throw new JSONException("default constructor not found. " + clazz);
}

此方法的目的是通过反射获取传入的clazz类的构造器，从而为后面解析创建对象时使用。在Json串解析时将值赋值给对应属性时，也会提前通过反射去构造一个FileInfo，它里面保存了对应的属性名和set方法。在赋值时会调用对应的set方法。

而我们的数据类声明的是val类型的变量，那么编译器会帮我们生成对应的get、toString方法等，通过Android Studio查看数据类字节码反编译后的结果，可以看到val所修饰的属性不会生成对应的set方法，并且也不会生成默认的无参构造器，只有一个全参构造器，那么执行上面的代码时：构造器获取不到会抛出异常，set方法获取不到无法给属性赋值，因此打断了框架利用反射解析JSON的施法。通过上面的结果我们可以对数据类改造如下：

**`data class ComplexEntity(
var id: Int = 0,
var name: String = "",
var score: Float = 0f,
var userInfo: UserInfo = UserInfo()
) : Serializable
data class UserInfo(
var userName: String ="",
var userAge: Int = 0,
var userFriends: List<FriendsInfo> = mutableListOf()
) : Serializable
data class FriendsInfo(
var phoneNumber: String = "",
var userTag: String = "",
var groupId: Int = 0
) : Serializable`**

这样写之后，在Json解析为对象时，就能够通过反射正确反射出类的构造器以及set方法，并正确为每个属性进行赋值了。

但是依然有一个问题，当我们的Json字符串中某个String或者对象类型的值为null时，例如：{......,"name":null,......}这样的Json在进行解析时则会出现以下异常：

很显然，是在反射进行赋值的时候将null赋值给了不可为空的属性，导致异常发生。所以说在遇到这种字段时，我们需要将对应的属性设置为可空类型的。

另外就是很多项目在进行release打包后，会混淆代码，但是在Json解析时，如果代码属性名方法名亦或是类名混淆之后，反射还能正常工作吗，当然不能，因此还需要配置混淆规则，Json解析的类不进行混淆。

2、FastJson现状

首先我们先来了解以下FastJson的版本，目前项目中使用的是1.1.56版本，GitHub上FastJson1的最后一个版本是1.2.83，于2022年五月发布，至今一年多没有迭代新的版本。

而我们使用的版本更是2017年一月发布的版本，时至今日，已经六年多时间过去了，期间也出过FastJson 漏洞的事件。六年里，FastJson 团队一致在积极维护更新。随着Kotlin**** 语言的发展，FastJson 也对Kotlin进行了一定的支持。****

FastJson2 于2022年四月发布，依旧是之前的团队进行开发维护，该框架从官方介绍上说是对性能有了进一步的提升，目的是为下一个10年提供一个高性能的JSON库，覆盖的场景挺多，对Android和Kotlin进行了一定的支持。并且groupId发生了改变，因此升级需要替换包名并且验证所有API的兼容性，具体可参考GitHub详细介绍。

3、FastJson1与FastJson2对数据类的支持情况

经过测试，不管是FastJson1还是FastJson2都没有很好的兼容Kotlin Data Class，我们在使用过程中，发现新旧最新版本在对Kotlin数据类进行支持时，都需要引入Kotlin-reflect包，这是一个Kotlin实现反射的包，包大小超过2M，在当下包体大小也是一个App的指标，增加2M包体大小固然不是很好的解决方式。我们主要测试的结果如下：

首先，测试FastJson1，版本1.2.83，混淆导致出错的解决方案已经在上面提到，因此这里不在测试混淆后的结果。

● 数据类中的属性由val修饰，无默认值，结果如下：

我们找到JavaBeanInfo类的build方法中，可以看到有下面一段代码：

String[] paramNames = null;
if (kotlin && constructors.length > 0) {
    paramNames = TypeUtils.getKoltinConstructorParameters(clazz);
    creatorConstructor = TypeUtils.getKotlinConstructor(constructors, paramNames);
    TypeUtils.setAccessible(creatorConstructor);
} else {
  ......
}
public static String[] getKoltinConstructorParameters(Class clazz) {
        if (kotlin_kclass_constructor == null && !kotlin_class_klass_error) {
            try {
                Class class_kotlin_kclass = Class.forName("kotlin.reflect.jvm.internal.KClassImpl");
                kotlin_kclass_constructor = class_kotlin_kclass.getConstructor(Class.class);
            } catch (Throwable e) {
                kotlin_class_klass_error = true;
            }
        }
        if (kotlin_kclass_constructor == null) {
            return null;
        }
  ......

我们可以看到在反射创建构造器时，如果是Kotlin类，那么则使用Kotlin-reflect反射来获取对应的构造方法，因此看到这里，就知道为什么需要引入Kotlin-reflect才能够解析成功了。因此我们引入kotlin反射相关的依赖，则解析成功。开启混淆之后，由于我们的实体类都实现了java.io.Serializable接口，因此我们的配置如下：

-keep class kotlin.reflect.jvm.** {*;}
-keep class * implements java.io.Serializable {*;}

接下来测试FastJson2对数据类的支持，我们在项目中导入com.alibaba.fastjson2:fastjson2:2.0.34.android4的依赖，该版本适配了Android4。接下来依旧针对上述内容进行测试。

数据类使用val 修饰，没有默认值，未开启混淆并且为导入kotlin-reflect的情况下，运行程序发生如下异常：

对发生异常的地方进行调试，再次遇到了一个熟悉的异常，发现是Kotlin数据类的空安全类型导致的，因为此处创建对象时会给属性赋默认值，而在Java当中，String或者其它Object类型的默认值为null，将一个null值赋值给Kotlin的no-null类型的属性便会发生异常。

将数据类中String 或者其它引用类型声明为可空类型的属性，再次测试得到的结果时返回了一个只有默认值的对象，解析失败。因为其底层原理依旧是反射，因此导入kotlin-reflect反射依赖，解析成功。既然是一个全新的框架，可以不依赖反射吗？

当然是可以的，我们根据其FastJson核心是反射的原理将数据类进行改造，让编译器为数据类生成默认构造器以及set方法，改造如下：其中default字段在JSON串中并不存在对应的Key-Value，但是解析后默认值依然存在，另外开启混淆之后，将实体类的混淆 关闭即可。

data class ComplexEntity(
    var id: Int = 0,
    var name: String = "",
    var score: Float = 0f,
    var userInfo: UserInfo = UserInfo(),
    val default: Int = 10012,
) : Serializable

data class UserInfo(
    var userName: String ="",
    var userAge: Int = 0,
    var userFriends: List<FriendsInfo> = mutableListOf()
) : Serializable

data class FriendsInfo(
    var phoneNumber: String = "",
    var userTag: String = "",
    var groupId: Int = 0
) : Serializable

05

Gson如何？

Gson是Google团队开发维护的用于Java中JSON解析的框架，其底层原理依旧使用了反射，具体的反射过程与解析这里就不再分析了；数据类亦能够正常解析为对象，但是当Json串中值出现null之后，他不会进行空安全类型检查，会直接赋值为null。

val json =
           "{\"id\":100,\"name\":null,\"score\":99.9,\"userInfo\":{\"userAge\":24,\"userFriends\":null,\"userName\":\"Tom\"}}"

val parseObject = gson.fromJson(json, ComplexEntity::class.java)
Log.d(TAG, parseObject.toString())
//ComplexEntity(id=100, name=null, score=99.9, userInfo=UserInfo(userName=Tom, userAge=24, userFriends=null))

这样在使用数据类对应的属性时容易导致异常造成程序崩溃。

另外一个就是不支持数据类的默认值，当我们数据类定义有具有默认值的属性，而Json串中没有时，此时我们解析之后会发现我们定义的值变成了该类型的默认值，在某些特殊情况下可能会导致异常。

data class ComplexEntity(
    val id: Int,
    val name: String,
    val score: Float,
    val userInfo: UserInfo,
    val default: Int = 1223//默认值为1223  解析后：default属性的值为：0
) : Serializable

06

Kotlinx-Serialization

Kotlinx-Serialization是Kotlin官方序列化库，相比于FastJson，Kotlin-Serializable未使用反射，并且许多生成代码相关的功能添加到了编译器中，GitHub地址： kotlinx-serialization官网 ，它由两个主要部分组成:

• Gradle插件org.jetbrains.kotlin.plugin.serialization

• 运行时库

Kotlinx-Serialization由Kotlin语言编写，并且利用了Kotlin编译器能够生成代码的特性从而为可序列化的类生成序列化反序列化相关的代码，从而不需要向其它框架一样使用反射，另外一个特点就是它的体积很小，并且对数据类进行了很好的支持，并且API也和其它JSON解析框架一样丰富，能够满足我们所需。

1、kotlin-serialization的环境配置

导入依赖：

implementation "org.jetbrains.kotlinx:kotlinx-serialization-json:1.5.1"

开启编译器插件：我的测试项目Gradle版本是7.1.2，不同的版本配置略有差异，但目的都是配置插件。

模块的build.gradle：

plugins {
    id 'com.android.application'
    id 'org.jetbrains.kotlin.android'
    id 'org.jetbrains.kotlin.plugin.serialization' version '1.8.21'
}

工程的settings.gradle：

pluginManagement {
    repositories {
        gradlePluginPortal()
        google()
        mavenCentral()
        maven ()
    }

    plugins {
        id 'com.android.application' version '7.1.2'
        id 'com.android.library' version '7.1.2'
        id 'org.jetbrains.kotlin.android' version '1.8.21'
        id 'org.jetbrains.kotlin.plugin.serialization' version '1.8.21'
    }
}

这样插件就配置好了，接下来sync以下就可以使用kotlin官方的序列化了。

2、kotlin-serialization的基础介绍

在使用kotlin-serialization时，需要给数据类加上注解@Serializable，以此来标识这是一个可以被序列化的Kotlin类，从而编译器会生成对应的代码。

@kotlinx.serialization.Serializable
data class ComplexEntity(
    val id: Int,
    val name: String,
    val score: Float,
    val userInfo: UserInfo,
    val default: Int = 1223
)

@kotlinx.serialization.Serializable
data class UserInfo(
    val userName: String,
    val userAge: Int,
    val userFriends: List<FriendsInfo>
)

@kotlinx.serialization.Serializable
data class FriendsInfo(
    val phoneNumber: String,
    val userTag: String,
    val groupId: Int
)

通过字节码反编译后，我们看到编译器生成了一个内部类，它实现了GeneratedSerializer，这个接口是给编译器插件使用的，该内部类主要就是为Kotlin序列化提供相关的方法，将对象序列化为Json或者将Json字符串反序列化为对象都要通过该类的方法去实现。

序列化与反序列化示例：

private fun testFastJsonKtBean() {
    val complexEntity = ComplexEntity(100, "null", 99.90f, UserInfo("Tom", 24, mutableListOf<FriendsInfo>().apply {
        add(FriendsInfo("12311111111", "lover", 1))
        add(FriendsInfo("12322222222", "normal", 2))
        add(FriendsInfo("12333333333", "normal", 2))
    }))
    val jsonString = Json.encodeToString(complexEntity)
    Log.d(TAG, jsonString)

    val json = "{\"id\":100,\"name\":\"Android Developer\",\"score\":99.9,\"userInfo\":{\"userName\":\"Tom\",\"userAge\":24,\"userFriends\":[{\"phoneNumber\":\"12311111111\",\"userTag\":\"lover\",\"groupId\":1},{\"phoneNumber\":\"12322222222\",\"userTag\":\"normal\",\"groupId\":2},{\"phoneNumber\":\"12333333333\",\"userTag\":\"normal\",\"groupId\":2}]}}"
    val parseObject = Json.decodeFromString<ComplexEntity>(json)
    Log.d(TAG, parseObject.toString())
}

kotlin-serialization完全符合Kotlin属性的空安全性，解析的过程中对默认值也没有任何的影响，但是JSON字符串中常常会含有null或者空对象{}来表示某个属性为空，因此我们需要将可能出现为空的属性设置上默认值或者声明为可空类型来保证正常解析。

3、kotlin-serialization常用API

• 序列化与反序列化：

//序列化JSON
Json.encodeToString(value:T):String
//JSON反序列化
Json.decodeFromString(string: String):T

• 将JSON字符串转化为JsonElement，对应其它框架的JsonObject：

//该方法返回一个JsonElemnt
parseToJsonElement(json:String)
//判断jsonElement中是否含有key
jsonElement?.jsonObject?.containsKey(key:String)
//获取jsonElement
jsonElement?.jsonObject?.get(key)

//获取key对应的各种类型的值
jsonElement?.jsonObject?.get(key)?.jsonPrimitive?.boolean

jsonElement?.jsonObject?.get(key)?.jsonPrimitive?.int

jsonElement?.jsonObject?.get(key)?.jsonPrimitive?.long

jsonElement?.jsonObject?.get(key)?.jsonPrimitive?.float

jsonElement?.jsonObject?.get(key)?.jsonPrimitive?.double

jsonElement?.jsonObject?.get(key)?.jsonArray

• 构造JsonObject：

val element = buildJsonObject {
    put("name", "kotlinx.serialization")
    putJsonObject("owner") {
        put("name", "kotlin")
    }
    putJsonArray("forks") {
        addJsonObject {
            put("votes", 42)
        }
        addJsonObject {
            put("votes", 9000)
        }
    }
}

• 指定序列化和反序列化相关的Json配置：

//指定配置
val json = Json {
    //忽略Json字符串中冗余的键值对，否则会发生异常
    ignoreUnknownKeys = true
    //Json串中为null但是属性为no-null类型,或者枚举值不存在
    coerceInputValues = true
}

4、如何封装以适应现有业务

首先，为什么要对第三方框架进行封装呢？做过第三方框架升级的朋友应该很清楚，当我们在项目当中直接使用大量的第三方提供的库时，特别是某些框架对外提供的接口比较多的情况下，每个人在使用的时候写法不同，所使用的方法也不同，因此升级后，需要对每一处调用的地方进行Review，防止兼容性问题导致功能异常。因此最好的解决方式就是根据自己的业务对三方框架进行二次封装，这样在升级框架的时候，如果某些Api变化较大，我们只需要对自己封装的框架进行简单的改动就行。所以我们要针对于数据类解析对kotlin-serialization进行封装。

我们需要明白在客户端场景下对Json的解析最常用的Api是哪些，主要分为两大类，序列化和反序列化，前者用的相对没有反序列化频繁，但也是必须的，我们先来看反序列化。反序列化需要将JSON解析为对象，当然也有解析字段在进行手动构造的对象的情况。因此我们定义了一些适合业务的接口，其中的第一个接口是通过类型将JSON字符串解析为对象，同时要保证每个方法的健壮性以及可维护性。

/**
 * 配置解析为对象的时候忽略Json字符串中冗余的键值对
 */
val json = Json {
    ignoreUnknownKeys = true
    coerceInputValues = true
}

/**
 * 调用举例，EntityName为返回的类型
 * 当JSON字符串中的值为 null 时,可以使用两种方式选其一可解决异常：
 * ① 声明对应的属性为可控类型，赋值为null
 * ② 给对应字段赋值默认值
 * ```
 * val entity:EntityName = KJson.parseObject<EntityName>(jsonStr)
 * ```
 * @param jsonStr 需要解析的Json字符串
 * @return 返回解析后对应的对象，对象类需要使用注解 @Serializable
 */
inline fun <reified T> parseObject(jsonStr: String?): T? {
    jsonStr?.let {
        return try {
            json.decodeFromString<T>(jsonStr)
        } catch (e: Exception) {
            null
        }
    }
    return null
}

在FastJson或者Gson中有JsonObject类，在kotlin-serialization中前面介绍到对应的是JsonElement类，因此我们也需要提供对应的方法，这两个方法会把对象或者JSON字符串解析为JsonElement对象。

/**
 * 将对象转换成JsonElement?，发生异常时返回null
 * @param obj 有 @Serializable 注解标注的Kotlin类
 * @return JsonElement?
 */
inline fun <reified T> parseJsonElement(obj: T): JsonElement? {
    return try {
        Json.encodeToJsonElement(obj)
    } catch (e: Exception) {
        null
    }
}

/**
 * 将Json字符串解析为JsonElement,类似与其它框架的JsonObject
 * @param jsonStr Json字符串
 * @return JsonElement?
 */
fun parseJsonElement(jsonStr: String?): JsonElement? {
    jsonStr?.let {
        return try {
            Json.parseToJsonElement(jsonStr)
        } catch (e: Exception) {
            null
        }
    }
    return null
}

在现有业务中，我们使用FastJson在解析数据之前，会对基本的数据进行校验才会进行接下来的解析，类似于下面的代码，我们封装的API接口也需要提供这些基本的方法。

fun containsKey(jsonElement: JsonElement, key: String): Boolean {
    return jsonElement.jsonObject.containsKey(key)
}

当我们尝试封装一个判断JsonElement是否含有某个key时，需要调用JsonElement类的containsKey()方法，这样设计对业务调用者不利，需要传两个参数。仔细分析，内部用于判断的实际方法JsonElement中的jsonObject的判断方法，因此直接使用扩展函数对JsonElement进行扩展，对应的方法如下：

/**
 * 判断JsonElement中是否含有某一个Key-value
 * @param key 需要查找的关键词
 * @return Boolean
 */
fun JsonElement.containsKey(key: String): Boolean {
    return jsonObject.containsKey(key)
}

/**
 *  从JsonElement中获取[key]对应String类型的值,未找到或异常返回默认值[defaultStr]
 * @param key 需要查找的关键词
 * @param defaultStr 默认值
 * @return String
 */
fun JsonElement.getString(key: String): String? {
    return try {
        if (containsKey(key))
            jsonObject[key]?.jsonPrimitive?.contentOrNull
        else null
    } catch (e: Exception) {
        null
    }
}

/**
 * 从JsonElement中获取[key]对应Int类型的值，默认值为[defaultVal]
 * @param key 需要查找的关键词
 * @param defaultVal 不存在或异常情况返回默认值
 * @return Int
 */
fun JsonElement.getInt(key: String, defaultVal: Int = 0): Int {
    return try {
        if (containsKey(key))
            jsonObject[key]?.jsonPrimitive?.int ?: defaultVal
        else defaultVal
    } catch (e: Exception) {
        defaultVal
    }
}

/**
 * 从JsonElement中获取[key]对应的JsonArray，发生异常时返回null
 * @param key 需要查找的关键词
 * @return JsonArray?
 */
fun JsonElement.getJsonArray(key: String): JsonArray? {
    return try {
        if (containsKey(key))
            jsonObject[key]?.jsonArray
        else null
    } catch (e: Exception) {
        null
    }
}

以上封装了获取String和Int类型以及JsonArray类型的API，其它基本数据类型的API类似，就不再赘述了。我们对反序列化的API进行了封装，接下来是对序列化的API进行一个封装：

/**
 * @param obj 需要转换的对象，对象类需要使用注解 @Serializable
 * @return 返回对象转换后的Json字符串
 */
fun toJsonString(obj: Any): String? {
    return try {
        Json.encodeToString(obj)
    } catch (e: Exception) {
        printLog("toJsonString", e)
        null
    }
}

到此，业务常用的API及已经封装完成了，这样大家在使用的时候直接调用封装的接口，如果要升级我们只需要检验框架中的API是否会有兼容性的问题即可，以便于业务的快速迭代。

参考 ：

• Aoe, J. I. (1989). An efficient implementation of static string pattern matching machines. IEEE Transactions on SoftwareEngineering, 15(8), 1010-1016.

• GitHub - Kotlin/kotlinx.serialization: Kotlin multiplatform / multi-format serialization

• https://github.com/Kotlin/kotlinx.serialization/blob/master/docs/serialization-guide.md