精华内容
下载资源
问答
  • @order注解 解答

    2021-08-31 14:19:37
    注解@Order或者接口Ordered的作用是定义Spring IOC容器中Bean的执行顺序的优先级,而不是定义Bean的加载顺序,Bean的加载顺序不受@Order或Ordered接口的影响; 注解源码解读: @Retention(RetentionPolicy....

    注解@Order或者接口Ordered的作用是定义Spring IOC容器中Bean的执行顺序的优先级,而不是定义Bean的加载顺序,Bean的加载顺序不受@Order或Ordered接口的影响;

    注解源码解读:

    @Retention(RetentionPolicy.RUNTIME)
    @Target({ElementType.TYPE, ElementType.METHOD, ElementType.FIELD})
    @Documented
    public @interface Order {
    
    	/**
    	 * 默认是最低优先级,值越小优先级越高
    	 */
    	int value() default Ordered.LOWEST_PRECEDENCE;
    
    }

    示例代码:

    package com.runlion.tms.admin.constant;
    
    public class AService {
    
    }
    package com.runlion.tms.admin.constant;
    
    public class BService {
    
    }
    
    
    

     

    package com.runlion.tms.admin.constant;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.core.annotation.Order;
    
    @Configuration
    @Order(2)
    public class AConfig {
      @Bean
      public AService AService() {
        System.out.println("AService 加载了");
        return new AService();
      }
    
    }
    package com.runlion.tms.admin.constant;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.core.annotation.Order;
    
    @Configuration
    @Order(1)
    public class BConfig {
      @Bean
      public BService bService() {
        System.out.println("BService 加载了");
        return new BService();
      }
    }
    package com.runlion.tms.admin.constant;
    
    import org.springframework.context.annotation.AnnotationConfigApplicationContext;
    
    public class OrderMain {
      public static void main(String[] args) {
        AnnotationConfigApplicationContext context =
            new AnnotationConfigApplicationContext("com.runlion.tms.admin.constant");
      }
    }

    展开全文
  • @Order注解使用

    2021-02-04 01:43:45
    注解@Order或者接口Ordered的作用是定义Spring IOC容器中Bean的执行顺序的优先级,而不是定义Bean的加载顺序,Bean的加载顺序不受@Order或Ordered接口的影响 1.@Order注解源码解读 @Retention(RetentionPolicy....

    注解@Order或者接口Ordered的作用是定义Spring IOC容器中Bean的执行顺序的优先级,而不是定义Bean的加载顺序,Bean的加载顺序不受@Order或Ordered接口的影响

    1.@Order的注解源码解读

    @Retention(RetentionPolicy.RUNTIME)
    @Target({ElementType.TYPE, ElementType.METHOD, ElementType.FIELD})
    @Documented
    public @interface Order {
    
    	/**
    	 * 默认是最低优先级,值越小优先级越高
    	 */
    	int value() default Ordered.LOWEST_PRECEDENCE;
    
    }
    
    • 注解可以作用在类(接口、枚举)、方法、字段声明(包括枚举常量);
    • 注解有一个int类型的参数,可以不传,默认是最低优先级;
    • 通过常量类的值我们可以推测参数值越小优先级越高;

    2.Ordered接口类

    package org.springframework.core;
    
    public interface Ordered {
        int HIGHEST_PRECEDENCE = -2147483648;
        int LOWEST_PRECEDENCE = 2147483647;
    
        int getOrder();
    }
    

    3.创建BlackPersion、YellowPersion类,这两个类都实现CommandLineRunner

    实现CommandLineRunner接口的类会在Spring IOC容器加载完毕后执行,适合预加载类及其它资源;也可以使用ApplicationRunner,使用方法及效果是一样的

    package com.yaomy.common.order;
    
    import org.springframework.boot.CommandLineRunner;
    import org.springframework.core.annotation.Order;
    import org.springframework.stereotype.Component;
    
    /**
     * @Description: Description
     * @ProjectName: spring-parent
     * @Version: 1.0
     */
    @Component
    @Order(1)
    public class BlackPersion implements CommandLineRunner {
        @Override
        public void run(String... args) throws Exception {
            System.out.println("----BlackPersion----");
        }
    }
    
    package com.yaomy.common.order;
    
    import org.springframework.boot.CommandLineRunner;
    import org.springframework.core.annotation.Order;
    import org.springframework.stereotype.Component;
    
    /**
     * @Description: Description
     * @ProjectName: spring-parent
     * @Version: 1.0
     */
    @Component
    @Order(0)
    public class YellowPersion implements CommandLineRunner {
        @Override
        public void run(String... args) throws Exception {
            System.out.println("----YellowPersion----");
        }
    }
    

    4.启动应用程序打印出结果

    ----YellowPersion----
    ----BlackPersion----
    

    5.到这里可能会疑惑IOC容器是如何根据优先级值来先后执行程序的,那接下来看容器是如何加载component的

    • 看如下的启动main方法
    @SpringBootApplication
    public class CommonBootStrap {
        public static void main(String[] args) {
            SpringApplication.run(CommonBootStrap.class, args);
        }
    }
    

    这个不用过多的解释,进入run方法…

        public ConfigurableApplicationContext run(String... args) {
            StopWatch stopWatch = new StopWatch();
            stopWatch.start();
            ConfigurableApplicationContext context = null;
            Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList();
            this.configureHeadlessProperty();
            SpringApplicationRunListeners listeners = this.getRunListeners(args);
            listeners.starting();
    
            Collection exceptionReporters;
            try {
                ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
                ConfigurableEnvironment environment = this.prepareEnvironment(listeners, applicationArguments);
                this.configureIgnoreBeanInfo(environment);
                Banner printedBanner = this.printBanner(environment);
                context = this.createApplicationContext();
                exceptionReporters = this.getSpringFactoriesInstances(SpringBootExceptionReporter.class, new Class[]{ConfigurableApplicationContext.class}, context);
                this.prepareContext(context, environment, listeners, applicationArguments, printedBanner);
                this.refreshContext(context);
                this.afterRefresh(context, applicationArguments);
                stopWatch.stop();
                if (this.logStartupInfo) {
                    (new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), stopWatch);
                }
    
                listeners.started(context);
                //这里是重点,调用具体的执行方法
                this.callRunners(context, applicationArguments);
            } catch (Throwable var10) {
                this.handleRunFailure(context, var10, exceptionReporters, listeners);
                throw new IllegalStateException(var10);
            }
    
            try {
                listeners.running(context);
                return context;
            } catch (Throwable var9) {
                this.handleRunFailure(context, var9, exceptionReporters, (SpringApplicationRunListeners)null);
                throw new IllegalStateException(var9);
            }
        }
       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);
            Iterator var4 = (new LinkedHashSet(runners)).iterator();
            //循环调用具体方法
            while(var4.hasNext()) {
                Object runner = var4.next();
                if (runner instanceof ApplicationRunner) {
                    this.callRunner((ApplicationRunner)runner, args);
                }
    
                if (runner instanceof CommandLineRunner) {
                    this.callRunner((CommandLineRunner)runner, args);
                }
            }
    
        }
    
        private void callRunner(ApplicationRunner runner, ApplicationArguments args) {
            try {
                //执行方法
                runner.run(args);
            } catch (Exception var4) {
                throw new IllegalStateException("Failed to execute ApplicationRunner", var4);
            }
        }
    
        private void callRunner(CommandLineRunner runner, ApplicationArguments args) {
            try {
                //执行方法
                runner.run(args.getSourceArgs());
            } catch (Exception var4) {
                throw new IllegalStateException("Failed to execute CommandLineRunner", var4);
            }
        }
    

    到这里优先级类的示例及其执行原理都分析完毕;不过还是要强调下@Order、Ordered不影响类的加载顺序而是影响Bean加载如IOC容器之后执行的顺序(优先级);

    转载自https://blog.csdn.net/yaomingyang/article/details/86649072

    GitHub源码:https://github.com/mingyang66/spring-parent

    展开全文
  • 2、Spring在加载Bean的时候,有用到order注解。 3、通过@Order指定执行顺序,值越小,越先执行 4、@Order注解常用于定义的AOP先于事物执行 1.@Order的注解源码解读 注解类: @Retention(RetentionPolicy.RUNTIME) @...

    @Order

    1、Spring 4.2 利用@Order控制配置类的加载顺序,

    2、Spring在加载Bean的时候,有用到order注解。

    3、通过@Order指定执行顺序,值越小,越先执行

    4、@Order注解常用于定义的AOP先于事物执行

    1.@Order的注解源码解读
    注解类:

    @Retention(RetentionPolicy.RUNTIME)
    @Target({ElementType.TYPE, ElementType.METHOD, ElementType.FIELD})
    @Documented
    public @interface Order {
    
        /**
         * 默认是最低优先级
         */
        int value() default Ordered.LOWEST_PRECEDENCE;
    
    }
    

    常量类:

    public interface Ordered {
    
        /**
         * 最高优先级的常量值
         * @see java.lang.Integer#MIN_VALUE
         */
        int HIGHEST_PRECEDENCE = Integer.MIN_VALUE;
    
        /**
         * 最低优先级的常量值
         * @see java.lang.Integer#MAX_VALUE
         */
        int LOWEST_PRECEDENCE = Integer.MAX_VALUE;
    
        int getOrder();
    
    }
    

    注解可以作用在类、方法、字段声明(包括枚举常量);
    注解有一个int类型的参数,可以不传,默认是最低优先级;
    通过常量类的值我们可以推测参数值越小优先级越高;

    2.创建三个POJO类Cat、Cat2、Cat3,使用@Component注解将其交给Spring容器自动加载,每个类分别加上@Order(1)、@Order(2)、@Order(3)注解,下面只列出Cat的代码其它的类似

    package com.eureka.client.co;
    
    import org.springframework.core.annotation.Order;
    import org.springframework.stereotype.Component;
    
    @Component
    @Order(1)
    public class Cat {
        
        private String catName;
        private int age;
        
        public Cat() {
            System.out.println("Order:1");
        }
        public String getCatName() {
            return catName;
        }
        public void setCatName(String catName) {
            this.catName = catName;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
    }
    

    3.启动应用程序主类

    package com.eureka.client;
    
    import java.util.Map;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    import com.eureka.client.co.Person;
    
    @SpringBootApplication
    public class EurekaClientApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(EurekaClientApplication.class, args);
    
        }
    }
    

    输出结果是:

    Order:1
    Order:2
    Order:3
    
    展开全文
  • 前言Spring的@Order注解或者Ordered接口大家都知道是控制顺序的,那么它们到底是控制什么顺序的?是控制Bean的注入顺序,还是Bean的实例化顺序,还是Bean的执行顺序呢?那么我们先直接给出结论再来验证结论。结论:...

    前言

    Spring的@Order注解或者Ordered接口大家都知道是控制顺序的,那么它们到底是控制什么顺序的?是控制Bean的注入顺序,还是Bean的实例化顺序,还是Bean的执行顺序呢?那么我们先直接给出结论再来验证结论。

    结论:Spring的@Order注解或者Ordered接口,不决定Bean的加载顺序和实例化顺序,只决定Bean的执行顺序。

    实例论证:@Order不决定Bean的加载和实例化顺序

    步骤一:创建DemoService接口和三个实现类,分别打上注解@Order(0)-DemoServiceImpl01、@Order(1)-DemoServiceImpl02、@Order(2)-DemoServiceImpl03,观察实例化顺序。

    @Service

    @Order(0)

    public class DemoServiceImpl01 implements DemoService {

    public DemoServiceImpl01() {

    System.out.println("DemoServiceImpl01被实例化了");

    }

    }

    @Service

    @Order(1)

    public class DemoServiceImpl02 implements DemoService {

    public DemoServiceImpl02() {

    System.out.println("DemoServiceImpl02被实例化了");

    }

    }

    @Service

    @Order(2)

    public class DemoServiceImpl03 implements DemoService {

    public DemoServiceImpl03() {

    System.out.println("DemoServiceImpl03被实例化了");

    }

    }

    // 运行结果如下

    DemoServiceImpl01被实例化了

    DemoServiceImpl02被实例化了

    DemoServiceImpl03被实例化了

    步骤二:改变DemoService接口三个实现类的注解序值,@Order(2)-DemoServiceImpl01、@Order(1)-DemoServiceImpl02、@Order(0)-DemoServiceImpl03,观察实例化顺序

    @Service

    @Order(2)

    public class DemoServiceImpl01 implements DemoService {

    public DemoServiceImpl01() {

    System.out.println("DemoServiceImpl01被实例化了");

    }

    }

    @Service

    @Order(1)

    public class DemoServiceImpl02 implements DemoService {

    public DemoServiceImpl02() {

    System.out.println("DemoServiceImpl02被实例化了");

    }

    }

    @Service

    @Order(0)

    public class DemoServiceImpl03 implements DemoService {

    public DemoServiceImpl03() {

    System.out.println("DemoServiceImpl03被实例化了");

    }

    }

    // 运行结果如下

    DemoServiceImpl01被实例化了

    DemoServiceImpl02被实例化了

    DemoServiceImpl03被实例化了

    结果:当改变DemoService接口的三个实现类注解序值时,类的加载和实例化顺序根本没有变化,即@Order注解不决定Bean的加载和实例化顺序。

    实例论证:@Order决定Bean的执行顺序

    步骤一:创建RunServiceImpl类,并通过构造函数依赖注入DemoService的三个实现类,且循序依次执行三个实现类方法,观察Bean的执行顺序。

    @Service

    public class RunServiceImpl implements RunService {

    public RunServiceImpl(List demoServices) {

    demoServices.forEach(demoService -> demoService.say());

    }

    }

    @Service

    @Order(0)

    public class DemoServiceImpl01 implements DemoService {

    public DemoServiceImpl01() {

    System.out.println("DemoServiceImpl01被实例化了");

    }

    @Override

    public void say() {

    System.out.println("DemoServiceImpl01被执行了");

    }

    }

    @Service

    @Order(1)

    public class DemoServiceImpl02 implements DemoService {

    public DemoServiceImpl02() {

    System.out.println("DemoServiceImpl02被实例化了");

    }

    @Override

    public void say() {

    System.out.println("DemoServiceImpl02被执行了");

    }

    }

    @Service

    @Order(2)

    public class DemoServiceImpl03 implements DemoService {

    public DemoServiceImpl03() {

    System.out.println("DemoServiceImpl03被实例化了");

    }

    @Override

    public void say() {

    System.out.println("DemoServiceImpl03被执行了");

    }

    }

    // 运行结果如下

    DemoServiceImpl01被执行了

    DemoServiceImpl02被执行了

    DemoServiceImpl03被执行了

    步骤二:改变DemoService接口三个实现类的注解序值,@Order(2)-DemoServiceImpl01、@Order(1)-DemoServiceImpl02、@Order(0)-DemoServiceImpl03,观察Bean的执行顺序。

    @Service

    public class RunServiceImpl implements RunService {

    public RunServiceImpl(List demoServices) {

    demoServices.forEach(demoService -> demoService.say());

    }

    }

    @Service

    @Order(2)

    public class DemoServiceImpl01 implements DemoService {

    public DemoServiceImpl01() {

    System.out.println("DemoServiceImpl01被实例化了");

    }

    @Override

    public void say() {

    System.out.println("DemoServiceImpl01被执行了");

    }

    }

    @Service

    @Order(1)

    public class DemoServiceImpl02 implements DemoService {

    public DemoServiceImpl02() {

    System.out.println("DemoServiceImpl02被实例化了");

    }

    @Override

    public void say() {

    System.out.println("DemoServiceImpl02被执行了");

    }

    }

    @Service

    @Order(0)

    public class DemoServiceImpl03 implements DemoService {

    public DemoServiceImpl03() {

    System.out.println("DemoServiceImpl03被实例化了");

    }

    @Override

    public void say() {

    System.out.println("DemoServiceImpl03被执行了");

    }

    }

    // 运行结果如下

    DemoServiceImpl03被执行了

    DemoServiceImpl02被执行了

    DemoServiceImpl01被执行了

    结果:当改变DemoService接口的三个实现类注解序值时,类的执行顺序也随之发生变化,即@Order决定Bean的执行顺序。

    @Order注解或Ordered接口决定Bean的执行顺序原理分析

    通过上面实例论证,大家应该清楚@Order注解或Ordered接口只是决定了Bean的执行顺序,那么Spring是如何在依赖注入时完成根据@Order注解或Ordered接口控制Bean执行顺序?

    原理分析:

    当通过构造函数或者方法参数注入进某个List时,Spring的DefaultListableBeanFactory类会在注入时调用AnnotationAwareOrderComparator.sort(listA)帮我们去完成根据@Order或者Ordered接口序值排序。

    备注:

    AnnotationAwareOrderComparator是OrderComparator的子类,而OrderComparator实现比较器Comparator接口,AnnotationAwareOrderComparator.sort(listA)会调用父类sort方法,会根据@Order或者Ordered接口设置的int序值重写sort方法进行排序,值越小优先级越高。

    我的专栏

    本文地址:https://blog.csdn.net/zkc7441976/article/details/112548075

    希望与广大网友互动??

    点此进行留言吧!

    展开全文
  • 不采用注解,使用实现接口Ordered的方式。 import org.springframework.cloud.gateway.filter.GatewayFilterChain; import org.springframework.cloud.gateway.filter.GlobalFilter; import org.springframework....
  • Order注解可以做到集合bean依赖注入的时候,定义集合内部Bean的加载顺序,因此在需要有序消费bean的时候,不需要再次排序,直接定义好Order注解得value值就好。 但是这个order值并不影响bean本身实例化的顺序,...
  • 目录 前言 DefaultListableBeanFactory OrderComparator 前言 基于Spring-5.2.15.RELEASE版本分析... } } } else { order = this.findOrder(orderSource); } } } return order != null ? order : this.getOrder(obj); }
  • 踩坑:@PostConstruct、@DependsOn、@Order注解嵌套使用案例 今天在工作中写需求代码时,遇到的一个关于Sping Bean对象加载优先级问题,结合了Spring源码,大概总结了一下遇到Bean加载顺序需求问题时,比较常用的3...
  • Spring @Order注解的使用

    2021-01-05 09:08:45
    注解@Order或者接口Ordered的作用是定义Spring IOC容器中Bean的执行顺序的优先级,而不是定义Bean的加载顺序,Bean的加载顺序不受@Order或Ordered接口的影响; 目录 1.@Order注解源码解读 2.Ordered接口类 ...
  • @Order注解和Ordered接口

    2021-01-15 09:54:45
    @Order(0) public class DemoServiceImpl01 implements DemoService { public DemoServiceImpl01() { System.out.println("DemoServiceImpl01被实例化了"); } } @Service @Order(1) public class DemoServiceImpl...
  • 今天要来说一下Orderd接口以及@Order、@Primary、@Priority注解这几个东西,原本只是想介绍一下@Order,但是这几个有一定的关联,因此这里一起进行介绍。这几个接口是用来排序,本文主要介绍用法,具体的比如Spring...
  • 注解@Order或者接口Ordered的作用是定义Spring IOC容器中Bean的执行顺序的优先级,而不是定义Bean的加载顺序,Bean的加载顺序不受@Order或Ordered接口的影响; 1.@Order注解源码解读
  • //获取order注解 Order order = handleIntercept.getClass().getAnnotation(Order.class); if (ObjectUtils.isEmpty(order)){ noOrderHandleInterceptList.add(handleIntercept); }else { orderHandleInterceptList...
  • 本文介绍@Order(顺序)和@AliasFor(别名)两个注解的用法。 @Order 简介 @Order的作用: 指定AOP的优先级 多个 Bean 注入到集合时在集合中的顺序 @Order的使用 Integer.MIN_VALUE <= Order <= ...
  • Spring注解@Order

    2021-08-27 18:10:44
    @order注解 注解可以作用在类(接口、枚举)、方法、字段声明(包括枚举常量); 注解有一个int类型的参数,可以不传,默认是最低优先级; 通过常量类的值我们可以推测参数值越小优先级越高; 注解相关源码: @...
  • order接口的大体介绍Spring框架中有这个一个接口,名字叫Ordered,联想我们在数据库中应用的Ordered,很容易想到它的含义就是用来排序。那么问题来了,Spring中为什么要定义这样一个排序接口呢。我们知道spring框架...
  • B 5、Spring 中,下面哪一项不是使用事务的方法() A,proxies B,declaratively C,programmaticly 正确答案:A 6、Spring提供了JMS层的抽象,正确吗() A,正确 B,错误 正确答案:A 7、关于"@Order"注解,...
  • 1.进入聚合文档页面,选择文档管理-个性化设置 2. 勾选启用Knife4j提供的增强功能 即可
  • I have a query with where conditions , order by and limit. I am using prepared statements to set the where conditions and limit. Currently i am using string append for order by which causing SQL injec...
  • 语法SELECTcolumn_name(s)FROMtable_nameORDERBYcolumn_name注释:SQL对大小写不敏感。ORDERBY与orderby等效。常见的三种用法:降序:[desc]升序:[asc]多列排序:排序列与列之间逗号隔开.升序或降序的排序如果您使用...
  • 4)TCHINESE_RADICAL_M Traditional Chinese sort based on radical as primary order and number of strokes order as secondary order 注释:繁体中文按照第一顺序是“部首”第二顺序是“笔画数”进行排序;...
  • } 配置文件写法 </p><p>LIMIT #{offset},#{rowCount}</p><p> </p><p>SELECT * FROM users WHERE 1 = 1</p><p></p><p>AND name LIKE CONCAT('%', #{name}, '%')</p><p></p><p>ORDER BY id ASC</p><p> </p><p>SELECT ...
  • 目录 问题背景 实验 1- 构建测试用例 2- 执行测试sql ...生产环境数据产品项目出现相同代码多次执行结果不同的问题,经过排查...select * ,first_value(s_id) over (partition by c_id order by s_score)first_show f
  • 转:http://www.cnblogs.com/lovesqcc/p/8799187.html概述假设我们要从一个 ES 索引(相当于一张DB表)查询数据,ES表有 order_no, order_type, state 等字段, 而应用对象则有属性 orderNo, orderType, state等。...
  • 引言最近有个网友问了一个问题,zuul中如果两个filter的order一样,是如何排序的?引起了我的兴趣,特地去阅读了它的源码。zuul是干什么的如果你有使用过springcloud应该...
  • ‘F’的元素array([[ 0, 1, 2, 3],[ 4, 5, 6, 7],[ 8, 9, 10, 11],[12, 13, 14, 15]])是[0,4,8,12,1,5,9 …]现在用(2,8)数组重新排列它们....尝试a.ravel(order =’F’).重塑(2,8).哎呀,我得到了你的期望:...
  • 这里发现一个问题:我在两个Listener类加了@Order注解,理论上值越小的越应该先执行对吧?但是上面输出结果来看,并不是我们期望的这样,而是HandlerListener先输出了,Order不生效了? 经查阅文章后了解到,Spring...
  • 我以为我了解Numpy中的重塑功能,直到我弄乱它并遇到以下示例:a = np.arange(16).reshape((4,4))返回:array([[ 0, 1, 2, 3],[ 4, 5, 6, 7],[ 8, 9, 10, 11],[12, 13...a.reshape((2,8), order = 'F')它返回:array...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 210,431
精华内容 84,172
关键字:

order注解