Spring泛型组件构造函数中如何注入泛型Class类型？

问题背景 #

需要实现通用的Spring组件MyClass<C>，继承自SomeAbstractClass<A, C>，父类构造依赖A.class和C.class。由于C是泛型参数，直接写C.class会编译报错；改为构造函数注入Class<C>后，Spring无法自动解析并注入该参数。而通过创建具体泛型子类的方案，通用性和可维护性较差。

原始代码（编译报错）：

@Component
public class MyClass<C> extends SomeAbstractClass<A, C> {

    public MyClass(SomeClass1 someClass1, SomeClass2 someClass2) {
        super(superMethod(A.class, C.class));
    }
}

尝试后的代码（Spring无法注入Class<C>）：

@Component
public class MyClass<C> extends SomeAbstractClass<A, C> {

    public MyClass(SomeClass1 someClass1, SomeClass2 someClass2, Class<C> clazz) {
        super(superMethod(A.class, clazz));
    }
}

可行解决方案 #

方案1：利用ResolvableType解析泛型类型 #

通过Spring提供的ResolvableType工具类，在Bean初始化时解析当前类的父类泛型参数，获取C对应的Class对象。

@Component
public class MyClass<C> extends SomeAbstractClass<A, C> {

    public MyClass(SomeClass1 someClass1, SomeClass2 someClass2, ApplicationContext applicationContext) {
        super(superMethod(A.class, resolveGenericType(applicationContext)));
    }

    @SuppressWarnings("unchecked")
    private Class<C> resolveGenericType(ApplicationContext applicationContext) {
        // 解析当前类的父类泛型信息
        ResolvableType superType = ResolvableType.forClass(getClass(), applicationContext.getClassLoader())
                .getSuperType();
        // 获取第二个泛型参数（对应C的类型）
        return (Class<C>) superType.getGeneric(1).resolve();
    }
}

注意：该方案要求Bean的泛型类型在注册时是明确的（比如通过子类指定泛型，或@Bean方法明确泛型参数），Spring才能正确解析泛型信息。

方案2：通过@Bean方法显式注册泛型Bean #

在配置类中为每个需要的泛型类型编写@Bean方法，直接传入对应的Class对象，避免Spring自动注入的问题。

@Configuration
public class MyBeanConfig {

    @Bean
    public MyClass<B> myClassB(SomeClass1 someClass1, SomeClass2 someClass2) {
        return new MyClass<>(someClass1, someClass2, B.class);
    }

    @Bean
    public MyClass<D> myClassD(SomeClass1 someClass1, SomeClass2 someClass2) {
        return new MyClass<>(someClass1, someClass2, D.class);
    }
}

相比创建具体子类，该方案无需重复编写类代码，仅需配置Bean即可，可维护性更强。

方案3：自定义FactoryBean创建泛型Bean #

实现Spring的FactoryBean接口，封装泛型Bean的创建逻辑，在工厂中传入指定的泛型Class对象。

public class MyClassFactoryBean<C> implements FactoryBean<MyClass<C>> {

    private final Class<C> genericType;
    private SomeClass1 someClass1;
    private SomeClass2 someClass2;

    public MyClassFactoryBean(Class<C> genericType) {
        this.genericType = genericType;
    }

    @Autowired
    public void setDependencies(SomeClass1 someClass1, SomeClass2 someClass2) {
        this.someClass1 = someClass1;
        this.someClass2 = someClass2;
    }

    @Override
    public MyClass<C> getObject() {
        return new MyClass<>(someClass1, someClass2, genericType);
    }

    @Override
    public Class<?> getObjectType() {
        return MyClass.class;
    }
}

在配置类中注册工厂Bean：

@Configuration
public class MyBeanConfig {

    @Bean
    public MyClassFactoryBean<B> myClassBFactory() {
        return new MyClassFactoryBean<>(B.class);
    }

    @Bean
    public MyClassFactoryBean<D> myClassDFactory() {
        return new MyClassFactoryBean<>(D.class);
    }
}

该方案将Bean创建逻辑集中到工厂类，配置更清晰，适合需要复用创建逻辑的场景。

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