在Spring中实现类似SpringBoot的环境检测能力

前言

​ 在Boot 你的应用一文中提到了有时候我们需要检测当前时环境是否匹配我们的运行时要求，并根据不同的环境进行个性化的适配。

​ Spring4已经引入了简单的扩展接口 @Conditional和Condition，允许大家自行去识别环境信息，但也仅此而已，并没有内置一些可以让大家在实际场景中使用的条件判定器。

​ 真正将 @Conditional和Condition发扬光大的是SpringBoot，在SpringBoot是全面采用了 AutoConfiguration和 @Conditional将自动配置的强大功能展现得淋漓尽致，内置了超过10种不同类型支持超过100种不同场景的环境检测器。比如：检测当前环境中是否存在某个Class，检测当前容器中是否定义了某个SpringBean，检测当前是否有某个配置项，配置项的值是多少等等。所有的环境检测器都在 org.springframework.boot.autoconfigure.condition 下面，大家可以去翻阅源码学习了解。

@Conditional 与 Condition 介绍

​ 前文提到在 Spring 框架中仅仅提供了这两个扩展点，并没有能运用在实际应用场景中的环境检测器，这一节我们将分析这两个接口，并实现一个简单的环境检测功能。

​ 以下是@Conditional的源码：

/**
 * Indicates that a component is only eligible for registration when all
 * {@linkplain #value() specified conditions} match.
 *
 * <p>A <em>condition</em> is any state that can be determined programmatically
 * before the bean definition is due to be registered (see {@link Condition} for details).
 *
 * <p>The {@code @Conditional} annotation may be used in any of the following ways:
 * <ul>
 * <li>as a type-level annotation on any class directly or indirectly annotated with
 * {@code @Component}, including {@link Configuration @Configuration} classes</li>
 * <li>as a meta-annotation, for the purpose of composing custom stereotype
 * annotations</li>
 * <li>as a method-level annotation on any {@link Bean @Bean} method</li>
 * </ul>
 *
 * <p>If a {@code @Configuration} class is marked with {@code @Conditional}, all of the
 * {@code @Bean} methods, {@link Import @Import} and {@link ComponentScan @ComponentScan}
 * annotations associated with that class will be subject to the conditions.
 *
 * <p>NOTE: {@code @Conditional} annotations are not inherited; any conditions from
 * superclasses or from overridden methods are not being considered.
 *
 * @author Phillip Webb
 * @since 4.0
 * @see Condition
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
public @interface Conditional {

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

}

​ 这是一个注解，从注释中我们看到这是 @Since 4.0 的，即在 Spring4 开始提供的，用来指定一系列的配置条件，当所有指定的条件都满足时，被 @Configuration 中标注的 @Bean，@Import，@ComponentScan才会生效。

​ 它接受一个Condition数组，用来标记所有的筛选条件，当所有的Condition.matches条件均返回true时即可认为该Conditional成立，从而完成环境检测。

​ Condition接口只有一个方法，源码如下：

/**
 * A single {@code condition} that must be {@linkplain #matches matched} in order
 * for a component to be registered.
 *
 * <p>Conditions are checked immediately before the bean-definition is due to be
 * registered and are free to veto registration based on any criteria that can
 * be determined at that point.
 *
 * <p>Conditions must follow the same restrictions as {@link BeanFactoryPostProcessor}
 * and take care to never interact with bean instances. For more fine-grained control
 * of conditions that interact with {@code @Configuration} beans consider the
 * {@link ConfigurationCondition} interface.
 *
 * @author Phillip Webb
 * @since 4.0
 * @see ConfigurationCondition
 * @see Conditional
 * @see ConditionContext
 */
public interface Condition {

	/**
	 * Determine if the condition matches.
	 * @param context the condition context
	 * @param metadata metadata of the {@link org.springframework.core.type.AnnotationMetadata class}
	 * or {@link org.springframework.core.type.MethodMetadata method} being checked.
	 * @return {@code true} if the condition matches and the component can be registered
	 * or {@code false} to veto registration.
	 */
	boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata);

}

​ 只需要实现matches方法并根据自己的需要完成环境检测判定即可。

​

简单用法示例

​ 下面我们用一个小的示例来演示这两个接口的使用方法，假设需求：根据不同的操作系统注册不同的 MXBean 服务

1. 实现在不同操作系统环境下的条件判定

​ 这个过程我们就简化地判定当前的os.name就可以，代码如下：

Windows 环境的判定器：

/**
 * 判定当前环境是否为 Windows 的条件
 *
 * @author <a href="mailto:huangfengjing@gmail.com">Ivan</a>
 * created on 2018/12/10.
 */
public class WindowsCondition implements Condition {

    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        return context.getEnvironment().getProperty("os.name").contains("Windows");
    }
}

Linux 环境的判定器：

/**
 * 判定当前环境是否为 Windows 的条件
 *
 * @author <a href="mailto:huangfengjing@gmail.com">Ivan</a>
 * created on 2018/12/10.
 */
public class WindowsCondition implements Condition {

    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        return context.getEnvironment().getProperty("os.name").contains("Linux");
    }
}

2. 在Bean注册时带上条件注解

​ 有了第1步的的条件判定器，那么在我们进行 @Configuraiton的Bean注册时就可以将这些条件附带上，让Spring容器根据不同的条件加载不同的Bean配置。代码如下所示：

/**
 * 根据不同的操作系统加载不同的 MXBean
 *
 * @author <a href="mailto:huangfengjing@gmail.com">Ivan</a>
 * created on 2018/12/10.
 */
@Configuration
public class ConditionalMXBeanConifg {
    
    @Bean
    @Conditional(WindowsCondition.class)
    public BaseMXBean windowsMXBeanService() {
        return new WindowsMXBean();
    }

    @Bean
    @Conditional(LinuxCondition.class)
    public BaseMXBean linuxMXBeanService() {
        return new LinuxMXBean();
    }
}

根据以上的配置，在不同的操作系统环境下，Spring会分别注册不同的 MXBean 。

高级用法示例

​ 在简单用法示例中我们可以看到，虽然实现了不同环境下的判定识别，但还是太简单了，还是比较静态的，如果我们要像SpringBoot那样动态的判定当前环境中是否存在某个类，Spring容器中是否存在某个Bean定义该怎么做呢？下面我们将演示这几种更高级的用法。

判定当前 classpath 下是否存在某个类

​ 这类条件判定器主要用在一些模板类SDK中，根据当前用户是否依赖了某些类来确定是否要定义相应的模板、工具、服务等。如同应用分发 base-boot-starter 的使用说明中对于 OA 权限平台的判定一样，当用户没有添加OA权限平台这个MAVEN依赖时，应用仍然能智能判定而不是抛出 NoClassDefFoundError。

1. 首先定义一个自定义的注解，供用户使用判定

   /**
    * 是否存在某个类的条件判定注解
    *
    * @author <a href="mailto:huangfengjing@gmail.com">Ivan</a>
    * Time: 2018/12/7 : 19:34
    */
   @Target({ElementType.TYPE, ElementType.METHOD})
   @Retention(RetentionPolicy.RUNTIME)
   @Documented
   @Conditional(OnClassCondition.class)
   public @interface ConditionalOnClass {
   
       /**
        * 必须存在的类
        *
        * @return 必须存在的类
        */
       Class<?>[] value() default {};
   
       /**
        * 必须存在的类名
        *
        * @return 必须存在的类名
        */
       String[] name() default {};
   
   }

当用户在注解某个@Bean进，可以添加这个注解来进行判定。这个注解本身还依赖另外一个注解@Conditional(OnClassCondition.class)，表示扫Spring容器在扫描到某个类定义被标注了@ConditionalOnClass时，会执行里面的OnClassCondition来完成条件判定。

2. 定义真正的条件判定器 OnClassCondition

   /**
    * 判定某个类是否存在的条件
    *
    * @author <a href="mailto:huangfengjing@gmail.com">Ivan</a>
    * Time: 2018/12/7 : 19:29
    */
   public class OnClassCondition extends BaseCondition implements Condition {
   
       @Override
       public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
   
           MultiValueMap<String, Object> attributes = metadata
                   .getAllAnnotationAttributes(ConditionalOnClass.class.getName(), true);
           if (null == attributes) {
               return false;
           }
           List<String> candidates = new ArrayList<>();
           addAll(candidates, attributes.get("value"));
           addAll(candidates, attributes.get("name"));
   
           for (String candidate : candidates) {
               if (!ClassUtils.isPresent(candidate, null)) {
                   return false;
               }
           }
   
           return true;
       }
   }

   其实也很简单，就是从注解中获取当前用户要判定是否存在的Class（支持类定义，和全类名），然后在当前 classpath 下去查找这个类是否存在即完成判定过程。

3. 使用自定义的注解

   使用起来就比较简单了，加上注解即可，如下所示：

   @ConditionalOnClass(SSOFilter.class)
   @Configuration
   public class SsoAutoConfiguration {...｝

判定当前Spring容器中是否定义了某个Bean

​ 这类判定主要用在如下的场景：某些组件需要依赖某个SpringBean，如果当前Spring容器中不存在这个Bean，那么就要添加一个，如果存在就不能再添加，防止产生NoSuchBeanDefinitionException或者NoUniqueBeanDefinitionException异常。

​ 其实现过程其实和@ConditionalOnClass大同小异，最主要的区别在于Condition.matches方法一个是判定类是否存在，一个是判定Bean是否存在。代码如下：

/**
 * 判定某个 bean 是否存在的条件
 *
 * @author <a href="mailto:huangfengjing@gmail.com">Ivan</a>
 * Time: 2018/12/7 : 19:29
 */
@Slf4j
public class OnBeanCondition extends BaseCondition implements Condition {

    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {

        MultiValueMap<String, Object> conditionOnBeanAttrs = metadata
                .getAllAnnotationAttributes(ConditionalOnBean.class.getName(), true);
        if (null != conditionOnBeanAttrs) {
            return matchBean(context, conditionOnBeanAttrs, metadata);
        }

        MultiValueMap<String, Object> conditionOnMissingBeanAttrs = metadata
                .getAllAnnotationAttributes(ConditionalOnMissingBean.class.getName(), true);
        if (conditionOnMissingBeanAttrs != null) {
            return matchMissingBean(context, conditionOnMissingBeanAttrs, metadata);
        }
        return false;
    }

    private boolean matchBean(ConditionContext context, MultiValueMap<String, Object> attributes, AnnotatedTypeMetadata metadata) {
        if (attributes == null) {
            return false;
        }

        BeanFactory beanFactory = context.getBeanFactory();

        List<String> classNameCandidates = new ArrayList<>();
        addAll(classNameCandidates, attributes.get("value"));
        try {
            for (String clsName : classNameCandidates) {
                beanFactory.getBean(Class.forName(clsName));
            }
        } catch (Exception e) {
            log.debug("没有找到需要的 Bean: {}", e.getMessage());
            return false;
        }

        List<String> beanNameCandidates = new ArrayList<>();
        addAll(beanNameCandidates, attributes.get("name"));
        for (String beanName : beanNameCandidates) {
            if (!beanFactory.containsBean(beanName)) {
                log.debug("没有找到需要的 bean: {}", beanName);
                return false;
            }
        }

        return true;
    }

    private boolean matchMissingBean(ConditionContext context, MultiValueMap<String, Object> attributes, AnnotatedTypeMetadata metadata) {
        // ... 和 matchBean 相反，判定是否不存在某个 Bean，省略
    }
}

总结

​ 本文主要讲解了如何通过@Conditional和Condition实现环境检测的能力，并从源码及示例两方面演示了从简单到高级的用法支持。其它的诸如判定当时配置项中的值以及资源判定的实现原理都差不多，感兴趣的可以翻阅应用分发 base-boot-starter 的源码。

当然，这里高级应用里面的判定规则并不如SpringBoot中的功能强大，但应付常规的应用已经足够，当不满足需求时，通过本文的讲解读者应该也已经了解到了如何自行扩展，或者联系我协助。