/** * Sort advisors based on ordering. Subclasses may choose to override this * method to customize the sorting strategy. * @param advisors the source List of Advisors * @return the sorted List of Advisors * @see org.springframework.core.Ordered * @see org.springframework.core.annotation.Order * @see org.springframework.core.annotation.AnnotationAwareOrderComparator */ protected List<Advisor> sortAdvisors(List<Advisor> advisors) { AnnotationAwareOrderComparator.sort(advisors); return advisors; }
@SuppressWarnings({ "unchecked", "rawtypes" }) private void applyInitializers(ConfigurableApplicationContext context, List<ApplicationContextInitializer<?>> initializers) { initializers.sort(new AnnotationAwareOrderComparator()); for (ApplicationContextInitializer initializer : initializers) { initializer.initialize(context); } }
@Override public int getOrder(Object obj) { return super.getOrder(obj); } }.getOrder(value);
private <T> List<Entry<String, T>> getOrderedBeansOfType( ListableBeanFactory beanFactory, Class<T> type, Set<?> excludes) { String[] names = beanFactory.getBeanNamesForType(type, true, false); Map<String, T> map = new LinkedHashMap<>(); for (String name : names) { if (!excludes.contains(name) && !ScopedProxyUtils.isScopedTarget(name)) { T bean = beanFactory.getBean(name, type); if (!excludes.contains(bean)) { map.put(name, bean); } } } List<Entry<String, T>> beans = new ArrayList<>(); beans.addAll(map.entrySet()); beans.sort((o1, o2) -> AnnotationAwareOrderComparator.INSTANCE .compare(o1.getValue(), o2.getValue())); return beans; }
@Test public void compareOrderWebSecurityConfigurerAdapterWhenLowestOrderToDefaultOrderThenGreaterThanZero() throws Exception { AnnotationAwareOrderComparator comparator = new AnnotationAwareOrderComparator(); assertThat(comparator.compare( new LowestPriorityWebSecurityConfig(), new DefaultOrderWebSecurityConfig())).isGreaterThan(0); }
@Test public void order() { assertThat(AnnotationAwareOrderComparator.INSTANCE.compare(this.filter, new SessionRepositoryFilterDefaultOrder())); }
/** * Sort the given array or List with a default AnnotationAwareOrderComparator, * if necessary. Simply skips sorting when given any other value. * <p>Optimized to skip sorting for lists with size 0 or 1, * in order to avoid unnecessary array extraction. * @param value the array or List to sort * @see java.util.Arrays#sort(Object[], java.util.Comparator) */ public static void sortIfNecessary(Object value) { if (value instanceof Object[]) { sort((Object[]) value); } else if (value instanceof List) { sort((List<?>) value); } }
@PostConstruct /* package */ void initialize() { Collections.sort(filters, new AnnotationAwareOrderComparator()); }
@Override public int compareTo(EventHandlerMethod o) { return AnnotationAwareOrderComparator.INSTANCE.compare(this.method, o.method); } }
@Override protected int getOrder(Object obj) { return super.getOrder(obj); } }
/** * Constructor with an {@link ReactiveAdapterRegistry} instance. * @param viewResolvers the view resolver to use * @param contentTypeResolver to determine the requested content type * @param registry for adaptation to reactive types */ public ViewResolutionResultHandler(List<ViewResolver> viewResolvers, RequestedContentTypeResolver contentTypeResolver, ReactiveAdapterRegistry registry) { super(contentTypeResolver, registry); this.viewResolvers.addAll(viewResolvers); AnnotationAwareOrderComparator.sort(this.viewResolvers); }
public MetadataJcrConfigurator(List<PostMetadataConfigAction> actions) { this.postConfigActions.addAll(actions); this.postConfigActions.sort(new AnnotationAwareOrderComparator()); }
@Override public int compareTo(EventHandlerMethod o) { return AnnotationAwareOrderComparator.INSTANCE.compare(this.method, o.method); }
@Override protected int getOrder(Object obj) { return super.getOrder(obj); } }
/** * Sort the given array or List with a default AnnotationAwareOrderComparator, * if necessary. Simply skips sorting when given any other value. * <p>Optimized to skip sorting for lists with size 0 or 1, * in order to avoid unnecessary array extraction. * @param value the array or List to sort * @see java.util.Arrays#sort(Object[], java.util.Comparator) */ public static void sortIfNecessary(Object value) { if (value instanceof Object[]) { sort((Object[]) value); } else if (value instanceof List) { sort((List<?>) value); } }
/******************************************************************************************************************* * * Logs the {@link RequestProcessor}s. * ******************************************************************************************************************/ @PostConstruct /* package */ void initialize() { Collections.sort(requestProcessors, new AnnotationAwareOrderComparator()); log.info(">>>> requestProcessors:"); for (final RequestProcessor requestProcessor : requestProcessors) { log.info(">>>>>>>> {}", requestProcessor); } } }
@Override public int compare(Object o1, Object o2) { return super.compare(((Map.Entry<?, ?>) o1).getValue(), ((Map.Entry<?, ?>) o2).getValue()); } }
@Override protected int getOrder(Object obj) { return super.getOrder(obj); } }
/** * Set the request interceptors that this accessor should use. * <p>The interceptors will get sorted according to their order * once the {@link ClientHttpRequestFactory} will be built. * @see #getRequestFactory() * @see AnnotationAwareOrderComparator */ public void setInterceptors(List<ClientHttpRequestInterceptor> interceptors) { // Take getInterceptors() List as-is when passed in here if (this.interceptors != interceptors) { this.interceptors.clear(); this.interceptors.addAll(interceptors); AnnotationAwareOrderComparator.sort(this.interceptors); } }
protected Collection<PredefinedDateInterval> getPredefinedDateIntervals() { List<PredefinedDateInterval> intervals = new ArrayList<>(AppBeans.getAll(PredefinedDateInterval.class).values()); intervals.sort(new AnnotationAwareOrderComparator()); return intervals; }