SpringBoot的条件注解@ConditionalOnXxx

SpringBoot中有一个很重要的模块，那就是spring-boot-autoconfigure。可以说我们所有的三方依赖的自动配置AutoConfiguration（自动化配置类），比如KafkaAutoConfiguration、GsonAutoConfiguration、WebMvcAutoConfiguration、JsonbAutoConfiguration等。

这些AutoConfiguration都只会在特定情况下才会生效，具体是如何实现的呢？就是依赖于SpringBoot的条件注解。

SpringBoot的条件注解

条件注解	作用	条件注解解析类
ConditionalOnBean	ApplicationContext存在某些bean时条件才成立	OnBeanCondition
ConditionalOnClass	classPath中存在某些Class时条件才成立	OnClassCondition
ConditionalOnCloudPlatform	在某些云平台(Kubemetes、Heroku、Cloud Foundry)下条件才成立	OnCloudPlatformCondition
ConditionalOnExpression	SPEL表达式成立时条件才成立	OnExpressionCondition
ConditionalOnJava	JDK某些版本条件才成立	OnJavaCondition
ConditionalOnJndi	JNDI路径下存在时条件才成立	OnJndiCondition
ConditionalOnMissingBean	ApplicationContext不存在某些bean时条件才成立	OnBeanCondition
ConditionalOnMissingClass	classpath中不存在某些class是条件才成立	OnClassCondition
ConditionalOnNotWebApplication	在非Web环境下条件才成立	OnWebApplicationCondition
ConditionalOnProperty	Environment中存在某些配置项时条件才成立	OnPropertyCondition
ConditionalOnResource	存在某些资源时条件才成立	OnResourceCondition
ConditionalOnSingleCandidate	ApplicationContext中存在且只有一个bean时条件成立	OnBeanCondition
ConditionalOnWebApplication	在Web环境下条件才成立	OnWebApplicationCondition

注意：一些如@ConditionalOnClass注解，提供了条件类型是Class或字符串两种方式，这里的字符串一般是类的全路径名（包名+类名）

实现原理

单纯的注释肯定实现不了这个功能，处理逻辑一般都在条件注解解析类中，我们来看看OnJndiCondition是如何实现的。

@Order(Ordered.HIGHEST_PRECEDENCE + 20)
class OnJavaCondition extends SpringBootCondition {

    private static final JavaVersion JVM_VERSION = JavaVersion.getJavaVersion();

    /**
	 * 根据 JavaVersion 获取当前jdk版本， JavaVersion 是SpringBoot 自己封装的
	 * JavaVersion中的实现主要是根据 jdk特有版本的一些方法来判断 jdk的版本的
	 * 比如： 判断Optional empty方法是否存在，来看这是不是 jdk8 判断 Optional stream方法是否存在，来看是不是 jdk9
	 * ConditionOutcome 包含两个属性 match：条件是否匹配的结果 ConditionMessage：条件的匹配结果的信息对象
	 * @param context the condition context
	 * @param metadata the annotation metadata
	 * @return
	 */
    @Override
    public ConditionOutcome getMatchOutcome(ConditionContext context, AnnotatedTypeMetadata metadata) {
        // 获取 ConditionalOnJava 注解的属性
        Map<String, Object> attributes = metadata.getAnnotationAttributes(ConditionalOnJava.class.getName());
        Range range = (Range) attributes.get("range");
        JavaVersion version = (JavaVersion) attributes.get("value");
        // 判断当前jdk版本是否满足条件
        return getMatchOutcome(range, JVM_VERSION, version);
    }

    protected ConditionOutcome getMatchOutcome(Range range, JavaVersion runningVersion, JavaVersion version) {
        boolean match = isWithin(runningVersion, range, version);
        String expected = String.format((range != Range.EQUAL_OR_NEWER) ? "(older than %s)" : "(%s or newer)", version);
        ConditionMessage message = ConditionMessage.forCondition(ConditionalOnJava.class, expected)
            .foundExactly(runningVersion);
        return new ConditionOutcome(match, message);
    }

    /**
	 * Determines if the {@code runningVersion} is within the specified range of versions.
	 * @param runningVersion the current version.
	 * @param range the range
	 * @param version the bounds of the range
	 * @return if this version is within the specified range
	 */
    private boolean isWithin(JavaVersion runningVersion, Range range, JavaVersion version) {
        if (range == Range.EQUAL_OR_NEWER) {
            return runningVersion.isEqualOrNewerThan(version);
        }
        if (range == Range.OLDER_THAN) {
            return runningVersion.isOlderThan(version);
        }
        throw new IllegalStateException("Unknown range " + range);
    }

}

其实我们看到上面的OnJavaCondition是继承了抽象类SpringBootCondition。

而抽象类SpringBootCondition实现了Condition接口

public abstract class SpringBootCondition implements Condition {

    private final Log logger = LogFactory.getLog(getClass());

    @Override
    public final boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        String classOrMethodName = getClassOrMethodName(metadata);
        try {
            ConditionOutcome outcome = getMatchOutcome(context, metadata);
            logOutcome(classOrMethodName, outcome);
            recordEvaluation(context, classOrMethodName, outcome);
            return outcome.isMatch();
        }
        catch (NoClassDefFoundError ex) {
            throw new IllegalStateException("Could not evaluate condition on " + classOrMethodName + " due to "
                                            + ex.getMessage() + " not found. Make sure your own configuration does not rely on "
                                            + "that class. This can also happen if you are "
                                            + "@ComponentScanning a springframework package (e.g. if you "
                                            + "put a @ComponentScan in the default package by mistake)", ex);
        }
        catch (RuntimeException ex) {
            throw new IllegalStateException("Error processing condition on " + getName(metadata), ex);
        }
    }

    private String getName(AnnotatedTypeMetadata metadata) {
        if (metadata instanceof AnnotationMetadata) {
            return ((AnnotationMetadata) metadata).getClassName();
        }
        if (metadata instanceof MethodMetadata) {
            MethodMetadata methodMetadata = (MethodMetadata) metadata;
            return methodMetadata.getDeclaringClassName() + "." + methodMetadata.getMethodName();
        }
        return metadata.toString();
    }

    private static String getClassOrMethodName(AnnotatedTypeMetadata metadata) {
        if (metadata instanceof ClassMetadata) {
            ClassMetadata classMetadata = (ClassMetadata) metadata;
            return classMetadata.getClassName();
        }
        MethodMetadata methodMetadata = (MethodMetadata) metadata;
        return methodMetadata.getDeclaringClassName() + "#" + methodMetadata.getMethodName();
    }

    protected final void logOutcome(String classOrMethodName, ConditionOutcome outcome) {
        if (this.logger.isTraceEnabled()) {
            this.logger.trace(getLogMessage(classOrMethodName, outcome));
        }
    }

    private StringBuilder getLogMessage(String classOrMethodName, ConditionOutcome outcome) {
        StringBuilder message = new StringBuilder();
        message.append("Condition ");
        message.append(ClassUtils.getShortName(getClass()));
        message.append(" on ");
        message.append(classOrMethodName);
        message.append(outcome.isMatch() ? " matched" : " did not match");
        if (StringUtils.hasLength(outcome.getMessage())) {
            message.append(" due to ");
            message.append(outcome.getMessage());
        }
        return message;
    }

    private void recordEvaluation(ConditionContext context, String classOrMethodName, ConditionOutcome outcome) {
        if (context.getBeanFactory() != null) {
            ConditionEvaluationReport.get(context.getBeanFactory()).recordConditionEvaluation(classOrMethodName, this,
                                                                                              outcome);
        }
    }

    /**
	 * Determine the outcome of the match along with suitable log output.
	 * @param context the condition context
	 * @param metadata the annotation metadata
	 * @return the condition outcome
	 */
    public abstract ConditionOutcome getMatchOutcome(ConditionContext context, AnnotatedTypeMetadata metadata);

    /**
	 * Return true if any of the specified conditions match.
	 * @param context the context
	 * @param metadata the annotation meta-data
	 * @param conditions conditions to test
	 * @return {@code true} if any condition matches.
	 */
    protected final boolean anyMatches(ConditionContext context, AnnotatedTypeMetadata metadata,
                                       Condition... conditions) {
        for (Condition condition : conditions) {
            if (matches(context, metadata, condition)) {
                return true;
            }
        }
        return false;
    }

    /**
	 * Return true if any of the specified condition matches.
	 * @param context the context
	 * @param metadata the annotation meta-data
	 * @param condition condition to test
	 * @return {@code true} if the condition matches.
	 */
    protected final boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata, Condition condition) {
        if (condition instanceof SpringBootCondition) {
            return ((SpringBootCondition) condition).getMatchOutcome(context, metadata).isMatch();
        }
        return condition.matches(context, metadata);
    }

}

@Conditional 原理解析

需要注意的是@Conditional不是springboot提供的注解，是spring提供的，所以Springboot上面的接口都是基于Spring的@Conditional接口扩展的。

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Conditional {

    /**
     * All {@link Condition} classes that must {@linkplain Condition#matches match}
     * in order for the component to be registered.
     */
    Class<? extends Condition>[] value();

}

可以看到 Conditional源码中的属性需要传递一个实现了接口Condition的类。

我们简单来使用下，我们随便定义一个自己的Condition实现类。

public class MyConditional implements Condition {

    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        return false;
    }
}

这里我们设置 matches 方法返回的是 false。

然后我们再定义一个配置类

@Component
@Conditional(MyConditional.class)
public class TestConfig {


    public TestConfig() {
        System.out.println("测试我加载了");
    }
}

我们在启动的时候可以看到TestConfig类是不会被加载，如果将matches方法改为true就会加载了

条件注解解析类(类似OnJavaCondition)到底怎么自动加载的

我们知道了条件解析类的实现类如OnJavaCondition，那它是如何被SpringBoot加载的呢？

这里我们就需要了解SpringBoot的工作加载机制了。

一般我们可以看到一些SpringBoot整合的三方jar通常会在META-INF路径看到这么一个文件：spring.factories

SpringBoot应用在启动的时候都会加@SpringBootApplication注解，而@SpringBootApplication注解内部又包含EnableAutoConfiguration注解。

EnableAutoConfiguration注解里面有导入了AutoConfigurationImportSelector.class类

在 AutoConfigurationImportSelector类中又通过Spring的SpringFactoriesLoader取加载类，即Spring的Spi机制