在Kotlin中绕过泛型类型擦除的实战指南

Kotlin的泛型类型擦除是JVM的固有特性，导致运行时无法直接获取泛型参数的具体类型（例如无法区分List<String>和List<Int>）。但在实际开发中，我们常需要保留泛型类型信息。本文将详解四种绕过类型擦除的实用方法，并提供完整的代码示例。

---

1. reified + 内联函数：编译时类型固化

原理

通过inline函数将代码嵌入调用处，结合reified关键字将泛型类型参数"固化"为具体类型。

完整示例

import com.google.gson.Gson

inline fun <reified T> parseJson(json: String): T {
    // 直接访问 T 的类对象
    return Gson().fromJson(json, T::class.java)
}

// 调用示例
data class User(val name: String, val age: Int)

fun main() {
    val json = """{"name":"Alice", "age":30}"""
    val user: User = parseJson(json) // 自动推导为 User 类型
    println(user) // User(name=Alice, age=30)
}

场景扩展：解析嵌套泛型

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

// 调用
val jsonList = """[{"name":"Bob"}, {"name":"Charlie"}]"""
val users: List<User> = parseJsonList(jsonList) // 正确解析 List<User>

优点

• 简洁直观，无反射开销
• 编译时类型安全

限制

• 仅适用于内联函数
• 无法处理无限定符类型（如T本身是泛型）

---

2. TypeToken 模式：反射提取泛型参数

原理

通过创建匿名子类继承泛型基类，利用反射从java.lang.reflect.Type中提取泛型信息。

完整示例

import java.lang.reflect.ParameterizedType
import com.google.gson.Gson

abstract class TypeToken<T> {
    val type: Type
        get() = (javaClass.genericSuperclass as ParameterizedType).actualTypeArguments[0]
}

// 使用示例
fun <T> parseJsonDynamic(json: String, typeToken: TypeToken<T>): T {
    return Gson().fromJson(json, typeToken.type)
}

fun main() {
    val json = """[{"name":"Bob"}, {"name":"Charlie"}]"""
    val typeToken = object : TypeToken<List<User>>() {} // 明确指定泛型类型
    val users = parseJsonDynamic(json, typeToken)
    println(users) // [User(name=Bob), User(name=Charlie)]
}

场景扩展：动态构建复杂泛型

// 解析 Map<String, List<User>> 类型
val complexTypeToken = object : TypeToken<Map<String, List<User>>>() {}
val complexJson = """{"data": [{"name":"Bob"}]}"""
val map: Map<String, List<User>> = parseJsonDynamic(complexJson, complexTypeToken)

优点

• 支持任意复杂泛型结构
• 兼容性高（广泛用于Gson等库）

限制

• 反射调用存在性能损耗
• 需要手动传递TypeToken实例

---

3. Kotlin反射：typeOf获取完整类型信息

原理

使用Kotlin标准库的typeOf()函数，直接获取包含泛型参数的KType。

完整示例（Kotlin 1.6+）

import kotlin.reflect.typeOf

inline fun <reified T> logTypeInfo() {
    val kType = typeOf<T>()
    println("Type: $kType")
    println("Classifier: ${kType.classifier}") // 例如 List::class
    println("Arguments: ${kType.arguments}")   // 例如 [String::class]
}

// 调用示例
fun main() {
    logTypeInfo<Map<String, List<User>>>()
    // 输出：
    // Type: kotlin.collections.Map<kotlin.String, kotlin.collections.List<User>>
    // Classifier: class kotlin.collections.Map
    // Arguments: [KTypeProjection(variance=INVARIANT, type??: kotlin.String), ...]
}

场景扩展：结合Gson解析

inline fun <reified T> parseWithKotlinReflection(json: String): T {
    val type = typeOf<T>()
    return Gson().fromJson(json, type.javaType)
}

// 调用
val users = parseWithKotlinReflection<List<User>>(jsonList)

优点

• 支持Kotlin特有类型（如不可空类型）
• 类型信息更精确

限制

• 需要Kotlin 1.6+
• 部分场景需处理KType到Java Type的转换

---

4. 显式传递类型参数

原理

手动传递Class或Type对象，绕过类型擦除。

完整示例

fun <T> parseJsonManual(json: String, type: Type): T {
    return Gson().fromJson(json, type)
}

// 调用示例
fun main() {
    val json = """{"name":"Alice"}"""
    val userType = User::class.java
    val user = parseJsonManual<User>(json, userType) // 传递 User 的 Class 对象
}

场景扩展：Retrofit中的类型传递

interface ApiService {
    @GET("users")
    fun getUsers(): Call<List<User>> // Retrofit 通过返回类型自动解析泛型
}

优点

• 无魔法，直接可控
• 兼容所有Java/Kotlin版本

限制

• 代码冗余
• 无法处理嵌套泛型

---

方法对比与选型建议

方法	适用场景	性能	代码简洁性	泛型复杂度支持
reified + 内联函数	简单类型、高频调用	⭐⭐⭐	⭐⭐⭐	⭐⭐
TypeToken反射	动态类型、复杂泛型（如Gson解析）	⭐⭐	⭐⭐	⭐⭐⭐
Kotlin反射 (typeOf)	需要Kotlin类型元数据	⭐⭐	⭐⭐⭐	⭐⭐⭐
显式传递类型	兼容性要求高、简单场景	⭐⭐⭐	⭐	⭐

选型指南：

1. 优先reified ：适用于大多数简单场景，如解析List<User>或Map<String, Int>。
2. 复杂泛型用TypeToken ：处理多层嵌套类型（如Response<Page<List<User>>>）。
3. 精确元数据用typeOf ：需要区分String与String?等Kotlin特性时。
4. 显式传递兜底：兼容旧代码或无法使用内联/反射的场景。

---

总结

Kotlin通过reified、TypeToken模式和反射API，提供了灵活的方式绕过JVM泛型类型擦除。根据场景选择：

• 简单类型 → reified
• 动态复杂泛型 → TypeToken
• Kotlin类型精确控制 → typeOf
• 极致性能/兼容性 → 显式传递Type

合理利用这些方法，可以在保证类型安全的同时，实现高度灵活的泛型操作。