Get bean from ApplicationContext by qualifier - spring

Question

Given this code:
public interface Service {}
#Component
#Qualifier("NotWanted")
public class NotWantedService implements Service {}
#Component
#Qualifier("Wanted")
public class WantedService implements Service {}
AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
ctx.register(NotWantedService.class);
ctx.register(WantedService.class);
ctx.refresh()
How do I now do:
ctx.getBean(Service.class)
in a way that will only get the one with #Qualifier("Wanted") and not the one with #Qualifier("NotWanted")? I'm specifically asking if it's possible to do it using getBean, not injecting to a class, then using that one as a kind of proxy.

Answer 1

You can use
BeanFactoryAnnotationUtils.qualifiedBeanOfType(ctx.getBeanFactory(), Service.class, "Wanted")
It's important to use ctx.getBeanFactory(), not ctx itself, because the 'qualifiedBeanOfType' method can resolve qualifiers only for ConfigurableListenableBeanFactory.

Answer 2

It's not the #Qualifier annotation's purpose to use it when getting beans via ApplicationContext. But since you need such or similar functionality for some reasons, I suggest a workaround.
Create #Wanted and #NotWanted annotation:
#Target({ElementType.CONSTRUCTOR, ElementType.FIELD,
ElementType.METHOD, ElementType.TYPE})
#Retention(RetentionPolicy.RUNTIME)
public #interface Wanted {
}
and
#Target({ElementType.CONSTRUCTOR, ElementType.FIELD,
ElementType.METHOD, ElementType.TYPE})
#Retention(RetentionPolicy.RUNTIME)
public #interface NotWanted {
}
Annotate your bean classes with these new annotations:
#Component
#NotWanted
public class NotWantedService implements Service {}
and
#Component
#Wanted
public class WantedService implements Service {}
Then you should add 2 methods somewhere where you have access to the ApplicationContext :
ApplicationContext applicationContext;
private <T> Collection<T> getBeansByTypeAndAnnotation(Class<T> clazz, Class<? extends Annotation> annotationType){
Map<String, T> typedBeans = applicationContext.getBeansOfType(clazz);
Map<String, Object> annotatedBeans = applicationContext.getBeansWithAnnotation(annotationType);
typedBeans.keySet().retainAll(annotatedBeans.keySet());
return typedBeans.values();
}
private <T> Optional<T> getBeanByTypeAndAnnotation(Class<T> clazz, Class<? extends Annotation> annotationType) {
Collection<T> beans = getBeansByTypeAndAnnotation(clazz, annotationType);
return beans.stream().findFirst();
}
And now you can use them to get beans or one bean by annotation and type like this:
Collection<Service> services = getBeansByTypeAndAnnotation(Service.class, Wanted.class);
or
Service service = getBeanByTypeAndAnnotation(Service.class, Wanted.class);
Possibly it's not the best way to deal with the problem. But since we are unable to get beans from ApplicationContext by qualifier and type 'out of box', that's one of the ways to do this.

Answer 3

If you want to get bean from context not injecting, better way to define bean name in #Component annotation and get it by name from context. In most cases #Qualifier is used for injections.

Answer 4

In my case, I have two qualified bean of one class, e.g
#Configuration
public class AConfig {
#Bean(name = "a")
public Hello hello1() {
return new Hello();
}
#Bean(name = "b")
public Hello hello2() {
return new Hello();
}
}
Then I can get a specific bean by
ApplicationContext context = SpringApplication.run(AutoConfiguration.class);
var aHello = context.getBean("a", Hello.class);
var bHello = context.getBean("b", Hello.class);
This is the simplest way of doing this. Or you can do the same thing as below:
var aHello = context.getBeansOfType(Hello.class).getBean("a");
var bHello = context.getBeansOfType(Hello.class).getBean("b");
Or you can also do as #Dmitry Ovchinnikov says:
BeanFactoryAnnotationUtils.qualifiedBeanOfType(ctx.getBeanFactory(), Service.class, "Wanted")
In this case, ctx.getBeanFactory() can be replaced by context.getAutowireCapableBeanFactory().

Answer 5

The closest canonical way to do this in Spring is with the utility class BeanFactoryAnnotationUtils ... but this sadly only works with #Qualifier annotation value argument directly (hence why the argument is a string).
What #Rozart is recommending is the best approach and really something like that should be in BeanFactoryAnnotationUtils. I only included the above answer in the case someone lands here and does want to use #Qualifier directly (and all the bean aliasing that comes along with it).
I recommend filing a feature request in Spring (I would but I think they might be tired of me bugging them :-) ).