Suppose we will work with small interface:<\/p>\n When we have only one bean implementing then everything works great and test passes.<\/p>\n But what will happen, if we add another implementation of Now out test with fail with exception:<\/p>\n We have to decide which implementation we want to use in our test, so …<\/p>\n Each bean is registered with name equal its class. For example Now our test passes again.<\/p>\n If field is names like implementing class (for example And test passes:<\/p>\n Thanks to We often have one implementation which we almost always want to inject, so do we still have to put We could mark one implementation as Autowired<\/code> is great annotation, which by default inject beans by type to annotated element (constructor, setter or field). But how to use it, when there is more than one bean of requested type.<\/p>\nAutowired<\/code> with one bean<\/h2>\ninterface IHeaderPrinter {
String printHeader(String header)
}<\/pre>\nIHeaderPrinter<\/code>:<\/p>\n@Component
class HtmlHeaderPrinter implements IHeaderPrinter{
@Override
String printHeader(String header) {
return \"<h1>$header<\/h1>\"
}
}<\/pre>\n@Autowired
IHeaderPrinter headerPrinter
@Test
void shouldPrintHtmlHeader() {
assert headerPrinter.printHeader('myTitle') == '<h1>myTitle<\/h1>'
}<\/pre>\nTwo implementations<\/h2>\n
IHeaderPrinter<\/code>, e. g. MarkdownHeaderPrinter<\/code>?<\/p>\n@Component
class MarkdownHeaderPrinter implements IHeaderPrinter {
@Override
String printHeader(String header) {
return \"# $header\"
}
}<\/pre>\nError creating bean with name 'com.blogspot.przybyszd.spring.autowire.SpringAutowireWithQualifiersApplicationTests': Injection of autowired dependencies failed; nested exception is org.springframework.beans.factory.BeanCreationException: Could not autowire field: private com.blogspot.przybyszd.spring.autowire.IHeaderPrinter com.blogspot.przybyszd.spring.autowire.SpringAutowireWithQualifiersApplicationTests.headerPrinter; nested exception is org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type [com.blogspot.przybyszd.spring.autowire.IHeaderPrinter] is defined: expected single matching bean but found 2: markdownHeaderPrinter,htmlHeaderPrinter<\/pre>\n
Two implementations with
Qualifier<\/code><\/h2>\nHtmlHeaderPrinter<\/code> is named htmlHeaderPrinter<\/code>. The name is also its qualifier. We have to tell Autowired<\/code>, that it should inject htmlHeaderPrinter<\/code>:<\/p>\n@Autowired
@Qualifier('htmlHeaderPrinter')
IHeaderPrinter headerPrinter<\/pre>\nTwo implementations qualified by field name<\/h2>\n
htmlHeaderPrinter<\/code>), then this class implementation will be injected:<\/p>\n@Autowired
IHeaderPrinter htmlHeaderPrinter<\/pre>\n@Test
void shouldPrintHtmlHeader() {
assert htmlHeaderPrinter.printHeader('myTitle') == '<h1>myTitle<\/h1>'
}<\/pre>\n@marcinjasion<\/code>.<\/p>\nTwo implementation with
Primary<\/code><\/h2>\nQualifier<\/code> with its name wherever we want to use it? No.<\/p>\nPrimary<\/code> and this bean will be wired by default (unless we explicit give another Qualifier<\/code> to use injection point):<\/p>\n@Component
@Primary
class HtmlHeaderPrinter implements IHeaderPrinter{
\/\/ ...
}<\/pre>\n@Autowired
IHeaderPrinter headerPrinter<\/pre>\nSummary<\/h2>\n
Autowired<\/code> annotation allows us to inject dependencies to beans. It works great without additional configuration, when each bean could be uniquely find by type. When we have more than one bean, that could be injected, we have to use Qualifier<\/code> or Primary<\/code> annotation to help it find desired implementation.<\/p>\n