Java中如何声明并传递带嵌套子类型的泛型Class类型参数

核心结论 #

Java中不存在Class<Foo<Bar>>类型的合法实例，你无法为这个变量赋一个类型安全、无编译警告的有效值。

根本原因 #

Java泛型是编译期实现的语法糖，运行时遵循泛型擦除规则：

• 所有Foo<T>形式的参数化类型，运行时对应的Class对象只有一个，即Foo.class，它的编译时类型固定为Class<Foo>，和泛型参数T没有任何关系
• Java语法规定类字面量Xxx.class仅支持原生类型、非泛型类型、无界通配符泛型（比如List<?>.class是合法的，List<String>.class不合法），这也是你无法使用类似C#的Foo<Bar>.class写法的原因

你可以通过强制类型转换写(Class<Foo<Bar>>) (Class<?>) Foo.class绕过编译检查，但会产生unchecked警告，这种写法本质只是骗过编译器，运行时不会保留任何Bar相关的泛型信息，和直接使用Foo.class没有区别。

正确实现方案 #

不要尝试构造不存在的Class<Foo<Bar>>实例，Java反射API提供了Type体系来承载完整的泛型类型信息，你可以通过**超类令牌（Super Type Token）**模式获取嵌套泛型的完整类型，适配你的DAO场景：

1. 首先定义超类令牌用于捕获完整泛型类型，同时准备基础实体代码

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Objects;

interface Entity {}
class Foo<T extends Entity> extends Entity {}
class Bar extends Entity {}
class Session {
    @SuppressWarnings("unchecked")
    public <T> T get(Class<T> rawType, int id) {
        Objects.requireNonNull(rawType);
        // 模拟数据库查询逻辑
        return null;
    }
}

// 超类令牌实现，用于捕获完整泛型类型
abstract class TypeReference<T> {
    private final Type type;

    protected TypeReference() {
        Type superClass = getClass().getGenericSuperclass();
        if (superClass instanceof Class<?>) {
            throw new IllegalArgumentException("TypeReference必须指定泛型参数");
        }
        this.type = ((ParameterizedType) superClass).getActualTypeArguments()[0];
    }

    public Type getType() {
        return type;
    }
}

2. 改造DAO类，通过TypeReference传入完整类型信息

class EntityDAO<T extends Entity> {
    private final Type entityType;
    private final Session session;

    public EntityDAO(TypeReference<T> typeRef, Session session) {
        this.entityType = typeRef.getType();
        this.session = session;
    }

    @SuppressWarnings("unchecked")
    public T get(int id) {
        // 从完整泛型类型中提取原生Class，供ORM查询使用
        Class<T> rawClass = (Class<T>) (entityType instanceof ParameterizedType pt 
                ? pt.getRawType() 
                : entityType);
        T entity = session.get(rawClass, id);
        
        // 如果业务逻辑需要用到泛型参数（比如这里的Bar类型），可以直接从entityType解析获取
        // 示例：
        // ParameterizedType pt = (ParameterizedType) entityType;
        // Type genericArg = pt.getActualTypeArguments()[0]; 拿到的就是Bar的类型
        return entity;
    }
}

3. 业务代码中使用时，就可以完整保留嵌套泛型信息

public class TestApp {
    public static void main(String[] args) {
        Session session = new Session();
        // 构造TypeReference实例，完整保留Foo<Bar>的泛型信息
        TypeReference<Foo<Bar>> fooBarType = new TypeReference<Foo<Bar>>() {};
        EntityDAO<Foo<Bar>> fooBarDAO = new EntityDAO<>(fooBarType, session);
        Foo<Bar> entity = fooBarDAO.get(1);
    }
}

如果你的ORM框架本身只支持Class作为查询入参，直接传入提取到的原生Foo.class即可，运行时框架本身也只能识别原生类信息，泛型参数的逻辑处理你可以自己通过解析Type对象实现，不需要强行构造不存在的带泛型参数的Class实例。

内容的提问来源于stack exchange，提问作者djmj