Java注解的使用-阿里云开发者社区

java 提供了一种源程序中的元素关联任何信息和任何元数据的途径和方法。

Java 中常见的注解

JDK自带的注解

@Override

用来指定方法的重载，他可以强制一个子类必须覆盖父类的方法。

public class Per {
    String name;
    public String getName() {
        return name;
    }
}
class Man extends Per{
    //指定下面方法必须重写父类方法
    @Override
    public String getName() {
        return super.getName();
    }
}

@Deprecated
表示当前(类，方法)等，已经过时，当程序调用这个 类 ，方法时，编译器会给出警告。
public class Per {
    String name;
    @Deprecated
    public String getName() {
        return name;
    }
    public static void main(String[] args){
        Per per = new Per();
        //调用getName方法时，会给出警告
        per.getName();
    }
}

@Suppvisewarnings
抑制编辑器警告，被该注解修饰的程序元素 将会被取消显示编译器的警告。
public class Per {
    String name;
    @Deprecated
    public String getName() {
        return name;
    }
    @SuppressWarnings(value = "unchecked")
    public static void main(String[] args){
        Per per = new Per();
        //使用 @SuppressWarnings 后不会再有警告
        per.getName();
    }
}

注解的分类

源码注解：只在源码中存在，编译成 .class 文件后就不存在了。

编译时注解：注解在源码和 .class 文件中都存在。上面的三种注解就属于编译时注解，只在编译的时候有效。

运行是注解：在运行阶段还起作用，甚至还会影响运行逻辑。

自定义注解

/**
 *  使用 @interface 用来定义注解。
 *
 *  带成员变量的注解
 *      成员变量以无参无异常的方式声明
 *      成员变量以方法的形式来声明
 *      一旦在注解里面定义了成员变量后，使用该注解时 就应该为他的成员变量指定值
 *          (成员如果指定了默认值，则不用)
 */

public @interface Description {
    //没有 指定默认值的成员
    String desc();
    //可以使用 default 为成员指定一个默认的值。
    int age() default 20;
}

使用如下：

public class Per {
    @Description(desc = "为没有指定默认值的成员 赋值")
    public static void main(String[] args){
        Per per = new Per();
    }
}

元注解

@Retention

该注解只能用于修饰注解定义，用于指定被修饰的注解可以保留多长时间，包含一个Retention Policy 类型的value成员变量，所以使用该注解时必须为该注解指定成员变量的值。

value 的值只能是如下三个：

Retention Policy.CLASS : 编译器将会把注解记录在 class 文件中，当运行 java 程序时，JVM 不可获取注解的信息。这是默认值。

Retention Policy.RUNTIME : 编译器将会把注解记录在 class 文件中，当运行 java 程序时，JVM 也可以获取注解信息，程序可以通过反射获取该注解的信息。

Retention Policy.SOURCE : 注解只保留在源代码中，编译器直接丢弃这种注解。

// 定义下面的 @Description 注解保留到运行时。
@Retention(value = RetentionPolicy.RUNTIME)
public @interface Description {
    String desc();
    int age() default 20;
}

也可以采用入下代码来为 value 指定值

@Retention(RetentionPolicy.RUNTIME)
public @interface Description {
    String desc();
    int age() default 20;
}

上面使用 @Retention 元注解时，并未通过 value = Retention Policy.RUNTIME 的方式来为该成员指定值，这是因为当注解的成员变量名为 value 时，程序可以直接在注解后的括号里指定该成员变量的值。

@Target

他用于指定被修饰的的注解能用于修饰那些程序单元。@Target 注解也包含一个为 value 的成员变量，该成员变量的值只能是如下几个。

比如第一个，表示只能修饰注解，2，只能修饰构造函数。…

@Target(ElementType.CONSTRUCTOR)
public @interface Description {
    String desc();
    int age() default 20;
}

上面程序表示注解只能修饰构造方法

如果用来修饰方法就会报错。

@Documented

指定被该元注解修饰的注解将被 java doc 工具提取成文档，所有使用该元注解的程序的 API 文档中将会包含该注解的说明

@Inherited

该元注解指定被他修饰的注解将具有继承性，如果某个类使用了 @xxx注解 (定义该注解时使用了 @Inherited)修饰，则其子类将自动被@xxx继承。

如下所示：

@Retention(RetentionPolicy.RUNTIME)
@Inherited
public @interface Description {
}

上面注解中使用了 @Inherited 代表具有继承。如果某个类使用了该注解，则他的子类会默认被该注解修饰。注意：@Retention(RetentionPolicy.RUNTIME) 这个必须加。

@Description
public class Per {
    Per() {}
    public static void main(String[] args){
        new Student();
    }
}
class Student extends Per{
    public Student() {
        super();
        System.out.println(Student.class.isAnnotationPresent(Description.class));
    }
}

打印结果为 true,说明该注解具有继承性。

@Repeatable

可重复注解。代表着该注解在某个类或者方法等上面可以使用多次。要创建可重复注解，必须创建容器注解。然后将该注解的类型作为 @Repeatable 的参数，如下所示：

//使用可重复注解
@Repeatable(FKTags.class)
//该注解将被保留在运行时。
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@interface FKTag{
  String name() default "哈哈哈";
  int age();
}
//可重复注解的容器，如果上面的注解 在某个类或方法等 上面使用了多次，他的注解就会被保存在该注解的集合中。
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@interface FKTags{
  FKTag[] value();
}

然后使用注解，提取充注解的信息

@FKTag(age = 20)
@FKTag(name = "嘻嘻嘻",age=30)
public class Tast {
  public static void main(String[] args) throws ClassNotFoundException {
  Class<Tast> c = Tast.class;
  FKTags fk = c.getAnnotation(FKTags.class);
  for(FKTag f : fk.value()){
    System.out.println(f.age());
    System.out.println(f.name());
  }
  System.out.println("--------------");
        //找出 修饰Tast 类的 @FKTags 注解
  FKTags f =c.getDeclaredAnnotation(FKTags.class);
  for(FKTag fktag : fk.value()){
    System.out.println(fktag.age());
    System.out.println(fktag.name());
  }
  }
}

个人感觉：如果重复注解使用两次以上，就会将他的这些注解保存在定义的容器中，然后直接遍历该容器，就可以拿到注解中的信息了。

如果只是用了一次，就不会放在容器中，遍历容器就会直接报错，这时直接提取该注解信息就好了，而不是去遍历容器。

提取注解的信息

使用了注解修饰类、方法、成员变量之后，这些注解不会自动生效，必须由开发者提供相应的工具来提取并处理注解信息。

Annotation 定义类型为 @interface ，所有的 Annotation 都会自动继承 java.lang.Annotation 这一接口，并且不能去继承别的类或者接口。

要获取类、方法和字段的注解想信息，必须通过 Java 的反射技术来获取 Annotation 对象，除此之外没有别的方法。

同时为了运行时能准确的获取注解的相关信息，java 在 java.lang.reflect 反射包下新新增了 AnnotatedElement 接口，态抓以后用于表示目前正在 JVM 中运行的程序中已使用注解的元素。通过该接口提供的方法可以利用反射技术读取注解的信息，如反射包的Constructor类、Field类、Method 类、Package 类和 Class 类都实现了 AnnotatedElement 接口。

Class ：类的Class对象定义

Constructor ：代表着构造器的定义。

Field ：类的成员变量定义

Method ：类方法的定义

Package ：类的包定义

AnnotatedElement 接口是所有程序元素(Class , Method, Constructor 等 )的父接口，所以程序通过反射获取了某个类的 AnnotatedElement 对象之后，程序就可调用该对象的如下几个方法来访问注解的信息。

@Retention(RetentionPolicy.RUNTIME)//该注解 生存周期是运行时。
@Target(ElementType.METHOD)//该注解只能用于方法上
public @interface AnnotationTest {
    int value() default 20;
}

public class Test {
    private String name;
    private int age;
    @AnnotationTest
    public void setAge(int age) {
        this.age = age;
    }
    @AnnotationTest
    public void setName(String name) {
        this.name = name;
    }
    public static void main(String[] args) throws ClassNotFoundException {
        //加载类 类对象
        Class<?> tclass = Class.forName("cn.lvkang.com.gradletest.annotationtest.Test");
        if (tclass.isAnnotationPresent(AnnotationTest.class)){
            //拿到注解类实例
            AnnotationTest at = tclass.getAnnotation(AnnotationTest.class);
            //因为该注解只用于方法上，所以在这里打印为空。
            System.out.println(at.value());
        }
        //找到使用 该注解的方法
        Method[] methods = tclass.getMethods();
        for (Method m :methods){
           //判断该方法如果使用了注解，则 提取信息
            if (m.isAnnotationPresent(AnnotationTest.class)) {
                AnnotationTest a = m.getAnnotation(AnnotationTest.class);
                System.out.println(a.value());
            }
        }
        //另外一种解析方法
        for (Method m : methods){
            //返回这个方法上面的所有注释
            Annotation[] a = m.getAnnotations();
            for (Annotation annotation: a){
                //判断 该注释 是不是 AnnotationTest的实例
                if (annotation instanceof AnnotationTest){
                    System.out.println(((AnnotationTest) annotation).value());
                }
            }
        }
    }
}

使用注解

@Retention(RetentionPolicy.RUNTIME)//该注解 生存周期是运行时。
@Target(ElementType.METHOD)//该注解只能用于方法上
public @interface AnnotationTest {
    int value() default 20;
}

上面的注解用来标记那些方法是可以进行使用的

//使用 @AnnotationTest 指定该方法是可以测试的。
public class Test {
    @AnnotationTest
    public static void test1(){
    }
    public static void test2(){
    }
    @AnnotationTest
    public static void test3(){
        throw new RuntimeException("参数错误");
    }
    public static void test4(){
    }
    @AnnotationTest
    public static void test5(){
    }
    public static void test6(){
    }
    @AnnotationTest
    public static void test7(){
        throw new RuntimeException("程序业务出现异常");
    }
    public static void test8(){
    }
}

上面加注解的代表要被执行

public class ProcessorTest {
    public static void process(String clazz) throws ClassNotFoundException {
        int passed  = 0;
        int failed = 0;
        for(Method m : Class.forName(clazz).getMethods()){
            if (m.isAnnotationPresent(AnnotationTest.class)){
                try {
                    //调用m 的方法
                    m.invoke(null);
                    passed++;
                } catch (Exception e) {
                    failed++;
                    System.out.println(m + "方法运行失败，异常"+e.getCause());
                }
            }
        }
        System.out.println("共运行了"+(passed+failed)+"次，成功"+passed+"次，失败"+failed+"次");
    }
}

上面的类的 process 方法会通过传进去的参数进行反射，拿到使用注解的方法，并测试是否可以成功运行。

public class RunTest {
    public static void main(String[] args) throws ClassNotFoundException {
        ProcessorTest.process("cn.lvkang.com.gradletest.annotationtest.Test");
    }
}

运行结果如下：

public static void cn.lvkang.com.gradletest.annotationtest.Test.test7()方法运行失败，异常java.lang.RuntimeException: 程序业务出现异常

public static void cn.lvkang.com.gradletest.annotationtest.Test.test3()方法运行失败，异常java.lang.RuntimeException: 参数错误

共运行了4次，成功2次，失败2次

我们一共加了四个注解，然后抛了两个异常，如结果所示，说明我们设置的注解起了作用。

Java注解的使用

Java 中常见的注解

JDK自带的注解

注解的分类

自定义注解

元注解

提取注解的信息

使用注解

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Java注解的使用

Java 中常见的注解

JDK自带的注解

注解的分类

自定义注解

元注解

提取注解的信息

使用注解

热门文章

最新文章

相关课程

相关电子书

相关实验场景