java - 如何在 Spring 中通过带有类参数的泛型类型创建单例？

Question

假设我有一个通用类型的包装器:

@Component
@Scope(value = ConfigurableBeanFactory.SCOPE_SINGLETON)
public class Wrapper<T> {
    private final Class<T> wrappedClass;
    
    public Wrapper(Class<T> wrappedClass) {
       this.wrappedClass = wrappedClass;
    }
}

我想用这个 Wrapper有很多类(例如> 100)。是否可以让 Spring 为每个泛型类型创建单独的包装器并将泛型类作为参数传递给构造函数？例如，Spring 必须始终注入(inject)相同的 Wrapper<Foo> 实例。 .如果可能，请给出java代码配置的例子，但不要用xml。

Answer 1

如果我理解正确的话，您想根据一些 bean(如 Foo/Bar)遵守而另一些不遵守的一些标准动态添加包装器 bean。

这是 spring 中的一种高级东西，但简而言之，您将必须实现一个 Bean Factory 后处理器，它将在启动期间由 spring 自动调用。

在这一点上，您可以通过遍历所有“可访问”bean(如 Foo/Bar 等)来分析 bean，对于应该包装的 bean，您将创建包装器的 bean 定义，尽管事实上包装器本身不是一个 bean。

我创建了一个简单示例来说明这一点。在我的示例项目中，我将所有内容都放在“wrappers”包下:

@Wrappable
public class Foo {
}
@Wrappable
public class Bar {
}

public class ShouldNotBeWrapped {
}

请注意，我已经放置了一个注释 @Wrappable - 一个自定义注释，它将作为应包装和不包装内容的“区分器”。注释的处理将在 Bean Factory 后处理器中完成。

注解其实没什么特别的，它应该在运行时是可以访问的(spring是一个运行时框架，放在类上):

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Wrappable {
}

Java 配置将添加 Foo、Bar、ShouldNotBeWrapped 作为 beans 以及我将在下面描述的 Bean Factory 后处理器:

@Configuration
public class WrappersJavaConfig {
    @Bean
    public Foo foo () {
        return new Foo();
    }

    @Bean
    public Bar bar () {
        return new Bar();
    }

    @Bean
    public ShouldNotBeWrapped shouldNotBeWrapped () {
        return new ShouldNotBeWrapped();
    }

    @Bean
    public WrappersEnrichmentBFPP wrappersEnrichmentBFPP () {
        return new WrappersEnrichmentBFPP();
    }
}

为了示例，Wrapper 类本身具有 toString，但它与问题中提供的包装器没有太大区别:

public class Wrapper<T> {
    private T wrapped;

    public Wrapper(T wrapped) {
        this.wrapped = wrapped;
    }

    @Override
    public String toString() {
        return "Wrapper for" + wrapped;
    }
}

Main 类将列出所有已加载的 bean 并获取它们的类 + 调用 toString 以便我们可以看到包装器已正确定义:

public class Main {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(WrappersJavaConfig.class);

        String[] names = ctx.getBeanDefinitionNames();
        for(String name : names) {
            Object bean = ctx.getBean(name);
            if(bean.getClass().getPackage().getName().startsWith("wrappers")) { 
                System.out.println(ctx.getBean(name).getClass() + " ==> " + ctx.getBean(name));
            }
        }
    }
}

旁注，main 方法中的“if”条件是因为我不想打印 spring 自己加载的 bean(infra 东西等)——只有我的 bean，它们都位于包“wrappers”中，因为我上面已经提到了。

现在 BeanFactoryPostProcessor - 在某种意义上是一个常规 bean，它在 java 配置中注册并且看起来像这样(您的实现可能不同，但想法是相同的):

public class WrappersEnrichmentBFPP implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        String[] bddNames = beanFactory.getBeanDefinitionNames();
        for(String bddName : bddNames) {
            Object bean = beanFactory.getBean(bddName);
            if(bean.getClass().isAnnotationPresent(Wrappable.class)) {
                BeanDefinition wrappedBdd = BeanDefinitionBuilder.genericBeanDefinition(Wrapper.class)
                        .addConstructorArgReference(bddName)
                        .getBeanDefinition();
                ((BeanDefinitionRegistry)beanFactory).registerBeanDefinition("wrapperFor" + bddName, wrappedBdd);
            }
        }
    }
}

所以我在 for-each 循环中一个一个地获取所有的 bean，然后我在 if 条件 中询问 bean 是否有一个注释“wrappable”。如果有 - 它必须被包裹起来。在这种情况下，我为 Wrapper 创建了一个“人工”bean 定义，并添加了一个将引用我的应该被包装的 bean 的构造函数。然后我通过将 bean 定义添加到应用程序上下文来注册它。

运行上面的代码，你会看到类似于我的输出:

class wrappers.WrappersJavaConfig$$EnhancerBySpringCGLIB$$f88f147d ==> wrappers.WrappersJavaConfig$$EnhancerBySpringCGLIB$$f88f147d@1283bb96
class wrappers.Foo ==> wrappers.Foo@74f0ea28
class wrappers.Bar ==> wrappers.Bar@f6efaab
class wrappers.ShouldNotBeWrapped ==> wrappers.ShouldNotBeWrapped@3c19aaa5
class wrappers.WrappersEnrichmentBFPP ==> wrappers.WrappersEnrichmentBFPP@3349e9bb
class wrappers.Wrapper ==> Wrapper forwrappers.Foo@74f0ea28
class wrappers.Wrapper ==> Wrapper forwrappers.Bar@f6efaab

如您所见，最后两行对应于为 Foo 和 Bar 的相同实例创建的包装器 bean，但没有为 创建任何内容ShouldNotBeWrapped bean

所使用的 API 有点晦涩，看起来已经过时，但它又是相当先进的东西，并且在 spring 容器基础设施本身的级别上工作。话虽如此，关于BeanFactoryPostProcessor-s的教程还是很多的。

由于使用 BFPP 不是一项常见任务，尽管我提供了解决方案，但我没有看到它的任何实际用法，因此不能使用包装器“代替”Foo或 Bar 类，没有它们的 API 等。也许您可以解释为什么需要对某些 ​​bean 进行包装。通常人们使用 Aspects/BeanPostProcessors(不是 BFPP 而是 BPP)将类包装到动态代理(cglib/java.lang.Proxy)中并添加额外的行为，比如 @Transactional、缓存处理等是在 spring 中使用 BeanPostProcessors 实现的，因此也请考虑检查这个方向。