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类型元数据 | ⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐ |
| 显式传递类型 | 兼容性要求高、简单场景 | ⭐⭐⭐ | ⭐ | ⭐ |
选型指南：
- 优先
reified：适用于大多数简单场景，如解析List<User>或Map<String, Int>。 - 复杂泛型用TypeToken：处理多层嵌套类型（如
Response<Page<List<User>>>）。 - 精确元数据用
typeOf：需要区分String与String?等Kotlin特性时。 - 显式传递兜底：兼容旧代码或无法使用内联/反射的场景。
总结
Kotlin通过reified、TypeToken模式和反射API，提供了灵活的方式绕过JVM泛型类型擦除。根据场景选择：
- 简单类型 →
reified - 动态复杂泛型 → TypeToken
- Kotlin类型精确控制 →
typeOf - 极致性能/兼容性 → 显式传递
Type
合理利用这些方法，可以在保证类型安全的同时，实现高度灵活的泛型操作。
