How can I find all beans with the custom annotation @Foo?

Question

I have this spring configuration:

@Lazy
@Configuration
public class MyAppConfig {
    @Foo @Bean
    public IFooService service1() { return new SpecialFooServiceImpl(); }
}

How can I get a list of all beans that are annotated with @Foo?

Note: @Foo is a custom annotation defined by me. It's not one of the "official" Spring annotations.

[EDIT] Following the suggestions of Avinash T., I wrote this test case:

import static org.junit.Assert.*;
import java.lang.annotation.ElementType;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import java.lang.annotation.Retention;
import java.lang.reflect.Method;
import java.util.Map;
import org.junit.Test;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Lazy;

public class CustomAnnotationsTest {

    @Test
    public void testFindByAnnotation() throws Exception {

        AnnotationConfigApplicationContext appContext = new AnnotationConfigApplicationContext( CustomAnnotationsSpringCfg.class );

        Method m = CustomAnnotationsSpringCfg.class.getMethod( "a" );
        assertNotNull( m );
        assertNotNull( m.getAnnotation( Foo.class ) );

        BeanDefinition bdf = appContext.getBeanFactory().getBeanDefinition( "a" );
        // Is there a way to list all annotations of bdf?

        Map<String, Object> beans = appContext.getBeansWithAnnotation( Foo.class );
        assertEquals( "[a]", beans.keySet().toString() );
    }


    @Retention( RetentionPolicy.RUNTIME )
    @Target( ElementType.METHOD )
    public static @interface Foo {

    }

    public static class Named {
        private final String name;

        public Named( String name ) {
            this.name = name;
        }

        @Override
        public String toString() {
            return name;
        }
    }

    @Lazy
    @Configuration
    public static class CustomAnnotationsSpringCfg {

        @Foo @Bean public Named a() { return new Named( "a" ); }
             @Bean public Named b() { return new Named( "b" ); }
    }
}

but it fails with org.junit.ComparisonFailure: expected:<[[a]]> but was:<[[]]>. Why?

score 55 · Answer 1 · edited May 23 '17 at 12:09

55

Use getBeansWithAnnotation() method to get beans with annotation.

Map<String,Object> beans = applicationContext.getBeansWithAnnotation(Foo.class);

Here is similar discussion.

edited May 23 '17 at 12:09

Community

1
1

answered Jan 09 '13 at 13:43

Avinash T.

2,280
2
16
23

Thanks, I completely missed that. I wrote a test case but the test fails (see my edited question). Any idea why? – Aaron Digulla Jan 09 '13 at 13:47
That's because `getBeansWithAnnotation()` returns an empty map -> it doesn't find any beans. Why is that? – Aaron Digulla Jan 09 '13 at 13:58
@AaronDigulla : I am not sure but can you create any object other than `String` and check? I think in Spring we can not have String as a bean. – Nandkumar Tekale Jan 09 '13 at 14:04
@AaronDigulla : I am talking about `@Foo @Bean public String a() { return "a"; }` – Nandkumar Tekale Jan 09 '13 at 14:05
*: I updated my test case. It checks that the annotation is on the method and I'm using a non-String bean type. But it still fails :-( – Aaron Digulla Jan 09 '13 at 14:13
@AaronDigulla OK. Can you get your bean by bean name ? like, provide name to bean `@Foo @Bean("myNameIsA") public Named a() { return new Named( "a" ); }` so if we are getting it this way, we can go to next step to solve this issue. :) – Nandkumar Tekale Jan 09 '13 at 14:27
I can't use names. I want to group my beans by using several annotations (so a bean can be in several groups or none). – Aaron Digulla Jan 09 '13 at 14:31
I meant, if you could get bean by name, then you could get it by annotation too. So I suggested you to test it. – Nandkumar Tekale Jan 09 '13 at 14:41
2

The bean just does not have the annotation, only the bean factory method has - but you are not querying for methods. – Hauke Ingmar Schmidt Jan 09 '13 at 23:39
1

Why is this answer upvoted so much? It completely misses the point! – kaqqao Feb 05 '18 at 17:11

kaqqao · Answer 2 · 2021-03-29T20:54:12.360

38

UPDATE: Spring 5.2 changed the behavior of context.getBeansWithAnnotation(...) and it now correctly handles beans created via factory methods. So simply use that.

Original answer

While the accepted answer and Grzegorz's answer contain approaches that will work in all cases, I found a much much simpler one that worked equally well for the most common cases.

Meta-annotate @Foo with @Qualifier:

@Target({ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.TYPE, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Qualifier
public @interface Foo {
}

Sprinkle @Foo onto the factory methods, as described in the question:

@Foo
@Bean
public IFooService service1() {
    return new SpecialFooServiceImpl();
}

But it will also work on the type level:

@Foo
@Component
public class EvenMoreSpecialFooServiceImpl { ... }

Then, inject all the instances qualified by @Foo, regardless of their type and creation method:
```
@Autowired
@Foo
List<Object> fooBeans; 
```

fooBeans will then contain all the instances produced by a @Foo-annotated method (as required in the question), or created from a discovered @Foo annotated class.

The list can additionally be filtered by type if needed:

@Autowired
@Foo
List<SpecialFooServiceImpl> fooBeans;

The good part is that it will not interfere with any other @Qualifier (meta)annotations on the methods, nor @Component and others on the type level. Nor does it enforce any particular name or type on the target beans.

edited Mar 29 '21 at 20:54

answered Feb 05 '18 at 23:15

kaqqao

12,984
10
64
118

1

Great answer, thanks for sharing. If you could briefly explain in which situations this is not enough and why? – User1291 May 20 '19 at 07:53
@User1291 You might not be able to add `@Qualifier` to `@Foo` because it's coming for a 3rd party, for example. My answer depends on your ability to modify the beans and annotations, and not only on inspecting the container from the outside. – kaqqao May 20 '19 at 08:01
1

Hm ... it looks like this doesn't work when I give the annotation properties (e.g. `@Foo(weight = 100)` won't get recognised as a `@Foo`-qualified anymore. Any ideas? – User1291 May 20 '19 at 09:19
1

@User1291 I think that's because Spring checks for the annotation equality between the injection point and the candidates, and `@Foo` and `@Foo(weight = 100)` are not equal. I think for your case you'd have to inspect the container as described in the other answers. – kaqqao May 20 '19 at 09:50
Yup, you're right, if I specifically search for `@Foo(weight = 100)` on the collection, it autowires them again. Shame, I had hoped I could somehow turn off the property-checks and get them all regardless of their weights. Thanks, though. – User1291 May 20 '19 at 10:21

Aaron Digulla · Accepted Answer · 2018-05-17T08:10:19.157

With the help of a couple of Spring experts, I found a solution: The source property of a BeanDefinition can be AnnotatedTypeMetadata. This interface has a method getAnnotationAttributes() which I can use to get the annotations of a bean method:

public List<String> getBeansWithAnnotation( Class<? extends Annotation> type, Predicate<Map<String, Object>> attributeFilter ) {

    List<String> result = Lists.newArrayList();

    ConfigurableListableBeanFactory factory = applicationContext.getBeanFactory();
    for( String name : factory.getBeanDefinitionNames() ) {
        BeanDefinition bd = factory.getBeanDefinition( name );

        if( bd.getSource() instanceof AnnotatedTypeMetadata ) {
            AnnotatedTypeMetadata metadata = (AnnotatedTypeMetadata) bd.getSource();

            Map<String, Object> attributes = metadata.getAnnotationAttributes( type.getName() );
            if( null == attributes ) {
                continue;
            }

            if( attributeFilter.apply( attributes ) ) {
                result.add( name );
            }
        }
    }
    return result;
}

gist with full code of helper class and test case

score 13 · Answer 4 · edited Jan 10 '13 at 09:55

Short story

It is not enough to put @Foo on the a() method in order to make the a bean annotated with @Foo.

Long story

I didn't realize it before I started debugging Spring code, a breakpoint at org.springframework.beans.factory.support.DefaultListableBeanFactory.findAnnotationOnBean(String, Class<A>) helped me understand it.

Of course, if you moved your annotation to the Named class:

  @Foo
  public static class Named {
  ...

and fixed some minor details of your test (annotation target, etc.) the test works.

After giving it a second thought, it's quite natural. When getBeansWithAnnotation() is called, the only information Spring has are the beans. And beans are objects, objects have classes. And Spring doesn't seem to need to store any additional information, incl. what was the factory method used to create the bean annotated with, etc.

EDIT There is an issue which requests to preserve annotations for @Bean methods: https://jira.springsource.org/browse/SPR-5611

It has been closed as "Won't fix" with the following workaround:

Employ a BeanPostProcessor
Use the beanName provided to the BPP methods to look up the associated BeanDefinition from the enclosing BeanFactory
Query that BeanDefinition for its factoryBeanName (the @Configuration bean) and factoryMethodName (the @Bean name)
use reflection to get hold of the Method the bean originated from
use reflection to interrogate any custom annotations from that method

Thanks. It's a pity that I can't use annotations to create groups of beans in my Spring config without changing the types but I can probably find a way around it. — Aaron Digulla, Jan 10 '13 at 08:32

score 2 · Answer 5 · answered Mar 18 '22 at 16:45

To get all annotated beans:

context.getBeansWithAnnotation(Foo.class)

This returns a Map<String, Object> where the key is the bean name.

To get the annotation class:

context.findAnnotationOnBean(beanName, Foo.class);

This can be helpful when the annotation has values (@Foo(weight=100)).

user3913029 · Answer 6 · 2021-08-05T11:33:27.197

0

This is how to get annotated beans.

@Autowired
private ApplicationContext ctx;

public void processAnnotation() {
    // Getting annotated beans with names
    Map<String, Object> allBeansWithNames = ctx.getBeansWithAnnotation(TestDetails.class);
    //If you want the annotated data
    allBeansWithNames.forEach((beanName, bean) -> {
        TestDetails testDetails = (TestDetails) ctx.findAnnotationOnBean(beanName, TestDetails.class);
        LOGGER.info("testDetails: {}", testDetails);
    });
}

edited Aug 05 '21 at 11:33

answered May 03 '19 at 07:45

user3913029

11
2

2

Sorry, this doesn't work for the reasons outlined in the answer by Grzegorz Oledzki. – Aaron Digulla May 07 '19 at 13:31

score 0 · Answer 7 · answered Mar 07 '22 at 09:48

In my case getBeansWithAnnotation was returning an empty list. My mistake was to not adding retention and target on my custom annotation.

Adding these lines no top of my annotation fixed it.

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)

How can I find all beans with the custom annotation @Foo?

7 Answers7

Short story

Long story

Linked

Related