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 {
    // 調(diào)用 shouldSkip 方法，對應(yīng)的階段是 PARSE_CONFIGURATION
    if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
			return;
	}
    ... 省略
}

private void loadBeanDefinitionsForConfigurationClass(ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {
    // 調(diào)用的還是 conditionEvaluator.shouldSkip，在其基礎(chǔ)上做了個緩存。
    // 對應(yīng)的階段是 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);
    // 調(diào)用 shouldSkip 方法，對應(yīng)的階段為 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 等注解，則任務(wù)是配置解析階段
        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 進(jìn)行排序
    AnnotationAwareOrderComparator.sort(conditions);
    for (Condition condition : conditions) {
        ConfigurationPhase requiredPhase = null;
        if (condition instanceof ConfigurationCondition) {
            requiredPhase = ((ConfigurationCondition) condition).getConfigurationPhase();
        }
        // 調(diào)用 Condition 的 matches 方法，不符合條件的則跳過
        if ((requiredPhase == null || requiredPhase == phase) && !condition.matches(this.context, metadata)) {
            return true;
        }
    }
    // 所有的 Condition 都符合，則不跳過，進(jìn)行后續(xù)處理
    return false;
}