【重写SpringFramework】条件判定（chapter 3-9）配置类通过多种方式加载组件，在此基础上，条件判定

1. 前言

在配置类中，我们可以通过多种方式来加载组件，比如组件扫描、导入或工厂方法。在此基础上，有时候需要根据一定的条件来决定是否加载某个 Bean。现有的解决方案是在 @ComponentScan 注解中指定 includeFilters 或 excludeFilters 属性，实际上是向 ClassPathScanningCandidateComponentProvider 添加包含规则或排除规则。

这种方式有两个缺点，一是使用硬编码的方式事先决定是否加载某些组件，并没有体现「根据一定的条件」这一逻辑判断过程。二是不能覆盖所有场景，仅适用于组件扫描，不能在导入和工厂方法中使用。因此我们需要一种更加灵活的方式，可以在任意加载组件的场景下使用，判断的依据也应该是任意的。条件判定与加载 Bean 的组件密切配合，为我们提供了非常灵活的判定方式。

2. 条件组件

2.1 继承结构

条件判定的主要由四部分组成，注解类作为条件判定的入口，指向一个或多个条件类。条件评估器是整个体系的枢纽，持有一个条件上下文实例，通过对条件注解的解析，得到对应的条件类集合，然后通过对这些条件类的综合评定来决定是否加载 Bean。

• 注解类：@Conditional 作为元注解，声明在其他条件注解类上，指向一个具体的条件类

• 条件类：Condition 接口定义了判定的行为，子类可以实现自定义的判定逻辑。

• 条件上下文：ConditionContext 接口定义了在条件判定的过程中使用的相关组件

• 条件评估器：ConditionEvaluator 是条件判定的核心类，通过条件注解获取对应的条件类，然后综合判定是否应当加载组件

2.2 @Conditional

@Conditional 作为元注解，声明在其他条件注解之上。value 属性用于指定条件注解对应的条件类，也就是 Condition 接口的实现类。

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

2.3 Condition

真正的处理逻辑是定义在 Condition 接口。一般来说，一个条件注解背后至少有一个条件类提供支持，比如 ProfileCondition 就是专门负责解析 @Profile 注解的。

public interface Condition {
    boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata);
}

2.4 ConditionContext

在条件判定的过程中用到了一些组件，ConditionContext 接口将它们封装成一个上下文对象，供 ConditionEvaluator 使用。比如我们要根据某个配置项来判断是否加载组件，就需要用到 Enviroment 对象，因为配置参数都存放在环境变量中。有时判断的依据是 Spring 容器中存在某个类型的 Bean，需要用到 BeanFactory 对象。唯一的实现类 ConditionContextImpl 是 ConditionEvaluator 的内部类。

public interface ConditionContext {
    BeanDefinitionRegistry getRegistry();
    ConfigurableBeanFactory getBeanFactory();
    Environment getEnvironment();
    ResourceLoader getResourceLoader();
    ClassLoader getClassLoader();
}

2.5 Profile 相关

Profile 是指应用程序的运行环境，常见的有开发、测试、生产等环境。不同的运行环境下可以进行相应的设置，比如连接不同的数据库。Spring 提供了 @Profile 注解和相应的条件类，实现了通过不同运行环境决定是否加载组件的功能。@Profile 注解上声明了 @Conditional 元注解，并指定条件类为 ProfileCondition。

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Conditional(ProfileCondition.class)
public @interface Profile {
    String[] value();
}

ProfileCondition 作为条件类实现了 Condition 接口，matches 方法的匹配逻辑分为两步。首先获取 @Profile 注解的 value 属性值，比如 dev 或 prd（可以是一个数组）。然后取出 Spring 容器中的环境变量，调用 acceptsProfiles 方法判断是否支持相应的运行环境。当然了，前提是先调用 setActiveProfiles 方法设置支持的运行环境。

public class ProfileCondition implements Condition {

    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        //1. 获取@Profile注解的信息
        MultiValueMap<String, Object> attrs = metadata.getAllAnnotationAttributes(Profile.class.getName());
        if (attrs != null) {
            for (Object value : attrs.get("value")) {
                //2. 判断当前运行环境是否支持
                if(context.getEnvironment().acceptsProfiles((String[]) value)){
                    return true;
                }
            }
            return false;
        }
        return false;
    }
}

3. 条件评估器

ConditionEvaluator 类的核心是 shouldSkip 方法，metadata 参数表示一个类或工厂方法。shouldSkip 方法可以分为三步：

1. 如果没有声明 @Conditional 注解，说明是普通 Bean，默认是允许加载的。
2. 从条件注解中提取条件类。首先调用 getConditionClasses 方法解析 @Conditional 注解的 value 属性，得到条件类的全类名数组。然后遍历调用 getCondition 方法实例化条件类，最后进行排序。
3. 遍历所有的 Condition，只要有一个条件不符合，说明不应加载 Bean，也就是说判定规则采用的是一票否决制。

public class ConditionEvaluator {
    private final ConditionContextImpl context;

    public boolean shouldSkip(AnnotatedTypeMetadata metadata) {
        //1. 没有@Conditional注解，被视为正常的Bean
        if(metadata == null || !metadata.isAnnotated(Conditional.class.getName())){
            return false;
        }

        //2. 解析@Conditional注解，并转换成Condition集合
        List<Condition> conditions = new ArrayList<>();
        for (String[] conditionClasses : getConditionClasses(metadata)) {
            for (String conditionClass : conditionClasses) {
                Condition condition = getCondition(conditionClas-s, this.context.getClassLoader());
                conditions.add(condition);
            }
        }
        AnnotationAwareOrderComparator.sort(conditions);

        //3. 对所有的Condition进行判定，只要有一个条件不符合，说明不应加载Bean。
        boolean flag = false;
        for (Condition condition : conditions) {
            if (!condition.matches(this.context, metadata)) {
                flag = true;
                break;
            }
        }
        return flag;
    }
}

4. 判定时机

4.1 概述

ConditionEvaluator 实现了条件判定的主要逻辑，只要涉及到注册 BeanDefinition 的地方，基本都需要使用条件判定。context 模块有四个组件会执行注册 BeanDefinition 的操作，简单介绍如下：

• AnnotatedBeanDefinitionReader 注册指定的 Bean

• ClassPathBeanDefinitionScanner 批量加载组件，需要进行多次过滤

• ConfigurationClassParser 包括两个操作，一是解析配置类，二是处理组件扫描的注解

• ConfigurationClassBeanDefinitionReader 包括两个操作，一是处理 ConfigurationClass ，二是注册 BeanMethod

4.2 AnnotatedBeanDefinitionReader

在 AnnotatedBeanDefinitionReader 类的 registerBean 方法中，首先对 Bean 进行条件判定，符合条件的才会注册到 Spring 容器中。

public class AnnotatedBeanDefinitionReader {

    private void registerBean(Class<?> annotatedClass, String name) {
        AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
        //1. 根据条件判定Bean是否加载
        if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
            return;
        }
        //2. 根据@Role、@Primary等注解的信息来设置BeanDefinition的相关属性（略）
        //3. 注册BeanDefinition（略）
    }
}

4.3 ClassPathBeanDefinitionScanner

在 ClassPathBeanDefinitionScanner 的父类的 isCandidateComponent 方法中，经过排除规则和包含规则的两层过滤之后，还要调用 isConditionMatch方法进行条件判定。

public class ClassPathScanningCandidateComponentProvider implements ResourceLoaderAware {

    //根据排除或包含规则、以及条件判定，过滤出符合条件的候选项
    private boolean isCandidateComponent(MetadataReader metadataReader) throws IOException {
        //排除需要过滤掉的项（略）

        //加载指定规则的项，比如使用@Component注解声明的类
        for (TypeFilter tf : this.includeFilters) {
            if (tf.match(metadataReader, this.metadataReaderFactory)) {
                //进一步检查Condition
                return isConditionMatch(metadataReader);
            }
        }
        return false;
    }

    private boolean isConditionMatch(MetadataReader metadataReader) {
        return !this.conditionEvaluator.shouldSkip(metadataReader.getAnnotationMetadata());
    }
}

4.3 ConfigurationClassParser

ConfigurationClassParser 有两处需要使用条件判定，一是 processConfigurationClass 方法负责解析指定的配置类。按理来说，解析配置类会触发一连串的操作，因此在解析之前有必要对配置类进行条件判定。

protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
    //根据@Conditional判断是否应该处理配置类
    if (this.conditionEvaluator.shouldSkip(configClass.getMetadata())) {
        return;
    }

    ......
}

二是 doProcessConfigurationClass 方法在处理声明了 @ComponentScan 注解的类时，也需要进行条件判定。这是因为组件扫描是不可逆的过程，可能会注册大量的 BeanDefinition，因此必须对配置类进行检查。

protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass) throws IOException {
    //3. 组件扫描@ComponentScan
    AnnotationAttributes componentScan = AnnotationConfigUtils.attributesFor(metadata, ComponentScan.class);
    if(componentScan != null && !this.conditionEvaluator.shouldSkip(sourceClass.getMetadata())){
        ......
    }
}

4.4 ConfigurationClassBeanDefinitionReader

ConfigurationClassBeanDefinitionReader 有两处使用了条件判定。一是 loadBeanDefinitionsForConfigurationClass 方法中，需要先判断配置类是否应当被处理，然后才能进行后续的注册流程。如果不满足条件，需要移除已存在的 BeanDefinition，防止后续被实例化。需要注意的是，入参 configClass 可能是内部类或导入类，那么它们能否加载还要看宿主配置类的判定情况，因此使用内部类 TrackedConditionEvaluator 来处理。

private void loadBeanDefinitionsForConfigurationClass(ConfigurationClass configClass) {
    //判断配置类是否应该被处理
    boolean skip = this.trackedConditionEvaluator.shouldSkip(configClass);
    if (skip) {
        //移除已注册的BeanDefinition，否则配置类仍会被实例化
        this.registry.removeBeanDefinition(configClass.getBeanName());
        return;
    }

    //1. 注册配置类（略）
    //2. 注册BeanMethod（略）
    //3. 注册导入的类（略）
}

首先检查配置类是否由宿主导入，如果是则对所有的宿主类进行条件判定，当所有的全部宿主都不满足条件，说明配置类不应被加载。反过来说，只要有一个宿主满足条件，那么配置类就有可能被加载。注意，我们只是说可能，因为接下来还要对配置类进行条件判定，如果本身也满足条件，那么最终确定是可以被加载的。

private class TrackedConditionEvaluator {
    private final Map<ConfigurationClass, Boolean> skipped = new HashMap<>();

    public boolean shouldSkip(ConfigurationClass configClass) {
        Boolean skip = this.skipped.get(configClass);
        if (skip == null) {
            //检查配置类是否由宿主导入的
            if (configClass.isImported()) {
                boolean allSkipped = true;
                for (ConfigurationClass importedBy : configClass.getImportedBy()) {
                    if (!shouldSkip(importedBy)) {
                        allSkipped = false;
                        break;
                    }
                }
                //如果所有的宿主都不满足条件，说明当前配置类不应被加载
                if (allSkipped) {
                    skip = true;
                }
            }

            //对配置类本身进行判定（配置类不是被导入的，或者至少有一个宿主类满足条件）
            if (skip == null) {
                skip = conditionEvaluator.shouldSkip(configClass.getMetadata());
            }
            this.skipped.put(configClass, skip);
        }
        return skip;
    }
}

举个例子，配置类 A 和配置类 B 都导入了 配置类 C，那么加载配置类 C 必须满足两个条件，一是满足 ConditionA 或 ConditionB，二是同时满足 ConditionC。换句话说，满足条件 A + 条件 C，或条件 B + 条件 C，都可以加载配置类 C。

//示例代码
@Import(ConfigC.class)
@ConditionA
@Configuration
public class ConfigA {}

@Import(ConfigC.class)
@ConditionB
@Configuration
public class ConfigB {}

@ConditionC
@Configuration
public class ConfigC {}

二是 loadBeanDefinitionsForBeanMethod 方法，先进行条件判定，然后执行 BeanMethod 的处理流程。BeanMethod 本身也可以声明条件注解，因此需要进一步进行条件判定。由此可知，之前的检查是针对配置类的，这里的检查是针对工厂方法的。

private void loadBeanDefinitionsForBeanMethod(BeanMethod beanMethod) {
    ConfigurationClass configClass = beanMethod.getConfigurationClass();
    MethodMetadata metadata = beanMethod.getMetadata();
    String methodName = metadata.getMethodName();

    //1. 根据Condition判断是否需要加载BeanMethod
    if (this.conditionEvaluator.shouldSkip(metadata)) {
        return;
    }

    //其余代码，略
}

6. 测试

@6.1 Profile 注解

首先准备两个测试类，ConditionBean 是普通的组件，profile 字段声明了 @Value 注解，用于注入 profile 环境变量。ConditionConfig 是一个配置类，定义了两个 BeanMethod，且都声明了 @Profile 注解，一个指定为 dev 开发环境，另一个指定为 prd 生产环境。

//测试类
public class ConditionBean {
    @Value("${spring.profiles.active}")
    private String profile;
}

@Configuration
public class ConditionConfig {

    //测试环境加载
    @Profile("dev")
    @Bean
    public ConditionBean devConditionBean(){
        return new ConditionBean();
    }

    //生产环境加载
    @Profile("prd")
    @Bean
    public ConditionBean prdConditionBean(){
        return new ConditionBean();
    }
}

在测试方法中，获取 ApplicationContext 中的环境变量对象，然后对 Environment 进行两个操作，一是设置支持的运行环境，二是设置环境变量的参数。前者为条件判定服务，后者为依赖注入服务。由于设置的运行环境是 dev，因此只加载了 devConditionBean 实例。

//测试方法
@Test
public void testProfileCondition(){
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
    ConfigurableEnvironment environment = context.getEnvironment();
    String profile = "dev";
    environment.setActiveProfiles(profile); //设置支持的运行环境
    environment.getSystemProperties().put("spring.profiles.active", profile); //设置环境变量的参数
    context.register(ConditionConfig.class);
    context.refresh();

    Map<String, ConditionBean> beans = context.getBeansOfType(ConditionBean.class);
    for (Map.Entry<String, ConditionBean> entry : beans.entrySet()) {
        System.out.println("单例名称：" + entry.getKey() + ", profile：" + entry.getValue().getProfile());
    }
}

从测试结果可以看到，加载的是开发环境下的组件。如果将运行环境换成 prd，那么加载的就是 prdConditionBean。

单例名称：devConditionBean, profile：dev

6.2 @ConditionalOnBean注解

Spring Boot 提供了一组常用的条件注解，比如 @ConditionalOnBean 注解的作用是检查 Spring 容器中是否存在指定类型的单例，这里使用 @MyConditionalOnBean 注解来模拟。

//测试类，模拟@ConditionalOnBean
@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Conditional(MyOnBeanCondition.class)
public @interface MyConditionalOnBean {
    Class<?>[] value() default {};
}

MyOnBeanCondition 作为条件类提供了具体的语义。具体来说，解析 @MyConditionalOnBean 注解的 value 属性，得到一个字符串数组，然后转换成 Class 类型，检查 Spring 容器中是否存在指定类型的 beanName 集合，如果不为空，说明是匹配的。

//测试类
public class MyOnBeanCondition implements Condition {

    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        MultiValueMap<String, Object> attrs = metadata.getAllAnnotationAttributes(MyConditionalOnBean.class.getName(), true);
        if (attrs != null) {
            for (Object value : attrs.get("value")) {
                if (value instanceof String[]) {
                    String[] arr = (String[]) value;
                    try {
                        Class<?> typeClass = ClassUtils.forName(arr[0], context.getClassLoader());
                        //获取指定类型的Bean的集合，只查询名称
                        List<String> beanNames = context.getBeanFactory().getBeanNamesForType(typeClass);
                        if (!beanNames.isEmpty()) {
                            return true;
                        }
                    } catch (ClassNotFoundException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
        return false;
    }
}

接下来定义一个配置类，声明 MyConditionalOnBean 注解，表示当 Spring 容器中存在 ConditionBean 类型的单例时条件生效。

//测试类
@MyConditionalOnBean(ConditionBean.class)
@Configuration
public class ConfigC {

    public ConfigC() {
        System.out.println("创建ConfigC...");
    }
}

测试方法比较简单，创建 ApplicationContext 实例之后，注册 ConditionBean 和 ConfigC。

//测试方法
@Test
public void testOnBeanCondition() {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
    context.register(ConditionBean.class);
    context.register(ConfigC.class);
    context.refresh();
}

从测试结果可以看到，当容器中存在 ConditionBean 时，配置类 ConfigC 是可以正常注册的。同样地，如果没有注册 ConditionBean，那么 ConfigC 也不会注册。

创建ConfigC...

6.3 宿主类导入

当多个宿主类导入同一个配置类时，只要其中一个宿主类存在，则加载该配置类。如下所示，ConfigA 和 ConfigB 是宿主类，它们都导入了 ConfigC。我们通过 @Profile 注解来控制是否加载宿主类，分为以下几种情况：

• 运行环境是 dev：加载 ConfigA，最终导入 ConfigC
• 运行环境是 prd：加载 ConfigB，最终导入 ConfigC
• 其他运行环境或不指定：不加载宿主类，不导入 ConfigC

//测试类
@Profile("dev")
@Import(ConfigC.class)
@Configuration
public class ConfigA {}

@Profile("prd")
@Import(ConfigC.class)
@Configuration
public class ConfigB {}

在测试方法中，通过运行环境来控制两个宿主类的加载情况。由于 ConfigC 还声明了 @MyConditionalOnBean 注解，因此 ConfigC 是否加载，取决于两个条件，且必须同时满足。一是宿主类 ConfigA 或 ConfigB 存在，二是 ConditionBean 必须存在。

//测试方法
@Test
public void testImportConfiguration() {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
    ConfigurableEnvironment environment = context.getEnvironment();
    String profile = "dev";
    environment.setActiveProfiles(profile); //设置支持的运行环境
    environment.getSystemProperties().put("spring.profiles.active", profile); //设置环境变量的参数

    context.register(ConditionBean.class);
    context.register(ConfigA.class);
    context.register(ConfigB.class);
    context.refresh();
}

从测试结果可以看到，ConfigC 创建成功，说明所有条件都满足。此外，还可以测试其他情况，比如不注册 ConditionBean，或者不指定运行环境，都会出现条件不匹配，从而导致不加载 ConfigC 的情况。

创建ConfigC...

7. 总结

Spring 提供了多种注册 BeanDefinition 的方式，有时我们需要根据一定的条件决定是否加载某个组件。Spring 将判断条件抽象成 Condition 接口，并通过条件评估器组件完成判定逻辑。对于条件注解的判定需要遵循以下两条规则：

• 如果目标类或方法声明了多个条件注解，那么必须同时满足所有条件，才能加载组件。（逻辑与）
• 对于导入机制来说，多个宿主配置类可能导入同一个目标配置类，只要其中一个宿主类被加载，目标配置类就应该被加载。（逻辑或）

之前介绍了四个加载 BeanDefinition 的组件，我们对这些组件涉及条件判定的情况进行逐一分析。此外，我们以 @Profile 注解为例，介绍了条件判定的运行机制。具体来说，@Prifile 注解根据不同的运行环境来决定是否加载组件，这是一个很有用的功能。至于更为复杂的条件判定用例，我们将在第二部 Spring Boot 的自动配置模块进行详细介绍。

8.项目信息

新增修改一览，新增（14），修改（4）。

context
└─ src
   ├─ main
   │  └─ java
   │     └─ cn.stimd.spring.context
   │        └─ annotation
   │           ├─ AnnotatedBeanDefinitionReader.java (*)
   │           ├─ ClassPathScanningCandidateComponentProvider.java (*)
   │           ├─ Condition.java (+)
   │           ├─ Conditional.java (+)
   │           ├─ ConditionContext.java (+)
   │           ├─ ConditionEvaluator.java (+)
   │           ├─ ConfigurationClassBeanDefinitionReader.java (*)
   │           ├─ ConfigurationClassParser.java (*)
   │           ├─ Profile.java (+)
   │           └─ ProfileCondition.java (+)
   └─ test
      └─ java
         └─ context
            └─ condition
               ├─ ConditionBean.java (+)
               ├─ ConditionConfig.java (+)
               ├─ ConditionTest.java (+)
               ├─ ConfigA.java (+)
               ├─ ConfigB.java (+)
               ├─ ConfigC.java (+)
               ├─ MyConditionalOnBean.java (+)
               └─ MyOnBeanCondition.java (+)

注：+号表示新增、*表示修改

• 项目地址：gitee.com/stimd/sprin…

• 本节分支：gitee.com/stimd/sprin…

注：项目的 master 分支会跟随教程的进度不断更新，如果想查看某一节的代码，请选择对应小节的分支代码。

---

欢迎关注公众号【Java编程探微】，加群一起讨论。

原创不易，觉得内容不错请关注、点赞、收藏。