泛型在反射中怎么用

在 Java 反射（Reflection） 中，泛型的使用是一个“编译期有，运行期基本消失”的问题。下面我从 原理 → 常见用法 → 代码示例 → 注意事项 讲清楚。

一、先说结论（很重要）

Java 的泛型在运行时被擦除（Type Erasure）
所以：

• Class 本身 拿不到泛型参数
• 但 字段 / 方法参数 / 方法返回值 / 父类定义 可以保留泛型信息
• 这些信息通过 Type 体系 获取，而不是 Class

二、泛型擦除在反射中的体现

List<String> list = new ArrayList<>();

编译后等价于：

List list = new ArrayList();

所以在反射中：

Method m = obj.getClass().getMethod("getList");
Class<?> returnType = m.getReturnType(); // List，不是 List<String>

✅ 拿不到 <String>

三、反射中能获取泛型的地方（重点）

✅ 1. 获取 字段的泛型类型

class User {
    private List<String> roles;
}

Field field = User.class.getDeclaredField("roles");

Type type = field.getGenericType();

if (type instanceof ParameterizedType pType) {
    Type[] actualTypes = pType.getActualTypeArguments();
    for (Type t : actualTypes) {
        System.out.println(t); // class java.lang.String
    }
}

✅ 这是反射 + 泛型最常用场景

✅ 2. 获取 方法返回值的泛型

class Service {
    public Map<String, Integer> getData() {
        return null;
    }
}

Method method = Service.class.getMethod("getData");
Type returnType = method.getGenericReturnType();

if (returnType instanceof ParameterizedType pType) {
    Type[] types = pType.getActualTypeArguments();
    System.out.println(types[0]); // String
    System.out.println(types[1]); // Integer
}

✅ 3. 获取 方法参数的泛型

class Service {
    public void setData(Map<String, Integer> map) {}
}

Method method = Service.class.getMethod("setData", Map.class);
Type[] paramTypes = method.getGenericParameterTypes();

ParameterizedType pType = (ParameterizedType) paramTypes[0];
Type[] actualTypes = pType.getActualTypeArguments();

✅ 4. 获取 父类的泛型（非常常见）

class BaseDao<T> {}

class UserDao extends BaseDao<String> {}

Type superClass = UserDao.class.getGenericSuperclass();

if (superClass instanceof ParameterizedType pType) {
    Type[] types = pType.getActualTypeArguments();
    System.out.println(types[0]); // class java.lang.String
}

✅ 这是 ORM / 框架里最常用的技巧

四、反射中泛型相关的核心 API

五、一个完整示例（通用 DAO）

class BaseDao<T> {
    private Class<T> entityClass;

    public BaseDao() {
        Type superClass = getClass().getGenericSuperclass();
        ParameterizedType pType = (ParameterizedType) superClass;
        entityClass = (Class<T>) pType.getActualTypeArguments()[0];
    }

    public void save(T entity) {
        System.out.println("保存：" + entityClass.getName());
    }
}

class User {}

class UserDao extends BaseDao<User> {}

new UserDao().save(new User());

✅ 框架中 Hibernate / MyBatis / Spring 大量使用这种方式

六、常见误区（⚠️）

❌ 1. 直接通过 Class 获取泛型

Class<?> c = List.class; // ❌ 拿不到 <String>

❌ 2. 认为运行时还能区分 List<String> 和 List<Integer>

List<String> a = new ArrayList<>();
List<Integer> b = new ArrayList<>();

a.getClass() == b.getClass(); // true

七、一句话总结

反射不能直接获取泛型的“具体参数”，但可以通过字段、方法、父类定义中的 Type 信息间接获取。

如果你愿意，我可以：

• 用 Spring / MyBatis 的真实源码 给你讲
• 或结合 Kotlin / Android 场景讲
• 或讲 为什么 Java 要泛型擦除

你更想深入哪一块？