实例：Java注解深入浅出

最新推荐文章于 2022-09-05 15:56:04 发布

Chin_style

最新推荐文章于 2022-09-05 15:56:04 发布

阅读量307

点赞数

分类专栏：高级要求 Java for Android 文章标签：注解 Annotation

本文链接：https://blog.csdn.net/weixin_41101173/article/details/114240276

版权

高级要求同时被 2 个专栏收录

71 篇文章 2 订阅

订阅专栏

Java for Android

9 篇文章 0 订阅

订阅专栏

一，前期基础知识储备

1）Java 注解（Annotation）

又称 Java 标注，是 JDK5.0 引入的一种注释机制。Java 语言中的类、方法、变量、参数和包等都可以被标注。Java 注解用于为 Java 代码提供元数据。作为元数据，注解不直接影响你的代码执行，但也有一些类型的注解实际上可以用于这一目的。

日常开发中新建Java类，我们使用class、interface比较多，而注解和它们一样，也是一种类的类型。

2）Java内置的注解

Java 定义了一套注解，共有 7 个，3 个在 java.lang 中，剩下 4 个在 java.lang.annotation 中。

作用在代码的注解是

@Override - 检查该方法是否是重写方法。如果发现其父类，或者是引用的接口中并没有该方法时，会报编译错误。
@Deprecated - 标记过时方法。如果使用该方法，会报编译警告。
@SuppressWarnings - 指示编译器去忽略注解中声明的警告

元注解（作用在其他注解的注解）是:

@Retention - 标识这个注解怎么保存，是只在代码中，还是编入class文件中，或者是在运行时可以通过反射访问。
@Documented - 标记这些注解是否包含在用户文档中。
@Target - 标记这个注解应该是哪种 Java 成员。
@Inherited - 标记这个注解是继承于哪个注解类(默认注解并没有继承于任何子类)

从 Java 7 开始，额外添加了 3 个注解:

@SafeVarargs - Java 7 开始支持，忽略任何使用参数为泛型变量的方法或构造函数调用产生的警告。
@FunctionalInterface - Java 8 开始支持，标识一个匿名函数或函数式接口。
@Repeatable - Java 8 开始支持，标识某注解可以在同一个声明上使用多次。

@Retention

Retention英文意思有保留、保持的意思，它表示注解存在阶段是保留在源码（编译期），字节码（类加载）或者运行期（JVM中运行）。在@Retention注解中使用枚举RetentionPolicy来表示注解保留时期

@Retention(RetentionPolicy.SOURCE)，注解仅存在于源码中，在class字节码文件中不包含；

@Retention(RetentionPolicy.CLASS)，默认的保留策略，注解会在class字节码文件中存在，但运行时无法获得；

@Retention(RetentionPolicy.RUNTIME)，注解会在class字节码文件中存在，在运行时可以通过反射获取到；

如果我们是自定义注解，则通过前面分析，我们自定义注解如果只存着源码中或者字节码文件中就无法发挥作用，而在运行期间能获取到注解才能实现我们目的，所以自定义注解中肯定是使用 @Retention(RetentionPolicy.RUNTIME)。

@Retention(RetentionPolicy.RUNTIME)
public @interface MyTestAnnotation {

}

@Target

Target的英文意思是目标，这也很容易理解，使用@Target元注解表示我们的注解作用的范围就比较具体了，可以是类，方法，方法参数变量等，同样也是通过枚举类ElementType表达作用类型。

@Target(ElementType.TYPE) 作用接口、类、枚举、注解

@Target(ElementType.FIELD) 作用属性字段、枚举的常量

@Target(ElementType.METHOD) 作用方法

@Target(ElementType.PARAMETER) 作用方法参数

@Target(ElementType.CONSTRUCTOR) 作用构造函数

@Target(ElementType.LOCAL_VARIABLE)作用局部变量

@Target(ElementType.ANNOTATION_TYPE)作用于注解（@Retention注解中就使用该属性）

@Target(ElementType.PACKAGE) 作用于包

@Target(ElementType.TYPE_PARAMETER) 作用于类型泛型，即泛型方法、泛型类、泛型接口（jdk1.8加入）

@Target(ElementType.TYPE_USE) 类型使用.可以用于标注任意类型除了 class （jdk1.8加入）

一般比较常用的是ElementType.TYPE类型。

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface MyTestAnnotation {

}

@Inherited

Inherited的英文意思是继承，但是这个继承和我们平时理解的继承大同小异，一个被@Inherited注解了的注解修饰了一个父类，它的子类也会继承了父类的注解。

/**自定义注解*/
@Documented
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface MyTestAnnotation {
}
/**父类标注自定义注解*/
@MyTestAnnotation
public class Father {
}
/**子类*/
public class Son extends Father {
}
/**测试子类获取父类自定义注解*/
public class test {
   public static void main(String[] args){

      //获取Son的class对象
       Class<Son> sonClass = Son.class;
      // 获取Son类上的注解MyTestAnnotation可以执行成功
      MyTestAnnotation annotation = sonClass.getAnnotation(MyTestAnnotation.class);
   }
}

@Repeatable

Repeatable的英文意思是可重复的。顾名思义说明被这个元注解修饰的注解可以同时作用一个对象多次，但是每次作用注解又可以代表不同的含义。

/**一个人喜欢玩游戏，他喜欢玩英雄联盟，绝地求生，极品飞车，尘埃4等，则我们需要定义一个人的注解，他属性代表喜欢玩游戏集合，一个游戏注解，游戏属性代表游戏名称*/
/**玩家注解*/
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface People {
    Game[] value() ;
}
/**游戏注解*/
@Repeatable(People.class)
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Game {
    String value() default "";
}
/**玩游戏类*/
@Game(value = "LOL")
@Game(value = "PUBG")
@Game(value = "NFS")
@Game(value = "Dirt4")
public class PlayGame {
}

3）Annotation 组成部分

java Annotation 的组成中，有 3 个非常重要的主干类。它们分别是：

package java.lang.annotation;
public interface Annotation {

    boolean equals(Object obj);

    int hashCode();

    String toString();

    Class<? extends Annotation> annotationType();
}

package java.lang.annotation;

public enum ElementType {
    TYPE,               /* 类、接口（包括注释类型）或枚举声明  */

    FIELD,              /* 字段声明（包括枚举常量）  */

    METHOD,             /* 方法声明  */

    PARAMETER,          /* 参数声明  */

    CONSTRUCTOR,        /* 构造方法声明  */

    LOCAL_VARIABLE,     /* 局部变量声明  */

    ANNOTATION_TYPE,    /* 注释类型声明  */

    PACKAGE             /* 包声明  */
}

package java.lang.annotation;
public enum RetentionPolicy {
    SOURCE,            /* Annotation信息仅存在于编译器处理期间，编译器处理完之后就没有该Annotation信息了  */

    CLASS,             /* 编译器将Annotation存储于类对应的.class文件中。默认行为  */

    RUNTIME            /* 编译器将Annotation存储于class文件中，并且可由JVM读入 永久保存，可以反射获取 */
}

① Annotation 就是个接口。

"每 1 个 Annotation" 都与 "1 个 RetentionPolicy" 关联，并且与 "1～n 个 ElementType" 关联。可以通俗的理解为：每 1 个 Annotation 对象，都会有唯一的 RetentionPolicy 属性；至于 ElementType 属性，则有 1~n 个。

②ElementType 是 Enum 枚举类型，它用来指定 Annotation 的类型。

"每 1 个 Annotation" 都与 "1～n 个 ElementType" 关联。当 Annotation 与某个 ElementType 关联时，就意味着：Annotation有了某种用途。例如，若一个 Annotation 对象是 METHOD 类型，则该 Annotation 只能用来修饰方法。

③RetentionPolicy 是 Enum 枚举类型，它用来指定 Annotation 的策略。通俗点说，就是不同 RetentionPolicy 类型的 Annotation 的作用域不同。

4）自定义Annotation

格式为：

元注解
public @interface 注解名{
    定义体；
}

@Documented
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation1 {
    String name() default "mao";
    int age() default 18;
}

自定义一个 Annotation，它的名字是 MyAnnotation1。定义了 MyAnnotation1 之后，我们可以在代码中通过 "@MyAnnotation1" 来使用它。其它的，@Documented, @Target, @Retention, @interface 都是来修饰 MyAnnotation1 的。下面分别说说它们的含义：

① @interface

使用 @interface 定义注解时，意味着它实现了 java.lang.annotation.Annotation 接口，即该注解就是一个Annotation。

定义 Annotation 时，@interface 是必须的。

注意：它和我们通常的 implemented 实现接口的方法不同。Annotation 接口的实现细节都由编译器完成。通过 @interface 定义注解后，该注解不能继承其他的注解或接口。

② @Documented

类和方法的 Annotation 在缺省情况下是不出现在 javadoc 中的。如果使用 @Documented 修饰该 Annotation，则表示它可以出现在 javadoc 中。

定义 Annotation 时，@Documented 可有可无；若没有定义，则 Annotation 不会出现在 javadoc 中。

③ @Target(ElementType.TYPE)

前面我们说过，ElementType 是 Annotation 的类型属性。而 @Target 的作用，就是来指定 Annotation 的类型属性。

@Target(ElementType.TYPE) 的意思就是指定该 Annotation 的类型是 ElementType.TYPE。这就意味着，MyAnnotation1 是来修饰"类、接口（包括注释类型）或枚举声明"的注解。

定义 Annotation 时，@Target 可有可无。若有 @Target，则该 Annotation 只能用于它所指定的地方；若没有 @Target，则该 Annotation 可以用于任何地方。

④ @Retention(RetentionPolicy.RUNTIME)

前面我们说过，RetentionPolicy 是 Annotation 的策略属性，而 @Retention 的作用，就是指定 Annotation 的策略属性。

@Retention(RetentionPolicy.RUNTIME) 的意思就是指定该 Annotation 的策略是 RetentionPolicy.RUNTIME。这就意味着，编译器会将该 Annotation 信息保留在 .class 文件中，并且能被虚拟机读取，永久保存，可以反射获取。

定义 Annotation 时，@Retention 可有可无。若没有 @Retention，则默认是 RetentionPolicy.CLASS。

另外，还需要注意，

注解类中的方法只能用public或者默认这两个访问权修饰，不写public就是默认；

如果注解类中只有一个成员，最好把方法名设置为"value"

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface FruitName {
    String value() default "";
}

注解元素必须有确定的值，要么在定义注解的默认值中指定，要么在使用注解时指定，非基本类型的注解元素的值不可为null。因此, 使用空字符串或0作为默认值是一种常用的做法。

@MyAnnotation1(name = "father",age = 50)
public class Father {
}

5）获取注解属性

对于一个类或者接口来说，Class 类中提供了以下一些方法用于反射注解。

getAnnotation：返回指定的注解

isAnnotationPresent：判定当前元素是否被指定注解修饰

getAnnotations：返回所有的注解

getDeclaredAnnotation：返回本元素的指定注解

getDeclaredAnnotations：返回本元素的所有注解，不包含父类继承而来的

二，上代码，具体实现（注解与反射机制）

解析一个类或者方法的注解往往有两种形式，一种是编译期直接的扫描，一种是运行期反射。

编译器的扫描指的是编译器在对 java 代码编译字节码的过程中会检测到某个类或者方法被一些注解修饰，这时它就会对于这些注解进行某些处理。

典型的就是注解 @Override，一旦编译器检测到某个方法被修饰了 @Override 注解，编译器就会检查当前方法的方法签名是否真正重写了父类的某个方法，也就是比较父类中是否具有一个同样的方法签名。

使用注解的过程中，注解处理器是必不可少的，利用Java反射机制，完成对自定义注解的处理。

1）自定义注解，修饰变量；

//用来说明SXtStudent 里面的属性特性
@Target(value = ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface SxtFiled
{
    String columnName();
    String type();
    int length();
}

2）自定义注解，修饰类；

@Target(value = ElementType.TYPE)//修饰类
@Retention(value = RetentionPolicy.RUNTIME)
public @interface SxtTable
{
    String value();
}

3）创建类，用自定义注解标注；

@SxtTable("tb_table")
public class SxtStudent
{
    @SxtFiled(columnName = "id",type="int",length = 10)
    private int id;
    //对属性做了说明，

    @SxtFiled(columnName = "sname",type="varchar",length = 10)
    private  String StudentName;

    @SxtFiled(columnName = "age",type="int",length = 3)
    private int age;

    ......

}

4）利用反射，调用自定义注解的方法；

public static void setTestAnnotaion(){
        try {
            Class mClass = Class.forName("com.example.javatast.annotation.SxtStudent");//包含对应类的全部信息 包含注解

            Annotation annot[]=mClass.getAnnotations();//获取所有注解
            for(Annotation a:annot)
            {
                Log.d(TAG, "main 00: " + a);
                /*@com.example.javatast.annotation.SxtTable(value=tb_table)*/
            }

            //直接获得特定的注解
            SxtTable st= (SxtTable) mClass.getAnnotation(SxtTable.class);
            Log.d(TAG, "main 11: " + st);
            /*@com.example.javatast.annotation.SxtTable(value=tb_table)*/

            //获得对应类的属性的注解
            Field f=mClass.getDeclaredField("StudentName");
            Log.d(TAG, "main 22: " + f); /*private java.lang.String com.example.javatast.annotation.SxtStudent.StudentName*/
            SxtFiled sxtf=f.getAnnotation(SxtFiled.class);
            Log.d(TAG, "main 33: " + sxtf); /*@com.example.javatast.annotation.SxtFiled(columnName=sname, length=10, type=varchar)*/
            Log.d(TAG, "main 44: " + sxtf.columnName()); /*sname*/
            Log.d(TAG, "main 55: " + sxtf.length()); /*10*/
            Log.d(TAG, "main 66: " + sxtf.type()); /*varchar*/
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

三，实例，使用注解进行参数配置

下面我们看一个银行转账的例子，假设银行有个转账业务，转账的限额可能会根据汇率的变化而变化，我们可以利用注解灵活配置转账的限额，而不用每次都去修改我们的业务代码。

/**定义限额注解*/
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface BankTransferMoney {
    double maxMoney() default 10000;
}
/**转账处理业务类*/
public class BankService {
    /**
     * @param money 转账金额
     */
    @BankTransferMoney(maxMoney = 15000)
    public static void TransferMoney(double money){
        System.out.println(processAnnotationMoney(money));

    }
    private static String processAnnotationMoney(double money) {
        try {
            Method transferMoney = BankService.class.getDeclaredMethod("TransferMoney",double.class);
            boolean annotationPresent = transferMoney.isAnnotationPresent(BankTransferMoney.class);
            if(annotationPresent){
                BankTransferMoney annotation = transferMoney.getAnnotation(BankTransferMoney.class);
                double l = annotation.maxMoney();
                if(money>l){
                   return "转账金额大于限额，转账失败";
                }else {
                    return"转账金额为:"+money+"，转账成功";
                }
            }
        } catch ( NoSuchMethodException e) {
            e.printStackTrace();
        }
        return "转账处理失败";
    }
    public static void main(String[] args){
        TransferMoney(10000);
    }
}

通过上面的例子，只要汇率变化，我们就改变注解的配置值就可以直接改变当前最大限额。

第三方框架的应用

作为一个Android 开发者，平常我们所使用的第三方框架ButterKnife，Retrofit2，Dagger2等都有注解的应用，如果我们要了解这些框架的原理，则注解的基础知识则是必不可少的。

注解的作用

提供信息给编译器：编译器可以利用注解来检测出错误或者警告信息，打印出日志。

编译阶段时的处理：软件工具可以用来利用注解信息来自动生成代码、文档或者做其它相应的自动处理。

运行时处理：某些注解可以在程序运行的时候接受代码的提取，自动做相应的操作。

正如官方文档的那句话所说，注解能够提供元数据，转账例子中处理获取注解值的过程是我们开发者直接写的注解提取逻辑，处理提取和处理 Annotation 的代码统称为 APT（Annotation Processing Tool)。上面转账例子中的processAnnotationMoney方法就可以理解为APT工具类。

参考文章：

《深入理解Java注解类型(@Annotation)》

《JAVA 注解的基本原理》

《Java注解基本用法》

《Java 注解（Annotation）》