In a @Configuration class, the methods annotated with @Bean may depend on other beans to initialize themselves. Other beans should be annotated with @Bean as well to be registered with the Spring container.
Spring provides a mechanism where we can pass such bean dependencies with @Bean method parameters. They are injected by the framework just like a arbitrary method's dependencies are resolved
There are following scenarios:
Injecting by type: If there's only one bean instance available to be injected to the injection target point then it will be injected successfully by type.
Injecting by name: If there are more than one instance of the same type available for a target injection point then there's a conflict (ambiguity). Spring doesn't know which particular instance to be injected in that case. If the name of parameter is same as bean's definition method (the method annotated with @Bean) name then the dependency is resolved by name. The bean's definition method can provide a different name than the method name by using @Bean(name = ...), the injection point method's parameter name should match in that case as well.
-
Injecting by bean's name with matching @Qualifier: If there's an ambiguity then it can also be resolved if the injection point method parameter add a @Qualifier annotation with matching target bean's name.
-
Injecting by matching @Qualifiers Ambiguity can also be resolve by using @Qualifier on the both sides. This is important when a bean provider method has already indented to be exposed as a @Qualifier per business logic sense, so that a particular bean's implementation can be changed without updating all injection points.
Examples
Bean classes
package com.logicbig.example;
public class BeanA {
private String name;
public BeanA(String name){
this.name = name;
}
@Override
public String toString() {
return "BeanA{" +
"name='" + name + '\'' +
'}';
}
}
package com.logicbig.example;
public class BeanB {
private BeanA beanA;
BeanB (BeanA beanA) {
this.beanA = beanA;
}
public BeanA getBeanA () {
return beanA;
}
@Override
public String toString() {
return "BeanB{" +
"beanA=" + beanA +
'}';
}
}
package com.logicbig.example;
public class BeanC {
private String name;
public BeanC(String name){
this.name = name;
}
@Override
public String toString() {
return "BeanC{" +
"name='" + name + '\'' +
'}';
}
}
Injecting by type
package com.logicbig.example;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
public class InjectParameterByType {
public static void main (String[] args) {
AnnotationConfigApplicationContext context =
new AnnotationConfigApplicationContext(
Config.class);
BeanB beanB = context.getBean(BeanB.class);
System.out.println("In the main method: " + beanB.getBeanA());
}
@Configuration
public static class Config {
@Bean
public BeanA bean1 () {
return new BeanA("a1");
}
@Bean
public BeanB bean2 (BeanA theBean) {
BeanB beanB = new BeanB(theBean);
System.out.println("method bean2: beanB created = " + beanB +
"\n with constructor param BeanA = " + theBean);
return beanB;
}
}
}Outputmethod bean2: beanB created = BeanB{beanA=BeanA{name='a1'}}
with constructor param BeanA = BeanA{name='a1'}
In the main method: BeanA{name='a1'}
Injecting by default bean names
package com.logicbig.example;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
public class InjectParameterByName {
public static void main (String[] args) {
AnnotationConfigApplicationContext context =
new AnnotationConfigApplicationContext(
Config.class);
BeanB beanB = context.getBean(BeanB.class);
System.out.println("In the main method: " + beanB.getBeanA());
}
@Configuration
public static class Config {
@Bean
public BeanA bean1 () {
return new BeanA("a1");
}
@Bean
public BeanA bean2 () {
return new BeanA("a2");
}
@Bean
public BeanB bean3 (BeanA bean1) {
BeanB beanB = new BeanB(bean1);
System.out.println("method bean3: beanB created = " + beanB +
"\n with constructor param BeanA: " + bean1);
return beanB;
}
}
}Outputmethod bean3: beanB created = BeanB{beanA=BeanA{name='a1'}}
with constructor param BeanA: BeanA{name='a1'}
In the main method: BeanA{name='a1'}
Post Spring 6.1.0 we need to use --parameters during compilation. That's because spring internal class LocalVariableTableParameterNameDiscoverer has been removed in 6.1. Java 8+ -parameter flag is used for parameter name retention.
<compilerArgs>
<arg>-parameters</arg>
</compilerArgs>
Injecting by using @Qualifier at both places
package com.logicbig.example;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
public class InjectParameterByQualifier {
public static void main (String[] args) {
AnnotationConfigApplicationContext context =
new AnnotationConfigApplicationContext(
Config.class);
BeanB beanB = context.getBean(BeanB.class);
System.out.println("In the main method: " + beanB.getBeanA());
}
@Configuration
public static class Config {
@Bean
public BeanA bean1 () {
return new BeanA("a1");
}
@Qualifier("myBean")
@Bean
public BeanA bean2 () {
return new BeanA("a2");
}
@Bean
public BeanB bean3 (@Qualifier("myBean") BeanA theBean) {
BeanB beanB = new BeanB(theBean);
System.out.println("method bean3: beanB created = " + beanB +
"\n with constructor param BeanA = " + theBean);
return beanB;
}
}
}Outputmethod bean3: beanB created = BeanB{beanA=BeanA{name='a2'}}
with constructor param BeanA = BeanA{name='a2'}
In the main method: BeanA{name='a2'}
Injecting by using @Qualifier at injection point only
package com.logicbig.example;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
public class InjectParameterByQualifier2 {
public static void main(String[] args) {
AnnotationConfigApplicationContext context =
new AnnotationConfigApplicationContext(
Config.class);
BeanB beanB = context.getBean(BeanB.class);
System.out.println("In the main method: " + beanB.getBeanA());
}
@Configuration
public static class Config {
@Bean
public BeanA bean1() {
return new BeanA("a1");
}
@Bean
public BeanA bean2() {
return new BeanA("a2");
}
@Bean
public BeanB bean3(@Qualifier("bean2") BeanA theBean) {
BeanB beanB = new BeanB(theBean);
System.out.println("method bean3: beanB created = " + beanB +
"\n with constructor param BeanA = " + theBean);
return beanB;
}
}
}Outputmethod bean3: beanB created = BeanB{beanA=BeanA{name='a2'}}
with constructor param BeanA = BeanA{name='a2'}
In the main method: BeanA{name='a2'}
Injecting multiple beans using @Qualifier
package com.logicbig.example;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
public class InjectParameterByQualifier3 {
public static void main(String[] args) {
AnnotationConfigApplicationContext context =
new AnnotationConfigApplicationContext(
Config.class);
BeanB beanB = context.getBean(BeanB.class);
System.out.println("In the main method: " + beanB.getBeanA());
}
@Configuration
public static class Config {
@Bean
public BeanA bean1() {
return new BeanA("a1");
}
@Bean
@Qualifier("myBean")
public BeanA bean2() {
return new BeanA("a2");
}
@Bean
public BeanC bean3() {
return new BeanC("c1");
}
@Bean
@Qualifier("myBean2")
public BeanC bean4() {
return new BeanC("c2");
}
@Bean
public BeanB bean5(@Qualifier("myBean") BeanA theBean,
@Qualifier("myBean2") BeanC theBean2) {
BeanB beanB = new BeanB(theBean);
System.out.println("method bean5: beanB created = " + beanB +
"\n with constructor param of type BeanA= " + theBean);
System.out.println("method bean5: theBean2 instance (can also be in as constructor " +
"arg or some " +
"other way): " + theBean2);
return beanB;
}
}
}Outputmethod bean5: beanB created = BeanB{beanA=BeanA{name='a2'}}
with constructor param of type BeanA= BeanA{name='a2'}
method bean5: theBean2 instance (can also be in as constructor arg or some other way): BeanC{name='c2'}
In the main method: BeanA{name='a2'}
Example ProjectDependencies and Technologies Used: - spring-context 6.1.2 (Spring Context)
Version Compatibility: 3.2.9.RELEASE - 6.1.2 Version compatibilities of spring-context with this example: Versions in green have been tested.
- JDK 17
- Maven 3.8.1
|
