Spring(18) @Order注解介绍、使用、底层原理

已于 2023-10-17 17:06:26 修改
阅读量8.8k 收藏 14
点赞数 4
分类专栏： Spring 文章标签： spring java 后端
于 2023-10-17 17:06:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33204709/article/details/133888330
版权

目录

一、简介

@Order：是 spring-core 包下的一个注解。@Order 作用是定义 Spring IOC 容器中 Bean 的执行顺序。

注意： Spring 的 @Order 注解或者 Ordered 接口，不决定 Bean 的加载顺序和实例化顺序，只决定 Bean 注入到 List 中的顺序。

@Order 注解接受一个整数值作为参数，数值越小表示优先级越高。当存在多个具有 @Order 注解的组件时，Spring Boot将按照数值从小到大的顺序加载它们。

需要注意的是：

  • @Order 注解只能用于标记 Spring 容器中的组件，而不适用于标记普通的类。因此，在使用 @Order 注解时，确保你的组件被正确地注册到 Spring 容器中。
  • @Order 注解只决定Bean的注入顺序，并不保证实际执行的顺序。例如：在 Web 应用中，Filter 的执行顺序并不受 @Order 注解影响。如果需要确保 Filter 按照顺序执行，可以使用 FilterRegistrationBean 来设置 Filter 的顺序。

二、List 注入使用示例

包结构如下：

在这里插入图片描述

2.1 测试接口类

IOrderTest 接口中定义了一个 handle() 方法用于测试。

IOrderTest.java

/**
 * <p> @Title IOrderTest
 * <p> @Description @Order注解测试接口
 *
 * @author ACGkaka
 * @date 2023/10/17 11:20
 */
public interface IOrderTest {

    /**
     * 处理
     */
    void handle();
}

2.2 测试接口实现类1

@Order注解测试实现类01 和 @Order注解测试实现类02 实现了 IOrderTest 接口，用于测试 @Order 的生效。

OrderTestImpl01.java

import com.demo.test.IOrderTest;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

/**
 * <p> @Title OrderTestA
 * <p> @Description @Order注解测试实现类01
 *
 * @author ACGkaka
 * @date 2023/10/17 11:18
 */
@Order(1)
@Component
public class OrderTestImpl01 implements IOrderTest {

    public OrderTestImpl01() {
        System.out.println("=== OrderTestImpl01 constructor() ==");
    }

    @Override
    public void handle() {
        System.out.println("=== OrderTestImpl01 handle() ===");
    }
}

2.3 测试接口实现类2

@Order注解测试实现类01 和 @Order注解测试实现类02 实现了 IOrderTest 接口，用于测试 @Order 的生效。

OrderTestImpl02.java

import com.demo.test.IOrderTest;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

/**
 * <p> @Title OrderTestImpl02
 * <p> @Description @Order注解测试实现类02
 *
 * @author ACGkaka
 * @date 2023/10/17 11:18
 */
@Order(2)
@Component
public class OrderTestImpl02 implements IOrderTest {

    public OrderTestImpl02() {
        System.out.println("=== OrderTestImpl02 constructor() ===");
    }

    @Override
    public void handle() {
        System.out.println("=== OrderTestImpl02 handle() ===");
    }
}

2.4 启动类（测试）

SpringbootDemoApplication.java

import com.demo.test.IOrderTest;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

import java.util.List;

@SpringBootApplication
public class SpringbootDemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootDemoApplication.class, args);
    }

    @Bean
    public CommandLineRunner commandLineRunner(List<IOrderTest> list) {
        return args -> {
            System.out.println("=== CommandLineRunner ===");
            list.forEach(IOrderTest::handle);
        };
    }
}

2.5 测试结果

场景一：
  • @Order(1) 注解修饰 OrderTestImpl01.java
  • @Order(2) 注解修饰 OrderTestImpl02.java

执行结果如下：

在这里插入图片描述

场景二：
  • @Order(1) 注解修饰 OrderTestImpl02.java
  • @Order(2) 注解修饰 OrderTestImpl01.java

执行结果如下：

在这里插入图片描述

三、CommandLineRunner 使用示例

3.1 接口实现类1

CommandLineRunner01.java

import org.springframework.boot.CommandLineRunner;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

/**
 * <p> @Title CommandLineRunner01
 * <p> @Description @Order注解测试01
 *
 * @author ACGkaka
 * @date 2023/10/17 11:20
 */
@Component
@Order(1)
public class CommandLineRunner01 implements CommandLineRunner {

    @Override
    public void run(String... args) {
        System.out.println("=== CommandLineRunner01 ===");
    }
}

3.2 接口实现类2

CommandLineRunner02.java

import org.springframework.boot.CommandLineRunner;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

/**
 * <p> @Title CommandLineRunner02
 * <p> @Description @Order注解测试02
 *
 * @author ACGkaka
 * @date 2023/10/17 11:20
 */
@Component
@Order(2)
public class CommandLineRunner02 implements CommandLineRunner {

    @Override
    public void run(String... args) {
        System.out.println("=== CommandLineRunner02 ===");
    }
}

3.3 测试结果

场景一：
  • @Order(1) 注解修饰 CommandLineRunner01.java
  • @Order(2) 注解修饰 CommandLineRunner02.java

执行结果如下：

在这里插入图片描述

场景二：
  • @Order(1) 注解修饰 CommandLineRunner02.java
  • @Order(2) 注解修饰 CommandLineRunner01.java

执行结果如下：

在这里插入图片描述

四、@Order失效场景

失效场景： 在 @Configuration 里面通过 @Bean 方式创建 Bean，在上面加 @Order 控制顺序是没有效果的。

4.1 失效代码示例

SpringbootDemoApplication.java

import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.core.annotation.Order;

@SpringBootApplication
public class SpringbootDemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootDemoApplication.class, args);
    }

    @Order(2)
    @Bean
    public CommandLineRunner commandLineRunner01() {
        return args -> System.out.println("=== commandLineRunner01 ===");
    }

    @Order(1)
    @Bean
    public CommandLineRunner commandLineRunner02() {
        return args -> System.out.println("=== commandLineRunner02 ===");
    }
}

4.2 执行结果

由下图可知，虽然我们使用 @Order 注解明确声明要先执行 commandLineRunner02，但是并没有生效。

在这里插入图片描述

4.3 失效场景补救

在 @Order 注解失效的场景下，可以通过以下方式来控制顺序：

  • 方式一： 可以通过具体实现类的方式创建 Bean，用 @Order + @Component 注解修饰。
  • 方式二： 可以通过 RegistrationBean 方式创建 Bean，用 setOrder 添加顺序。
  • 方式三： filter 可以通过 FilterRegistrationBean 创建 filter 的 Bean，用 setOrder 添加顺序。

五、@Order、@Priority底层原理

看完 @Order 注解的时候，可能会疑惑 IOC 容器时如何通过 @Order 注解来控制程序的先后顺序的，接下来我们从源码层面看下，容器是如何加载的。

先说结论：

  • @Order 底层是在 Bean 注入 IOC 容器之后执行的，所以无法控制 Bean 的加载顺序。
  • @Order 底层是通过 List.sort(Comparator) 实现的，AnnotationAwareOrderComparator 类集成 OrderComparator 类，通过获取注解的 value 值实现了比对逻辑。

5.1 平平无奇的启动类

SpringbootDemoApplication.java

@SpringBootApplication
public class SpringbootDemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootDemoApplication.class, args);
    }
}

5.2 神奇的 run() 方法

SpringApplication.run()

public ConfigurableApplicationContext run(String... args) {
    StopWatch stopWatch = new StopWatch();
    stopWatch.start();
    ConfigurableApplicationContext context = null;
    Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
    configureHeadlessProperty();
    SpringApplicationRunListeners listeners = getRunListeners(args);
    listeners.starting();
    try {
        ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
        ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
        configureIgnoreBeanInfo(environment);
        Banner printedBanner = printBanner(environment);
        context = createApplicationContext();
        exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
                new Class[] { ConfigurableApplicationContext.class }, context);
        prepareContext(context, environment, listeners, applicationArguments, printedBanner);
        refreshContext(context);
        afterRefresh(context, applicationArguments);
        stopWatch.stop();
        if (this.logStartupInfo) {
            new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
        }
        listeners.started(context);
        // #### 重点！！！调用具体的执行方法 ###
        callRunners(context, applicationArguments);
    }
    catch (Throwable ex) {
        handleRunFailure(context, ex, exceptionReporters, listeners);
        throw new IllegalStateException(ex);
    }

    try {
        listeners.running(context);
    }
    catch (Throwable ex) {
        handleRunFailure(context, ex, exceptionReporters, null);
        throw new IllegalStateException(ex);
    }
    return context;
}

5.3 开始排序的 callRunners() 方法

SpringApplication.callRunners()

private void callRunners(ApplicationContext context, ApplicationArguments args) {
    List<Object> runners = new ArrayList<>();
    runners.addAll(context.getBeansOfType(ApplicationRunner.class).values());
    runners.addAll(context.getBeansOfType(CommandLineRunner.class).values());
    // ### 重点！！！按照定义的优先级顺序排序 ###
    AnnotationAwareOrderComparator.sort(runners);
    for (Object runner : new LinkedHashSet<>(runners)) {
        if (runner instanceof ApplicationRunner) {
            callRunner((ApplicationRunner) runner, args);
        }
        if (runner instanceof CommandLineRunner) {
            callRunner((CommandLineRunner) runner, args);
        }
    }
}

5.4 排序调用图

由于剩下的实现内容调用链比较长，为了看起来更清晰直观，采用顺序图展现出来：

SpringApplication AnnotationAwareOrderComparator List OrderComparator OrderUtils run() callRunners() sort() sort() compare() doCompare() getOrder() findOrder() findOrderFromAnnotation() getOrderFromAnnotations() findOrder() SpringApplication AnnotationAwareOrderComparator List OrderComparator OrderUtils

5.5 排序的根源 findOrder() 方法

获取 @Order 注解的 value 值，来进行排序。

OrderUtils.findOrder()

@Nullable
private static Integer findOrder(MergedAnnotations annotations) {
    MergedAnnotation<Order> orderAnnotation = annotations.get(Order.class);
    if (orderAnnotation.isPresent()) {
        // ### 重点！！！获取@Order注解的value值
        return orderAnnotation.getInt(MergedAnnotation.VALUE);
    }
    MergedAnnotation<?> priorityAnnotation = annotations.get(JAVAX_PRIORITY_ANNOTATION);
    if (priorityAnnotation.isPresent()) {
        // ### 重点！！！获取@Priority注解的value值
        return priorityAnnotation.getInt(MergedAnnotation.VALUE);
    }
    return null;
}

整理完毕，完结撒花~ 🌻





参考地址：

1.浅谈Spring @Order注解的使用，https://blog.csdn.net/yaomingyang/article/details/86649072

2.深入理解Spring的@Order注解和Ordered接口，https://blog.csdn.net/zkc7441976/article/details/112548075

3.踩坑！@Order失效。。。https://blog.csdn.net/qq_34142184/article/details/126951618

深入解析Spring Boot中的`@Transactional`注解
fudaihb的博客
09-03 3353
在Spring Boot开发中，数据库事务管理是一个至关重要的环节。`@Transactional`注解是Spring框架提供的一个强大工具，能够帮助开发者方便地管理事务。本文将深入解析`@Transactional`注解的工作原理、使用方式以及注意事项，并结合实际应用场景，帮助开发者更好地掌握这一工具。
SpringIOC之@Bean 等注解的实现原理
Coder_Boy_的博客
02-06 1513
我们了解到@Component注解（及其派生注解）标注的 Class 类都会被解析成 BeanDefinition（Bean 的“前身”）然后实例化为早期Bean，再进行Bean的属性注入，最后会被初始化成完整Bean对象(如果需要代理则会创建Bean代理对象)。而@Bean注解不是@Component的派生注解，且用于标注方法，使用方法名作为BeanName，返回值作为Bean，那么Spring 中是如何解析@Bean注解的呢？
@Order in Spring Spring框架中的@Order注解
u011225581的专栏
03-18 828
@Order in Spring 1. Overview 简述 In this tutorial, we're going to learn about Spring's@Orderannotation.The@Orderannotation defines the sorting order of an annotated component or bean. 这里与大家一起学习下Spring中的@Order注解，它用来对被注解标记的bean对象进行排序 It has an o...
Spring注解--@Order--使用/实例
IT利刃出鞘的博客
10-11 4531
本文用示例介绍@Order（顺序）注解的用法。
Spring 框架中 @Order 注解：使用教程、原理剖析与应用场景
最新发布
qq_35800459的博客
04-10 1080
它通过定义优先级来影响Bean在集合中的注入顺序、切面的执行顺序以及特定扩展点（如过滤器、监听器）的排序。它通过定义优先级来影响Bean在集合中的注入顺序、切面的执行顺序以及特定扩展点（如过滤器、监听器）的排序。，可以确保Spring应用的组件按预期协同工作，提升系统的可维护性和稳定性。，可以确保Spring应用的组件按预期协同工作，提升系统的可维护性和稳定性。是Spring框架中实现组件排序的核心工具，其核心价值在于。是Spring框架中实现组件排序的核心工具，其核心价值在于。等注解解决复杂的顺序问题。
@order 注解用法
怪咖@的博客
10-26 4万+
@order注解是spring-core包下的一个注解，@Order的作用是定义Spring IOC容器中Bean的执行顺序的优先级（这里的顺序也可以理解为存放到容器中的先后顺序）。开发过程当中有时候经常会出现配置依赖关系，例如注入A对象使用了@ConditionalOnBean(B.class)，意思是要求容器当中必须存在B.class的实例的时候，才会进行注入A。这时候我们就必须保证B对象在注入A对象前进行注入。
spring中Order注解
weixin_30323961的博客
08-16 183
Spring在加载Bean的时候，有用到order注解。 PS:顾名思义，Order是顺序，此注解可操作于类、方法、字段，当作用在类时，值越小，则加载的优先级越高！ @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.TYPE, ElementType.METHOD, ElementType.FIELD}) @Docu...
浅谈Spring @Order注解的使用
热门推荐
OceanSky的专栏
01-26 19万+
注解@Order的作用是定义Spring容器加载Bean的顺序，接下来我们通过分析源码和示例测试详细的学习。 1.@Order的注解源码解读 注解类： @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.TYPE, ElementType.METHOD, ElementType.FIELD}) @Documented public @i...
Spring @Async 注解的使用以及原理（二）
灵颖桥人的博客
05-01 2549
在上一篇中《Spring @Async 注解的使用以及原理（一）》简单介绍了@Async的使用，本篇简单分析一下它的源码以及实现异步的机制。 我们用spring-context-5.0.5.RELEASE.jar包，先看一下@Async的源码： package org.springframework.scheduling.annotation; import j...
Spring异步注解@Async,@EnableAsync底层源码分析
weixin_55568616的博客
05-21 438
Spring实现Aop，首先是需要对应的Advisor，里面就包含了对应的pointCut和advice，其中pointCut就是对应的切点，advice对应了代理的逻辑（这里对于SpringAop我就不详细讲述了，如果感兴趣可在评论区留言，我出一篇关于Aop原理的文章）。那么就不需要创建了代理对象了，只需要看当前的这个对象是不是满足pointCut，也就是当前的这个对象里面的方法有没有加@Async注解，如果加了，那么就表示当前这个对象里面的方法需要代理拦截，那么就添加advisor即可。
@Transactional注解详解（事务失效+源码分析）
weixin_63267854的博客
09-22 1786
@Transactional注解使用以及注意事项，以及事务失效的种类和失效原因源码分析
深入分析Spring的@Order注解
L的博客
03-26 4707
一文让你理解Spring中的@Order注解的作用。
spring之@Order注解
花&败
06-03 1373
在Java开发中，我们经常会遇到需要对某些类或者方法进行排序的场景，比如拦截器、过滤器等。Spring框架提供了@Order注解，它可以简化这种排序操作。本文将深入解析@Order注解，同时通过实际的Java代码示例，展示其在复杂业务场景中的应用@order注解是包下的一个注解，@Order的作用是定义Spring IOC容器中Bean的执行顺序的优先级（这里的顺序也可以理解为存放到容器中的先后顺序）。开发过程当中有时候经常会出现配置依赖关系，例如注入A对象使用了，意思是要求容器当中必须存在。
Spring-@Order注解
zym_1321的博客
07-01 968
一、@Order 注解@Order的作用是定义Spring容器加载Bean的顺序 @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.TYPE, ElementType.METHOD, ElementType.FIELD}) @Documented public @interface Order { /** * 默认最低优先级 */ int value() default Ordered.LOWEST_PRECEDENCE; } 二
Spring @Order注解详解
qq_42582773的博客
03-24 1220
注解@Order的作用是定义Spring容器加载Bean的顺序。 源码 @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.TYPE, ElementType.METHOD, ElementType.FIELD}) @Documented public @interface Order { /** * The order value. * <p>Default is {@link Ordered#LOWEST_PREC.
Spring中@Order注解的使用
爱学习的软件开发的博客
10-12 1063
使用场景：例如一些后置处理器，在执行完某段程序之后，需要对结果有其他的处理，我们就可以增加实现类，利用@Order注解指定执行顺序即可，既不会影响原有代码的逻辑也可以实现其他需求。
@Order注解
qq_38087131的博客
09-21 5859
@Order的作用是定义Spring IOC容器中Bean的执行顺序的优先级， 而不是定义Bean的加载顺序， Bean的加载顺序不受@Order或Ordered接口的影响； 1.@Order的注解源码解读 @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.TYPE, ElementType.METHOD, ElementType.FIELD}) @Documented public @interface Order { /**
spring @Order注解
学亮编程手记
02-16 440
spring的@Order注解
03-30
@Order注解是Spring框架中的一个注解，用于指定Bean的加载顺序。在一个应用程序中，可能有多个Bean需要被加载，如果这些Bean之间存在相互依赖的关系，那么它们的加载顺序就非常重要。@Order注解可以让开发者指定Bean之间的加载顺序，从而确保应用程序的正确性。 @Order注解可以用在类、方法、构造函数等地方。在类上使用@Order注解时，它会指定这个类的加载顺序。在方法或构造函数上使用@Order注解时，它会指定这个方法或构造函数在Bean初始化时的执行顺序。 @Order注解的值是一个整数，表示Bean的加载顺序。值越小的Bean越先被加载。如果两个Bean的@Order注解的值相同，则它们的加载顺序是不确定的。 @Order注解的使用示例： @Service @Order(2) public class MyService1 { //... } @Service @Order(1) public class MyService2 { //... } 在上面的例子中，MyService2的@Order注解的值是1，因此它会先被加载；MyService1的@Order注解的值是2，因此它会后被加载。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

不愿放下技术的小赵

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值