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 {
}
package com.logicbig.example;
public class BeanB {
private BeanA beanA;
BeanB (BeanA beanA) {
this.beanA = beanA;
}
public BeanA getBeanA () {
return beanA;
}
}
package com.logicbig.example;
public class BeanC {
}
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 () {
BeanA beanA = new BeanA();
System.out.println("method bean1: beanA created = " + beanA);
return beanA;
}
@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 bean1: beanA created = com.logicbig.example.BeanA@22dcf4fa method bean2: beanB created = com.logicbig.example.BeanB@ad19da9 with constructor param BeanA = com.logicbig.example.BeanA@22dcf4fa In the main method: com.logicbig.example.BeanA@22dcf4fa
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 () {
BeanA beanA = new BeanA();
System.out.println("method bean1: beanA created = " + beanA);
return beanA;
}
@Bean
public BeanA bean2 () {
BeanA beanA = new BeanA();
System.out.println("method bean2: beanA created = " + beanA);
return beanA;
}
@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 bean1: beanA created = com.logicbig.example.BeanA@595532b method bean2: beanA created = com.logicbig.example.BeanA@1592340b method bean3: beanB created = com.logicbig.example.BeanB@131f2c23 with constructor param BeanA: com.logicbig.example.BeanA@595532b In the main method: com.logicbig.example.BeanA@595532b
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 () {
BeanA beanA = new BeanA();
System.out.println("method bean1: beanA created = " + beanA);
return beanA;
}
@Qualifier("myBean")
@Bean
public BeanA bean2 () {
BeanA beanA = new BeanA();
System.out.println("method bean2: beanA created = " + beanA);
return beanA;
}
@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 bean1: beanA created = com.logicbig.example.BeanA@334b9848 method bean2: beanA created = com.logicbig.example.BeanA@e0c33ff method bean3: beanB created = com.logicbig.example.BeanB@1a69c4d3 with constructor param BeanA = com.logicbig.example.BeanA@e0c33ff In the main method: com.logicbig.example.BeanA@e0c33ff
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 () {
BeanA beanA = new BeanA();
System.out.println("method bean1: beanA created = " + beanA);
return beanA;
}
@Bean
public BeanA bean2 () {
BeanA beanA = new BeanA();
System.out.println("method bean2: beanA created = " + beanA);
return beanA;
}
@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 bean1: beanA created = com.logicbig.example.BeanA@7df9cdea method bean2: beanA created = com.logicbig.example.BeanA@729f4474 method bean3: beanB created = com.logicbig.example.BeanB@2bb1c183 with constructor param BeanA = com.logicbig.example.BeanA@729f4474 In the main method: com.logicbig.example.BeanA@729f4474
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 () {
BeanA beanA = new BeanA();
System.out.println("method bean1: beanA created = " + beanA);
return beanA;
}
@Bean
@Qualifier("myBean")
public BeanA bean2 () {
BeanA beanA = new BeanA();
System.out.println("method bean2: beanA created = " + beanA);
return beanA;
}
@Bean
public BeanC bean3 () {
BeanC beanC = new BeanC();
System.out.println("method bean3: beanC created = " + beanC);
return beanC;
}
@Bean
@Qualifier("myBean2")
public BeanC bean4 () {
BeanC beanC = new BeanC();
System.out.println("method bean4: beanC created = " + beanC);
return beanC;
}
@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 bean4: beanC created = com.logicbig.example.BeanC@440a5936 method bean3: beanC created = com.logicbig.example.BeanC@6bce6f30 method bean1: beanA created = com.logicbig.example.BeanA@32208ffa method bean2: beanA created = com.logicbig.example.BeanA@fd85dc7 method bean5: beanB created = com.logicbig.example.BeanB@8558531 with constructor param of type BeanA= com.logicbig.example.BeanA@fd85dc7 method bean5: theBean2 instance (can also be in as constructor arg or some other way): com.logicbig.example.BeanC@440a5936 In the main method: com.logicbig.example.BeanA@fd85dc7
Example ProjectDependencies and Technologies Used: - Spring Context 4.3.2.RELEASE: Spring Context.
- JDK 1.8
- Maven 3.0.4
|