Kotlin：具体化类型参数使Gson失败

Question

我遇到了一个奇怪的行为，在类型为“具体化”的函数中使用Gson进行反序列化。仅当类型参数中涉及接口时才会发生这种情况。

采用以下代码：

val toBeSerialized = listOf("1337")
with(Gson()) {
    val ser = toJson(toBeSerialized)
    val deser = fromJson<List<Serializable>>(ser)
}

第4行使用自定义扩展函数Gson。fromJson（json:String）：T。

如果定义为具体化，则失败：

inline fun <reified T> Gson.fromJson(json: String): T = fromJson<T>(json, object : TypeToken<T>() {}.type)

如果它被定义为普通类型参数，它就可以工作：

fun <T> Gson.fromJson(json: String): T = fromJson<T>(json, object : TypeToken<T>() {}.type)

（注意，使T具体化在这里没有意义，只是想了解它在特殊用例中的影响）

使用具体化时的异常如下所示：

Exception in thread "main" java.lang.RuntimeException: Unable to invoke no-args constructor for ? extends java.io.Serializable. Registering an InstanceCreator with Gson for this type may fix this problem.
    at com.google.gson.internal.ConstructorConstructor$14.construct(ConstructorConstructor.java:226)
    at com.google.gson.internal.bind.ReflectiveTypeAdapterFactory$Adapter.read(ReflectiveTypeAdapterFactory.java:210)
    at com.google.gson.internal.bind.TypeAdapterRuntimeTypeWrapper.read(TypeAdapterRuntimeTypeWrapper.java:41)
    at com.google.gson.internal.bind.CollectionTypeAdapterFactory$Adapter.read(CollectionTypeAdapterFactory.java:82)
    at com.google.gson.internal.bind.CollectionTypeAdapterFactory$Adapter.read(CollectionTypeAdapterFactory.java:61)
    at com.google.gson.Gson.fromJson(Gson.java:888)
    at com.google.gson.Gson.fromJson(Gson.java:853)
    at com.google.gson.Gson.fromJson(Gson.java:802)
    at SoTestsKt.main(SoTests.kt:25)
Caused by: java.lang.UnsupportedOperationException: Interface can't be instantiated! Interface name: java.io.Serializable
    at com.google.gson.internal.UnsafeAllocator.assertInstantiable(UnsafeAllocator.java:117)
    at com.google.gson.internal.UnsafeAllocator$1.newInstance(UnsafeAllocator.java:49)
    at com.google.gson.internal.ConstructorConstructor$14.construct(ConstructorConstructor.java:223)
    ... 8 more

Answer 1

正如@jornvernee所提到的，序列化/反序列化json需要具体化。如果未添加具体化的，它将被视为列表

要序列化/反序列化接口，需要注册一个自定义适配器来添加所实现类的类型信息。这里是一个适配器类，我从该站点引用它并对其进行一些更改。

class InterfaceAdapter<T : Serializable> : JsonSerializer<T>, JsonDeserializer<T> {

    companion object {
        private val CLASSNAME = "CLASSNAME"
        private val DATA = "DATA"
    }

    @Throws(JsonParseException::class)
    override fun deserialize(jsonElement: JsonElement, type: Type, jsonDeserializationContext: JsonDeserializationContext): T {
        val jsonObject = jsonElement.asJsonObject
        val prim = jsonObject.get(CLASSNAME) as JsonPrimitive
        val className = prim.asString
        val klass = getObjectClass(className)
        return jsonDeserializationContext.deserialize(jsonObject.get(DATA), klass)
    }

    override fun serialize(jsonElement: T, type: Type, jsonSerializationContext: JsonSerializationContext): JsonElement {
        val jsonObject = JsonObject()
        jsonObject.addProperty(CLASSNAME, jsonElement.javaClass.name)
        jsonObject.add(DATA, jsonSerializationContext.serialize(jsonElement))
        return jsonObject
    }

    private fun getObjectClass(className: String): Class<*> {
        try {
            return Class.forName(className)
        } catch (e: ClassNotFoundException) {
            throw JsonParseException(e.message)
        }
    }
}

将适配器注册到gson对象并提供类型信息。

inline fun <reified T> Any.toJson(): String {
    val builder = GsonBuilder()
    builder.registerTypeAdapter(Serializable::class.java, InterfaceAdapter<Serializable>())
    val gson = builder.create()
    return gson.toJson(this, object : TypeToken<T>() {}.type)
}

inline fun <reified T> fromJson(json: String): T {
    val builder = GsonBuilder()
    builder.registerTypeAdapter(Serializable::class.java, InterfaceAdapter<Serializable>())
    val gson = builder.create()
    return gson.fromJson<T>(json, object : TypeToken<T>() {}.type)
}

示例代码：

data class User(val name: String) : Serializable

val data = listOf(User("Sam"))
val ser = data.toJson<List<Serializable>>()
val deser = fromJson<List<Serializable>>(ser)

println(ser)
println(deser.get(0)::class)
println(deser.get(0))

/* Output
    [{"CLASSNAME":"User","DATA":{"name":"Sam"}}]
    class User
    User(name=Sam)
*/

Answer 2

使用具体化T的版本失败，因为它试图将“1337”反序列化为可序列化的，这是一个接口，因此无法实例化，默认情况下，没有类型适配器可以反序列化为可序列化的

在非具体化版本中，没有实际的类型信息传递给扩展函数。您可以通过打印从令牌获取的类型来验证这一点：

fun <T> Gson.fromJson(json: String): T {
    val tt = object : TypeToken<T>() {}.type;
    println(tt);
    return fromJson(json, tt);
}

在无具体化版本中，它只打印T（即没有可用的实际类型信息），但在具体化版本中，它将打印实际类型（任何静态编程语言声明站点差异修饰符，因此列表

非具体化版本之所以有效，是因为巧合。因为Gson反序列化的默认类型是ArrayList

如果您稍微修改示例，例如通过指定不同类型的列表来执行不同的强制转换，则会遇到问题：

val deser = fromJson<LinkedList<Serializable>>(ser)

抛出java。lang.ClassCastException：java。util。ArrayList无法转换为java。util。LinkedList

您需要具体化T才能传递类型信息，但这也意味着失败将更早发生，并且不会因为类型擦除而被忽视，就像在非具体化版本中一样。