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

FastJson要升级新版本吗

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方法。

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

首先，测试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

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

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

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

导入依赖：

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官方的序列化了。

在使用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或者空对象{}来表示某个属性为空，因此我们需要将可能出现为空的属性设置上默认值或者声明为可空类型来保证正常解析。

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

//该方法返回一个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

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

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

首先，为什么要对第三方框架进行封装呢？做过第三方框架升级的朋友应该很清楚，当我们在项目当中直接使用大量的第三方提供的库时，特别是某些框架对外提供的接口比较多的情况下，每个人在使用的时候写法不同，所使用的方法也不同，因此升级后，需要对每一处调用的地方进行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是否会有兼容性的问题即可，以便于业务的快速迭代。