【小家Java】聊聊Java中的比较器（排序）：Comparable和Comparator；Spring中的Comparators和AnnotationAwareOrderComparator(下)

// @since 1.2.2 比较器，用于将可比较器适配比较器接口。
public class ComparableComparator<T extends Comparable<T>> implements Comparator<T> {
  // 实例 单例    这样子的话就可以当作Comparator来使用了
  @SuppressWarnings("rawtypes")
  public static final ComparableComparator INSTANCE = new ComparableComparator();
  @Override
  public int compare(T o1, T o2) {
    return o1.compareTo(o2);
  }
}

// @since 5.0  注意使用它和直接使用Comparator的区别是，它要求你比较的对象都实现了Comparable的   否则都是不适用的
public abstract class Comparators {
  // 自然排序~~~~
  // Arrays.sort(people, Comparators.comparable()); 比如你这么用，是要求peple里面元素实现了Comparable接口的  否则报错
  @SuppressWarnings("unchecked")
  public static <T> Comparator<T> comparable() {
    return ComparableComparator.INSTANCE;
  }
  // null放在最后
  @SuppressWarnings("unchecked")
  public static <T> Comparator<T> nullsLow() {
    return NullSafeComparator.NULLS_LOW;
  }
  /// null放最后  并且我们还可以提供一个自定义的比较器
  public static <T> Comparator<T> nullsLow(Comparator<T> comparator) {
    return new NullSafeComparator<>(comparator, true);
  }
  @SuppressWarnings("unchecked")
  public static <T> Comparator<T> nullsHigh() {
    return NullSafeComparator.NULLS_HIGH;
  }
  public static <T> Comparator<T> nullsHigh(Comparator<T> comparator) {
    return new NullSafeComparator<>(comparator, false);
  }
}

public class OrderComparator implements Comparator<Object> {
  ...
  public static void sort(List<?> list) {
    if (list.size() > 1) {
      list.sort(INSTANCE);
    }
  }
  public static void sort(Object[] array) {
    if (array.length > 1) {
      Arrays.sort(array, INSTANCE);
    }
  }
  public static void sortIfNecessary(Object value) {
    if (value instanceof Object[]) {
      sort((Object[]) value);
    }
    else if (value instanceof List) {
      sort((List<?>) value);
    }
  }
}

public class AnnotationAwareOrderComparator extends OrderComparator {
  /**
   * 用来检查实现Ordered接口、@Order和@Priority注解
   */
    protected Integer findOrder(Object obj) {
    // 检查常规的Ordered接口，通过子类重写的getOrder方法返回顺序值
        Integer order = super.findOrder(obj);
    if (order != null) {
      return order;
    }
    // 检查实现@Order和@Priority注解
    if (obj instanceof Class) {
            // 在类上检查@Order和@Priority注解，并找出顺序值
      return OrderUtils.getOrder((Class<?>) obj);
    } else if (obj instanceof Method) {
            // 在方法上检查@Order注解，并找出顺序值
      Order ann = AnnotationUtils.findAnnotation((Method) obj, Order.class);
      if (ann != null) {
        return ann.value();
      }
    } else if (obj instanceof AnnotatedElement) {
            // 在注解中找@Order注解，并找出顺序值
      Order ann = AnnotationUtils.getAnnotation((AnnotatedElement) obj, Order.class);
      if (ann != null) {
        return ann.value();
      }
    } else if (obj != null) {
      order = OrderUtils.getOrder(obj.getClass());
      if (order == null && obj instanceof DecoratingProxy) {
        order = OrderUtils.getOrder(((DecoratingProxy) obj).getDecoratedClass());
      }
    }
    return order;
  }
  // ==================================================================
  // 注意此处和上面的区别，它用的是自己的instance
  public static void sort(List<?> list) {
    if (list.size() > 1) {
      list.sort(INSTANCE);
    }
  }
   */
  public static void sort(Object[] array) {
    if (array.length > 1) {
      Arrays.sort(array, INSTANCE);
    }
  }
  public static void sortIfNecessary(Object value) {
    if (value instanceof Object[]) {
      sort((Object[]) value);
    }
    else if (value instanceof List) {
      sort((List<?>) value);
    }
  }
}