Spring 5 DefaultListableBeanFactory-- adaptOrderComparator源码分析

相关源码注释

ApplicationContext

Spring 5 DefaultResourceLoader 源码注释
Spring 5 AbstractApplicationContext 源码注释

BeanFactory

Spring 5 SimpleAliasRegistry 源码注释
Spring 5 DefaultSingletonBeanRegistry 源码注释
Spring 5 FactoryBeanRegistrySupport 源码注释
Spring 5 AbstractBeanFactory 源码注释
Spring 5 AbstractAutowireCapableBeanFactory 源码注释
Spring 5 DefaultLisbaleBeanFactory 源码注释

adaptOrderComparator(Map<String, ?> )

构建排序比较器,用于对matchingBean的所有bean对象进行优先级排序:

1. 获取该工厂的依赖关系比较器【变量 dependencyComparator】，SpringBoot默认 使用【org.springframework.core.annotation.AnnotationAwareOrderComparator】
2. 如果dependencyComparator是OrderComparator的实例,就让comparator引用该实例， 否则使用OrderComparator的默认实例【变量 comparator】
3. 创建工厂感知排序源提供者实例【FactoryAwareOrderSourceProvider】,并让comparator引用它
4. 返回比较器【comparator】

/**
	 * 构建排序比较器,用于对matchingBean的所有bean对象进行优先级排序
	 * @param matchingBeans 要排序的Bean对象Map，key=Bean名,value=Bean对象
	 * @return 排序比较器，一定是 {@link OrderComparator} 实例
	 */
	private Comparator<Object> adaptOrderComparator(Map<String, ?> matchingBeans) {
    
    
		//获取该工厂的依赖关系比较器，SpringBoot默认使用 AnnotationAwareOrderComparator
		Comparator<Object> dependencyComparator = getDependencyComparator();
		//如果dependencyComparator是OrderComparator的实例,就让comparator引用该实例，否则使用OrderComparator的默认实例
		OrderComparator comparator = (dependencyComparator instanceof OrderComparator ?
				(OrderComparator) dependencyComparator : OrderComparator.INSTANCE);
		//创建工厂感知排序源提供者实例【FactoryAwareOrderSourceProvider】,并让comparator引用它
		return comparator.withSourceProvider(createFactoryAwareOrderSourceProvider(matchingBeans));
	}

AnnotationAwareOrderComparator

AnnotationAwareOrderComparator是OrderComparator的扩展,它支持Spring 的org.springframework.core.Ordered接口以及@Oreder和@Priority注解,其中
Ordered 实例提供的Order值将覆盖静态定义的注解值(如果有)

Spring 5 OrderComparator 源码注释

createFactoryAwareOrderSourceProvider(matchingBeans)

创建工厂感知排序源提供者实例：

1. 定义一个IdentityHashMap对象,用于保存要排序的Bean对象，key为Bean对象，value为bean名【变量 instancesToBeanNames】
2. 将beans的所有key/value添加到instancesToBeanNames中
3. 新建一个工厂感知排序源提供者实例用于提供要排序对象的Order来源,用于代替obj获取优先级值 【DefaultListableBeanFactory.FactoryAwareOrderSourceProvider】；并返回出去

/**
	 * 创建工厂感知排序源提供者实例
	 * @param beans 要排序的Bean对象Map，key=Bean名,value=Bean对象
	 * @return FactoryAwareOrderSourceProvider(用于提供要排序对象的Order来源,用于代替obj获取优先级值)
	 */
	private OrderComparator.OrderSourceProvider createFactoryAwareOrderSourceProvider(Map<String, ?> beans) {
    
    
		//IdentityHashMap:允许"相同"的key保存进来,所谓的"相同"是指key的hashCode()和equal()的返回值相同.在使用get()的时候
		// 需要保证与key是同一个对象(即地址值相同)才能获取到对应的value.因为IdentityHashMap比较key值时，直接使用的是==
		//定义一个IdentityHashMap对象,用于保存要排序的Bean对象，key为Bean对象，value为bean名
		IdentityHashMap<Object, String> instancesToBeanNames = new IdentityHashMap<>();
		//将beans的所有key/value添加到instancesToBeanNames中
		beans.forEach((beanName, instance) -> instancesToBeanNames.put(instance, beanName));
		//新建一个工厂感知排序源提供者实例：提供要排序对象的Order来源,用于代替obj获取优先级值。主要Order来源:
		//  1. obj对应的Bean名的合并后RootBeanDefinition的工厂方法对象
		//  2. obj对应的Bean名的合并后RootBeanDefinition的目标类型
		return new FactoryAwareOrderSourceProvider(instancesToBeanNames);
	}

FactoryAwareOrderSourceProvider

工厂感知排序源提供者：提供obj的Order来源,用于代替obj获取优先级值。主要Order来源:

1. obj对应的Bean名的合并后RootBeanDefinition的工厂方法对象
2. obj对应的Bean名的合并后RootBeanDefinition的目标类型

/**
	 * <p>工厂感知排序源提供者：提供obj的Order来源,用于代替obj获取优先级值。主要Order来源
	 * </p>
	 * An {@link org.springframework.core.OrderComparator.OrderSourceProvider} implementation
	 * that is aware of the bean metadata of the instances to sort.
	 * <p>一个OrderComparator.OrderSourceProvider实现,该实现知道要排序的实例的Bean元数据</p>
	 * <p>Lookup for the method factory of an instance to sort, if any, and let the
	 * comparator retrieve the {@link org.springframework.core.annotation.Order}
	 * value defined on it. This essentially allows for the following construct:
	 * <p>查找要排序的实例的方法工厂(如果有),并让比较器检索在其上定义的
	 * org.springframwwork.core.annotation.Order的值.这本质上允许以下构造:</p>
	 */
	private class FactoryAwareOrderSourceProvider implements OrderComparator.OrderSourceProvider {
    
    

		/**
		 * 要排序的Bean对象Map，key=Bean名,value=Bean对象
		 */
		private final Map<Object, String> instancesToBeanNames;

		/**
		 * 新建一个FactoryAwareOrderSourceProvider实例
		 * @param instancesToBeanNames 要排序的Bean对象Map，key=Bean名,value=Bean对象
		 */
		public FactoryAwareOrderSourceProvider(Map<Object, String> instancesToBeanNames) {
    
    
			this.instancesToBeanNames = instancesToBeanNames;
		}

		/**
		 * 获取obj的Order来源,用于代替obj获取优先级值;来源主要是:
		 * <ul>
		 *  <li>obj对应的Bean名的合并后RootBeanDefinition的工厂方法对象</li>
		 *  <li>obj对应的Bean名的合并后RootBeanDefinition的目标类型</li>
		 * </ul>
		 * <ol>
		 *  <li>获取obj的bean名【变量 beanName】</li>
		 *  <li>如果beanName为null 或者 Beand定义对象映射【beanDefinitionMap】
		 *  中不存在beanName该键，返回null</li>
		 *  <li>获取beanName所对应的合并后RootBeanDefinition对象【变量 beanDefinition】</li>
		 *  <li>定义一个用于存储源对象的集合【变量 sources】</li>
		 *  <li>【<b>obj对应的Bean名的合并后RootBeanDefinition的工厂方法对象</b>】:
		 *   <ol>
		 *     <li>获取beanDefinition的工厂方法对象【变量 factoryMethod】</li>
		 *     <li>如果有factoryMethod,将factoryMethod添加到sources中</li>
		 *   </ol>
		 *  </li>
		 *  <li>【<b>obj对应的Bean名的合并后RootBeanDefinition的目标类型</b>】
		 *   <ol>
		 *    <li>获取beanDefinition的目标类型【targetType】</li>
		 *    <li>如果有目标类型且目标类型不是obj类型,将目标类型添加到sources</li>
		 *   </ol>
		 *  </li>
		 *  <li>将source装换成数组返回出去</li>
		 * </ol>
		 *
		 * @param obj the object to find an order source for
		 *            -- 查找Order来源的对象
		 * @return 源对象数组
		 */
		@Override
		@Nullable
		public Object getOrderSource(Object obj) {
    
    
			//获取obj的bean名
			String beanName = this.instancesToBeanNames.get(obj);
			//如果beanName为null 或者 Beand定义对象映射【beanDefinitionMap】中不存在beanName该键，
			if (beanName == null || !containsBeanDefinition(beanName)) {
    
    
				// 返回null
				return null;
			}
			//获取beanName所对应的合并后RootBeanDefinition对象
			RootBeanDefinition beanDefinition = getMergedLocalBeanDefinition(beanName);
			//定义一个用于存储源对象的集合
			List<Object> sources = new ArrayList<>(2);
			//获取beanDefinition的工厂方法对象
			Method factoryMethod = beanDefinition.getResolvedFactoryMethod();
			//如果有工厂方法对象
			if (factoryMethod != null) {
    
    
				//将工厂方法对象添加到sources中
				sources.add(factoryMethod);
			}
			//获取beanDefinition的目标类型
			Class<?> targetType = beanDefinition.getTargetType();
			//如果有目标类型且目标类型不是obj类型
			if (targetType != null && targetType != obj.getClass()) {
    
    
				//将目标类型添加到sources
				sources.add(targetType);
			}
			//将source装换成数组返回出去
			return sources.toArray();
		}
	}