如何获取泛型类中类型参数T的Class对象？

首先得明确：你遇到的核心障碍是Java的类型擦除机制——编译后泛型参数<T>的实际类型信息会被擦除，所以直接通过getClass().getGenericSuperclass()获取ParameterizedType只在一种场景下有效：当前类是泛型类的具体子类（比如class RequestContext extends Context<Request>），而你直接new Context<Request>()创建的实例，其运行时类型是原始的Context类，getGenericSuperclass()返回的是Object，自然无法转成ParameterizedType。

下面给你两种符合JDK标准机制的解决方案：

方案1：利用匿名内部类保留泛型信息（无需手动传Class） #

我们可以通过匿名内部类让JVM保留泛型参数的运行时信息，再结合静态工厂方法简化调用：

public class Context<T> {
    private final Class<T> clazz;
    private final String resource;
    private final com.thirdparty.Context context;

    // 受保护构造方法，仅供子类/匿名子类调用
    protected Context(String resource) {
        Type genericSuperclass = getClass().getGenericSuperclass();
        // 校验是否为参数化类型
        if (!(genericSuperclass instanceof ParameterizedType)) {
            throw new IllegalArgumentException("请使用匿名内部类或静态工厂方法创建实例，例如：Context.create(\"request.xsd\")");
        }
        ParameterizedType parameterizedType = (ParameterizedType) genericSuperclass;
        Type actualType = parameterizedType.getActualTypeArguments()[0];
        // 确保泛型参数是具体类（不支持通配符或嵌套泛型）
        if (!(actualType instanceof Class)) {
            throw new IllegalArgumentException("泛型参数必须是具体类，不能是通配符或参数化类型（如List<String>）");
        }
        this.clazz = (Class<T>) actualType;
        this.resource = resource;
        this.context = com.thirdparty.Context.newInstance(this.clazz);
    }

    // 静态工厂方法，封装匿名内部类的创建逻辑
    public static <T> Context<T> create(String resource) {
        return new Context<T>(resource) {};
    }

    public String marshall(final T element) {
        return this.context.marshall(element);
    }

    public T unmarshall(final String element) {
        return this.clazz.cast(this.context.unmarshall(element));
    }
}

使用示例 #

// 推荐：用静态工厂方法，无需手动写匿名内部类
Context<Request> context = Context.create("request.xsd");

// 也可以直接创建匿名内部类
// Context<Request> context = new Context<Request>("request.xsd") {};

// 序列化
Request request = new Request();
String xml = context.marshall(request);

// 反序列化，自动类型转换
Request roundTrip = context.unmarshall(xml);

方案2：保留Class参数，用类型推断简化调用（更稳妥） #

如果不想依赖匿名内部类，最可靠的方式还是保留Class参数，但利用Java的类型推断让调用更简洁：

public class Context<T> {
    private final Class<T> clazz;
    private final String resource;
    private final com.thirdparty.Context context;

    public Context(String resource, Class<T> clazz) {
        this.clazz = clazz;
        this.resource = resource;
        this.context = com.thirdparty.Context.newInstance(this.clazz);
    }

    // 静态工厂方法进一步简化调用
    public static <T> Context<T> of(String resource, Class<T> clazz) {
        return new Context<>(resource, clazz);
    }

    public String marshall(final T element) {
        return this.context.marshall(element);
    }

    public T unmarshall(final String element) {
        return this.clazz.cast(this.context.unmarshall(element));
    }
}

使用示例 #

// 方式1：直接构造，类型推断自动识别T为Request
Context<Request> context = new Context<>("request.xsd", Request.class);

// 方式2：用静态工厂方法
Context<Request> context = Context.of("request.xsd", Request.class);

关键说明 #

• 方案1的核心原理：匿名内部类的字节码会保留父类的泛型参数信息，所以getGenericSuperclass()能拿到ParameterizedType，从而提取出Class<T>。但这种方式不支持嵌套泛型（如Context<List<String>>），因为此时actualType是ParameterizedType而非Class。
• 方案2虽然需要传Class<T>，但兼容性更好，支持所有泛型场景，而且类型推断让调用几乎和你期望的一样简洁。

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