SpringBoot--注解--@Order/@AliasFor

太过爱你忘了你带给我的痛 2022-08-28 06:45 285阅读 0赞

原文网址：[SpringBoot--注解--@Order/@AliasFor\_IT利刃出鞘的博客-CSDN博客][SpringBoot--_--_Order_AliasFor_IT_-CSDN]

# 简介 #

本文介绍@Order（顺序）和@AliasFor（别名）两个注解的用法。

# @Order #

**简介**

**@Order的作用**：

1.  指定AOP的优先级
2.  多个 Bean 注入到集合时在集合中的顺序

**@Order的使用**

*  Integer.MIN\_VALUE <= Order <= Integer.MAX\_VALUE。  
    这个值已经定义在org/springframework/core/Ordered：  
    int HIGHEST\_PRECEDENCE = Integer.MIN\_VALUE;  
    int LOWEST\_PRECEDENCE = Integer.MAX\_VALUE;
 *  Order值越小，优先级越高！
 *  @Order的使用位置： ElementType.TYPE, ElementType.METHOD, ElementType.FIELD

**@Order不支持的操作**：

1.  不能指定 bean 的加载顺序
    
    1.  它对于实例的 bean 之间的加载顺序，没有任何影响。
    2.  无论使用@Order还是实现Ordered接口，都不行
2.  不能指定@AutoConfigureOrder外部依赖的 AutoConfig 的加载顺序（即定义在/META-INF/spring.factories文件中的配置 bean 优先级)
    
    1.  在当前工程中使用这个注解并没有什么鸟用。
    2.  同样的 @AutoConfigureBefore和 @AutoConfigureAfter这两个注解的适用范围和@AutoConfigureOrder一样。

**官方注释**

\{@code @Order\} defines the sort order for an annotated component. Since Spring 4.0, annotation-based ordering is supported for many kinds of components in Spring, even for collection injection where the order values of the target components are taken into account (either from their target class or from their \{@code @Bean\} method). While such order values may influence priorities at injection points, please be aware that they do not influence singleton startup order which is an orthogonal concern determined by dependency relationships and \{@code @DependsOn\} declarations (influencing a runtime-determined dependency graph).

最开始 @Order 用于切面的优先级指定；Spring4.0 之后它的功能进行了增强，支持集合的注入时，指定集合中 bean 的顺序。它对于实例的 bean 之间的顺序，没有任何影响。

## 集合顺序 ##

**接口**

package com.example.test;
    
    public interface IBean {
    }

**实现类1**

package com.example.test;
    
    import lombok.Data;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.core.annotation.Order;
    
    @Configuration
    public class DemoConfig1 {
        @Bean
        @Order(2)
        public DemoBean1 demo1Service(){
            System.out.println("config-1 加载了");
            return new DemoBean1();
        }
    
        @Data
        private class DemoBean1 implements IBean{
            private String name;
            private Integer age;
        }
    }

**实现类2**

package com.example.test;
    
    import lombok.Data;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.core.annotation.Order;
    
    @Configuration
    public class DemoConfig2 {
        @Bean
        @Order(1)
        public DemoBean2 demo2Service(){
            System.out.println("config-2 加载了");
            return new DemoBean2();
        }
    
        @Data
        private class DemoBean2 implements IBean{
            private String name;
            private String phone;
        }
    }

**测试类**

package com.example.test;
    
    import org.springframework.stereotype.Component;
    
    import java.util.List;
    
    @Component
    public class CollectionIOC {
        public CollectionIOC(List<IBean> iBeans) {
            for (IBean iBean : iBeans) {
                System.out.println(iBean.getClass().getName());
            }
        }
    }

执行结果

config-1 加载了
    config-2 加载了
    com.example.test.DemoConfig2$DemoBean2
    com.example.test.DemoConfig1$DemoBean1

颠倒顺序

config-1 加载了
    config-2 加载了
    com.example.test.DemoConfig1$DemoBean1
    com.example.test.DemoConfig2$DemoBean2

@Order放到这三个位置有相同的效果：@Bean、Bean类、@Component

例如：

package com.example.test;
    
    import lombok.Data;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.core.annotation.Order;
    
    @Configuration
    public class DemoConfig2 {
        @Bean
        public DemoBean2 demo2Service(){
            System.out.println("config-2 加载了");
            return new DemoBean2();
        }
    
        @Data
        @Order(1)
        private class DemoBean2 implements IBean{
            private String name;
            private String phone;
        }
    }

package com.example.test;
    
    import lombok.Data;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.core.annotation.Order;
    
    @Configuration
    public class DemoConfig2 {
        @Bean
        @Order(1)
        public DemoBean2 demo2Service(){
            System.out.println("config-2 加载了");
            return new DemoBean2();
        }
    
        @Data
        private class DemoBean2 implements IBean{
            private String name;
            private String phone;
        }
    }

## **AOP顺序** ##

见：[Spring--AOP--用法/顺序--使用/实例/示例/教程/实战--@Order控制顺序\_IT利刃出鞘的博客-CSDN博客][Spring--AOP--_--_--_Order_IT_-CSDN]

## 无效的场景 ##

@Bean + @Order，@Configuration+@Order都是无法确定顺序的。

**@Bean + @Order（无效）**

package com.example.test;
    
    import lombok.Data;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.core.annotation.Order;
    
    @Configuration
    public class DemoConfig1 {
        @Bean
        @Order(1)
        public DemoBean1 demo1Service(){
            System.out.println("config-1 加载了");
            return new DemoBean1();
        }
    
        @Data
        private class DemoBean1 {
            private String name;
            private Integer age;
        }
    }

package com.example.test;
    
    import lombok.Data;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.core.annotation.Order;
    
    @Configuration
    public class DemoConfig2 {
        @Bean
        @Order(2)
        public DemoBean2 demo2Service(){
            System.out.println("config-2 加载了");
            return new DemoBean2();
        }
    
        @Data
        private class DemoBean2 {
            private String name;
            private String phone;
        }
    }

执行结果

config-1 加载了
    config-2 加载了

执行结果（颠倒Order）

config-1 加载了
    config-2 加载了

**@Configuration+@Order（无效）**

package com.example.test;
    
    import lombok.Data;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.core.annotation.Order;
    
    @Configuration
    @Order(1)
    public class DemoConfig1 {
        @Bean
        public DemoBean1 demo1Service(){
            System.out.println("config-1 加载了");
            return new DemoBean1();
        }
    
        @Data
        private class DemoBean1 {
            private String name;
            private Integer age;
        }
    }

package com.example.test;
    
    import lombok.Data;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.core.annotation.Order;
    
    @Configuration
    @Order(2)
    public class DemoConfig2 {
        @Bean
        public DemoBean2 demo2Service(){
            System.out.println("config-2 加载了");
            return new DemoBean2();
        }
    
        @Data
        private class DemoBean2 {
            private String name;
            private String phone;
        }
    }

执行结果

config-1 加载了
    config-2 加载了

执行结果（颠倒@Order）

config-1 加载了
    config-2 加载了

# @AliasFor #

**其他网址**

[认识Spring 的注解 (三)之 @AliasFor 使用规则 - 夏之夜 - 博客园][Spring _ _ _AliasFor _ - _ -]

## **1.注解的属性互为别名** ##

**简介**

它可以注解到自定义注解的两个属性上，表示这两个互为别名，也就是说这两个属性其实同一个含义。

1.  其中一个属性名必须是"value"
2.  无论指明设置哪个属性名设置属性值，另一个属性名也是同样属性值，也可以缺省属性名。
3.  若两个都指明属性值，要求值必须相同，否则会报错。
4.  使用简洁。这样使用之后，@MyAnno(location="shanghai")可以直接写为：@MyAnno("shanghai");

这个功能产生的原因：

若自定义注解有一个属性，且该属性命名上为了体现其含义，调用方必须每次使用自定义注解的时候，都必须写明属性 ，然后设置，这样稍微麻烦。

**代码**

**注解**

**控制器**

package com.example.controller;
    
    import com.example.annotation.MyAnnotation;
    import org.springframework.core.annotation.AnnotationUtils;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    @RestController
    @RequestMapping("/hello")
    public class HelloController {
    
        @MyAnnotation(value = "location")
        /*//下边这两种写法结果与上边是相同的
        @MyAnnotation("location")
        @MyAnnotation(location = "location")*/
        @RequestMapping("/test1")
        public String test1() {
            MyAnnotation myAnnotation = null;
            try {
                myAnnotation = AnnotationUtils.getAnnotation(this.getClass().getMethod("test1"), MyAnnotation.class);
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            }
    
            return  "value:" + myAnnotation.value() + ";loation:" + myAnnotation.location();
        }
    }

**测试**

前端访问：[http://localhost:8080/hello/test1][http_localhost_8080_hello_test1]

前端结果（value和location都是同一个值）

value:location;loation:location

## **2.继承父注解的属性，不重写属性名** ##

**简介**

子注解的属性值的读写，其实是对父注解的属性值的读写。（对继承的属性来说）

此时，只能读写继承了的属性值。

**代码**

**注解**

**控制器**

package com.example.controller;
    
    import com.example.annotation.MyAnnotation;
    import com.example.annotation.SubMyAnnotation;
    import org.springframework.core.annotation.AnnotatedElementUtils;
    import org.springframework.core.annotation.AnnotationUtils;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    @RestController
    @RequestMapping("/hello")
    public class HelloController {
        @SubMyAnnotation(location = "location(my)")
        @RequestMapping("/test")
        public String test() {
            SubMyAnnotation subMyAnnotation = null;
            MyAnnotation myAnnotation = null;
            MyAnnotation myAnnotation1 = null;
    
            try {
                subMyAnnotation = AnnotationUtils.getAnnotation(this.getClass().getMethod("test"), SubMyAnnotation.class);
                myAnnotation = AnnotationUtils.getAnnotation(this.getClass().getMethod("test"), MyAnnotation.class);
                myAnnotation1 = AnnotatedElementUtils.getMergedAnnotation(this.getClass().getMethod("test"), MyAnnotation.class);
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            }
    
            return "loation(sub):" + subMyAnnotation.location() + "\n" +
                    "location:" + myAnnotation.location() + "\n" +
                    "location:" + myAnnotation1.location();
        }
    }

**测试**

前端访问：[http://localhost:8080/hello/test][http_localhost_8080_hello_test]

结果

loation(sub):location(my)
    location:
    location:location(my)

## **3.继承父注解的属性，并重写属性名** ##

**简介**

1.  子注解的属性值的读写，其实是对父注解的属性值的读写。（对重写的属性来说）
2.  无论指明设置哪个属性名设置属性值，另一个属性名也是同样属性值，**不可以**缺省属性名。
3.  若两个都指明属性值，要求值必须相同，否则会报错。

**代码**

**注解**

package com.example.annotation;
     
    import org.springframework.core.annotation.AliasFor;
     
    import java.lang.annotation.*;
     
    @Retention(RetentionPolicy.RUNTIME)
    @Target({ElementType.METHOD, ElementType.TYPE})
    @Documented
    @Inherited
    @MyAnnotation
    public @interface SubMyAnnotation {
        @AliasFor(attribute = "value", annotation = MyAnnotation.class)
        String subValue() default "";
    
        @AliasFor(attribute = "location", annotation = MyAnnotation.class)
        String subLocation() default "";
    
    //    subLocation属性写成下边这两种结果是一样的
    //    @AliasFor(attribute = "value", annotation = MyAnnotation.class)
    //    String subLocation() default "";
    
    //    @AliasFor(value = "location", annotation = MyAnnotation.class)
    //    String subLocation() default "";
    //
    }

**控制器**

package com.example.controller;
    
    import com.example.annotation.MyAnnotation;
    import com.example.annotation.SubMyAnnotation;
    import org.springframework.core.annotation.AnnotatedElementUtils;
    import org.springframework.core.annotation.AnnotationUtils;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    @RestController
    @RequestMapping("/hello")
    public class HelloController {
        @SubMyAnnotation(subValue = "subLocation")
    //    @SubMyAnnotation(subLocation = "subLocation")   //这个与上边结果相同
    //    @SubMyAnnotation("subLocation")   //缺省属性名会报错
        @RequestMapping("/test")
        public String test() {
            SubMyAnnotation subMyAnnotation = null;
            MyAnnotation myAnnotation = null;
            MyAnnotation myAnnotation1 = null;
    
            try {
                subMyAnnotation = AnnotationUtils.getAnnotation(this.getClass().getMethod("test"), SubMyAnnotation.class);
                myAnnotation = AnnotationUtils.getAnnotation(this.getClass().getMethod("test"), MyAnnotation.class);
                myAnnotation1 = AnnotatedElementUtils.getMergedAnnotation(this.getClass().getMethod("test"), MyAnnotation.class);
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            }
            return "subValue:" + subMyAnnotation.subValue() + ";subLoation:" + subMyAnnotation.subLocation() + "\n" +
                    "value:" + myAnnotation.value() + ";location:" + myAnnotation.location() + "\n" +
                    "value:" + myAnnotation1.value() + ";location:" + myAnnotation1.location();
        }
    }

**测试**

前端访问：[http://localhost:8080/hello/test][http_localhost_8080_hello_test]

结果

subValue:subLocation;subLoation:subLocation
    value:;location:
    value:subLocation;location:subLocation

# **其他网址** #

**@Autowired**

[SpringBoot系列之Bean：加载顺序之错误使用姿势辟谣 - 知乎][SpringBoot_Bean_ -]

[SpringBoot--_--_Order_AliasFor_IT_-CSDN]: https://knife.blog.csdn.net/article/details/120711158
[Spring--AOP--_--_--_Order_IT_-CSDN]: https://knife.blog.csdn.net/article/details/120711539
[Spring _ _ _AliasFor _ - _ -]: https://www.cnblogs.com/sandyflower/p/10877291.html
[http_localhost_8080_hello_test1]: http://localhost:8080/hello/test1
[http_localhost_8080_hello_test]: http://localhost:8080/hello/test
[SpringBoot_Bean_ -]: https://zhuanlan.zhihu.com/p/91783100