源码-Spring中对bean的@Order注解的处理过程

前言

基于Spring-5.2.15.RELEASE版本分析

是使用AnnotationAwareOrderComparator这个比较器类用来给bean排序，在autowired一个数组或者list的时候会对数组或list排序

DefaultListableBeanFactory

private Object resolveMultipleBeans(DependencyDescriptor descriptor, @Nullable String beanName,
      @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) {

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

   if (descriptor instanceof StreamDependencyDescriptor) {
      // ...
   }
   else if (type.isArray()) {
      // ...
      
      Object result = converter.convertIfNecessary(matchingBeans.values(), resolvedArrayType);
      if (result instanceof Object[]) {
         // 当我们autowired一个数组的时候，这里给数组排序
         Comparator<Object> comparator = adaptDependencyComparator(matchingBeans);
         if (comparator != null) {
            // 会调用比较器的compare方法
            Arrays.sort((Object[]) result, comparator);
         }
      }
      return result;
   }
   else if (Collection.class.isAssignableFrom(type) && type.isInterface()) {
      // ...
     
      Object result = converter.convertIfNecessary(matchingBeans.values(), type);
      if (result instanceof List) {
         if (((List<?>) result).size() > 1) {
         // 当我们autowired一个List的时候，这里给List排序
            Comparator<Object> comparator = adaptDependencyComparator(matchingBeans);
            if (comparator != null) {
                // 会调用比较器的compare方法
               ((List<?>) result).sort(comparator);
            }
         }
      }
      return result;
   }
   else if (Map.class == type) {
    // ...
   }
   else {
      return null;
   }
}

private Comparator<Object> adaptDependencyComparator(Map<String, ?> matchingBeans) {
   Comparator<Object> comparator = getDependencyComparator();
   if (comparator instanceof OrderComparator) {
      // 返回一个lambod表达式的比较器 
      return ((OrderComparator) comparator).withSourceProvider(
            // 将beanName和bean放入map，然后组合到一个FactoryAwareOrderSourceProvider类中
            createFactoryAwareOrderSourceProvider(matchingBeans));
   }
   else {
      return comparator;
   }
}

OrderComparator

public class OrderComparator implements Comparator<Object> {
    public static final OrderComparator INSTANCE = new OrderComparator();

    public OrderComparator() {
    }
    // 返回一个lambod表达式的比较器
    public Comparator<Object> withSourceProvider(OrderComparator.OrderSourceProvider sourceProvider) {
        // 在list.sort(comparator)时作为参数传入，最终会被调用
        return (o1, o2) -> {
            return this.doCompare(o1, o2, sourceProvider);
        };
    }
}

private int doCompare(@Nullable Object o1, @Nullable Object o2, @Nullable OrderComparator.OrderSourceProvider sourceProvider) {
    boolean p1 = o1 instanceof PriorityOrdered;
    boolean p2 = o2 instanceof PriorityOrdered;
    if (p1 && !p2) {
        return -1;
    } else if (p2 && !p1) {
        return 1;
    } else {
        int i1 = this.getOrder(o1, sourceProvider);
        int i2 = this.getOrder(o2, sourceProvider);
        return Integer.compare(i1, i2);
    }
}

private int getOrder(@Nullable Object obj, @Nullable OrderComparator.OrderSourceProvider sourceProvider) {
    Integer order = null;
    if (obj != null && sourceProvider != null) {
        // 这里返回的是bean么？TODO
        Object orderSource = sourceProvider.getOrderSource(obj);
        if (orderSource != null) {
            if (orderSource.getClass().isArray()) {
                Object[] var5 = ObjectUtils.toObjectArray(orderSource);
                int var6 = var5.length;

                for(int var7 = 0; var7 < var6; ++var7) {
                    Object source = var5[var7];
                    order = this.findOrder(source);
                    if (order != null) {
                        break;
                    }
                }
            } else {
                order = this.findOrder(orderSource);
            }
        }
    }

    return order != null ? order : this.getOrder(obj);
}