ObjectProvider 接口 orderedStream() 方法排序原则，PriorityOrdered接口、@order 注解在其中的优先级分析。

结论：ObjectProvider  接口的orderedStream()  方法可以获取指定类型所有实现类所组成的Stream流，并将他们按spring 定义的优先级排序排序。

排序原则：

1. 实现 PriorityOrdered 接口的类> 使用 @order > 两者都没有，则优先级按@order 最小优先级处理，即 int 最大值 。
2. 同类型中，按order 值越小，优先级越高，如PriorityOrdered 接口就按照 getOrder() 方法返回值判断，值越小，优先级越高，值相同，按类加载顺序

注意：

1，如果即实现  PriorityOrdered 接口，又使用 @order 注解，优先级也是按照 PriorityOrdered 接口优先级排序。 
2，PriorityOrdered 接口是 Ordered 接口的子接口
3，如果实现的是 Ordered 接口，不是PriorityOrdered 接口，虽然在排序判断中 会跳过 PriorityOrdered 接口判断，但获取order 优先级值时，Ordered接口返回的优先级也比 @order 注解的优先级高，在下面的源码中可以体现。

orderedStream() 源码：

涉及方法位置：
org.springframework.beans.factory.support.DefaultListableBeanFactory.BeanObjectProvider#orderedStream
@Override
            public Stream<T> orderedStream() {
                String[] beanNames = getBeanNamesForTypedStream(requiredType);//该方法最后是调用ListableBeanFactory接口 getBeanNamesForType 方法，获取指定类型所有bean名称，
                Map<String, T> matchingBeans = new LinkedHashMap<>(beanNames.length);
                for (String beanName : beanNames) {//根据bean名称获取bean 对象，并添加到map 集合中
                    Object beanInstance = getBean(beanName);
                    if (!(beanInstance instanceof NullBean)) {
                        matchingBeans.put(beanName, (T) beanInstance);
                    }
                }
                Stream<T> stream = matchingBeans.values().stream();//获取map集合value部分，并转换为stream 流
                return stream.sorted(adaptOrderComparator(matchingBeans));//调用spring 自定义排序接口，对流中
            }

spring 排序源码:
 

涉及方法位置：org.springframework.core.OrderComparator#doCompare
    private int doCompare(@Nullable Object o1, @Nullable Object o2, @Nullable OrderSourceProvider sourceProvider) {
        boolean p1 = (o1 instanceof PriorityOrdered);//判断是否实现PriorityOrdered 接口
        boolean p2 = (o2 instanceof PriorityOrdered);//判断是否实现PriorityOrdered 接口
        if (p1 && !p2) {//o1 实现，o2 没实现，直接返回-1，即 01优先级 > o2优先级
            return -1;
        }
        else if (p2 && !p1) {//o1 没实现，o2 实现，直接返回1，即 01优先级 < o2优先级
            return 1;
        }
        // 没有实现，则获取order优先级，进行比较 
        int i1 = getOrder(o1, sourceProvider);
        int i2 = getOrder(o2, sourceProvider);
        return Integer.compare(i1, i2);
    }

获取优先级源码：
 

涉及方法位置：org.springframework.core.annotation.AnnotationAwareOrderComparator#findOrder
    protected Integer findOrder(Object obj) {
        Integer order = super.findOrder(obj);// 按照 PriorityOrdered 接口实现类 获取优先级   
        if (order != null) {
            return order;
        }
        return findOrderFromAnnotation(obj);// 按照 @Order 注解获取优先级 
    }

从@Order 注解中获取优先级值源码：

涉及方法位置：org.springframework.core.annotation.OrderUtils#findOrder
@Nullable
    private static Integer findOrder(MergedAnnotations annotations) {
        MergedAnnotation<Order> orderAnnotation = annotations.get(Order.class);
        if (orderAnnotation.isPresent()) {
            return orderAnnotation.getInt(MergedAnnotation.VALUE);
        }
        MergedAnnotation<?> priorityAnnotation = annotations.get(JAVAX_PRIORITY_ANNOTATION);
        if (priorityAnnotation.isPresent()) {
            return priorityAnnotation.getInt(MergedAnnotation.VALUE);
        }
        return null;
    }

    
从PriorityOrdered 接口实现类中获取优先级源码：

涉及方法位置：org.springframework.core.OrderComparator#findOrder
    @Nullable
    protected Integer findOrder(Object obj) {
        return (obj instanceof Ordered ? ((Ordered) obj).getOrder() : null);//判断是否实现
    }