【Reflect】注解(Annotation)

￡神魔★判官ぃ 2022-05-31 11:44 176阅读 0赞

利用Java反射机制可以在运行期获取Java类的注解信息。

一 什么是注解

注解是Java5的一个新特性。注解是插入你代码中的一种注释或者说是一种元数据（meta data）。

这些注解信息可以在编译期使用预编译工具进行处理（pre-compiler tools），也可以在运行期使用Java反射机制进行处理。

下面是一个类注解的例子：

package com.lanhuigu.reflect.annotations;
    
    @MyAnnotation(name = "someName", value = "Hello World")
    public class TheClass {
    
    }

在TheClass类定义的上面有一个@MyAnnotation的注解。注解的定义与接口的定义相似，下面是MyAnnotation注解的定义：

package com.lanhuigu.reflect.annotations;
    
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.TYPE)
    public @interface MyAnnotation {
        public String name();
        public String value();
    }

在interface前面的@符号表名这是一个注解，一旦你定义了一个注解之后你就可以将其应用到你的代码中，

就像之前我们的那个例子那样。在注解定义中的两个指示@Retention(RetentionPolicy.RUNTIME)

和@Target(ElementType.TYPE)，说明了这个注解该如何使用。

**@Retention(RetentionPolicy.RUNTIME)**表示这个注解可以在运行期通过反射访问。

如果你没有在注解定义的时候使用这个指示那么这个注解的信息不会保留到运行期，这样反射就无法获取它的信息。

**@Target(ElementType.TYPE)**表示这个注解只能用在类型上面（比如类跟接口）。

你同样可以把Type改为Field或者Method，或者你可以不用这个指示，这样的话你的注解在类，方法和变量上就都可以使用了。

**RetentionPolicy枚举源码:**

/*
     * @author  Joshua Bloch
     * @since 1.5
     */
    public enum RetentionPolicy {
        /**
         * 已经不在使用。
         */
        SOURCE,
    
        /**
         * 注释由编译器在类文件中记录，但不需要在运行时由VM保留，这是默认的行为。
         */
        CLASS,
    
        /**
         * 注释由编译器在类文件中记录，并且在运行时由VM保留，因此可以通过反射读取。
         */
        RUNTIME
    }

**ElementType枚举源码:**

package java.lang.annotation;
    
    /**
     * @author  Joshua Bloch
     * @since 1.5
     * @jls 9.6.4.1 @Target
     * @jls 4.1 The Kinds of Types and Values
     */
    public enum ElementType {
        /** 类、接口（包括注释类型），或枚举声明 */
        TYPE,
    
        /** 变量声明(包括枚举常量) */
        FIELD,
    
        /** 方法声明 */
        METHOD,
    
        /** 形式参数声明 */
        PARAMETER,
    
        /** 构造器声明 */
        CONSTRUCTOR,
    
        /** 本地变量声明 */
        LOCAL_VARIABLE,
    
        /** 注解类型声明 */
        ANNOTATION_TYPE,
    
        /** 包声明 */
        PACKAGE,
    
        /**
         * 参数声明
         *
         * @since 1.8
         */
        TYPE_PARAMETER,
    
        /**
         * 类型使用
         *
         * @since 1.8
         */
        TYPE_USE
    }

二 类注解

你可以在运行期访问类，方法或者变量的注解信息，下是一个访问类注解的例子：

你还可以像下面这样指定访问一个类的注解的例子：

package com.lanhuigu.reflect.annotations;
    
    import com.lanhuigu.reflect.cls.MyObject;
    
    import java.lang.annotation.Annotation;
    
    public class Test {
        public static void main(String[] args) {
            /** 获取Class对象 */
            Class myClass = TheClass.class;
    
            /** 访问类注解方式1 */
            /*Annotation[] annotations = myClass.getAnnotations();
            for (Annotation annotation : annotations) {
                if (annotation instanceof MyAnnotation) {
                    MyAnnotation myAnnotation = (MyAnnotation) annotation;
                    System.out.println("myAnnotation name:" + myAnnotation.name());
                    System.out.println("myAnnotation value:" + myAnnotation.value());
                }
            }*/
    
            /** 访问类注解方式2 */
            Annotation annotation = myClass.getAnnotation(MyAnnotation.class);
            if (annotation instanceof MyAnnotation) {
                MyAnnotation myAnnotation = (MyAnnotation) annotation;
                System.out.println("myAnnotation name:" + myAnnotation.name());
                System.out.println("myAnnotation value:" + myAnnotation.value());
            }
        }
    }

三 方法注解

定义一个作用于方法的注解:

package com.lanhuigu.reflect.annotations;
    
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.METHOD)
    public @interface MyAnnotation1 {
        public String name();
        public String value();
    }

下面是一个方法注解的例子：

package com.lanhuigu.reflect.annotations;
    
    public class TheClass1 {
        @MyAnnotation1(name="someName",  value = "Hello World")
        public void doSomething(){}
    }

两种访问方法注解实例如下:

package com.lanhuigu.reflect.annotations;
    
    import java.lang.annotation.Annotation;
    import java.lang.reflect.Method;
    
    /**
     * 获取方法注解
     */
    public class Test1 {
        public static void main(String[] args) throws NoSuchMethodException {
            /** 获取Class对象 */
            Class myClass = TheClass1.class;
            /** 获取Method对象 */
            Method method = myClass.getMethod("doSomething", null);
    
            /** 获取方法注解方式1 */
            Annotation[] annotations = method.getDeclaredAnnotations();
            for (Annotation annotation : annotations) {
                if (annotation instanceof MyAnnotation1) {
                    MyAnnotation1 myAnnotation = (MyAnnotation1) annotation;
                    System.out.println("myAnnotation1 name:" + myAnnotation.name());
                    System.out.println("myAnnotation1 value:" + myAnnotation.value());
                }
            }
            /** 获取方法注解方式2 */
            Annotation annotation = method.getAnnotation(MyAnnotation1.class);
            if (annotation instanceof MyAnnotation1) {
                MyAnnotation1 myAnnotation = (MyAnnotation1) annotation;
                System.out.println("myAnnotation1 name:" + myAnnotation.name());
                System.out.println("myAnnotation1 value:" + myAnnotation.value());
            }
        }
    }

四 参数注解

定义一个作用于参数的注解:

package com.lanhuigu.reflect.annotations;
    
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.PARAMETER)
    public @interface MyAnnotation2 {
        public String name();
        public String value();
    }

方法参数也可以添加注解，就像下面这样：

package com.lanhuigu.reflect.annotations;
    
    public class TheClass2 {
        public static void doSomething(
            @MyAnnotation2(name="someName", value="Hello World") String parameter){
        }
    }

你可以通过Method对象来访问方法参数注解：

package com.lanhuigu.reflect.annotations;
    
    import java.lang.annotation.Annotation;
    import java.lang.reflect.Method;
    
    public class Test2 {
        public static void main(String[] args) throws NoSuchMethodException {
            /** 获取Class对象 */
            Class myClass = TheClass2.class;
    
            /** 获取Method */
            Method method = myClass.getMethod("doSomething", new Class[]{String.class});
    
            /** 获取方法参数注解、Method对应的参数列表 */
            Annotation[][] paramterAnnotations = method.getParameterAnnotations();
            Class[] parameterTypes = method.getParameterTypes();
    
            for (int i = 0; i < paramterAnnotations.length; i++) {
                Annotation[] annotations = paramterAnnotations[i];
                Class parameterType = parameterTypes[i++];
                for(Annotation annotation : annotations){
                    if(annotation instanceof MyAnnotation2){
                        MyAnnotation2 myAnnotation = (MyAnnotation2) annotation;
                        System.out.println("param: " + parameterType.getName());
                        System.out.println("name : " + myAnnotation.name());
                        System.out.println("value: " + myAnnotation.value());
                    }
                }
    
            }
        }
    }

需要注意的是Method.getParameterAnnotations()方法返回一个注解类型的二维数组，

每一个方法的参数包含一个注解数组。

五 变量注解

定义一个变量注解:

package com.lanhuigu.reflect.annotations;
    
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.FIELD)
    public @interface MyAnnotation3 {
        public String name();
        public String value();
    }

下面是一个变量注解的例子：

package com.lanhuigu.reflect.annotations;
    
    public class TheClass3 {
        @MyAnnotation3(name="someName",  value = "Hello World")
        public String myField = null;
    }

访问变量注解的两种方式：

package com.lanhuigu.reflect.annotations;
    
    import java.lang.annotation.Annotation;
    import java.lang.reflect.Field;
    
    public class Test3 {
        public static void main(String[] args) throws NoSuchFieldException {
            /** 获取Class对象 */
            Class myClass = TheClass3.class;
    
            /** 获取Field` */
            Field field = myClass.getField("myField");
    
            /** 获取属性注解方式1 */
            Annotation[] annotations = field.getDeclaredAnnotations();
            for (Annotation annotation : annotations) {
                if (annotation instanceof MyAnnotation3) {
                    MyAnnotation3 myAnnotation = (MyAnnotation3) annotation;
                    System.out.println("name: " + myAnnotation.name());
                    System.out.println("value: " + myAnnotation.value());
                }
            }
            System.out.println("=================================================");
            /** 获取属性注解方式2 */
            Annotation annotation = field.getAnnotation(MyAnnotation3.class);
            if (annotation instanceof MyAnnotation3) {
                MyAnnotation3 myAnnotation = (MyAnnotation3) annotation;
                System.out.println("name: " + myAnnotation.name());
                System.out.println("value: " + myAnnotation.value());
            }
        }
    }