注解，这个经常在开发中使用到的东西，它的使用语法是怎么样的？如何去自定义一个注解呢？

什么是注解

我们在日常开发中，比如 java 中的@Override，在 springboot 中用到的@SpringBootApplication等一系列标注在类或者方法上的注解。我们添加上注解后会有对应的事件处理，比如我们的@Override注解标明这个方法是重写了父类或者接口的方法，当参数不一致、返回类型不一致等不符合重写的要求时，编译器会报错。类似的@SpringBootApplication也是标明这个项目的一个 springboot 项目，默认会启动一个 tomcat 容器等。

注解是从 jdk5 开始引入的新特性。

注解的语法

1
public @interface FirstAnnotation {}

通过@interface即可声明一个注解。

内置的注解

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

作用在代码的注解是

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

元注解

我们通过上面的语法定义了一个注解，但还需要其他的注解一同作用。在 jdk1.5中定义了 4 个标准注解，它们用来提供对其他 annotation 类型做说明。分别是：

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

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

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

@Retention

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Retention {
   
    RetentionPolicy value();
}


public enum RetentionPolicy {
    /* 注解被编译器丢弃，不会保留到 class 文件中 */
    SOURCE,
    /* 默认的类型。 注解在 class 文件中可用，但会被 jvm 丢弃 */
    CLASS,
    /*在运行期也保留，可以通过反射机制读取注解的信息*/
    RUNTIME
}

这个注解只有一个变量，类型是一个枚举。可以通过这个变量来表明这个注解是保存在源码中(source)，还是编入 class 文件中(class)，还是在运行时通过反射访问(runtime)。

@Target

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Target {
    
    ElementType[] value();
}


public enum ElementType {
    /* 表明该注解可以用于 类，接口（包括注解类型）或枚举声明*/
    TYPE,
    /* 表明该注解可以用于 字段声明（包括枚举常量） */
    FIELD,
    /* 表明该注解可以用于 方法声明 */
    METHOD,
    /* 表明该注解可以用于 参数声明 */
    PARAMETER,
    /* 表明该注解可以用于 构造函数声明 */
    CONSTRUCTOR,
    /* 表明该注解可以用于 局部变量声明 */
    LOCAL_VARIABLE,
    /* 表明该注解可以用于 注解声明（应用于另一个注解上） */
    ANNOTATION_TYPE,
    /* 表明该注解可以用于 包声明 */
    PACKAGE,
    /* 表明该注解可以用于 类型参数声明@since 1.8 */
    TYPE_PARAMETER,
    /* 类型使用声明 */
    TYPE_USE
}

@Documented

1
2
3
4
5
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Documented {
}

它没有任何变量，添加这个注解可以让我们执行 JavaDoc 文档打包时注解会被保存进 doc 文档，反之将在打包时丢弃。

@Inherited

1
2
3
4
5
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Inherited {
}

这个注解是什么意思呢？我们通过一个例子来说明一下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
@Inherited
@Documented
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface DocumentFirst {
}

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

@DocumentFirst
class A{ }

class B extends A{ }

@DocumentSecond
class C{ }

class D extends C{ }


public class DocumentDemo {

    public static void main(String[] args){
        A instanceA=new B();
        System.out.println("实例 B 拥有的注解:"+Arrays.toString(instanceA.getClass().getAnnotations()));

        C instanceC = new D();

        System.out.println("实例 D 拥有的注解:"+Arrays.toString(instanceC.getClass().getAnnotations()));
    }

    /**
     * 运行结果:
     实例 B 拥有的注解:[@cn.lnj.annotationdemo.DocumentFirst()]
     实例 D 拥有的注解:[]
     */
}

可以看出来，添加了@Inherited元注解的注解，这个类被继承后的子类也可以拥有这个注解。也就是说这个注解的作用范围是父类和子类。而没有添加这个元注解的注解，作用范围只有被添加的类。

@Repeatable

添加这个注解后，注解可以在同一个声明上使用多次，来看一个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public @interface DocumentA {
    String[] names;
}

@Repeatable
public @interface DocumentB {
    String[] names;
}

//相同的注解，不能同时声明多次，因为没有添加@Repeatable注解
@DocumentA(names="AAA")
//@DocumentA(names="BBB")
class A { }

//相同的注解，可以同时被声明多次，不会报错
@DocumentB(names="AAA")
@DocumentB(names="BBB")
class B { }

@FunctionalInterface

在 jdk1.8中添加了 lambda 表达式，也就是函数式编程。虽然说添加了lambda，但也并不是所有的东西都可以无条件的去使用。需要在接口上添加@FunctionalInterface注解，并且这个接口里面只能有一个抽象方法。

通过 aop 来进行拦截

通过上面我们可以进行一个自定义的注解，但是我们即便把他声明在方法上，它其实还是没有作用的，如果需要这个注解起到我们想要的作用还需要进行自定义的处理。比如我们使用 aop 来进行这个处理

首先定义一个注解

1
2
3
4
5
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface HelloAnnotation {
    
}

然后在方法上添加这个注解

1
2
3
4
@HelloAnnotation
public void sayHello(){
    System.out.println("i am working");
}

最后定义拦截器

1
2
3
4
5
6
7
8
9
@Around("@annotation(HelloAnnotation)")
public Object around(ProceedingJoinPoint proceedingJoinPoint, HelloAnnotation helloAnnotation) {
	//方法执行前
    System.out.println("start");
    //调用方法
    proceedingJoinPoint.proceed();
    //方法执行后
    System.out.println("finish");
}

这样我们就可以在调用sayHello()这个方法后，执行这个拦截器逻辑。

参考