Spring中的@Conditional注解使用和原理详解

package org.springframework.context.annotation;
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Conditional {
	Class<? extends Condition>[] value();
}

package org.springframework.context.annotation;
@FunctionalInterface
public interface Condition {
    /**
	 * 判断条件是否匹配
	 * @param context 上下文信息，可以从中获取 BeanDefinitionRegistry，BeanFactory，Environment，ResourceLoader，ClassLoader 等一些用于资源加载的信息
	 * @param metadata 注解的元信息，可以从中获取注解的属性
	 * @return {@code true} 条件匹配，组件可以注册
	 * or {@code false} 否决组件的注册
	 */
	boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata);
}

public interface ConfigurationCondition extends Condition {
    /**
	 * 返回条件生效的阶段
	 */
    ConfigurationPhase getConfigurationPhase();
    enum ConfigurationPhase {
        /**
		 * 在 @Configuration 类解析时生效
		 */
        PARSE_CONFIGURATION,
        /**
		 * 在 bean 注册时生效。此时所有的 @Configuration 都解析完成了。
		 */
        REGISTER_BEAN
        }
}

@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
// Conditional 作为元注解，主要的判断逻辑在 OnBeanCondition 类中
@Conditional(OnBeanCondition.class)
public @interface ConditionalOnBean {
    // bean 的名称
    String[] name() default {};
}
// OnBeanCondition 主要的判断逻辑在 matches 方法中
class OnBeanCondition implements ConfigurationCondition {
    @Override
	public ConfigurationPhase getConfigurationPhase() {
		return ConfigurationPhase.REGISTER_BEAN;
	}
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        if (metadata.isAnnotated(ConditionalOnBean.class.getName())) {
            MultiValueMap<String, Object> attrs = metadata.getAllAnnotationAttributes(ConditionalOnShardingProps.class.getName());
            if (attrs != null) {
                ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
                for (Object beanName : attrs.get("name")) {
                    if(!beanFactory.containsBean((String) beanName)) {
                        return false;
                    }
                }
                return true;
            }
        }
        return true;
    }
}
// 使用 ConditionalOnBean 注解
@Configuration
@Conditional(ConditionalOnBean.class)
public static class OnBeanConfig {
    @Bean
    @ConditionalOnBean(name = "a")
    public B b() {
        return new B();
    }
}

// ConfigurationClassParser 的核心逻辑
protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
    // 调用 shouldSkip 方法，对应的阶段是 PARSE_CONFIGURATION
    if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
			return;
	}
    ... 省略
}

private void loadBeanDefinitionsForConfigurationClass(ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {
    // 调用的还是 conditionEvaluator.shouldSkip，在其基础上做了个缓存。
    // 对应的阶段是 REGISTER_BEAN
    if (trackedConditionEvaluator.shouldSkip(configClass)) {
        String beanName = configClass.getBeanName();
        if (StringUtils.hasLength(beanName) && this.registry.containsBeanDefinition(beanName)) {
            this.registry.removeBeanDefinition(beanName);
        }
        this.importRegistry.removeImportingClass(configClass.getMetadata().getClassName());
        return;
    }
    ... 省略
}

<T> void doRegisterBean(Class<T> beanClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name, @Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {
    AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);
    // 调用 shouldSkip 方法，对应的阶段为 null
    if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
        return;
    }
    ... 省略
}

public boolean shouldSkip(@Nullable AnnotatedTypeMetadata metadata, @Nullable ConfigurationPhase phase) {
    // 不存在 Conditional 注解，则不处理
    if (metadata == null || !metadata.isAnnotated(Conditional.class.getName())) {
        return false;
    }
    // 阶段为空时的处理逻辑
    if (phase == null) {
        // 有 Configuration、Component、ComponentScan、Import、ImportResource 等注解，则任务是配置解析阶段
        if (metadata instanceof AnnotationMetadata &&
            ConfigurationClassUtils.isConfigurationCandidate((AnnotationMetadata) metadata)) {
            return shouldSkip(metadata, ConfigurationPhase.PARSE_CONFIGURATION);
        }
        return shouldSkip(metadata, ConfigurationPhase.REGISTER_BEAN);
    }
    // 获取所有 Conditional 注解，并提取出 Condition 类
    List<Condition> conditions = new ArrayList<>();
    for (String[] conditionClasses : getConditionClasses(metadata)) {
        for (String conditionClass : conditionClasses) {
            Condition condition = getCondition(conditionClass, this.context.getClassLoader());
            conditions.add(condition);
        }
    }
    // 对 Condition 进行排序
    AnnotationAwareOrderComparator.sort(conditions);
    for (Condition condition : conditions) {
        ConfigurationPhase requiredPhase = null;
        if (condition instanceof ConfigurationCondition) {
            requiredPhase = ((ConfigurationCondition) condition).getConfigurationPhase();
        }
        // 调用 Condition 的 matches 方法，不符合条件的则跳过
        if ((requiredPhase == null || requiredPhase == phase) && !condition.matches(this.context, metadata)) {
            return true;
        }
    }
    // 所有的 Condition 都符合，则不跳过，进行后续处理
    return false;
}