Spring是如何根据条件创建Bean的?
日常工作过程中,相信这种情况是最常见的:根据某个或某些条件来执行相应的逻辑。换句话说,会通过if-else语句来执行一定的业务逻辑功能。
在Spring中,就有这样一个注解,它支持根据一定的条件来创建对应的Bean对象,并将Bean对象注册到IOC容器中。满足条件的Bean就会被注册到IOC容器中,不满足条件的Bean就不会被注册到IOC容器中。这个注解就是@Conditional注解,本章,就对@Conditional注解进行简单的介绍。
关于@Conditional注解的一点点说明~~
Spring提供的@Conditional注解支持按照条件向IOC容器中注册Bean,满足条件的Bean就会被注册到IOC容器中,不满足条件的Bean就不会被注册到IOC容器中。
@Conditional注解可以标注到类或方法上,能够实现按照条件向IOC容器中注册Bean。源码详见:org.springframework.context.annotation.Conditional。
/**
* @author Phillip Webb
* @author Sam Brannen
* @since 4.0
*/
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Conditional {
Class<? extends Condition>[] value();
}
从@Conditional注解的源码可以看出,@Conditional注解是从Spring 4.0版本开始提供的注解。在@Conditional注解注解中只提供了一个Class数组类型的value属性,具体含义如下所示。
如果使用Spring开发的应用程序需要根据不同的运行环境来读取不同的配置信息,例如在windows操作系统上需要读取Windows操作系统的环境信息,在macOS操作系统上需要读取MacOS操作系统的环境信息。此时,就可以使用@Conditional注解实现。
另外,@Conditional注解还有如下一些使用场景:
@Conditional注解案例实战~~
Spring的@Conditional注解可以标注到类或方法上,并且会实现按照一定的条件将对应的Bean注入到IOC容器中。所以,本节,会列举无条件(不加@Conditional注解)、@Conditional注解标注到方法上和@Conditional注解标注到类上以及将@Conditional注解同时标注到类上和方法上等四个主要案例。
本节,主要实现不使用@Conditional注解时,向IOC容器中注入Bean的案例,具体实现步骤如下所示。
(1)新增Founder类
Founder类的源码详见:spring-annotation-chapter-08工程下的io.binghe.spring.annotation.chapter08.bean.Founder。
public class Founder {
private String name;
public Founder(String name) {
this.name = name;
}
@Override
public String toString() {
return "Person{" + "name='" + name + ''' + '}';
}
}
可以看到,Founder类就是JAVA中的一个普通实体类。
(2)新增ConditionalConfig类
ConditionalConfig类的源码详见:spring-annotation-chapter-08工程下的io.binghe.spring.annotation.chapter08.config.ConditionalConfig。
@Configuration
public class ConditionalConfig {
@Bean(name = "bill")
public Founder windowsFounder(){
return new Founder("Bill Gates");
}
@Bean(name = "jobs")
public Founder macosFounder(){
return new Founder("Steve Jobs");
}
}
可以看到,ConditionalConfig类是一个Spring的配置类,并且在ConditionalConfig类中使用@Bean注解创建了两个Bean对象,并注册到IOC容器中,一个Bean的名称为bill,另一个Bean的名称为jobs。
(3)新增ConditionalTest类
ConditionalTest类的源码详见:spring-annotation-chapter-08工程下的io.binghe.spring.annotation.chapter08.ConditionalTest。
public class ConditionalTest {
public static void mAIn(String[] args) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ConditionalConfig.class);
String[] definitionNames = context.getBeanDefinitionNames();
Arrays.stream(definitionNames).forEach((definitionName) -> System.out.println(definitionName));
}
}
可以看到,在ConditionalTest类的main()方法中,会打印注入到IOC容器中的Bean名称。
(4)运行ConditionalTest类
运行ConditionalTest类的main()方法,输出的结果信息如下所示。
org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
conditionalConfig
bill
jobs
从输出的结果信息可以看出,向IOC容器中注入了名称为conditionalConfig、bill和jobs的Bean。
说明:没设置@Conditional注解时,会向Spring容器中注入所有使用@Bean注解创建的Bean。
本节,主要实现将@Conditional注解标注到方法上,向IOC容器中注入Bean的案例,具体实现步骤如下所示。
注意:本节的案例是在3.1节的基础上进行完善,在对应的方法上添加@Conditional注解。
(1)新增WindowsCondition类
WindowsCondition类的源码详见:spring-annotation-chapter-08工程下的io.binghe.spring.annotation.chapter08.condition.WindowsCondition。
public class WindowsCondition implements Condition {
@Override
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
String osName = context.getEnvironment().getProperty("os.name");
return osName.toLowerCase().contains("windows");
}
}
可以看到,WindowsCondition类实现了Condition接口,并实现了matches()方法。在matches()方法中,通过Spring的环境变量读取操作系统名称,如果操作系统名称中包含windows就返回true,否则返回false。当返回true时,使用@Conditional注解指定的条件为WindowsCondition类的Class对象的Bean会被创建并注入到IOC容器中。
(2)新增MacosCondition类
MacosCondition类的源码详见:spring-annotation-chapter-08工程下的io.binghe.spring.annotation.chapter08.condition.MacosCondition。
public class MacosCondition implements Condition {
@Override
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
String osName = context.getEnvironment().getProperty("os.name");
return osName.toLowerCase().contains("mac");
}
}
可以看到,MacosCondition类实现了Condition接口,并实现了matches()方法。在matches()方法中,通过Spring的环境变量读取操作系统名称,如果操作系统名称中包含mac就返回true,否则返回false。当返回true时,使用@Conditional注解指定的条件为MacosCondition类的Class对象的Bean会被创建并注入到IOC容器中。
(3)修改ConditionalConfig类
在ConditionalConfig类的方法上标注@Conditional注解,修改后的源码如下所示。
@Bean(name = "bill")
@Conditional(value = {WindowsCondition.class})
public Founder windowsFounder(){
System.out.println("创建名称为bill的Bean对象");
return new Founder("Bill Gates");
}
@Bean(name = "jobs")
@Conditional(value = {MacosCondition.class})
public Founder macosFounder(){
System.out.println("创建名称为jobs的Bean对象");
return new Founder("Steve Jobs");
}
可以看到,在创建名称为bill的Bean的方法上标注了@Conditional注解,并指定了value的属性为WindowsCondition类的class对象。在创建名称为jobs的Bean的方法上标注了@Conditional注解,并指定了value的属性为MacosCondition类的class对象。
(4)运行ConditionalTest类
运行ConditionalTest类的main()方法,输出的结果信息如下所示。
创建名称为bill的Bean对象
org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
conditionalConfig
bill
可以看到,由于我的电脑是Windows操作系统,所以,打印出的Bean名称包含conditionalConfig和bill,不包含jobs。
说明:@Conditional注解标注到使用@Bean创建Bean的方法上时,只有满足@Conditional注解的条件时,才会执行方法体创建Bean对象并注入到IOC容器中。
本节,主要实现将@Conditional注解标注到类上,向IOC容器中注入Bean的案例,具体实现步骤如下所示。
注意:本节的案例是在3.1节的基础上进行完善,在对应的类上添加@Conditional注解。
(1)修改ConditionalConfig类
删除ConditionalConfig类中的方法上的@Conditional注解,并在ConditionalConfig类上标注@Conditional注解。
@Configuration
@Conditional(value = {MacosCondition.class})
public class ConditionalConfig {
@Bean(name = "bill")
public Founder windowsFounder(){
System.out.println("创建名称为bill的Bean对象");
return new Founder("Bill Gates");
}
@Bean(name = "jobs")
public Founder macosFounder(){
System.out.println("创建名称为jobs的Bean对象");
return new Founder("Steve Jobs");
}
}
可以看到,在ConditionalConfig类上标注了@Conditional注解,并且将value属性设置为MacosCondition。也就是说,当前操作系统为MacOS操作系统时,才会创建名称为bill和jobs的Bean,并将其注入到IOC容器中。
(2)运行ConditionalTest类
运行ConditionalTest类的main()方法,输出的结果信息如下所示。
org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
从输出的结果信息可以看出,由于我的电脑是Windows操作系统,所以,在输出的Bean名称中,并不包含conditionalConfig、bill和jobs。
说明:当@Conditional注解标注到类上时,如果运行程序时,不满足@Conditional注解中指定的条件,则当前类的所有Bean都不会被创建,也不会注入到IOC容器中。
本节,主要实现将@Conditional注解同时标注到类和方法上,向IOC容器中注入Bean的案例,具体实现步骤如下所示。
注意:本节的案例是在3.1节的基础上进行完善,在对应的类上添加@Conditional注解。
(1)修改ConditionalConfig类
在ConditionalConfig类的类上和方法上同时标注@Conditional注解。如下所示。
@Configuration
@Conditional(value = {MacosCondition.class})
public class ConditionalConfig {
@Bean(name = "bill")
@Conditional(value = {WindowsCondition.class})
public Founder windowsFounder(){
System.out.println("创建名称为bill的Bean对象");
return new Founder("Bill Gates");
}
@Bean(name = "jobs")
@Conditional(value = {MacosCondition.class})
public Founder macosFounder(){
System.out.println("创建名称为jobs的Bean对象");
return new Founder("Steve Jobs");
}
}
可以看到,在ConditionalConfig类的类上和方法上都标注了@Conditional注解。其中,在类上标注的@Conditional注解的条件是当前操作系统为MacOS系统。
(2)运行ConditionalTest类
运行ConditionalTest类的main()方法,输出的结果信息如下所示。
org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
从输出的结果信息可以看出,由于我的电脑是Windows操作系统,所以,在输出的Bean名称中,并不包含conditionalConfig、bill和jobs。
说明:当@Conditional注解同时标注到类和方法上时,如果标注到类上的@Conditional注解不满足条件,即使类中的方法上标注的@Conditional注解满足条件,也不会创建Bean,并且也不会将Bean注入到IOC容器中。
结合时序图理解源码会事半功倍,你觉得呢?
本节,就以源码时序图的方式,直观的感受下@Conditional注解在Spring源码层面的执行流程。@Conditional注解的源码时序图如图8-1和8-2所示。
源码时序图整清楚了,那就整源码解析呗!
@Conditional注解在Spring源码层面的执行流程,结合源码执行的时序图,会理解的更加深刻。本节,就简单结合源码时序图简单分析下@Conditional注解在Spring源码层面的执行流程。
注意:@Conditional注解在Spring源码层面的执行流程与第7章的5.1节@DependsOn注解在Spring源码层面注册Bean的执行流程大体类似,只是在执行AnnotatedBeanDefinitionReader类的doRegisterBean()方法的逻辑时,略有差异。
(1)解析AnnotatedBeanDefinitionReader类的doRegisterBean(ClassbeanClass, String name, Class<? extends Annotation>[] qualifiers, Suppliersupplier, BeanDefinitionCustomizer[] customizers)方法
源码详见:org.springframework.context.annotation.AnnotatedBeanDefinitionReader#doRegisterBean(ClassbeanClass, String name, Class<? extends Annotation>[] qualifiers, Suppliersupplier, BeanDefinitionCustomizer[] customizers)。
private <T> void doRegisterBean(Class<T> beanClass, @Nullable String name, @Nullable Class<? extends Annotation>[] qualifiers, @Nullable Supplier<T> supplier, @Nullable BeanDefinitionCustomizer[] customizers) {
AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);
if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
return;
}
abd.setInstanceSupplier(supplier);
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
abd.setScope(scopeMetadata.getScopeName());
String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
if (qualifiers != null) {
for (Class<? extends Annotation> qualifier : qualifiers) {
if (Primary.class == qualifier) {
abd.setPrimary(true);
}
else if (Lazy.class == qualifier) {
abd.setLazyInit(true);
}
else {
abd.addQualifier(new AutowireCandidateQualifier(qualifier));
}
}
}
if (customizers != null) {
for (BeanDefinitionCustomizer customizer : customizers) {
customizer.customize(abd);
}
}
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}
可以看到,在AnnotatedBeanDefinitionReader类的doRegisterBean()方法中,调用了conditionEvaluator对象的shouldSkip()方法判断是否要忽略当前Bean的注册。
(2)解析ConditionEvaluator类的shouldSkip(AnnotatedTypeMetadata metadata)方法
源码详见:org.springframework.context.annotation.ConditionEvaluator#shouldSkip(AnnotatedTypeMetadata metadata)
public boolean shouldSkip(AnnotatedTypeMetadata metadata) {
return shouldSkip(metadata, null);
}
可以看到,在ConditionEvaluator类的shouldSkip()方法中,直接调用了另一个重载的shouldSkip()方法。
(3)解析ConditionEvaluator类的shouldSkip(AnnotatedTypeMetadata metadata, ConfigurationPhase phase)方法
源码详见:org.springframework.context.annotation.ConditionEvaluator#shouldSkip(AnnotatedTypeMetadata metadata, ConfigurationPhase phase)。
public boolean shouldSkip(@Nullable AnnotatedTypeMetadata metadata, @Nullable ConfigurationPhase phase) {
if (metadata == null || !metadata.isAnnotated(Conditional.class.getName())) {
return false;
}
if (phase == null) {
if (metadata instanceof AnnotationMetadata &&
ConfigurationClassUtils.isConfigurationCandidate((AnnotationMetadata) metadata)) {
return shouldSkip(metadata, ConfigurationPhase.PARSE_CONFIGURATION);
}
return shouldSkip(metadata, ConfigurationPhase.REGISTER_BEAN);
}
List<Condition> conditions = new ArrayList<>();
for (String[] conditionClasses : getConditionClasses(metadata)) {
for (String conditionClass : conditionClasses) {
Condition condition = getCondition(conditionClass, this.context.getClassLoader());
conditions.add(condition);
}
}
AnnotationAwareOrderComparator.sort(conditions);
for (Condition condition : conditions) {
ConfigurationPhase requiredPhase = null;
if (condition instanceof ConfigurationCondition) {
requiredPhase = ((ConfigurationCondition) condition).getConfigurationPhase();
}
if ((requiredPhase == null || requiredPhase == phase) && !condition.matches(this.context, metadata)) {
return true;
}
}
return false;
}
可以看到,在shouldSkip()方法中,首先会判断类或方法上是否标注了@Conditional注解,如果没有标注@Conditional注解,则直接返回false,此时对应的Bean会被创建并注入到IOC容器中。
否则,会解析@Conditional注解中的value属性设置的Class对象,将Class对象的全类名解析到conditionClasses数组中,遍历conditionClasses数组中的每个元素生成Condition对象,将Condition对象存入conditions集合中。后续会遍历conditions集合中的每个Condition对象,调用matches()方法,此处的逻辑与matches()方法的返回值正好相反。
接下来,就会回到AnnotatedBeanDefinitionReader类的doRegisterBean()方法继续执行后续流程,后续流程与第7章的5.1节@DependsOn注解在Spring源码层面注册Bean的执行流程一致,这里不再赘述。
至此,@Conditional注解在Spring源码层面的执行流程分析完毕。
@Conditional的扩展注解如下所示:
@ConditionalOnBean:仅仅在当前上下文中存在某个对象时,才会实例化一个Bean。@ConditionalOnClass:某个class位于类路径上,才会实例化一个Bean。@ConditionalOnExpression:当表达式为true的时候,才会实例化一个Bean。@ConditionalOnMissingBean:仅仅在当前上下文中不存在某个对象时,才会实例化一个Bean。@ConditionalOnMissingClass:某个class类路径上不存在的时候,才会实例化一个Bean。@ConditionalOnNotWebApplication:不是web应用,才会实例化一个Bean。@ConditionalOnBean:当容器中有指定Bean的条件下进行实例化。@ConditionalOnMissingBean:当容器里没有指定Bean的条件下进行实例化。@ConditionalOnClass:当classpath类路径下有指定类的条件下进行实例化。@ConditionalOnMissingClass:当类路径下没有指定类的条件下进行实例化。@ConditionalOnWebApplication:当项目是一个Web项目时进行实例化。@ConditionalOnNotWebApplication:当项目不是一个Web项目时进行实例化。@ConditionalOnProperty:当指定的属性有指定的值时进行实例化。@ConditionalOnExpression:基于SpEL表达式的条件判断。@ConditionalOnJava:当JVM版本为指定的版本范围时触发实例化。@ConditionalOnResource:当类路径下有指定的资源时触发实例化。@ConditionalOnJndi:在JNDI存在的条件下触发实例化。@ConditionalOnSingleCandidate:当指定的Bean在容器中只有一个,或者有多个但是指定了首选的Bean时触发实例化。
@Conditional注解介绍完了,我们一起总结下吧!
本章,首先介绍了@Conditional注解的源码和使用场景。随后,列举了四个关于@Conditional注解的案例,分别是:无条件案例、标注到方法上的案例、标注到类上的案例和同时标注到类和方法上的案例。接下来,介绍了@Conditional注解执行的源码时序图和源码流程。
既然学完了,就开始思考几个问题吧?
关于@Conditional注解,通常会有如下几个经典面试题: