java中的注解（Annotation）详解

前言

最近在学习ButterKnife知识,涉及到注解相关知识,就想系统学习下,查看了一些博客,甚至包括java作者Gosling编写的《java编程规范》第三版中译版看,看完后依旧不是太懂,直到看到了秒懂，Java 注解 （Annotation）你可以这样学这篇文章,才真正直到注解的用法与作用.然后我结合Java 注解（Annotation）这篇文章,从自己理解的角度补充了一些点知识.

定义

Java 注解（Annotation）又称 Java 标注，是 JDK5.0 引入的一种注释机制。

   大白话: 注解好比标签,给需要被标记的东西贴上就行了.

看完定义,还是一脸懵逼,这玩意有啥用呢? 没啥用我学它不是浪费时间嘛,下面我们来看看官方说明的用途

用途

1. 提供信息给编译器： 编译器可以利用注解来探测错误和警告信息

   比如我们常见到的 @Override, @Deprecated, @SuppressWarnings 是不是很熟悉的feel?
   

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

   比如我们常用的框架'ButterKnife, EventBus, Retrofit'等,都充斥着大量的注解,查看源码,了解注解知识必不可少.
   

3. 运行时的处理： 某些注解可以在程序运行的时候接受代码的提取

   运行时,通过动态获取属性来完成一些工作(这个有点抽象,下面会有例子说明).
   

关于注解其余的用处,等掌握了注解的详细知识,你就可以自由发挥啦! 现在我们知道注解用很多用处了,那就开始学习它吧.

注解的语法

 查看了Gosling编写的《java编程规范》第三版中译版,注解放在第九章接口这个章节里面讲解,其解释如下:

注解类型声明: 是一种特殊的接口声明,为了把注释类型声明与普通接口声明区分开,在关键字Interface前面放置了一个@符号.@”作为前缀声明 ，向编译器说明，该元素(Annotation)是注解.注解在编译后，编译器会自动继承java.lang.annotation.Annotation接口

public interface Annotation {
   
    boolean equals(Object obj);
    int hashCode();
    String toString();
    /**
     * Returns the annotation type of this annotation.
     * @return the annotation type of this annotation
     */
    Class annotationType();
}

使用自定义注解时应该注意以下几个问题:

• 定义注解(@interface )时，不能继承其他的注解或接口,编译器会自动继承java.lang.annotation.Annotation接口
• 只能用public或默认(default)这两个访问权修饰
• 参数成员只能用基本类型byte,short,char,int,long,float,double,boolean八种基本数据类型和 String,Enum,Class,annotations等数据类型,以及这一些类型的数组

这里说参数成员可能有些不懂,后面注解属性会讲到,这儿主要是先列出注解的语法,同比与类,接口,枚举等,它们都有自己的语法规则.

 *
 * @author  Peter von der Ahé
 * @author  Joshua Bloch
 * @jls 9.6.1.4 @Override
 * @since 1.5
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}

点开Override 的源码查看,确实如此,interface前面加了个@符号. 那么,下一个问题来了,我定义了一个这样的注解,它到底怎么工作呢?

public @interface TestAnnotation {
}

既然我们使用注解这个类型,自然要遵从人家的规则.java定义了几个元注解,用于注解到注解上的注解,它规定了注解的使用范围,生命周期等等, 元标签有 @Retention、@Documented、@Target、@Inherited、@Repeatable 5 种。以及预置的注解@Override,@Deprecated,@SuppressWarnings,@SafeVarargs,FunctionalInterface

这儿我举个栗子帮助理解下:
地球上的每个人都是人,从出生就被贴上了很多标签; 现在假设我们有如下几个元标签以及内置标签(这些都是地球人公认的东西,也是大家遵循的规则,好比我们java开发遵循java语法一样)

元标签
@Color: 有wihte, yellow, black三个值,---------------类比于元注解 @Retention
@Aera : 有Asia(亚洲),Europe(欧洲),North America(北美洲),South America(南美洲),Africa(非洲),Oceania(大洋洲),Antarctica(南极洲)------------类比于@Target

内置标签
@China, @English, @American 等等

此外我们遵循注解的语法,定义Otaku(宅男)这一标签

public @Interface Otaku{

}

好了,宅男定义完了,现在我们来给一个人来打标签

@Aera(Europe)
@Color(yellow)
@Otaku
public @Interface People{

}

现在我们就知道了,这个人是欧洲的黄种宅男,Otaku(宅男)就是我们的自定义标签,它与元标签,内置标签是同一层级关系,都是java.lang.annotation.Annotation接口的子类,只不过是我们划分的维度不一样..元标签,内置标签是jdk定义的,而Otaku(宅男)是我们自己定义.所以一个人可以从不同维度打很多个标签.

标签.png

Annotation.png

现在我们已经了解了注解的语法规则与元注解,内置注解,自定义注解的关系了,接下来我们就详细看看他们的作用吧.

元注解

1. @Retention

etention 的英文意为保留期的意思。当 @Retention 应用到一个注解上的时候，它解释说明了这个注解的生命周期。它的取值如下:

• RetentionPolicy.SOURCE 注解只在源码阶段保留，在编译器进行编译时它将被丢弃忽视。
• RetentionPolicy.CLASS 注解只被保留到编译进行的时候，它并不会被加载到 JVM 中。
• RetentionPolicy.RUNTIME 注解可以保留到程序运行的时候，它会被加载进入到 JVM 中，所以在程序运行时可以获取到它们。

2. @Documented

这个元注解肯定是和文档有关。它的作用是能够将注解中的元素包含到 Javadoc 中去。

3. @Target

指定了注解运用的地方。类比到标签，原本标签是你想张贴到哪个地方就到哪个地方，但是因为 @Target 的存在，它张贴的地方就非常具体了，比如只能张贴到方法上、类上、方法参数上等等。@Target 有下面的取值:

 * ElementType.ANNOTATION_TYPE---------------------给注解进行注解
* ElementType.CONSTRUCTOR --------------------------给构造方法进行注解
* ElementType.FIELD ---------------------------------给属性进行注解
* ElementType.LOCAL_VARIABLE  ----------------------给局部变量进行注解
* ElementType.METHOD  -----------------------------------给方法进行注解
* ElementType.PACKAGE  ----------------------------------给一个包进行注解
* ElementType.PARAMETER  ------------------------------给一个方法内的参数进行注解
* ElementType.TYPE  ------------------------------------给一个类型进行注解，比如类、接口、枚举

4. @Inherited
   Inherited 是继承的意思，但是它并不是说注解本身可以继承，而是说如果一个超类被 @Inherited 注解过的注解进行注解的话，那么如果它的子类没有被任何注解应用的话，那么这个子类就继承了超类的注解。
   说的比较抽象。代码来解释。

@Inherited
@Retention(RetentionPolicy.RUNTIME)
@interface Test {}


@Test
public class A {}


public class B extends A {}

注解 Test 被 @Inherited 修饰，之后类 A 被 Test 注解，类 B 继承 A,类 B 也拥有 Test 这个注解。
可以这样理解：

老子非常有钱，所以人们给他贴了一张标签叫做富豪。
老子的儿子长大后，只要没有和老子断绝父子关系，虽然别人没有给他贴标签，但是他自然也是富豪。
老子的孙子长大了，自然也是富豪。
这就是人们口中戏称的富一代，富二代，富三代。虽然叫法不同，好像好多个标签，但其实事情的本质也就是他们有一张共同的标签，也就是老子身上的那张富豪的标签。

5. @Repeatable

Repeatable 自然是可重复的意思。@Repeatable 是 Java 1.8 才加进来的，所以算是一个新的特性。
什么样的注解会多次应用呢？通常是注解的值可以同时取多个。

举个例子，一个人他既是程序员又是产品经理,同时他还是个画家。

@interface Persons {
    Person[]  value();
}


@Repeatable(Persons.class)
@interface Person{
    String role default "";
}


@Person(role="artist")
@Person(role="coder")
@Person(role="PM")
public class SuperMan{
    
}

注意上面的代码，@Repeatable 注解了 Person。而 @Repeatable 后面括号中的类相当于一个容器注解。
什么是容器注解呢？就是用来存放其它注解的地方。它本身也是一个注解。
我们再看看代码中的相关容器注解。

@interface Persons {
    Person[]  value();
}

按照规定，它里面必须要有一个 value 的属性，属性类型是一个被 @Repeatable 注解过的注解数组，注意它是数组。

如果不好理解的话，可以这样理解。Persons 是一张总的标签，上面贴满了 Person 这种同类型但内容不一样的标签。把 Persons 给一个 SuperMan 贴上，相当于同时给他贴了程序员、产品经理、画家的标签。

我们可能对于 @Person(role=“PM”) 括号里面的内容感兴趣，它其实就是给 Person 这个注解的 role 属性赋值为 PM ，大家不明白正常，请看下面注解的属性这一块。

注解属性(★★★)

注解的属性也叫做成员变量。注解只有成员变量，没有方法。注解的成员变量在注解的定义中以“无形参的方法”形式来声明，其方法名定义了该成员变量的名字，其返回值定义了该成员变量的类型。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface TestAnnotation {
    
    int id();    //注意,id是成员变量,返回值是int类型,它是以方法名定义了该成员变量的名字
    
    String msg();

}

上面代码定义了 TestAnnotation 这个注解中拥有 id 和 msg 两个属性。在使用的时候，我们应该给它们进行赋值。赋值的方式是在注解的括号内以 value="" 形式，多个属性之前用 ，隔开。

@TestAnnotation(id=3,msg="hello annotation")
public class Test {

}

需要注意的是，在注解中定义属性时它的类型必须是 8 种基本数据类型外加 类、接口、注解及它们的数组。
注解中属性可以有默认值，默认值需要用 default 关键值指定。比如：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface TestAnnotation {
    
    public int id() default -1;
    
    public String msg() default "Hi";

}

因为有默认值，所以无需要再在 @TestAnnotation 后面的括号里面进行赋值了，这一步可以省略。

@TestAnnotation()
public class Test {
}

另外，还有一种情况。如果一个注解内仅仅只有一个名字为 value 的属性时，应用这个注解时可以直接接属性值填写到括号内。

public @interface Check {
    String value();
}

//简单使用方式如下: 

@Check("hi")
int a;

//效果等同于
@Check(value="hi")
int a;

最后，还需要注意的一种情况是一个注解没有任何属性。比如

public @interface Perform {
}


//使用如下
@Perform
public void testMethod(){}

无属性的注解,括号可以省略. 这个例子很常见,比如我们常见的内置注解@Override,你加不加()都不影响.

内置注解

1. @Override

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}

很常见,大家都熟悉,提示子类要复写父类中被 @Override 修饰的方法,作用于方法上,生命周期:存在于源代码

2. @Deprecated

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE})
public @interface Deprecated {
}

这个元素是用来标记过时的元素，想必大家在日常开发中经常碰到。编译器在编译阶段遇到这个注解时会发出提醒警告，告诉开发者正在调用一个过时的元素比如过时的方法、过时的类、过时的成员变量。

3. @SuppressWarnings

@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.SOURCE)
public @interface SuppressWarnings {
    String[] value();
}

阻止警告的意思。之前说过调用被 @Deprecated 注解的方法后，编译器会警告提醒，而有时候开发者会忽略这种警告，他们可以在调用的地方通过 @SuppressWarnings 达到目的。

4. @SafeVarargs

参数安全类型注解。它的目的是提醒开发者不要用参数做一些不安全的操作,它的存在会阻止编译器产生 unchecked 这样的警告。它是在 Java 1.7 的版本中加入的。

@SafeVarargs // Not actually safe!
    static void m(List... stringLists) {
    Object[] array = stringLists;
    List tmpList = Arrays.asList(42);
    array[0] = tmpList; // Semantically invalid, but compiles without warnings
    String s = stringLists[0].get(0); // Oh no, ClassCastException at runtime!
}

上面的代码中，编译阶段不会报错，但是运行时会抛出 ClassCastException 这个异常，所以它虽然告诉开发者要妥善处理，但是开发者自己还是搞砸了。

Java 官方文档说，未来的版本会授权编译器对这种不安全的操作产生错误警告。

5. @FunctionalInterface

函数式接口注解，这个是 Java 1.8 版本引入的新特性。函数式编程很火，所以 Java 8 也及时添加了这个特性。函数式接口 (Functional Interface) 就是一个具有一个方法的普通接口。

上面我们已经弄清楚了注解的定义方法,以及作用域,生命周期等等,那么,我们使用注解后,如何来获取注解里面的内容呢?

要想正确检阅注解，离不开一个手段，那就是反射。

注解与反射

注解通过反射获取。首先可以通过 Class 对象的 isAnnotationPresent() 方法判断它是否应用了某个注解

public boolean isAnnotationPresent(Class annotationClass) {}

然后通过 getAnnotation() 方法来获取 Annotation 对象。

//返回指定类型的注解
public  A getAnnotation(Class annotationClass) {}

或者是 getAnnotations() 方法。

//返回注解到这个元素上的所有注解。适用于含有多个注解的情况
public Annotation[] getAnnotations() {}

如果获取到的 Annotation 如果不为 null，则就可以调用它们的属性方法了。比如

@TestAnnotation()
public class Test {
    
    public static void main(String[] args) {
        
        boolean hasAnnotation = Test.class.isAnnotationPresent(TestAnnotation.class);
        
        if ( hasAnnotation ) {
            TestAnnotation testAnnotation = Test.class.getAnnotation(TestAnnotation.class);
        
            System.out.println("id:"+testAnnotation.id());
            System.out.println("msg:"+testAnnotation.msg());
        }

    }

}

程序运行结果如下:

id:-1
msg:

上面的例子中，只是检阅出了注解在类上的注解，其实属性、方法上的注解照样是可以的。同样还是要假手于反射。

@TestAnnotation(msg="hello")
public class Test {
    
    @Check(value="hi")
    int a;
    
    
    @Perform
    public void testMethod(){}
    
    
    @SuppressWarnings("deprecation")
    public void test1(){
        Hero hero = new Hero();
        hero.say();
        hero.speak();
    }


    public static void main(String[] args) {
        
        boolean hasAnnotation = Test.class.isAnnotationPresent(TestAnnotation.class);
        
        if ( hasAnnotation ) {
            TestAnnotation testAnnotation = Test.class.getAnnotation(TestAnnotation.class);
            //获取类的注解
            System.out.println("id:"+testAnnotation.id());
            System.out.println("msg:"+testAnnotation.msg());
        }
        
        
        try {
            Field a = Test.class.getDeclaredField("a");
            a.setAccessible(true);
            //获取一个成员变量上的注解
            Check check = a.getAnnotation(Check.class);
            
            if ( check != null ) {
                System.out.println("check value:"+check.value());
            }
            
            Method testMethod = Test.class.getDeclaredMethod("testMethod");
            
            if ( testMethod != null ) {
                // 获取方法中的注解
                Annotation[] ans = testMethod.getAnnotations();
                for( int i = 0;i < ans.length;i++) {
                    System.out.println("method testMethod annotation:"+ans[i].annotationType().getSimpleName());
                }
            }
        } catch (NoSuchFieldException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            System.out.println(e.getMessage());
        } catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            System.out.println(e.getMessage());
        } catch (NoSuchMethodException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            System.out.println(e.getMessage());
        }
        
        

    }

}

运行结果如下:

id:-1
msg:hello
check value:hi
method testMethod annotation:Perform

需要注意的是，如果一个注解要在运行时被成功提取，那么 @Retention(RetentionPolicy.RUNTIME) 是必须的。

当开发者使用了自定义的Annotation 修饰了类、方法、Field 等成员之后，这些 Annotation 不会自己生效，必须由开发者提供相应的代码来提取并处理 Annotation 信息。这些处理提取和处理 Annotation 的代码统称为 APT（Annotation Processing Tool)。

回到我们前面所说的注解的作用第三条:

运行时的处理： 某些注解可以在程序运行的时候接受代码的提取

例子如下:

我要写一个测试框架，测试程序员的代码有无明显的异常。

—— 程序员 A : 我写了一个类，它的名字叫做 NoBug，因为它所有的方法都没有错误。
—— 我：自信是好事，不过为了防止意外，让我测试一下如何？
—— 程序员 A: 怎么测试？
—— 我：把你写的代码的方法都加上 @Jiecha 这个注解就好了。
—— 程序员 A: 好的。

public class NoBug {
   
   @Jiecha
   public void suanShu(){
       System.out.println("1234567890");
   }
   @Jiecha
   public void jiafa(){
       System.out.println("1+1="+1+1);
   }
   @Jiecha
   public void jiefa(){
       System.out.println("1-1="+(1-1));
   }
   @Jiecha
   public void chengfa(){
       System.out.println("3 x 5="+ 3*5);
   }
   @Jiecha
   public void chufa(){
       System.out.println("6 / 0="+ 6 / 0);
   }
   
   public void ziwojieshao(){
       System.out.println("我写的程序没有 bug!");
   }

}

上面的代码，有些方法上面运用了 @Jiecha 注解。这个注解是我写的测试软件框架中定义的注解

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

}

然后，我再编写一个测试类 TestTool 就可以测试 NoBug 相应的方法了。

public class TestTool {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        
        NoBug testobj = new NoBug();
        
        Class clazz = testobj.getClass();
        
        Method[] method = clazz.getDeclaredMethods();
        //用来记录测试产生的 log 信息
        StringBuilder log = new StringBuilder();
        // 记录异常的次数
        int errornum = 0;
        
        for ( Method m: method ) {
            // 只有被 @Jiecha 标注过的方法才进行测试
            if ( m.isAnnotationPresent( Jiecha.class )) {
                try {
                    m.setAccessible(true);
                    m.invoke(testobj, null);
                
                } catch (Exception e) {
                    // TODO Auto-generated catch block
                    //e.printStackTrace();
                    errornum++;
                    log.append(m.getName());
                    log.append(" ");
                    log.append("has error:");
                    log.append("\n\r  caused by ");
                    //记录测试过程中，发生的异常的名称
                    log.append(e.getCause().getClass().getSimpleName());
                    log.append("\n\r");
                    //记录测试过程中，发生的异常的具体信息
                    log.append(e.getCause().getMessage());
                    log.append("\n\r");
                } 
            }
        }
        
        
        log.append(clazz.getSimpleName());
        log.append(" has  ");
        log.append(errornum);
        log.append(" error.");
        
        // 生成测试报告
        System.out.println(log.toString());

    }

}

测试的结果是：

1234567890
1+1=11
1-1=0
3 x 5=15
chufa has error:

  caused by ArithmeticException

/ by zero

NoBug has  1 error.

其实,个人觉得,它更大的作用在于第二点

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

很多优秀的框架正是应用到了这点,减少了很多重复性的开发工作.

最后

本文几乎大多是转自秒懂，Java 注解 （Annotation）你可以这样学这篇文章,外加Java 注解（Annotation）结合并补充了自己的理解. 再次对作者表示敬意,本文主要记录自己学习理解过程,加深自己对这一知识的理解, 并不作为任何商业用途!

参考文献

秒懂，Java 注解 （Annotation）你可以这样学
Java 注解（Annotation）