胖虎的工具箱-编程导航 胖虎的工具箱-编程导航

《SpringBoot系列十五》源码+案例分析条件装配时多个Condition执行的顺序是什么样的？可以配置优先级吗？

2年前 (2022) 程序员胖胖胖虎阿
391 0 0

文章目录

  • 一、前言
  • 二、多个Condition的排序
    • 1、对多个Condition排序
      • 1）AnnotationAwareOrderComparator#findOrder()方法：
        • 1> `OrderComparator#findOrder()`方法：
        • 2> `AnnotationAwareOrderComparator#findOrderFromAnnotation()`方法：
        • 3> 进入`OrderUtils#getOrderFromAnnotations()`方法：
        • 4> 进入`OrderUtils#findOrder()`方法：
      • 2）List集合中的顺序是怎样的？
      • 3）排序总述
    • 2、Condition排序案例
      • 1）代码目录
        • 1> @ConditionalOnSystemProperty
        • 2> MyCondition
        • 3> OnSystemPropertyCondition
        • 4> ClassX
        • 5> ClassY
        • 6> 启动类
      • 2）Condition的顺序
  • 三、总结

一、前言

针对条件装配我们讨论了如下内容：

  1. 《SpringBoot系列十一》：精讲如何使用@Conditional系列注解做条件装配
  2. 《SpringBoot系列十二》：如何自定义条件装配（由@ConditionalOnClass推导）
  3. 《SpringBoot启动流程六》：SpringBoot自动装配时做条件装配的原理（万字图文源码分析）（含@ConditionalOnClass原理）
  4. 《SpringBoot系列十三》：图文精讲@Conditional条件装配实现原理
  5. 《SpringBoot系列十四》：@ConditionalOnBean、@ConditionalOnMissingBean注解居然失效了！

本文我们接着讨论多个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()方法执行的逻辑概括如下：

  1. 首先，如果入参类 为 null 或者 没有被@Conditional衍生注解标注，则直接返回FALSE，表示当前类不应该被过滤掉；
  2. 如果入参没有传条件装配的阶段；当类是配置类时，为 PARSE_CONFIGURATION 阶段，否则默认为 REGISTER_BEAN 阶段；
  3. 接着，获取类上所有的@Conditional 子注解，返回@Conditional注解中的value值。并对获取到的所有Condition接口的实现类进行排序。
  4. 遍历所有的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。
《SpringBoot系列十五》源码+案例分析条件装配时多个Condition执行的顺序是什么样的？可以配置优先级吗？
再看AnnotationAwareOrderComparator的类结构：
《SpringBoot系列十五》源码+案例分析条件装配时多个Condition执行的顺序是什么样的？可以配置优先级吗？
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);
}

方法逻辑如下：

  1. 本来的集合中的顺序是o2，o1；而入参参数的先后是顺序o1，o2，如果保持（o2 < o1）的顺序就返回1 或 0，交换o2和o1顺序就返回-1，0的含义是在两个元素相同时，不交换顺序（为了排序算法的稳定性，可以使用1来代替0，不要用-1来代替0）。即：想要升序，返回-1；降序返回1。详情见Arrays.sort()方法源码
  2. 实现PriorityOrdered接口的放前面，如果都实现了PriorityOrdered接口 或 都没实现，则根据获取到的顺序值对比排序。

因为OrderComparator#doCompare(Object o1, Object o2, OrderSourceProvider sourceProvider)方法中的入参sourceProvider为null，所以进入到getOrder()方法时，后续直接调用子类的findOrder(Object obj)方法去查找相应类的顺序值。
《SpringBoot系列十五》源码+案例分析条件装配时多个Condition执行的顺序是什么样的？可以配置优先级吗？

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注解中的值；
《SpringBoot系列十五》源码+案例分析条件装配时多个Condition执行的顺序是什么样的？可以配置优先级吗？

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;
}

方法逻辑：

  1. 首先从缓冲中获取顺序值，默认为null，即获取不到。
  2. 接着通过findOrder(MergedAnnotations)方法查找类上是否有@Order注解，如果没有返回null，否则返回@Order注解中的Value值；
  3. 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；
《SpringBoot系列十五》源码+案例分析条件装配时多个Condition执行的顺序是什么样的？可以配置优先级吗？

注意：如果两个对象的Order顺序值一样，则按原本在集合中的顺序先后排列。

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集合从左到右。

《SpringBoot系列十五》源码+案例分析条件装配时多个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)方法中；

  1. 比如：有两个需要被排序的对象o2, o1，它在原List集合中的位置顺序为o2, o1。
  2. 首先进行PriorityOrdered判断：
    • 如果o1对象实现了PriorityOrdered接口，o2对象没实现，返回-1，即交换o2 和 o1的位置，将o1 放在o2前面；
    • 如果o2对象实现了PriorityOrdered接口，o1对象没实现，返回1，即o2 和 o1的位置保持不变，o2 仍在o1前面；
    • 否则，如果o1 和 o2对象同时实现了PriorityOrdered接口 或 都没实现，则通过OrderComparator#getOrder()方法分别获取到 o2 和 o1对象的顺序值；
  3. OrderComparator#getOrder(Object, OrderSourceProvider)方法中：
    1. 首先通过OrderComparator#findOrder()方法查找顺序值，而AnnotationAwareOrderComparator重写了findOrder()方法，所以直接进入到AnnotationAwareOrderComparator#findOrder()方法。
    2. 在AnnotationAwareOrderComparator#findOrder()方法中，会先调用其父类OrderComparator#findOrder()方法判断对象是否实现Ordered接口 并 重写了getOrder()方法，有则返回getOrder()方法的返回值。
    3. 否则，通过findOrderFromAnnotation()方法从注解中获取顺序值（优先走orderCache缓存获取，获取不到才会进行如下逻辑，走如下逻辑获取到之后，再放去orderCache缓存中）：
      1> 首先从对象的@Order注解中获取其value值，有则会返回；
      2> 否者从对象的javax.annotation.Priority注解中获取其Value值，有则返回，
      3> 否者，返回null。
  4. 回到OrderComparator#getOrder()层面，如果findOrder()返回了具体的Integer值，则返回，否者返回Integer.MAX_VALUE。
  5. 最后，回到OrderComparator#doCompare()方法，返回Integer.compare(i1, i2)的结果，按顺序值的升序排序（即：顺序值小的在前面、大的在后面）。

2、Condition排序案例

从上面的讨论我们可以得知排序规则：如果Condition实现了PriorityOrdered接口，则放在最前面一部分；接着依次通过 <实现Ordered接口的getOrder()方法返回顺序值>、<从@Order注解中的Value值获取到顺序值返回> 、<从javax.annotation.Priority注解中的Value值获取到顺序值返回>，如果通过上面三种方式都没有获取到顺序值，则返回Integer.MAX_VALUE。

1）代码目录

自定义Condition参考博文：《SpringBoot系列十二》：如何自定义条件装配。

整体代码目录结构如下：
《SpringBoot系列十五》源码+案例分析条件装配时多个Condition执行的顺序是什么样的？可以配置优先级吗？

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为例：
《SpringBoot系列十五》源码+案例分析条件装配时多个Condition执行的顺序是什么样的？可以配置优先级吗？
其获取到的Condition的顺序为：OnClassCondition、OnBeanCondition、OnSystemPropertyCondition、MyCondition，这个排序的规则，正如我们上面所说：获取次序为：类上的注解从上至下、@Conditional中的Condition集合从左到右。。

再看排序后的结果：
《SpringBoot系列十五》源码+案例分析条件装配时多个Condition执行的顺序是什么样的？可以配置优先级吗？
由于只有MyCondition实现了PriorityOrdered接口，所以它在最前面，另外三个的顺序值都是一次按照顺序值大小排序。

三、总结

从自动装配类的条件装配来看，一般选择将Class Conditions类注解（@ConditionalOnClass、@ConditionalOnMissingClass） 放在最前面、Property Conditions类注解（@ConditionalOnProperty）其次、Bean Conditions类注解（@ConditionalOnBean、@ConditionalOnMissingBean）放最后。当然也还有其他种类的条件注解，一般常用的是这三种。
《SpringBoot系列十五》源码+案例分析条件装配时多个Condition执行的顺序是什么样的？可以配置优先级吗？
再结合配置类加载的两个阶段（配置类解析、注册Bean<见博文：《SpringBoot系列十三》：图文精讲@Conditional条件装配实现原理>）来看：

1> 自动装配类：

  • 自动装配类在配置类解析阶段会对Bean Conditions之外的条件注解做判断；而Bean Condtions类注解需要到注册bean阶段才会生效。

2> @Component标注的类：

  • 同样的@Component衍生注解标注的类 在配置类解析阶段会对Bean Conditions之外的条件注解做判断，与此同时也会注入到Spring的临时容器beanDefinitionNames中，所以针对@Component标注的类而言，Bean Conditions可能会在配置类解析阶段生效、也可能不会生效；所以最终还是要在注册Bean阶段做一个全面的条件装配。不过一般而言，正常业务中不会有人在@Component衍生注解里搞条件装配（@Configuration除外），通常都在在自动装配类中做那么个操作。
版权声明：程序员胖胖胖虎阿 发表于 2022年9月12日 上午8:00。
转载请注明：《SpringBoot系列十五》源码+案例分析条件装配时多个Condition执行的顺序是什么样的？可以配置优先级吗？ | 胖虎的工具箱-编程导航

相关文章

【2022最新版】Java基础面试题总结（70道题含答案解析）
程序员胖胖胖虎阿
422
起早贪黑几个月，我写完了人生第一本书！
程序员胖胖胖虎阿
362
IntelliJ IDEA2020激活码(Intellij IDEA2022免费激活码,永久有效)
程序员胖胖胖虎阿
234
IDEA最新版激活破解教程(windows/mac idea正版 破解教程,每日更新)
程序员胖胖胖虎阿
351
【C语言】指针和数组的深入理解（第三期）
程序员胖胖胖虎阿
250
IntelliJ IDEA正版激活工具(IDEA2022.1破解插件最新有效IDEA激活码)
程序员胖胖胖虎阿
200

暂无评论

暂无评论...
致力于称为最好的程序员导航网站

友链申请 免责声明 关于我们

Copyright © 2022  胖虎的工具箱-编程导航   陇ICP备2022001249号