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