Finding All Beans with a Custom Annotation – 用自定义注释找到所有Bean

最后修改: 2022年 5月 4日

中文/混合/英文(键盘快捷键：t)

1. Overview

1.概述

In this tutorial, we’ll explain how to find all beans annotated with a custom annotation in Spring. We’ll show different methods depending on the Spring version we use.

在本教程中，我们将解释如何在Spring中找到所有带有自定义注解的Bean。我们将根据我们使用的Spring版本展示不同的方法。

2. With Spring Boot 2.2 or Later

2.使用Spring Boot 2.2或更高版本

Since Spring Boot 2.2, we can use the getBeansWithAnnotation method.

从Spring Boot 2.2开始，我们可以使用getBeansWithAnnotationmethod。

Let’s build an example. First, we’ll define our custom annotation. Let’s annotate it with @Retention(RetentionPolicy.RUNTIME) to make sure the annotation can be accessed by the program during runtime:

让我们建立一个例子。首先，我们将定义我们的自定义注解。让我们用@Retention(RetentionPolicy.RUNTIME)来注释它，以确保程序在运行时可以访问该注释。

@Retention( RetentionPolicy.RUNTIME )
public @interface MyCustomAnnotation {

}

Now, let’s define a first bean annotated with our annotation. We’ll also annotate it with @Component:

现在，让我们定义一个带有我们注解的第一个Bean。我们还将用@Component来注解它。

@Component
@MyCustomAnnotation
public class MyComponent {

}

Then, let’s define another bean annotated with our annotation. However, this time we’ll create it thanks to a @Bean annotated method in a @Configuration file:

然后，让我们定义另一个带有我们注解的Bean。然而，这一次我们将通过@Configuration文件中的@Bean注解方法来创建它。

public class MyService {

}

@Configuration
public class MyConfigurationBean {

    @Bean
    @MyCustomAnnotation
    MyService myService() {
        return new MyService();
    }
}

Now, let’s write a test to check that the getBeansWithAnnotation method can detect both of our beans:

现在，让我们写一个测试，检查getBeansWithAnnotation方法是否能检测到我们的两个Bean。

@Test
void whenApplicationContextStarted_ThenShouldDetectAllAnnotatedBeans() {
    try (AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext( MyComponent.class, MyConfigurationBean.class )) {
        Map<String,Object> beans = applicationContext.getBeansWithAnnotation(MyCustomAnnotation.class);
        assertEquals(2, beans.size());
        assertTrue(beans.keySet().containsAll(List.of("myComponent", "myService")));
    }
}

3. With an Older Spring Version

3.使用较旧的Spring版本

3.1. Historical Context

3.1.历史背景

In Spring Framework versions prior to 5.2, the getBeansWithAnnotation method would only detect beans annotated at the class or interface level but was not able to detect the beans annotated at the factory method level.

在5.2之前的Spring Framework版本中，getBeansWithAnnotation方法只能检测到在类或接口级别注释的Bean，但无法检测在工厂方法级别注释的Bean。

Spring Framework dependency has been upgraded to 5.2 in Spring Boot 2.2, so that’s why with older versions of Spring, the test we have just written would fail:

在Spring Boot 2.2中，Spring框架的依赖性已经升级到了5.2，所以这就是为什么在旧版本的Spring中，我们刚才写的测试会失败。

  • the MyComponent bean is correctly detected because the annotation is at the class level
  • the MyService bean is not detected because it’s created through a factory method

Let’s see how we can get around this behavior.

让我们看看如何绕过这一行为。

3.2. Decorate Our Custom Annotation with @Qualifier

3.2.用@Qualifier装饰我们的自定义注解

There’s a rather straightforward workaround: We can simply decorate our annotation with @Qualifier.

有一个相当直接的解决方法。我们可以简单地用@Qualifier来装饰我们的注释。

Our annotation will then look like:

然后，我们的注释将看起来像。

@Retention( RetentionPolicy.RUNTIME )
@Qualifier
public @interface MyCustomAnnotation {

}

Now, we’re able to auto-wire both annotated beans. Let’s check that out with a test:

现在，我们能够自动连接这两个注解的bean了。让我们通过一个测试来检验一下。

@Autowired
@MyCustomAnnotation
private List<Object> annotatedBeans;

@Test
void whenAutowiring_ThenShouldDetectAllAnnotatedBeans() {
    assertEquals(2, annotatedBeans.size());
    List<String> classNames = annotatedBeans.stream()
        .map(Object::getClass)
        .map(Class::getName)
        .map(s -> s.substring(s.lastIndexOf(".") + 1))
        .collect(Collectors.toList());
    assertTrue(classNames.containsAll(List.of("MyComponent", "MyService")));
}

This workaround is the simplest, however, it might not fit our needs, for instance, if we don’t own the annotation.

这种解决方法是最简单的，但是，它可能不适合我们的需要，例如，如果我们不拥有注释。

Let’s also note that decorating our custom annotation with @Qualifier will turn it into a Spring qualifier.

我们还要注意，用@Qualifier来装饰我们的自定义注解将使它变成一个Spring限定符。

3.3. Listing the Beans Created via a Factory Method

3.3.列出通过工厂方法创建的Bean

Now that we’ve understood that the problem mainly arises with beans created via factory methods, let’s focus on how to list only those. We’ll present a solution that functions in all cases without implying any change to our custom annotation. We’ll use reflection to access the beans’ annotations.

既然我们已经了解到问题主要出现在通过工厂方法创建的Bean上，那么我们就来关注如何只列出这些Bean。我们将提出一个在所有情况下都有效的解决方案，而不需要对我们的自定义注解做任何改变。我们将使用反射来访问Bean的注解。

Given that we have access to the Spring ApplicationContext, we’ll follow a series of steps:

鉴于我们可以访问Spring ApplicationContext，我们将遵循一系列的步骤。

  • Access the BeanFactory
  • Look up the BeanDefinition associated with each bean
  • Check if the source of the BeanDefinition is an AnnotatedTypeMetadata, which means we’ll be able to access the annotations of the bean
  • If the bean has annotations, check if the desired annotation is among them

Let’s create our own BeanUtils utility class and implement this logic inside a method:

让我们创建我们自己的BeanUtils实用类，并在一个方法中实现这个逻辑。

public class BeanUtils {

    public static List<String> getBeansWithAnnotation(GenericApplicationContext applicationContext, Class<?> annotationClass) {
        List<String> result = new ArrayList<String>();
        ConfigurableListableBeanFactory factory = applicationContext.getBeanFactory();
        for(String name : factory.getBeanDefinitionNames()) {
            BeanDefinition bd = factory.getBeanDefinition(name);
            if(bd.getSource() instanceof AnnotatedTypeMetadata) {
                AnnotatedTypeMetadata metadata = (AnnotatedTypeMetadata) bd.getSource();
                if (metadata.getAnnotationAttributes(annotationClass.getName()) != null) {
                    result.add(name);
                }
            }
        }
        return result;
    }
}

Alternatively, we could also write the same function using Streams:

另外，我们也可以用Streams来写同样的函数。

public static List<String> getBeansWithAnnotation(GenericApplicationContext applicationContext, Class<?> annotationClass) {
    ConfigurableListableBeanFactory factory = applicationContext.getBeanFactory();
    return Arrays.stream(factory.getBeanDefinitionNames())
        .filter(name -> isAnnotated(factory, name, annotationClass))
        .collect(Collectors.toList());
}

private static boolean isAnnotated(ConfigurableListableBeanFactory factory, String beanName, Class<?> annotationClass) {
    BeanDefinition beanDefinition = factory.getBeanDefinition(beanName);
    if(beanDefinition.getSource() instanceof AnnotatedTypeMetadata) {
        AnnotatedTypeMetadata metadata = (AnnotatedTypeMetadata) beanDefinition.getSource();
        return metadata.getAnnotationAttributes(annotationClass.getName()) != null;
    }
    return false;
}

In these methods, we’ve used a GenericApplicationContext, which is an implementation of Spring ApplicationContext that doesn’t assume a specific bean definition format.

在这些方法中，我们使用了GenericApplicationContext，它是Spring ApplicationContext的一个实现，它不假定特定的bean定义格式。

To have access to the GenericApplicationContext, we can, for instance, inject it into a Spring component:

为了访问GenericApplicationContext，我们可以，例如，将其注入Spring组件中。

@Component
public class AnnotatedBeansComponent {

    @Autowired
    GenericApplicationContext applicationContext;
    
    public List<String> getBeansWithAnnotation(Class<?> annotationClass) {
        return BeanUtils.getBeansWithAnnotation(applicationContext, annotationClass);
    }
}

4. Conclusion

4.总结

In this article, we’ve discussed how to list the beans annotated with a given annotation. We’ve seen that since Spring Boot 2.2, this is done naturally by the getBeansWithAnnotation method.

在这篇文章中，我们讨论了如何列出带有给定注解的Bean。我们看到，从Spring Boot 2.2开始，这一点可以通过getBeansWithAnnotation方法自然完成。

On the other hand, we’ve shown some alternative methods to overcome the limits of the previous behavior of this method: either by only adding @Qualifier on top of our annotation or by looking up the beans, using reflection to check whether they have the annotation or not.

另一方面，我们已经展示了一些替代方法来克服这个方法先前行为的局限性：要么只在我们的注释上面添加@Qualifier，要么通过查找bean，使用反射来检查它们是否有这个注释。

As always, the complete code is available over on GitHub.

一如既往，完整的代码可在GitHub上获得，。