Generics kotlin，如何使用Gson解析泛型类型是一个用泛型类型定义的函数

如果类类型是泛型类型“T”，如何使用Gson进行分析

有一个泛型类型的类，在它的函数中将json字符串解析为运行时的泛型类型“T”。但是得到

java.lang.ClassCastException: com.google.gson.internal.LinkedTreeMap cannot be cast to com.example.model.content

这不适用于通用is“T”：

        val dataType = object : TypeToken<T>() {}.type
        val data = Gson().fromJson<T>(jsonStr, dataType)

这是一个采用泛型类型的类：

IHandler

，期望在运行时'T'应该是'solid'类型，即调用的类型应该是

内容

类型

class FetchRemoteDataCommand<T>(scheme: String, authority: String, path: String,
                         params: HashMap<String, String>,
                         dataReadyCb: IHandler<T>) {


val mBaseUrl = "$scheme://$authority/"
val mPath = path
val mParams = params
var mDataReadyListener = dataReadyCb

override fun dispose() {……}

override fun execute() {
    getRemoteData(object : Observer<ResponseBody> {
        override fun onNext(responseBody: ResponseBody) {

            val dataType = object : TypeToken<T>() {}.type
            val jsonStr = responseBody.string()
            val data = Gson().fromJson<T>(jsonStr, dataType)  ***//<=== throws***

            ///
            mDataReadyListener(data)  //<== suppose to pass back the pared data back
            ……
        }
        …………
    })
}

private fun getRemoteData(observer: Observer<ResponseBody>) : Unit {

    val service: IRemoteRepositoryService = ServiceFactory.createRetrofitService(
                          IRemoteRepositoryService::class.java, mBaseUrl)

    service.getRemoteData(mPath, mParams) 
           .subscribe(observer)

    }
 }

class FetchRemoteDataCommand（方案：字符串、权限：字符串、路径：字符串、，
params:HashMap，
dataReadyCb:IHandler）{
val mBaseUrl=“$scheme://$authority/”
val mPath=路径
val mParams=params
var mDataReadyListener=dataReadyCb
重写fun dispose（）{……}
重写fun execute（）{
getRemoteData（对象：Observer）{
覆盖fun onNext（响应库：响应库）{
val dataType=object:TypeToken（）{}.type
val jsonStr=responseBody.string（）
val data=Gson（）
因此，在运行时传递类类型而不是获取类型

class FetchRemoteDataCommand<T>(scheme: String, authority: String, path: String,
                     params: HashMap<String, String>,
                     dataReadyCb: IHandler<T>, handlerClassType: Class<T>) {


val mBaseUrl = "$scheme://$authority/"
val mPath = path
val mParams = params
var mDataReadyListener = dataReadyCb
private val clazz: Class<T> = handlerClassType //findTypeArguments(this.javaClass)  <== some time return null???

private fun findTypeArguments(t: Type) : Class<T> {
    return if (t is ParameterizedType) {
        val typeArgs = t.actualTypeArguments
        typeArgs[0] as Class<T>
    } else {
        val c = t as Class<*>
        findTypeArguments(c.genericSuperclass)
    }
}

fun getClassType(): Class<T> {
    return clazz
}


override fun execute() {
    getRemoteData(object : Observer<ResponseBody> {
        override fun onNext(responseBody: ResponseBody) {

            //val dataType = object : TypeToken<T>() {}.type
            //val jsonStr = responseBody.string()
            //val data = Gson().fromJson<T>(jsonStr, dataType)  ***//<=== throws***

/// test generic type with the passed in class type instead of reflecting at runtime
            val responseRecieved = responseBody.string()
            val data = Gson().fromJson(responseRecieved, getClassType())

            ///
            mDataReadyListener(data)  //<== suppose to pass back the pared data back
        ……
    }
    …………
    })
}

class FetchRemoteDataCommand（方案：字符串、权限：字符串、路径：字符串、，
params:HashMap，
dataReadyCb:IHandler，handlerClassType:Class）{
val mBaseUrl=“$scheme://$authority/”
val mPath=路径
val mParams=params
var mDataReadyListener=dataReadyCb
private val clazz:Class=handlerClassType//findTypeArguments（this.javaClass）
class FetchRemoteDataCommand<T>(scheme: String, authority: String, path: String,
                     params: HashMap<String, String>,
                     dataReadyCb: IHandler<T>, handlerClassType: Class<T>) {


val mBaseUrl = "$scheme://$authority/"
val mPath = path
val mParams = params
var mDataReadyListener = dataReadyCb
private val clazz: Class<T> = handlerClassType //findTypeArguments(this.javaClass)  <== some time return null???

private fun findTypeArguments(t: Type) : Class<T> {
    return if (t is ParameterizedType) {
        val typeArgs = t.actualTypeArguments
        typeArgs[0] as Class<T>
    } else {
        val c = t as Class<*>
        findTypeArguments(c.genericSuperclass)
    }
}

fun getClassType(): Class<T> {
    return clazz
}


override fun execute() {
    getRemoteData(object : Observer<ResponseBody> {
        override fun onNext(responseBody: ResponseBody) {

            //val dataType = object : TypeToken<T>() {}.type
            //val jsonStr = responseBody.string()
            //val data = Gson().fromJson<T>(jsonStr, dataType)  ***//<=== throws***

/// test generic type with the passed in class type instead of reflecting at runtime
            val responseRecieved = responseBody.string()
            val data = Gson().fromJson(responseRecieved, getClassType())

            ///
            mDataReadyListener(data)  //<== suppose to pass back the pared data back
        ……
    }
    …………
    })
}