org.springframework.core.Ordered.LOWEST_PRECEDENCE

@Override
public int getOrder() {
    return Ordered.LOWEST_PRECEDENCE;
}

@Test
public void orderShouldBeLowest() {
    replacedertThat(this.resolver.getOrder()).isEqualTo(Ordered.LOWEST_PRECEDENCE);
}

public static int resolveOrder(Object object) {
    if (!object.getClreplaced().isAnnotationPresent(Order.clreplaced)) {
        return Ordered.LOWEST_PRECEDENCE;
    } else {
        return object.getClreplaced().getAnnotation(Order.clreplaced).value();
    }
}

@Override
public int getOrder() {
    // make it as late as possible
    return Ordered.LOWEST_PRECEDENCE;
}

@Test
public void order() {
    replacedertEquals(Ordered.LOWEST_PRECEDENCE, this.registry.getOrder());
}

/**
 * The default implementation returns {@link Ordered#LOWEST_PRECEDENCE},
 * thereby ensuring that custom listeners are ordered after default
 * listeners supplied by the framework. Can be overridden by subclreplacedes
 * as necessary.
 * @since 4.1
 */
@Override
public int getOrder() {
    return Ordered.LOWEST_PRECEDENCE;
}

@Test
public void asyncProcessorIsOrderedLowestPrecedenceByDefault() {
    AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
    ctx.register(AsyncConfig.clreplaced);
    ctx.refresh();
    AsyncAnnotationBeanPostProcessor bpp = ctx.getBean(AsyncAnnotationBeanPostProcessor.clreplaced);
    replacedertThat(bpp.getOrder(), is(Ordered.LOWEST_PRECEDENCE));
    ctx.close();
}

@Override
public int getOrder() {
    if (this.order != null) {
        return this.order;
    }
    Advice advice = getAdvice();
    if (advice instanceof Ordered) {
        return ((Ordered) advice).getOrder();
    }
    return Ordered.LOWEST_PRECEDENCE;
}

@Override
public int getOrder() {
    if (this.beanFactory != null && this.aspectBeanName != null && this.beanFactory.isSingleton(this.aspectBeanName) && this.beanFactory.isTypeMatch(this.aspectBeanName, Ordered.clreplaced)) {
        return ((Ordered) this.beanFactory.getBean(this.aspectBeanName)).getOrder();
    }
    return Ordered.LOWEST_PRECEDENCE;
}

/**
 * Determine a fallback order for the case that the aspect instance
 * does not express an instance-specific order through implementing
 * the {@link org.springframework.core.Ordered} interface.
 * <p>The default implementation simply returns {@code Ordered.LOWEST_PRECEDENCE}.
 * @param aspectClreplaced the aspect clreplaced
 */
protected int getOrderForAspectClreplaced(Clreplaced<?> aspectClreplaced) {
    return Ordered.LOWEST_PRECEDENCE;
}

@Override
protected int getOrderForAspectClreplaced(Clreplaced<?> aspectClreplaced) {
    return OrderUtils.getOrder(aspectClreplaced, Ordered.LOWEST_PRECEDENCE);
}

/**
 * Determine the order for this factory's target aspect, either
 * an instance-specific order expressed through implementing the
 * {@link org.springframework.core.Ordered} interface (only
 * checked for singleton beans), or an order expressed through the
 * {@link org.springframework.core.annotation.Order} annotation
 * at the clreplaced level.
 * @see org.springframework.core.Ordered
 * @see org.springframework.core.annotation.Order
 */
@Override
public int getOrder() {
    Clreplaced<?> type = this.beanFactory.getType(this.name);
    if (type != null) {
        if (Ordered.clreplaced.isreplacedignableFrom(type) && this.beanFactory.isSingleton(this.name)) {
            return ((Ordered) this.beanFactory.getBean(this.name)).getOrder();
        }
        return OrderUtils.getOrder(type, Ordered.LOWEST_PRECEDENCE);
    }
    return Ordered.LOWEST_PRECEDENCE;
}

@Test
public void orderIsLowestPrecedence() {
    replacedertThat(forwardRoutingFilter.getOrder()).isEqualTo(Ordered.LOWEST_PRECEDENCE);
}

@Test
public void order() {
    replacedertThat(this.registry.getOrder()).isEqualTo(Ordered.LOWEST_PRECEDENCE);
}

@Test
public void asyncProcessorIsOrderedLowestPrecedenceByDefault() {
    AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
    ctx.register(AsyncConfig.clreplaced);
    ctx.refresh();
    AsyncAnnotationBeanPostProcessor bpp = ctx.getBean(AsyncAnnotationBeanPostProcessor.clreplaced);
    replacedertThat(bpp.getOrder()).isEqualTo(Ordered.LOWEST_PRECEDENCE);
    ctx.close();
}

public int getOrder() {
    return Ordered.LOWEST_PRECEDENCE;
}

@Test
public void shouldHaveLowestPrecedence() {
    replacedertThat(registrar.getOrder()).isEqualTo(Ordered.LOWEST_PRECEDENCE);
}

@Override
public int getOrder() {
    // TODO Auto-generated method stub
    return Ordered.LOWEST_PRECEDENCE;
}

@Override
public int filterOrder() {
    return Ordered.LOWEST_PRECEDENCE;
}

@Bean
static Advisor traceAdvisor() {
    var pointcut = new AspectJExpressionPointcut();
    pointcut.setExpression("bean(orderManagement)");
    var advisor = new DefaultPointcutAdvisor(pointcut, interceptor());
    advisor.setOrder(Ordered.LOWEST_PRECEDENCE);
    return advisor;
}

@Override
public int getOrder() {
    /**
     * 值越大，优先级越低
     */
    return Ordered.LOWEST_PRECEDENCE;
}

private static int initOrderFromBeanType(Clreplaced<?> beanType) {
    return OrderUtils.getOrder(beanType, Ordered.LOWEST_PRECEDENCE);
}

@Test
public void asyncProcessorIsOrderedLowestPrecedenceByDefault() {
    AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
    ctx.register(AsyncConfig.clreplaced);
    ctx.refresh();
    AsyncAnnotationBeanPostProcessor bpp = ctx.getBean(AsyncAnnotationBeanPostProcessor.clreplaced);
    replacedertThat(bpp.getOrder(), is(Ordered.LOWEST_PRECEDENCE));
}

@Override
public int getOrder() {
    if (this.beanFactory.isSingleton(this.aspectBeanName) && this.beanFactory.isTypeMatch(this.aspectBeanName, Ordered.clreplaced)) {
        return ((Ordered) this.beanFactory.getBean(this.aspectBeanName)).getOrder();
    }
    return Ordered.LOWEST_PRECEDENCE;
}

/**
 * 此过滤器的优先级别最高
 *
 * @return
 */
@Override
public int getOrder() {
    return Ordered.LOWEST_PRECEDENCE;
}

@Override
public int getOrder() {
    if (isSimple()) {
        if (((SimpleNode) this).isAttribute()) {
            return 10;
        }
        return 20;
    } else if (isComplex()) {
        return 30;
    } else if (isCollection()) {
        return 40;
    }
    return Ordered.LOWEST_PRECEDENCE;
}

@Override
public int getPhase() {
    return Ordered.LOWEST_PRECEDENCE;
}

@Test
public void testOrder() {
    replacedert.replacedertEquals(Ordered.LOWEST_PRECEDENCE, instance.getOrder());
}

@Test
public void testOrder() {
    replacedert.replacedertEquals(Ordered.LOWEST_PRECEDENCE, new DubboConfigBeanDefinitionConflictProcessor().getOrder());
}

@Test
public void order() {
    replacedertEquals(Ordered.LOWEST_PRECEDENCE, this.registry.getOrder());
    this.registry.enableContentNegotiation();
    replacedertEquals(Ordered.HIGHEST_PRECEDENCE, this.registry.getOrder());
}

@Override
public int getOrder() {
    // within PriorityOrdered
    return Ordered.LOWEST_PRECEDENCE;
}

@Test
public void order() {
    replacedertThat(this.registry.getOrder()).isEqualTo(Ordered.LOWEST_PRECEDENCE);
    this.registry.enableContentNegotiation();
    replacedertThat(this.registry.getOrder()).isEqualTo(Ordered.HIGHEST_PRECEDENCE);
}

@Test
public void orderedWithLowestPrecedenceByDefaultForBeanInstance() {
    replacedertOrder(new SimpleControllerAdvice(), Ordered.LOWEST_PRECEDENCE);
}

@Test
public void orderedWithLowestPrecedenceByDefaultForBeanName() {
    replacedertOrder(SimpleControllerAdvice.clreplaced, Ordered.LOWEST_PRECEDENCE);
}

/**
 * Configures some interceptors just to log the messages.
 *
 * @param registry MessageInterceptorRegistry used to register the interceptors.
 */
@Override
public void configureMessageInterceptors(final MessageInterceptorRegistry registry) {
    registry.register(senderChannelsWith((message) -> {
        LOG.info("Sending message {}", message);
        return message;
    }, Ordered.HIGHEST_PRECEDENCE));
    registry.register(receiverChannelsWith((message) -> {
        LOG.info("Received message {}", message);
        return message;
    }, Ordered.LOWEST_PRECEDENCE));
}

@Bean
public FilterRegistrationBean<ClearMDCFilter> clearMDCFilterBean() {
    val filter = new ClearMDCFilter();
    val bean = new FilterRegistrationBean<ClearMDCFilter>(filter);
    bean.setOrder(Ordered.LOWEST_PRECEDENCE);
    return bean;
}

@Test
public void orderedInterceptors() {
    this.registry.addInterceptor(this.interceptor1).order(Ordered.LOWEST_PRECEDENCE);
    this.registry.addInterceptor(this.interceptor2).order(Ordered.HIGHEST_PRECEDENCE);
    List<Object> interceptors = this.registry.getInterceptors();
    replacedertEquals(2, interceptors.size());
    replacedertSame(this.interceptor2, interceptors.get(0));
    replacedertSame(this.interceptor1, interceptors.get(1));
}

@Test
public void orderedInterceptors() {
    this.registry.addInterceptor(this.interceptor1).order(Ordered.LOWEST_PRECEDENCE);
    this.registry.addInterceptor(this.interceptor2).order(Ordered.HIGHEST_PRECEDENCE);
    List<Object> interceptors = this.registry.getInterceptors();
    replacedertThat(interceptors.size()).isEqualTo(2);
    replacedertThat(interceptors.get(0)).isSameAs(this.interceptor2);
    replacedertThat(interceptors.get(1)).isSameAs(this.interceptor1);
}

@Test
public void orderedInterceptors() throws Exception {
    this.registry.addInterceptor(this.interceptor1).order(Ordered.LOWEST_PRECEDENCE);
    this.registry.addInterceptor(this.interceptor2).order(Ordered.HIGHEST_PRECEDENCE);
    List<Object> interceptors = this.registry.getInterceptors();
    replacedertEquals(2, interceptors.size());
    replacedertSame(this.interceptor2, interceptors.get(0));
    replacedertSame(this.interceptor1, interceptors.get(1));
}

@Override
public void addInterceptors(InterceptorRegistry registry) {
    List<String> patterns = xssProperties.getPathPatterns();
    if (patterns.isEmpty()) {
        patterns.add("/**");
    }
    XssCleanInterceptor interceptor = new XssCleanInterceptor(xssProperties);
    registry.addInterceptor(interceptor).addPathPatterns(patterns).excludePathPatterns(xssProperties.getPathExcludePatterns()).order(Ordered.LOWEST_PRECEDENCE);
}

@Bean
@ConditionalOnProperty(prefix = "spring.flyway", name = "import-data")
@DependsOn("flywayInitializer")
public FlywayDataImporter flywayDataImporter() {
    FluentConfiguration flywayConf = plugin != null ? Flyway.configure(plugin.getWrapper().getPluginClreplacedLoader()) : Flyway.configure();
    flywayConf.configuration(flyway.getConfiguration());
    flywayConf.baselineVersion("0");
    flywayConf.baselineOnMigrate(true);
    flywayConf.locations("clreplacedpath:/db_data");
    flywayConf.table("_db_data");
    Flyway importDataFlyway = new Flyway(flywayConf);
    FlywayDataImporter importer = new FlywayDataImporter(importDataFlyway);
    importer.setOrder(Ordered.LOWEST_PRECEDENCE);
    return importer;
}

@ConditionalOnProperty(name = "bsf.health.ping.enabled", havingValue = "true", matchIfMissing = true)
@Bean
@ConditionalOnWebApplication
public FilterRegistrationBean pingFilter() {
    FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
    // 优先注入
    filterRegistrationBean.setOrder(Ordered.LOWEST_PRECEDENCE);
    filterRegistrationBean.setFilter(new PingFilter());
    filterRegistrationBean.setName("bsfpingFilter");
    filterRegistrationBean.addUrlPatterns("/bsf/health/ping/");
    LogUtils.info(HealthConfiguration.clreplaced, HealthProperties.Project, "health ping注册成功,访问:" + WebUtils.getBaseUrl() + "/bsf/health/ping/");
    return filterRegistrationBean;
}

@Bean
public FilterRegistrationBean<LoginUserTrackingFilter> loginUserTrackingFilterBean() {
    val filter = new LoginUserTrackingFilter();
    filter.setExcludeUrlPatterns(Arrays.asList(WEBJARS_URL, STATIC_RESOURCES_URL));
    val bean = new FilterRegistrationBean<LoginUserTrackingFilter>(filter);
    bean.setOrder(Ordered.LOWEST_PRECEDENCE);
    return bean;
}

@Bean(name = "filterShiroFilterRegistrationBean")
protected FilterRegistrationBean<AbstractShiroFilter> filterShiroFilterRegistrationBean() throws Exception {
    FilterRegistrationBean<AbstractShiroFilter> filterRegistrationBean = new FilterRegistrationBean<AbstractShiroFilter>();
    filterRegistrationBean.setFilter((AbstractShiroFilter) shiroFilterFactoryBean().getObject());
    filterRegistrationBean.setOrder(Ordered.LOWEST_PRECEDENCE);
    return filterRegistrationBean;
}

@Test
public void mvcViewResolver() {
    ApplicationContext context = initContext(WebConfig.clreplaced);
    ViewResolverComposite resolver = context.getBean("mvcViewResolver", ViewResolverComposite.clreplaced);
    replacedertNotNull(resolver);
    replacedertEquals(1, resolver.getViewResolvers().size());
    replacedertEquals(InternalResourceViewResolver.clreplaced, resolver.getViewResolvers().get(0).getClreplaced());
    replacedertEquals(Ordered.LOWEST_PRECEDENCE, resolver.getOrder());
}

/**
 * 防XSS注入
 */
@Bean
public FilterRegistrationBean<XssFilter> xssFilterRegistration() {
    FilterRegistrationBean<XssFilter> registration = new FilterRegistrationBean<>();
    registration.setDispatcherTypes(DispatcherType.REQUEST);
    registration.setFilter(new XssFilter(xssProperties, xssUrlProperties));
    registration.addUrlPatterns("/*");
    registration.setName("xssFilter");
    registration.setOrder(Ordered.LOWEST_PRECEDENCE);
    return registration;
}

@Test
public void mvcViewResolver() {
    ApplicationContext context = initContext(WebConfig.clreplaced);
    ViewResolverComposite resolver = context.getBean("mvcViewResolver", ViewResolverComposite.clreplaced);
    replacedertThat(resolver).isNotNull();
    replacedertThat(resolver.getViewResolvers().size()).isEqualTo(1);
    replacedertThat(resolver.getViewResolvers().get(0).getClreplaced()).isEqualTo(InternalResourceViewResolver.clreplaced);
    replacedertThat(resolver.getOrder()).isEqualTo(Ordered.LOWEST_PRECEDENCE);
}

/**
 * Register the Jersey filter
 */
@Bean
public FilterRegistrationBean jerseyFilterRegistration(javax.ws.rs.core.Application eurekaJerseyApp) {
    FilterRegistrationBean bean = new FilterRegistrationBean();
    bean.setFilter(new ServletContainer(eurekaJerseyApp));
    bean.setOrder(Ordered.LOWEST_PRECEDENCE);
    bean.setUrlPatterns(Collections.singletonList(EurekaConstants.DEFAULT_PREFIX + "/*"));
    return bean;
}

@Test
public void mvcViewResolverWithExistingResolver() throws Exception {
    ApplicationContext context = initContext(WebConfig.clreplaced, ViewResolverConfig.clreplaced);
    ViewResolverComposite resolver = context.getBean("mvcViewResolver", ViewResolverComposite.clreplaced);
    replacedertNotNull(resolver);
    replacedertEquals(0, resolver.getViewResolvers().size());
    replacedertEquals(Ordered.LOWEST_PRECEDENCE, resolver.getOrder());
    replacedertNull(resolver.resolveViewName("anyViewName", Locale.ENGLISH));
}

@Test
public void mvcViewResolverWithExistingResolver() throws Exception {
    ApplicationContext context = initContext(WebConfig.clreplaced, ViewResolverConfig.clreplaced);
    ViewResolverComposite resolver = context.getBean("mvcViewResolver", ViewResolverComposite.clreplaced);
    replacedertThat(resolver).isNotNull();
    replacedertThat(resolver.getViewResolvers().size()).isEqualTo(0);
    replacedertThat(resolver.getOrder()).isEqualTo(Ordered.LOWEST_PRECEDENCE);
    replacedertThat(resolver.resolveViewName("anyViewName", Locale.ENGLISH)).isNull();
}

See More Examples