夯实spring(十六):详解java注解

小鱼儿 2024-03-24 20:26 3阅读 0赞

这边文章来学习一下java注解。本文内容：

*  注解是干什么的？
 *  一个注解可以使用多次么？如何使用？
 *  @Inherited是做什么的？
 *  注解定义怎么实现继承

#### 1，注解是干什么的 ####

注释我们都知道，是我们用来备注代码，方便自己或他人理解代码的，是给我们开发者用的。注解和注释有点类似，唯一的区别就是开发者用的，而注释是给编译器和虚拟机看的。编译器和虚拟机在运行的过程中可以获取注解信息，然后可以根据这些注解的信息做各种想做的事情。比如我们看了注释就知道这段代码是干什么的，同样编译器和虚拟机看到了注解就知道要干什么，如@Override就是一个注解，加在方法上，标注当前方法重写了父类的方法，当编译器编译代码的时候，会对@Override标注的方法进行验证，验证其父类中是否也有同样签名的方法，否则报错，通过这个注解增强了代码的安全性。

#### 2，注解的使用 ####

3个步骤

1.  定义注解
2.  使用注解
3.  获取注解信息实现各种功能

##### 2.1定义注解 #####

jdk中注解相关的类和接口都定义在java.lang.annotation包中。  
注解的定义和我们常见的类、接口类似，只是注解使用@interface来定义，如下定义一个名称为MyAnnotation的注解：

public @interface MyAnnotation {
        
    }

注解中可以不定义参数也可以定义参数，定义参数如：

public @interface 注解名称{
        
        [public] 参数类型 参数名称1() [default 参数默认值];
        [public] 参数类型 参数名称2() [default 参数默认值];
        [public] 参数类型 参数名称n() [default 参数默认值];
    }

public @interface MyAnnotation {
        
        public String name() default "Hello";
    }

注解中可以定义多个参数，参数的定义需要遵循以下要求：

> 1.  访问修饰符必须为public，不写默认为public
> 2.  参数的类型只能是基本数据类型、String、Class、枚举类型、注解类型，以及上述类型的一位数组
> 3.  参数的名称一般定义为名词，如果注解中只有一个元素，请把名字起为value（后面使用会带来便利操作）
> 4.  参数名称后面的()不是定义方法参数的地方，也不能在括号中定义任何参数，仅仅只是一个特殊的语法。(获取注解的时候使用Annotation.参数()这样看起来更像方法调用获取方法的返回值)
> 5.  default代表默认值，值必须和第2点定义的类型一致，如果没有默认值，代表后续使用注解时必须给该类型元素赋值

###### 2.1.1 指定注解的使用范围：@Target ######

使用@Target注解定义注解的使用范围，如下：

@Target(value = {
        ElementType.TYPE,ElementType.METHOD})
    public @interface MyAnnotation {
        
    }

> 上面指定了MyAnnotation注解可以用在类、接口、注解类型、枚举类型以及方法上面，自定义注解上也可以不使用@Target注解，如果不使用，表示自定义注解可以用在任何地方。

**@Target 也是一个注解**

@Documented
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.ANNOTATION_TYPE)
    public @interface Target {
        
        /**
         * Returns an array of the kinds of elements an annotation type
         * can be applied to.
         * @return an array of the kinds of elements an annotation type
         * can be applied to
         */
        ElementType[] value();
    }

它的参数是一个ElementType类型数组

**ElementType是一个枚举类,它里面是注解的使用范围**：

public enum ElementType {
        
        /** Class, interface (including annotation type), or enum declaration */
         /*类、接口、枚举、注解上面*/
        TYPE,
    
        /** Field declaration (includes enum constants) */
         /*字段上*/
        FIELD,
    
        /** Method declaration */
        /*方法上*/
        METHOD,
    
        /** Formal parameter declaration */
        /*方法的参数上*/
        PARAMETER,
    
        /** Constructor declaration */
         /*构造函数上*/
        CONSTRUCTOR,
    
        /** Local variable declaration */
         /*本地变量上*/
        LOCAL_VARIABLE,
    
        /** Annotation type declaration */
        /*注解上*/
        ANNOTATION_TYPE,
    
        /** Package declaration */
        /*包上*/
        PACKAGE,
    
        /**
         * Type parameter declaration
         *
         * @since 1.8
         */
          /*类型参数上*/
        TYPE_PARAMETER,
    
        /**
         * Use of a type
         *
         * @since 1.8
         */
         /*类型名称上*/
        TYPE_USE
    }

###### 2.1.2 指定注解的保留策略：@Retention ######

我们知道java程序的3个过程

1.  源码阶段
2.  源码被编译为字节码之后变成class文件
3.  字节码被虚拟机加载然后运行

那么自定义注解会保留在上面哪个阶段就可以通过@Retention注解来指定：

@Target({
        ElementType.TYPE,ElementType.METHOD})
    @Retention(RetentionPolicy.SOURCE)
    public @interface MyAnnotation {
        
        public String name() default "Hello";
    }

> 上面指定了MyAnnotation只存在于源码阶段，后面的2个阶段都会丢失。

**同样@Retention也是一个注解**

@Documented
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.ANNOTATION_TYPE)
    public @interface Retention {
        
        /**
         * Returns the retention policy.
         * @return the retention policy
         */
        RetentionPolicy value();
    }

value参数是一个RetentionPolicy 类型：

**RetentionPolicy 是一个枚举类**

public enum RetentionPolicy {
        
        /**
         * Annotations are to be discarded by the compiler.
         */
         /*注解只保留在源码中，编译为字节码之后就丢失了，也就是class文件中就不存在了*/
        SOURCE,
    
        /**
         * Annotations are to be recorded in the class file by the compiler
         * but need not be retained by the VM at run time.  This is the default
         * behavior.
         */
          /*注解只保留在源码和字节码中，运行阶段会丢失*/
        CLASS,
    
        /**
         * Annotations are to be recorded in the class file by the compiler and
         * retained by the VM at run time, so they may be read reflectively.
         *
         * @see java.lang.reflect.AnnotatedElement
         */
         /*源码、字节码、运行期间都存在*/
        RUNTIME
    }

##### 2.2 使用注解 #####

将注解加载使用的目标上面，如下：

@注解名称(参数1=值1,参数2=值2,参数n=值n)
    目标对象

###### 2.2.1 无参注解 ######

@Target({
        ElementType.TYPE,ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    public @interface MyAnnotation1 {
        
       
    }
    
    @MyAnnotation1
    public class UserController {
        
    }

###### 2.2.2 有参注解 ######

@Target({
        ElementType.TYPE,ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    public @interface MyAnnotation1 {
        
        String name() default "tom";//注意没有默认值时，使用的时候一定要赋值
    }
    
    @MyAnnotation1(name = "jack")
    public class UserController {
        
    }

###### 2.2.3 参数为value的注解，可以省略参数名称 ######

**只有一个参数**，名称为value的时候，使用时参数名称可以省略,多个参数的时候不可以

@Target({
        ElementType.TYPE,ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    public @interface MyAnnotation1 {
        
        String value() default "tom";//注意没有默认值时，使用的时候一定要赋值
    }
    
    @MyAnnotation1("jack")
    public class UserController {
        
    }

###### 2.2.4 数组类型参数 ######

@Target({
        ElementType.TYPE,ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    public @interface MyAnnotation1 {
        
        String[] value();
    }
    
    @MyAnnotation1({
        "tom","jack"})
    public class UserController {
        
    }

> value有多个值的时候，需要使用\{\}包含起来，如果value只有一个值，\{\}可以省略

来一个总的案例：

@Target(value = {
        
            ElementType.TYPE,
            ElementType.METHOD,
            ElementType.FIELD,
            ElementType.PARAMETER,
            ElementType.CONSTRUCTOR,
            ElementType.LOCAL_VARIABLE
    })
    @Retention(RetentionPolicy.RUNTIME)
    public @interface MyAnnotation2 {
        
        String value();
    }

@MyAnnotation2("我用在类上")
    public class UserController {
        
        
        @MyAnnotation2(value = "我用在字段上")
        private String name;
        
        @MyAnnotation2(value = "我用在构造方法上")
        public UserController(@MyAnnotation2(value = "我用在方法参数上") String name) {
        
            this.name = name;
        }
        @MyAnnotation2(value = "我用在了普通方法上面")
        public void m1() {
        
            @MyAnnotation2(value = "我用在了本地变量上") String m;
        }
    }

#### 3，注解信息的获取 ####

为了运行时能准确获取到注解的相关信息，Java在java.lang.reflect 反射包下新增AnnotatedElement接口，它主要用于表示目前正在虚拟机中运行的程序中已使用注解的元素，通过该接口提供的方法可以利用反射技术地读取注解的信息  
![在这里插入图片描述][8350305aaa654b1c8dcd6b64e68e9748.png_pic_center]

Package：用来表示包的信息
    Class：用来表示类的信息
    Constructor：用来表示构造方法信息
    Field：用来表示类中属性信息
    Method：用来表示方法信息
    Parameter：用来表示方法参数信息
    TypeVariable：用来表示类型变量信息，如：类上定义的泛型类型变量，方法上面定义的泛型类型变量

使用上面总的案列来获取一下注解信息：

**解析类上的注解**

public class Main {
        
        public static void main(String[] args) {
        
            Annotation[] annotations = UserController.class.getAnnotations();
            for(Annotation annotation : annotations){
        
                System.out.println(annotation);
            }
        }
    }

@com.chen.netty.annotation.MyAnnotation2(value=我用在类上)

**解析字段name上的注解**

public class Main {
        
        public static void main(String[] args) throws NoSuchFieldException {
        
            Field name = UserController.class.getDeclaredField("name");
            for(Annotation annotation : name.getAnnotations()){
        
                System.out.println(annotation);
            }
        }
    }

@com.chen.netty.annotation.MyAnnotation2(value=我用在字段上)

**解析构造函数上的注解**

public class Main {
        
        public static void main(String[] args) throws NoSuchFieldException {
        
            Constructor<?> constructor = UserController.class.getConstructors()[0];
            for(Annotation annotation : constructor.getAnnotations()){
        
                System.out.println(annotation);
            }
        }
    }

@com.chen.netty.annotation.MyAnnotation2(value=我用在构造方法上)

**解析方法上的注解**

public class Main {
        
        public static void main(String[] args) throws NoSuchMethodException {
        
            Method method = UserController.class.getMethod("m1");
            for(Annotation annotation : method.getAnnotations()){
        
                System.out.println(annotation);
            }
        }
    }

@com.chen.netty.annotation.MyAnnotation2(value=我用在了普通方法上面)

**解析方法参数注解**

public class Main {
        
        public static void main(String[] args) throws NoSuchMethodException {
        
            Method method = UserController.class.getMethod("m1", String.class);
            for (Parameter parameter : method.getParameters()) {
        
                System.out.println(String.format("参数%s上的注解如下:", parameter.getName()));
                for (Annotation annotation : parameter.getAnnotations()) {
        
                    System.out.println(annotation);
                }
            }
        }
    }

#### 4，实现类之间的注解继承 @Inherit ####

**@Inherit**

@Documented
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.ANNOTATION_TYPE)
    public @interface Inherited {
        
    }

> 通过@Target元注解的属性值可以看出，这个@Inherited 是专门修饰注解的。  
> 作用是让子类可以继承父类中被@Inherited修饰的注解，注意是继承父类中的，如果接口中的注解也使用@Inherited修饰了，那么接口的实现类是无法继承这个注解的

@Target({
        ElementType.TYPE,ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    @Inherited
    public @interface Anno {
        
    }

@Target({
        ElementType.TYPE,ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    @Inherited
    public @interface Anno2 {
        
    }

> @Inherited 表示这个注解是可以继承的，如果一个类继承一个使用了这个注解的类，那么这个类就是使用这个注解，也会有这个注解。但是接口的实现类是无法继承这个注解的

@Anno
    public class Use {
        
    }
    
    @Anno2
    public interface IUse {
        
    }
    
    public class UseImpl extends Use implements IUse{
        
    }

> 上面Use 、IUse 分别都使用了@Anno 、@Anno2,两个注解都是可以继承的，只是@Anno标注在类上，@Anno2标注在接口上。类UseImpl 继承了Use和实现了IUse，并没用使用注解。

现在来看看UseImpl 上有什么注解

public class Main {
        
        public static void main(String[] args) throws NoSuchMethodException {
        
            Annotation[] annotations = UseImpl.class.getAnnotations();
            for (Annotation annotation : annotations) {
        
                System.out.println(annotation);
            }
        }
    }

@com.chen.netty.annotation.Anno()

> 从输出中可以看出类可以继承父类上被@Inherited修饰的注解，而不能继承接口上被@Inherited修饰的注解。

#### 5，重复使用注解 @Repeatable ####

![在这里插入图片描述][aec3054df5a0477c8e87b90881443464.png]

> 上面代码会报错，是因为Use上面重复使用了@Anno注解，默认情况下@Anno注解是不允许重复使用的。

如果我们想重复使用注解的时候，需要用到@Repeatable注解

**@Repeatable**

@Documented
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.ANNOTATION_TYPE)
    public @interface Repeatable {
        
        /**
         * Indicates the <em>containing annotation type</em> for the
         * repeatable annotation type.
         * @return the containing annotation type
         */
        Class<? extends Annotation> value();
    }

来个案例使用一下

**1，定义容器注解**

@Retention(RetentionPolicy.RUNTIME)
    @Target({
        ElementType.TYPE, ElementType.FIELD})
    public @interface Annos {
        
        Anno[] value();
    }

> 容器注解中必须有个value类型的参数，参数类型为子注解类型的数组，这里是@Anno

**2，为注解指定容器**

要让一个注解可以重复使用，需要在注解上加上@Repeatable注解，@Repeatable中value的值为容器注解

@Target({
        ElementType.TYPE,ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    @Inherited
    @Repeatable(Annos.class)//容器
    public @interface Anno {
        
    }

**3，使用注解**

![在这里插入图片描述][709067daa2c240319db22f02bad26fbf.png]

[8350305aaa654b1c8dcd6b64e68e9748.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/cc1a6775d00f4819ad14d12c573ef39c.png
[aec3054df5a0477c8e87b90881443464.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/fdac579092c54ba785bf0f9ba80e1ada.png
[709067daa2c240319db22f02bad26fbf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/4315bcda112348038dd6cbb7656895ef.png