@[TOC]
一、前言
针对条件装配我们讨论了如下内容：
本文我们接着讨论多个Condition的执行顺序。
二、多个Condition的排序
在博文<《SpringBoot系列十三》：图文精讲@Conditional条件装配实现原理>中，我们讨论了Condition条件装配的原理，其中介绍了条件装配如何执行？入口为：ConditionEvaluator#shouldSkip(AnnotatedTypeMetadata,ConfigurationPhase)方法，其返回值为boolean类型，方法返回true表示当前类应该被过滤掉（即不符合条件装配的规则）、否则表示当前类应该被留下（即符合条件装配的规则）。
/**
* Determine if an item should be skipped based on {@code @Conditional} annotations.
* @param metadata the meta data
* @param phase the phase of the call
* @return if the item should be skipped
*/
public boolean shouldSkip(@Nullable AnnotatedTypeMetadata metadata, @Nullable ConfigurationPhase phase) {
// 如果类没被@Conditional衍生注解标注，则直接返回FALSE，表示当前类不应该被过滤掉
if (metadata == null || !metadata.isAnnotated(Conditional.class.getName())) {
return false;
}
// 如果没设置条件装配的阶段，当类是配置类时，为 PARSE_CONFIGURATION 阶段，否则默认为 REGISTER_BEAN 阶段
if (phase == null) {
if (metadata instanceof AnnotationMetadata &&
ConfigurationClassUtils.isConfigurationCandidate((AnnotationMetadata) metadata)) {
return shouldSkip(metadata, ConfigurationPhase.PARSE_CONFIGURATION);
}
return shouldSkip(metadata, ConfigurationPhase.REGISTER_BEAN);
}
// 获取类上所有的@Conditional 子注解，返回@Conditional注解中的value值
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);
// 遍历所有的Condition，进行match
for (Condition condition : conditions) {
ConfigurationPhase requiredPhase = null;
if (condition instanceof ConfigurationCondition) {
// 获取当前Condition的执行阶段
requiredPhase = ((ConfigurationCondition) condition).getConfigurationPhase();
}
// 如果入参传入的阶段和Condition的阶段不同，直接返回FALSE。
// 如果阶段相同 或 Condition的阶段为null，再使用Condition#matches(this.context, metadata)做真正的条件装配逻辑，不符合则返回TRUE。
if ((requiredPhase == null || requiredPhase == phase) && !condition.matches(this.context, metadata)) {
return true;
}
}
return false;
}shouldSkip()方法执行的逻辑概括如下：
- 首先，如果入参类 为 null 或者 没有被@Conditional衍生注解标注，则直接返回FALSE，表示当前类不应该被过滤掉；
- 如果入参没有传条件装配的阶段；当类是配置类时，为 PARSE_CONFIGURATION 阶段，否则默认为 REGISTER_BEAN 阶段；
- 接着，获取类上所有的@Conditional 子注解，返回@Conditional注解中的value值。并对获取到的所有Condition接口的实现类进行排序。
- 遍历所有的Condition，进行匹配；如果入参传入的阶段和Condition的阶段不同，直接返回FALSE。如果阶段相同 或 Condition的阶段为null，再使用Condition#matches(this.context, metadata)做真正的条件装配逻辑，不符合则返回TRUE。
本文要讨论的多个Condition执行的顺序，就体现在AnnotationAwareOrderComparator.sort(conditions);方法。
1、对多个Condition排序
在博文《SpringBoot启动流程一》：万字debug梳理SpringBoot如何加载并处理META-INF/spring.factories文件中的信息我们有讨论过对所有自动装配类的排序，其实和这里是一样的，本文对其进行更细粒度的讨论；
进入到AnnotationAwareOrderComparator.sort(conditions)方法中；
AnnotationAwareOrderComparator.sort(conditions);sort()方法中直接使用List集合的sort()方法，但需要自定义Comparator为当前类实例AnnotationAwareOrderComparator。
再看AnnotationAwareOrderComparator的类结构：
AnnotationAwareOrderComparator继承自OrderComparator，自定义Comparator需要实现Comparator的抽象方法compare(T o1, T o2)。由于AnnotationAwareOrderComparator自身没有compare()方法，所以看其父类OrderComparator中的compare(Object o1, Object o2)方法；
@Override
public int compare(@Nullable Object o1, @Nullable Object o2) {
return doCompare(o1, o2, null);
}
private int doCompare(@Nullable Object o1, @Nullable Object o2, @Nullable OrderSourceProvider sourceProvider) {
// 判断o1是否实现PriorityOrdered接口
boolean p1 = (o1 instanceof PriorityOrdered);
// 判断o2是否实现PriorityOrdered接口
boolean p2 = (o2 instanceof PriorityOrdered);
// 如果o1实现了PriorityOrdered接口 而 o2没实现，则按 o1 在 o2之前的顺序排序（从集合中的排序来看就是交换o1 和 o2的位置）
if (p1 && !p2) {
return -1;
}
// 如果o2实现了PriorityOrdered接口 而 o1没实现，则按 o2在o1之前的顺序排序（从集合中的排序来看o2和o1的位置不变）
else if (p2 && !p1) {
return 1;
}
// 如果o2和o1都实现了 或 都没实现PriorityOrdered接口，则比对两者的顺序值。
int i1 = getOrder(o1, sourceProvider);
int i2 = getOrder(o2, sourceProvider);
return Integer.compare(i1, i2);
}方法逻辑如下：
- 本来的集合中的顺序是o2，o1；而入参参数的先后是顺序o1，o2，如果保持（o2 < o1）的顺序就返回1 或 0，交换o2和o1顺序就返回-1，0的含义是在两个元素相同时，不交换顺序（为了排序算法的稳定性，可以使用1来代替0，不要用-1来代替0）。即：想要升序，返回-1；降序返回1。详情见Arrays.sort()方法源码
- 实现PriorityOrdered接口的放前面，如果都实现了PriorityOrdered接口 或 都没实现，则根据获取到的顺序值对比排序。
因为OrderComparator#doCompare(Object o1, Object o2, OrderSourceProvider sourceProvider)方法中的入参sourceProvider为null，所以进入到getOrder()方法时，后续直接调用子类的findOrder(Object obj)方法去查找相应类的顺序值。
1）AnnotationAwareOrderComparator#findOrder()方法：
@Override
@Nullable
protected Integer findOrder(Object obj) {
Integer order = super.findOrder(obj);
if (order != null) {
return order;
}
return findOrderFromAnnotation(obj);
}先调用父类OrderComparator#findOrder()方法，如果找到顺序值直接返回，否者从类的@Order注解中取到顺序值。下面我们分别看OrderComparator#findOrder()方法和AnnotationAwareOrderComparator#findOrderFromAnnotation()方法。
1> OrderComparator#findOrder()方法：
@Nullable
protected Integer findOrder(Object obj) {
return (obj instanceof Ordered ? ((Ordered) obj).getOrder() : null);
}该方法判断obj有没有实现Ordered接口，实现Ordered接口之后，有没有重写其getOrder()方法，如果重写了，则直接从getOrder()中获取到序列值；否则返回null；
往上返，回到OrderComparator#findOrder()方法中；如果通过OrderComparator#findOrder()获取不到顺序值，即返回null，AnnotationAwareOrderComparator会再通过findOrderFromAnnotation()方法从@Order注解中获取顺序值。
2> AnnotationAwareOrderComparator#findOrderFromAnnotation()方法：
@Nullable
private Integer findOrderFromAnnotation(Object obj) {
AnnotatedElement element = (obj instanceof AnnotatedElement ? (AnnotatedElement) obj : obj.getClass());
MergedAnnotations annotations = MergedAnnotations.from(element, SearchStrategy.TYPE_HIERARCHY);
Integer order = OrderUtils.getOrderFromAnnotations(element, annotations);
if (order == null && obj instanceof DecoratingProxy) {
return findOrderFromAnnotation(((DecoratingProxy) obj).getDecoratedClass());
}
return order;
}而findOrderFromAnnotation()方法中通过OrderUtils.getOrderFromAnnotations(element, annotations);获取@Order注解中的值；
3> 进入OrderUtils#getOrderFromAnnotations()方法：
@Nullable
static Integer getOrderFromAnnotations(AnnotatedElement element, MergedAnnotations annotations) {
// 这里默认不会走
if (!(element instanceof Class)) {
return findOrder(annotations);
}
// 从缓存中获取，默认为null
Object cached = orderCache.get(element);
if (cached != null) {
return (cached instanceof Integer ? (Integer) cached : null);
}
// 查找类上是否有@Order注解，如果有，返回@Order注解中的Value值，否者返回null；
Integer result = findOrder(annotations);
orderCache.put(element, result != null ? result : NOT_ANNOTATED);
return result;
}方法逻辑：
- 首先从缓冲中获取顺序值，默认为null，即获取不到。
- 接着通过findOrder(MergedAnnotations)方法查找类上是否有@Order注解，如果没有返回null，否则返回@Order注解中的Value值；
- findOrder(MergedAnnotations)方法执行完之后，将查询到的@Order中的value值写入到缓存orderCache中。
4> 进入OrderUtils#findOrder()方法：
@Nullable
private static Integer findOrder(MergedAnnotations annotations) {
// 获取到类上的@Order注解
MergedAnnotation<Order> orderAnnotation = annotations.get(Order.class);
// 如果@Order注解存在，则返回@Order注解的Value值
if (orderAnnotation.isPresent()) {
return orderAnnotation.getInt(MergedAnnotation.VALUE);
}
// 如果@Order注解不存在，继续判断类上是否有`javax.annotation.Priority`注解
MergedAnnotation<?> priorityAnnotation = annotations.get(JAVAX_PRIORITY_ANNOTATION);
if (priorityAnnotation.isPresent()) {
return priorityAnnotation.getInt(MergedAnnotation.VALUE);
}
// 如果两个注解都没有，则返回null。
return null;
}最后返回到OrderComparator#getOrder()方法，如果通过子类AnnotationAwareOrderComparator的findOrder(Object)方法获取到的order为null，则此处将Order设置为Integer.MAX_VALUE；
<br/>
注意：如果两个对象的Order顺序值一样，则按原本在集合中的顺序先后排列。
<br/>
2）List集合中的顺序是怎样的？
private List<String[]> getConditionClasses(AnnotatedTypeMetadata metadata) {
// 获取类上所有@Conditional注解中的全部Condition
MultiValueMap<String, Object> attributes = metadata.getAllAnnotationAttributes(Conditional.class.getName(), true);
Object values = (attributes != null ? attributes.get("value") : null);
return (List<String[]>) (values != null ? values : Collections.emptyList());
}通过ConditionEvaluator#getConditionClasses(AnnotatedTypeMetadata)方法获取类上所有@Conditional注解中的全部Condition，获取次序为：类上的注解从上至下、@Conditional中的Condition集合从左到右。
下面我们用案例来例证这个结论。
3）排序总述
首先通过通过ConditionEvaluator#getConditionClasses(AnnotatedTypeMetadata)方法获取类上所有@Conditional注解中的全部Condition，获取次序为：类上的注解从上至下、@Conditional中的Condition集合从左到右。，返回一个List<Condition>集合。
然后利用List集合自身的排序，通过传入自定义的Comparator 实现排序规则。具体规则如下：
自定义Comparator需要实现compare(Object o1, Object o2)方法，AnnotationAwareOrderComparator类继承自OrderComparator，由于AnnotationAwareOrderComparator没有重写compare(Object o1, Object o2)方法，所以排序规则体现在OrderComparator的compare(Object o1, Object o2)方法中，进而进入到其doCompare(Object o1, Object o2, OrderSourceProvider sourceProvider)方法中；
- 比如：有两个需要被排序的对象o2, o1，它在原List集合中的位置顺序为o2, o1。
首先进行PriorityOrdered判断：
- 如果o1对象实现了PriorityOrdered接口，o2对象没实现，返回-1，即交换o2 和 o1的位置，将o1 放在o2前面；
- 如果o2对象实现了PriorityOrdered接口，o1对象没实现，返回1，即o2 和 o1的位置保持不变，o2 仍在o1前面；
- 否则，如果o1 和 o2对象同时实现了PriorityOrdered接口 或 都没实现，则通过
OrderComparator#getOrder()方法分别获取到 o2 和 o1对象的顺序值；
OrderComparator#getOrder(Object, OrderSourceProvider)方法中：
- 首先通过
OrderComparator#findOrder()方法查找顺序值，而AnnotationAwareOrderComparator重写了findOrder()方法，所以直接进入到AnnotationAwareOrderComparator#findOrder()方法。- 在AnnotationAwareOrderComparator#findOrder()方法中，会先调用其父类OrderComparator#findOrder()方法判断对象是否实现
Ordered接口 并 重写了getOrder()方法，有则返回getOrder()方法的返回值。- 否则，通过
findOrderFromAnnotation()方法从注解中获取顺序值（优先走orderCache缓存获取，获取不到才会进行如下逻辑，走如下逻辑获取到之后，再放去orderCache缓存中）：1> 首先从对象的@Order注解中获取其value值，有则会返回； 2> 否者从对象的`javax.annotation.Priority`注解中获取其Value值，有则返回， 3> 否者，返回null。- 回到
OrderComparator#getOrder()层面，如果findOrder()返回了具体的Integer值，则返回，否者返回Integer.MAX_VALUE。- 最后，回到
OrderComparator#doCompare()方法，返回Integer.compare(i1, i2)的结果，按顺序值的升序排序（即：顺序值小的在前面、大的在后面）。
2、Condition排序案例
从上面的讨论我们可以得知排序规则：如果Condition实现了PriorityOrdered接口，则放在最前面一部分；接着依次通过 <实现Ordered接口的getOrder()方法返回顺序值>、<从@Order注解中的Value值获取到顺序值返回> 、<从javax.annotation.Priority注解中的Value值获取到顺序值返回>，如果通过上面三种方式都没有获取到顺序值，则返回Integer.MAX_VALUE。
1）代码目录
自定义Condition参考博文：《SpringBoot系列十二》：如何自定义条件装配。
整体代码目录结构如下：
1> @ConditionalOnSystemProperty
package com.saint.autoconfigure.condition;
import org.springframework.context.annotation.Conditional;
import java.lang.annotation.*;
/**
* 系统属性名称与属性值匹配条件注解
*
* @author Saint
*/
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional({OnSystemPropertyCondition.class, MyCondition.class})
public @interface ConditionalOnSystemProperty {
/**
* 属性名
*
* @return
*/
String name();
/**
* 属性值
*
* @return
*/
String value();
}2> MyCondition
package com.saint.autoconfigure.condition;
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.PriorityOrdered;
import org.springframework.core.type.AnnotatedTypeMetadata;
/**
*
* @author Saint
*/
public class MyCondition implements Condition, PriorityOrdered {
@Override
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
return true;
}
@Override
public int getOrder() {
return 0;
}
}3> OnSystemPropertyCondition
package com.saint.autoconfigure.condition;
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;
import org.springframework.util.MultiValueMap;
import java.util.Objects;
/**
* 系统属性值与值匹配条件
*
* @author Saint
*/
public class OnSystemPropertyCondition implements Condition {
@Override
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
MultiValueMap<String, Object> attributes =
metadata.getAllAnnotationAttributes(ConditionalOnSystemProperty.class.getName());
String name = (String) attributes.getFirst("name");
String value = (String) attributes.getFirst("value");
String systemPropertyValue = System.getProperty(name);
// 比较系统属性值和方法的值
if (Objects.equals(systemPropertyValue, value)) {
System.out.printf("系统属性【名称： %s】找到匹配值：%s \n", name, value);
return true;
}
return false;
}
}4> ClassX
package com.saint;
import com.saint.autoconfigure.condition.ConditionalOnSystemProperty;
import com.saint.service.TestService;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.context.annotation.Configuration;
/**
* @author Saint
*/
@Configuration
@ConditionalOnClass(ClassY.class)
@ConditionalOnBean(TestService.class)
@ConditionalOnSystemProperty(name = "language", value = "Chinese")
public class ClassX {
public ClassX() {
System.out.println("初始化了ClassX!");
}
}5> ClassY
package com.saint;
/**
* @author Saint
*/
public class ClassY {
public ClassY() {
System.out.println("初始化了ClassY!");
}
}6> 启动类
package com.saint;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
@SpringBootApplication
//@Import(TestImportClassA.class)
public class SaintSpringbootApplication {
public static void main(String[] args) {
// 设置language属性值
System.setProperty("language", "Chinese");
ConfigurableApplicationContext context = SpringApplication.run(SaintSpringbootApplication.class, args);
// 从Spring上下文中获取beanName为message的类
String message = context.getBean("message", String.class);
System.out.println("当前message类型为：" + message);
}
}2）Condition的顺序
以上面自定义的ClassX为例：
其获取到的Condition的顺序为：OnClassCondition、OnBeanCondition、OnSystemPropertyCondition、MyCondition，这个排序的规则，正如我们上面所说：获取次序为：类上的注解从上至下、@Conditional中的Condition集合从左到右。。
再看排序后的结果：
由于只有MyCondition实现了PriorityOrdered接口，所以它在最前面，另外三个的顺序值都是一次按照顺序值大小排序。
三、总结
从自动装配类的条件装配来看，一般选择将Class Conditions类注解（@ConditionalOnClass、@ConditionalOnMissingClass） 放在最前面、Property Conditions类注解（@ConditionalOnProperty）其次、Bean Conditions类注解（@ConditionalOnBean、@ConditionalOnMissingBean）放最后。当然也还有其他种类的条件注解，一般常用的是这三种。
再结合配置类加载的两个阶段（配置类解析、注册Bean<见博文：《SpringBoot系列十三》：图文精讲@Conditional条件装配实现原理>）来看：
1> 自动装配类：
- 自动装配类在配置类解析阶段会对Bean Conditions之外的条件注解做判断；而Bean Condtions类注解需要到注册bean阶段才会生效。
2> @Component标注的类：
- 同样的@Component衍生注解标注的类 在配置类解析阶段会对Bean Conditions之外的条件注解做判断，与此同时也会注入到Spring的临时容器
beanDefinitionNames中，所以针对@Component标注的类而言，Bean Conditions可能会在配置类解析阶段生效、也可能不会生效；所以最终还是要在注册Bean阶段做一个全面的条件装配。不过一般而言，正常业务中不会有人在@Component衍生注解里搞条件装配（@Configuration除外），通常都在在自动装配类中做那么个操作。
