Spring @Autowired注入集合时如何控制顺序

//org.springframework.beans.factory.support.DefaultListableBeanFactory#resolveMultipleBeans
@Nullable
private Object resolveMultipleBeans(DependencyDescriptor descriptor, @Nullable String beanName,
		@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) {

	Class<?> type = descriptor.getDependencyType();

	if (descriptor instanceof StreamDependencyDescriptor) {
		Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
		if (autowiredBeanNames != null) {
			autowiredBeanNames.addAll(matchingBeans.keySet());
		}
		Stream<Object> stream = matchingBeans.keySet().stream()
				.map(name -> descriptor.resolveCandidate(name, type, this))
				.filter(bean -> !(bean instanceof NullBean));
		if (((StreamDependencyDescriptor) descriptor).isOrdered()) {
			stream = stream.sorted(adaptOrderComparator(matchingBeans));
		}
		return stream;
	}
	//支持数组
	else if (type.isArray()) {
		Class<?> componentType = type.getComponentType();
		ResolvableType resolvableType = descriptor.getResolvableType();
		Class<?> resolvedArrayType = resolvableType.resolve(type);
		if (resolvedArrayType != type) {
			componentType = resolvableType.getComponentType().resolve();
		}
		if (componentType == null) {
			return null;
		}
		//找到容器中匹配得实例<实例名,对象>
		Map<String, Object> matchingBeans = findAutowireCandidates(beanName, componentType,
				new MultiElementDescriptor(descriptor));
		if (matchingBeans.isEmpty()) {
			return null;
		}
		if (autowiredBeanNames != null) {
			autowiredBeanNames.addAll(matchingBeans.keySet());
		}
		//类型转换器
		TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
		//把找到的实例转换成需要的类型
		Object result = converter.convertIfNecessary(matchingBeans.values(), resolvedArrayType);
		if (result instanceof Object[]) {
			//近似看成得到一个AnnotationAwareOrderComparator外部比较器
			/**
			* 实际是得到一个OrderComparator对象 重写了compare方法 调用AnnotationAwareOrderComparator的doCompare方法
			**/
			Comparator<Object> comparator = adaptDependencyComparator(matchingBeans);
			if (comparator != null) {
				//排序**********
				Arrays.sort((Object[]) result, comparator);
			}
		}
		return result;
	}
	//支持Collection及其子类 必须为接口
	else if (Collection.class.isAssignableFrom(type) && type.isInterface()) {
		Class<?> elementType = descriptor.getResolvableType().asCollection().resolveGeneric();
		if (elementType == null) {
			return null;
		}
		//找到容器中匹配得实例<实例名,对象>
		Map<String, Object> matchingBeans = findAutowireCandidates(beanName, elementType,
				new MultiElementDescriptor(descriptor));
		if (matchingBeans.isEmpty()) {
			return null;
		}
		if (autowiredBeanNames != null) {
			autowiredBeanNames.addAll(matchingBeans.keySet());
		}
		//类型转换器
		TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
		//把找到的实例转换成需要的类型
		Object result = converter.convertIfNecessary(matchingBeans.values(), type);
		//只有是List集合 才会排序
		if (result instanceof List) {
			if (((List<?>) result).size() > 1) {
				//近似看成得到一个AnnotationAwareOrderComparator外部比较器
				/**
				* 实际是得到一个OrderComparator对象 重写了compare方法 调用AnnotationAwareOrderComparator的doCompare方法
				**/
				Comparator<Object> comparator = adaptDependencyComparator(matchingBeans);
				if (comparator != null) {
					//排序**********
					((List<?>) result).sort(comparator);
				}
			}
		}
		return result;
	}
	//支持Map类型 只能为Map
	else if (Map.class == type) {
		ResolvableType mapType = descriptor.getResolvableType().asMap();
		Class<?> keyType = mapType.resolveGeneric(0);
		if (String.class != keyType) {
			return null;
		}
		Class<?> valueType = mapType.resolveGeneric(1);
		if (valueType == null) {
			return null;
		}
		//找到容器中匹配得实例<实例名,对象>
		Map<String, Object> matchingBeans = findAutowireCandidates(beanName, valueType,
				new MultiElementDescriptor(descriptor));
		if (matchingBeans.isEmpty()) {
			return null;
		}
		if (autowiredBeanNames != null) {
			autowiredBeanNames.addAll(matchingBeans.keySet());
		}
		return matchingBeans;
	}
	else {
		return null;
	}
}

OrderComparator#doCompare
org.springframework.core.OrderComparator#getOrder(java.lang.Object, org.springframework.core.OrderComparator.OrderSourceProvider) org.springframework.core.annotation.AnnotationAwareOrderComparator#findOrder
org.springframework.core.OrderComparator#findOrder
org.springframework.core.OrderComparator#getOrder(java.lang.Object)

//org.springframework.core.OrderComparator#doCompare
private int doCompare(@Nullable Object o1, @Nullable Object o2, @Nullable OrderSourceProvider sourceProvider) {
	boolean p1 = (o1 instanceof PriorityOrdered);
	boolean p2 = (o2 instanceof PriorityOrdered);
	/**
	* PriorityOrdered接口实例和非PriorityOrdered接口实例比较PriorityOrdered实例放前面
	**/
	if (p1 && !p2) {
		return -1;
	}
	else if (p2 && !p1) {
		return 1;
	}
	
	int i1 = getOrder(o1, sourceProvider);
	int i2 = getOrder(o2, sourceProvider);
	return Integer.compare(i1, i2);
}

//org.springframework.core.OrderComparator#getOrder(java.lang.Object, org.springframework.core.OrderComparator.OrderSourceProvider)
private int getOrder(@Nullable Object obj, @Nullable OrderSourceProvider sourceProvider) {
	Integer order = null;
	if (obj != null && sourceProvider != null) {
		Object orderSource = sourceProvider.getOrderSource(obj);
		if (orderSource != null) {
			if (orderSource.getClass().isArray()) {
				for (Object source : ObjectUtils.toObjectArray(orderSource)) {
					order = findOrder(source);
					if (order != null) {
						break;
					}
				}
			}
			else {
				order = findOrder(orderSource);
			}
		}
	}
	return (order != null ? order : getOrder(obj));
}

//org.springframework.core.OrderComparator#getOrder(java.lang.Object)
protected int getOrder(@Nullable Object obj) {
	if (obj != null) {
		Integer order = findOrder(obj);
		if (order != null) {
			return order;
		}
	}
	//如果没有获取到排序值 返回返回最大排序值即放到最后
	return Ordered.LOWEST_PRECEDENCE;
}

//org.springframework.core.OrderComparator#findOrder
@Nullable
protected Integer findOrder(Object obj) {
	//得到Ordered接口中的排序值 PriorityOrdered也是Ordered子类 没实现Ordered接口接口返回null
	return (obj instanceof Ordered ? ((Ordered) obj).getOrder() : null);
}

//org.springframework.core.annotation.AnnotationAwareOrderComparator#findOrder
@Override
@Nullable
protected Integer findOrder(Object obj) {
	//调用父类Ordered接口中findOrder方法
	Integer order = super.findOrder(obj);
	//有排序值则直接返回
	if (order != null) {
		return order;
	}
	//如果为空 说明实例没有实现Ordered接口 则取类上@Order注解上获取排序值
	return findOrderFromAnnotation(obj);
}

//org.springframework.core.annotation.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);
	//获取@Order注解中的排序值 没有返回null
	Integer order = OrderUtils.getOrderFromAnnotations(element, annotations);
	if (order == null && obj instanceof DecoratingProxy) {
		return findOrderFromAnnotation(((DecoratingProxy) obj).getDecoratedClass());
	}
	return order;
}