java面试之注解

转载自
https://blog.csdn.net/qq_41701956/article/details/80250226
说说自定义注解的场景及实现
（此题自由发挥，就看你对注解的理解了!==）登陆、权限拦截、日志处理，以及各种Java框架，如Spring，Hibernate，JUnit 提到注解就不能不说反射，Java自定义注解是通过运行时靠反射获取注解。实际开发中，例如我们要获取某个方法的调用日志，可以通过AOP（动态代理机制）给方法添加切面，通过反射来获取方法包含的注解，如果包含日志注解，就进行日志记录。

什么是注解?

注解如同标签,想像代码具有生命，注解就是对于代码中某些鲜活个体的贴上去的一张标签。简化来讲，注解如同一张标签。比如xx是傻逼，这样下定义。
注解语法
因为平常开发少见，相信有不少的人员会认为注解的地位不高。其实同 classs 和 interface 一样，注解也属于一种类型。它是在 Java SE 5.0 版本中开始引入的概念。

注解的定义
注解可以通过 @interface 这样的的关键字进行定义。

public @interface TestAnnotation {
}
它的形式跟接口很类似，不过前面多了一个 @ 符号。上面的代码就创建了一个名字为 TestAnnotaion 的注解。

你可以简单理解为创建了一张名字为 TestAnnotation 的标签，并且表明这是一个接口。

元注解
元注解是什么意思呢？

元注解是可以注解到注解上的注解，或者说元注解是一种基本注解，但是它能够应用到其它的注解上面。

如果难于理解的话，你可以这样理解。元注解也是一张标签，但是它是一张特殊的标签，它的作用和目的就是给其他普通的标签进行解释说明的。
元标签有 @Retention、@Documented、@Target、@Inherited、@Repeatable 5 种。
jdk1.7
@SafeVarargs
参数安全类型注解。它的目的是提醒开发者不要用参数做一些不安全的操作,它的存在会阻止编译器产生 unchecked 这样的警告。它是在 Java 1.7 的版本中加入的。
jdk1.8
@FunctionalInterface
函数式接口注解，这个是 Java 1.8 版本引入的新特性。函数式编程很火，所以 Java 8 也及时添加了这个特性。

注解的使用场景
1，取决你使用的目的，比如调试bug，添加注释，表明身份，等
注解应用实例
Android，开发：JUnit，ButterKnife，Dagger2，Retrofit（Http 网络访问框架）

如果注解难于理解，你就把它类同于标签，标签为了解释事物，注解为了解释代码。
注解的基本语法，创建如同接口，但是多了个 @ 符号。
注解的元注解。
注解的属性。
注解主要给编译器及工具类型的软件用的。
注解的提取需要借助于 Java 的反射技术，反射比较慢，所以注解使用时也需要谨慎计较时间成本。

//-------------------以下是原文
推荐这个，写的有趣宜懂
https://blog.csdn.net/briblue/article/details/73824058
在这里插入图片描述

这处图片引自老罗的博客。为了避免不必要的麻烦，首先声明我个人比较尊敬老罗的。至于为什么放这张图，自然是为本篇博文服务，接下来我自会说明。好了，可以开始今天的博文了。

Annotation 中文译过来就是注解、标释的意思，在 Java 中注解是一个很重要的知识点，但经常还是有点让新手不容易理解。

我个人认为，比较糟糕的技术文档主要特征之一就是：用专业名词来介绍专业名词。

比如：

Java 注解用于为 Java 代码提供元数据。作为元数据，注解不直接影响你的代码执行，但也有一些类型的注解实际上可以用于这一目的。Java 注解是从 Java5 开始添加到 Java 的。

这是大多数网站上对于 Java 注解，解释确实正确，但是说实在话，我第一次学习的时候，头脑一片空白。这什么跟什么啊？听了像没有听一样。因为概念太过于抽象，所以初学者实在是比较吃力才能够理解，然后随着自己开发过程中不断地强化练习，才会慢慢对它形成正确的认识。

我在写这篇文章的时候，我就在思考。如何让自己或者让读者能够比较直观地认识注解这个概念？是要去官方文档上翻译说明吗？我马上否定了这个答案。

后来，我想到了一样东西————墨水，墨水可以挥发、可以有不同的颜色，用来解释注解正好。

不过，我继续发散思维后，想到了一样东西能够更好地代替墨水，那就是印章。印章可以沾上不同的墨水或者印泥，可以定制印章的文字或者图案，如果愿意它也可以被戳到你任何想戳的物体表面。

但是，我再继续发散思维后，又想到一样东西能够更好地代替印章，那就是标签。标签是一张便利纸，标签上的内容可以自由定义。常见的如货架上的商品价格标签、图书馆中的书本编码标签、实验室中化学材料的名称类别标签等等。

在这里插入图片描述

所以，基于如此，我完成了自我的知识认知升级，我决定用标签来解释注解。

注解如同标签
回到博文开始的地方，之前某新闻客户端的评论有盖楼的习惯，于是 “乔布斯重新定义了手机、罗永浩重新定义了傻X” 就经常极为工整地出现在了评论楼层中，并且广大网友在相当长的一段时间内对于这种行为乐此不疲。这其实就是等同于贴标签的行为。

在某些网友眼中，罗永浩就成了傻X的代名词。

广大网友给罗永浩贴了一个名为“傻x”的标签，他们并不真正了解罗永浩，不知道他当教师、砸冰箱、办博客的壮举，但是因为“傻x”这样的标签存在，这有助于他们直接快速地对罗永浩这个人做出评价，然后基于此，罗永浩就可以成为茶余饭后的谈资，这就是标签的力量。

在这里插入图片描述

老罗还是老罗，但是由于人们对于它贴上的标签不同，所以造成对于他的看法大相径庭，不喜欢他的人整天在网络上评论抨击嘲讽，而崇拜欣赏他的人则会愿意挣钱购买锤子手机的发布会门票。

我无意于评价这两种行为，我再引个例子。

《奇葩说》是近年网络上非常火热的辩论节目，其中辩手陈铭被另外一个辩手马薇薇攻击说是————“站在宇宙中心呼唤爱”，然后贴上了一个大大的标签————“鸡汤男”，自此以后，观众再看到陈铭的时候，首先映入脑海中便是“鸡汤男”三个大字，其实本身而言陈铭非常优秀，为人师表、作风正派、谈吐举止得体，但是在网络中，因为娱乐至上的环境所致，人们更愿意以娱乐的心态来认知一切，于是“鸡汤男”就如陈铭自己所说成了一个撕不了的标签。

我们可以抽象概括一下，标签是对事物行为的某些角度的评价与解释。

到这里，终于可以引出本文的主角注解了。

初学者可以这样理解注解：想像代码具有生命，注解就是对于代码中某些鲜活个体的贴上去的一张标签。简化来讲，注解如同一张标签。

在未开始学习任何注解具体语法而言，你可以把注解看成一张标签。这有助于你快速地理解它的大致作用。如果初学者在学习过程有大脑放空的时候，请不要慌张，对自己说：

注解，标签。注解，标签。

注解语法
因为平常开发少见，相信有不少的人员会认为注解的地位不高。其实同 classs 和 interface 一样，注解也属于一种类型。它是在 Java SE 5.0 版本中开始引入的概念。

注解的定义
注解通过 @interface 关键字进行定义。

public @interface TestAnnotation {
}

它的形式跟接口很类似，不过前面多了一个 @ 符号。上面的代码就创建了一个名字为 TestAnnotaion 的注解。

你可以简单理解为创建了一张名字为 TestAnnotation 的标签。

注解的应用
上面创建了一个注解，那么注解的的使用方法是什么呢。

@TestAnnotation
public class Test {
}

创建一个类 Test,然后在类定义的地方加上 @TestAnnotation 就可以用 TestAnnotation 注解这个类了。

你可以简单理解为将 TestAnnotation 这张标签贴到 Test 这个类上面。

不过，要想注解能够正常工作，还需要介绍一下一个新的概念那就是元注解。

元注解
元注解是什么意思呢？

元注解是可以注解到注解上的注解，或者说元注解是一种基本注解，但是它能够应用到其它的注解上面。

如果难于理解的话，你可以这样理解。元注解也是一张标签，但是它是一张特殊的标签，它的作用和目的就是给其他普通的标签进行解释说明的。

元标签有 @Retention、@Documented、@Target、@Inherited、@Repeatable 5 种。

@Retention
Retention 的英文意为保留期的意思。当 @Retention 应用到一个注解上的时候，它解释说明了这个注解的的存活时间。

它的取值如下：

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

我们可以这样的方式来加深理解，@Retention 去给一张标签解释的时候，它指定了这张标签张贴的时间。@Retention 相当于给一张标签上面盖了一张时间戳，时间戳指明了标签张贴的时间周期。

@Retention(RetentionPolicy.RUNTIME)
public @interface TestAnnotation {
}

上面的代码中，我们指定 TestAnnotation 可以在程序运行周期被获取到，因此它的生命周期非常的长。

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

@Target
Target 是目标的意思，@Target 指定了注解运用的地方。

你可以这样理解，当一个注解被 @Target 注解时，这个注解就被限定了运用的场景。

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

ElementType.ANNOTATION_TYPE 可以给一个注解进行注解
ElementType.CONSTRUCTOR 可以给构造方法进行注解
ElementType.FIELD 可以给属性进行注解
ElementType.LOCAL_VARIABLE 可以给局部变量进行注解
ElementType.METHOD 可以给方法进行注解
ElementType.PACKAGE 可以给一个包进行注解
ElementType.PARAMETER 可以给一个方法内的参数进行注解
ElementType.TYPE 可以给一个类型进行注解，比如类、接口、枚举
@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 这个注解。

可以这样理解：

老子非常有钱，所以人们给他贴了一张标签叫做富豪。

老子的儿子长大后，只要没有和老子断绝父子关系，虽然别人没有给他贴标签，但是他自然也是富豪。

老子的孙子长大了，自然也是富豪。

这就是人们口中戏称的富一代，富二代，富三代。虽然叫法不同，好像好多个标签，但其实事情的本质也就是他们有一张共同的标签，也就是老子身上的那张富豪的标签。

@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();
    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 中 id 属性默认值为 -1，msg 属性默认值为 Hi。
它可以这样应用。

@TestAnnotation()
public class Test {}
1
2
因为有默认值，所以无需要再在 @TestAnnotation 后面的括号里面进行赋值了，这一步可以省略。

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

public @interface Check {
String value();
}

上面代码中，Check 这个注解只有 value 这个属性。所以可以这样应用。

@Check(“hi”)
int a;
这和下面的效果是一样的

@Check(value=“hi”)
int a;

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

public @interface Perform {}

那么在应用这个注解的时候，括号都可以省略。

@Perform
public void testMethod(){}

Java 预置的注解
学习了上面相关的知识，我们已经可以自己定义一个注解了。其实 Java 语言本身已经提供了几个现成的注解。

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

public class Hero {

@Deprecated
public void say(){
    System.out.println("Noting has to say!");
}


public void speak(){
    System.out.println("I have a dream!");
}

}

定义了一个 Hero 类，它有两个方法 say() 和 speak() ，其中 say() 被 @Deprecated 注解。然后我们在 IDE 中分别调用它们。

可以看到，say() 方法上面被一条直线划了一条，这其实就是编译器识别后的提醒效果。

@Override
这个大家应该很熟悉了，提示子类要复写父类中被 @Override 修饰的方法

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

@SuppressWarnings(“deprecation”)
public void test1(){
Hero hero = new Hero();
hero.say();
hero.speak();
}

@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 官方文档说，未来的版本会授权编译器对这种不安全的操作产生错误警告。

@FunctionalInterface
函数式接口注解，这个是 Java 1.8 版本引入的新特性。函数式编程很火，所以 Java 8 也及时添加了这个特性。

函数式接口 (Functional Interface) 就是一个具有一个方法的普通接口。

比如

@FunctionalInterface
public interface Runnable {
/**
* When an object implementing interface Runnable is used
* to create a thread, starting the thread causes the object’s
* run method to be called in that separately executing
* thread.
*

* The general contract of the method run is that it may
* take any action whatsoever.
*
* @see java.lang.Thread#run()
*/
public abstract void run();
}

我们进行线程开发中常用的 Runnable 就是一个典型的函数式接口，上面源码可以看到它就被 @FunctionalInterface 注解。

可能有人会疑惑，函数式接口标记有什么用，这个原因是函数式接口可以很容易转换为 Lambda 表达式。这是另外的主题了，有兴趣的同学请自己搜索相关知识点学习。

注解的提取
博文前面的部分讲了注解的基本语法，现在是时候检测我们所学的内容了。

我通过用标签来比作注解，前面的内容是讲怎么写注解，然后贴到哪个地方去，而现在我们要做的工作就是检阅这些标签内容。形象的比喻就是你把这些注解标签在合适的时候撕下来，然后检阅上面的内容信息。

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

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

public boolean isAnnotationPresent(Class<? extends Annotation> 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 中 id 和 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) 是必须的。

注解的使用场景
我相信博文讲到这里大家都很熟悉了注解，但是有不少同学肯定会问，注解到底有什么用呢？

对啊注解到底有什么用？

我们不妨将目光放到 Java 官方文档上来。

文章开始的时候，我用标签来类比注解。但标签比喻只是我的手段，而不是目的。为的是让大家在初次学习注解时能够不被那些抽象的新概念搞懵。既然现在，我们已经对注解有所了解，我们不妨再仔细阅读官方最严谨的文档。

注解是一系列元数据，它提供数据用来解释程序代码，但是注解并非是所解释的代码本身的一部分。注解对于代码的运行效果没有直接影响。

注解有许多用处，主要如下：

提供信息给编译器：编译器可以利用注解来探测错误和警告信息
编译阶段时的处理：软件工具可以用来利用注解信息来生成代码、Html文档或者做其它相应处理。
运行时的处理：某些注解可以在程序运行的时候接受代码的提取

值得注意的是，注解不是代码本身的一部分。

如果难于理解，可以这样看。罗永浩还是罗永浩，不会因为某些人对于他“傻x”的评价而改变，标签只是某些人对于其他事物的评价，但是标签不会改变事物本身，标签只是特定人群的手段。所以，注解同样无法改变代码本身，注解只是某些工具的的工具。

还是回到官方文档的解释上，注解主要针对的是编译器和其它工具软件(SoftWare tool)。

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

现在，我们可以给自己答案了，注解有什么用？给谁用？给编译器或者 APT 用的。

如果，你还是没有搞清楚的话，我亲自写一个好了。

亲手自定义注解完成某个目的
我要写一个测试框架，测试程序员的代码有无明显的异常。

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

NoBug.java

package ceshi;
import ceshi.Jiecha;

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 注解。

这个注解是我写的测试软件框架中定义的注解。

package ceshi;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

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

}

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

package ceshi;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

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.

提示 NoBug 类中的 chufa() 这个方法有异常，这个异常名称叫做 ArithmeticException，原因是运算过程中进行了除 0 的操作。

所以，NoBug 这个类有 Bug。

这样，通过注解我完成了我自己的目的，那就是对别人的代码进行测试。

所以，再问我注解什么时候用？我只能告诉你，这取决于你想利用它干什么用。

注解应用实例
注解运用的地方太多了，因为我是 Android 开发者，所以我接触到的具体例子有下：

JUnit
JUnit 这个是一个测试框架，典型使用方法如下：

public class ExampleUnitTest {
@Test
public void addition_isCorrect() throws Exception {
assertEquals(4, 2 + 2);
}
}

@Test 标记了要进行测试的方法 addition_isCorrect().

ButterKnife
ButterKnife 是 Android 开发中大名鼎鼎的 IOC 框架，它减少了大量重复的代码。

public class MainActivity extends AppCompatActivity {

@BindView(R.id.tv_test)
TextView mTv;
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    ButterKnife.bind(this);
}

}

Dagger2
也是一个很有名的依赖注入框架。

Retrofit
很牛逼的 Http 网络访问框架

public interface GitHubService {
@GET(“users/{user}/repos”)
Call<List> listRepos(@Path(“user”) String user);
}

Retrofit retrofit = new Retrofit.Builder()
.baseUrl(“https://api.github.com/”)
.build();

GitHubService service = retrofit.create(GitHubService.class);

当然，还有许多注解应用的地方，这里不一一列举。

总结
如果注解难于理解，你就把它类同于标签，标签为了解释事物，注解为了解释代码。
注解的基本语法，创建如同接口，但是多了个 @ 符号。
注解的元注解。
注解的属性。
注解主要给编译器及工具类型的软件用的。
注解的提取需要借助于 Java 的反射技术，反射比较慢，所以注解使用时也需要谨慎计较时间成本。

转载自
作者：frank909

原文：https://blog.csdn.net/briblue/article/details/73824058

//------------------------------------
以下是关于java注解的一些使用
https://www.jianshu.com/p/b560b30726d4

PS：如果你还不会使用注解，你肯定不好意思对别人说你学过Spring，你学过Mybatis，因为它们用了大量的注解。可见注解在开发领域已经使用的非常广泛了。

配图.jpg

注解的好处：
1.能够读懂别人写的代码，特别是框架相关的代码。
2.本来可能需要很多配置文件，需要很多逻辑才能实现的内容，就可以使用一个或者多个注解来替代，这样就使得编程更加简洁，代码更加清晰。
3.（重点）刮目相看。
（但是怎么样才能让别人刮目相看呢？会用注解不是目的，最重要的是要使用自定义注解来解决问题。）
举个栗子：
如果面试的时候，你跟老板说你会使用注解，老板觉得你这个人还行；但是如果老板发现你会自定义注解解决问题，老板肯定就会眼前一亮。
注解这一概念是在java1.5版本提出的，说Java提供了一种原程序中的元素关联任何信息和任何元数据的途径的方法。
一、Java中的常见注解
1）JDK注解
JDK注解一共分为三类：

JDK注解.png

案例：
我们先新建一个接口people，如下：
public interface people {
public String name();
public int age();
public void work();
}

然后再建一个类Child实现类people这个接口，并实现该类的方法：
public class Child implements people {
@Override
public String name() {
return null;
}

@Override
public int age() {
    return 0;
}

@Override
public void work() {

}

看到这里，我们发现这里的所有方法都会加上一个@Override标记，它告诉我们，同时也告诉编译器我们的这些方法肯定覆盖了类people里面的方法的。假如说，我现在把类people里面的某一个方法注释掉：
//public String name();

再看类Child里面的name方法就会报错。这样，以后大家看到@Override的时候就能想到这个方法是覆盖了某个接口的方法的。
然后，我们回过头来看类people里面有一个work的方法。这里我们可以理解为人是要工作的，但是并不是所有的人都在工作，那么怎么办呢？如果说这个接口正在用，我们不能删除这个方法，这个时候我们就可以这样：
@Deprecated
public void work();

@Deprecated标记就表明这个方法已经过时了，在实际中，它又有什么样的应用场景呢？我们在建一个测试类：
public class Test {
public void work() {
people people=new Child();
！ people.work();
}
}

这个时候我们会发现myeclipse会给一个警告，并且在work中间出现一个破折号，意思就是这个方法已经过时了。那么问题来了，虽然这个方法过时了，但是我们就是那么傲娇，一定要用它，怎么办呢？只需要这样：
public class Test {
@SuppressWarnings(“deprecation”)
public void work() {
people people=new Child();
people.work();
}
}

这样我们就忽略了这个警告。@SuppressWarnings(“deprecation”)就表示我们忽略了deprecation这样的一个警告。
2）Java第三方注解

第三方注解.png

二、注解的分类
1）按照运行机制划分：
【源码注解→编译时注解→运行时注解】
源码注解：只在源码中存在，编译成.class文件就不存在了。
编译时注解：在源码和.class文件中都存在。像前面的@Override、@Deprecated、@SuppressWarnings，他们都属于编译时注解。
运行时注解：在运行阶段还起作用，甚至会影响运行逻辑的注解。像@Autowired自动注入的这样一种注解就属于运行时注解，它会在程序运行的时候把你的成员变量自动的注入进来。
2）按照来源划分：
【来自JDK的注解——来自第三方的注解——自定义注解】
3）元注解：
元注解是给注解进行注解，可以理解为注解的注解就是元注解。
三、自定义注解
我们分四步来解析自定义注解：
自定义注解的语法要求：
@Target({ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Description {
String desc();
String author();
int age() default 18;
}

首先我们要明确这不是一个接口，它是使用@interface关键字定义的一个注解。
然后我们看下面的几个方法，String desc();虽然它很类似于接口里面的方法，其实它在注解里面只是一个成员变量（成员以无参无异常的方式声明），int age() default 18;（成员变量可以用default指定一个默认值的）。
最后我们要知道：
①.成员类型是受限制的，合法的类型包括基本的数据类型以及String，Class，Annotation,Enumeration等。
②.如果注解只有一个成员，则成员名必须取名为value()，在使用时可以忽略成员名和赋值号（=）。
③.注解类可以没有成员，没有成员的注解称为标识注解。
元注解：
有没有发现上面那段代码有一个没有说呢？没错，它们就是我们所说的元注解：
@Target({ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented

我们先看第一行：@Target是这个注解的作用域，ElementType.METHOD是这个注解的作用域的列表，METHOD是方法声明，除此之外，还有：
CONSTRUCTOR（构造方法声明）,FIELD（字段声明）,LOCAL VARIABLE（局部变量声明）,METHOD（方法声明）,PACKAGE（包声明）,PARAMETER（参数声明）,TYPE（类接口）
第二行：@Retention是它的生命周期，前面不是说注解按照运行机制有一个分类嘛，RUNTIME就是在运行时存在，可以通过反射读取。除此之外，还有:
SOURCE（只在源码显示，编译时丢弃）,CLASS（编译时记录到class中，运行时忽略）,RUNTIME（运行时存在，可以通过反射读取）
第三行：@Inherited是一个标识性的元注解，它允许子注解继承它。
第四行：@Documented，生成javadoc时会包含注解。
使用自定义注解：
使用注解的语法：
@<注解名>(<成员名1>=<成员值1>,<成员名1>=<成员值1>,…)
案例：
@Description(desc=“i am Color”,author=“boy”,age=18)
public String Color() {
return “red”;
}

这里的Description是我们刚才在自定义注解语法要求里面定义的注解噢，然后我们可以给它的每一个成员变量赋值，注意数据类型。值得注意的是，因为我们前面定义的作用域是在方法和类接口上，所以这个注解在Color()方法上使用是没问题的。
解析注解
概念：
通过反射获取类、函数或成员上的运行时注解信息，从而实现动态控制程序运行的逻辑。
准备工作：

Description类.png

Child类.png

接下来，我们就开始测试了：
public class ParseAnn {
public static void main(String[] args) {
try {
// 使用类加载器加载类
Class c = Class.forName(“com.test.Child”);
// 找到类上面的注解
boolean isExist = c.isAnnotationPresent(Description.class);
// 上面的这个方法是用这个类来判断这个类是否存在Description这样的一个注解
if (isExist) {
// 拿到注解实例，解析类上面的注解
Description d = (Description) c.getAnnotation(Description.class);
System.out.println(d.value());
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}

输出的结果：
i am class annotation
可以看到，我们成功的解析了Child类上面的注解。
接下来，我们继续解析方法上的注解：
//获取所有的方法
Method[] ms = c.getMethods();
// 遍历所有的方法
for (Method m : ms) {
boolean isExist1 = m.isAnnotationPresent(Description.class);
if (isExist1) {
Description d1=m.getAnnotation(Description.class);
System.out.println(d1.value());
}
}

输出的结果：
i am class annotation
i am method annotation
可以看到，我们成功的解析了方法上面的注解。
//另一种解析方法
for (Method m : ms) {
//拿到方法上的所有的注解
Annotation[] as=m.getAnnotations();
for (Annotation a : as) {
//用二元操作符判断a是否是Description的实例
if (a instanceof Description) {
Description d=(Description) a;
System.out.println(d.value());
}
}
}

也可以得到上面的效果。
此时，如果把Description类里面的元注解改一下，比如:
@Retention(RetentionPolicy.RUNTIME)→@Retention(RetentionPolicy.SOURCE)，再运行程序，结果会成怎样呢？如果改成CLASS呢？读者们要不要试一试？
如果看过我写的《谈谈JAVA反射机制》——Class类的动态加载的读者，仔细想一下我们这个环境，就知道为什么了。

如果大家觉得我写的对你有帮助，请顺手点个赞支持一下呗；如果大家觉得我有写的不对的地方，欢迎大家多多发言。谢谢！

作者：locality
链接：https://www.jianshu.com/p/b560b30726d4
來源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。

https://blog.csdn.net/carson_ho/article/details/80728428

前言
在 Java中，注解（Annotation）非常重要，但对于很多开发者来说，这并不容易理解，甚至觉得有点神秘
今天，我将献上一份 Java注解的介绍 & 实战攻略，希望你们会喜欢。
目录

简介
定义：一种标识 / 标签
注解属于 Java中的一种类型，同类class 和接口interface 一样
在 Java SE 5.0开始引入
基础作用：标识 / 解释 Java 代码
应用场景
面向编译器 / APT 使用

APT（Annotation Processing Tool）：提取 & 处理 Annotation 的代码
因为当开发者使用Annotation 修饰类、方法、方法等成员后，这些 Annotation 不会自己生效，必须由开发者提供相应的代码来提取并处理 Annotation 信息。这些处理提取和处理 Annotation 的代码统称为 APT
所以说，注解除了最基本的解释 & 说明代码，注解的应用场景还取决于你想如何利用它

下面我举几个典型的应用场景：
场景1：测试代码
如出名的测试框架JUnit = 采用注解进行代码测试

public class ExampleUnitTest {
@Test
public void Method() throws Exception {
…
}
}
// @Test 标记了要进行测试的方法Method()

场景2：简化使用 & 降低代码量
如 Http网络请求库 Retrofit & IOC 框架ButterKnife

<-- Http网络请求库 Retrofit -->

// 采用注解描述网络请求参数
public interface GetRequest_Interface {

@GET(“ajax.php?a=fy&f=auto&t=auto&w=hello%20world”)
Call getCall();

}

<-- IOC 框架ButterKnife -->
public class MainActivity extends AppCompatActivity {

// 通过注解设置资源
@BindView(R.id.test)
TextView mTv;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);

    ButterKnife.bind(this);
}

}

注解的类型
注解的类型包括：元注解、 Java内置注解 & 自定义注解。

3.1 元注解
3.1.1 简介
定义：一种标识 / 标签
是一种基本注解 = Android系统内置的注解
作用：标识 / 解释开发者自定义的注解
3.1.2 注解、元注解 & Java代码的关系
元注解作用于注解 & 解释注解
// 元注解作用于注解 & 解释注解
// 元注解在注解定义时进行定义
@元注解
public @interface Carson_Annotation {

}

注解作用于Java代码 & 解释Java代码
// 注解作用于Java代码 & 解释Java代码
@Carson_Annotation
public class Carson {
}

3.1.3 元注解类型介绍
元注解共有5种，包括：

下面我将一一介绍
@Retention
定义：保留注解
作用：解释 / 说明了注解的生命周期
具体使用
// 元注解@Retention(RetentionPolicy.RUNTIME)的作用：说明注解Carson_Annotation的生命周期 = 保留到程序运行时 & 被加载到 JVM 中
@Retention(RetentionPolicy.RUNTIME)
public @interface Carson_Annotation {
}

<-- 元注解@Retention参数说明 -->
// RetentionPolicy.RUNTIME：注解保留到程序运行时 & 会被加载进入到 JVM 中，所以在程序运行时可以获取到它们
// RetentionPolicy.CLASS：注解只被保留到编译进行时 & 不会被加载到 JVM
// RetentionPolicy.SOURCE：注解只在源码阶段保留 & 在编译器进行编译时将被丢弃忽视。

@Documented
定义：Java文档注解
作用：将注解中的元素包含到 Javadoc文档中
具体使用
// 元注解@Documented作用：说明注解Carson_Annotation的元素包含到 Javadoc 文档中
@Documented
public @interface Carson_Annotation {
}

@Target
定义：目标注解
作用：限定了注解作用的目标范围，包括类、方法等等
具体使用
// 元注解@Target作用：限定了注解Carson_Annotation作用的目标范围 = 方法
// 即注解Carson_Annotation只能用于解释说明某个方法
@Target(ElementType.METHOD)
public @interface Carson_Annotation {
}

<-- @Target取值参数说明 -->
// ElementType.PACKAGE：可以给一个包进行注解
// ElementType.ANNOTATION_TYPE：可以给一个注解进行注解
// ElementType.TYPE：可以给一个类型进行注解，如类、接口、枚举
// ElementType.CONSTRUCTOR：可以给构造方法进行注解
// ElementType.METHOD：可以给方法进行注解
// ElementType.PARAMETER 可以给一个方法内的参数进行注解
// ElementType.FIELD：可以给属性进行注解
// ElementType.LOCAL_VARIABLE：可以给局部变量进行注解

@Inherited
定义：继承注解
作用：使得一个被@Inherited注解的注解作用的类的子类可以继承该类的注解
前提：子类没有被任何注解应用
如，注解@Carson_Annotation（被元注解@Inherited 注解）作用于A类，那么A类的子类则继承了A类的注解
具体使用

// 元注解@Inherited 作用于注解Carson_Annotation
@Inherited
public @interface Carson_Annotation {
}

// 注解Carson_Annotation 作用于A类
@Carson_Annotation
public class A {
}

// B类继承了A类，即B类 = A类的子类，且B类没被任何注解应用
// 那么B类继承了A类的注解 Carson_Annotation
public class B extends A {}

@Repeatable
定义：可重复注解
Java 1.8后引进
作用：使得作用的注解可以取多个值
具体使用
// 1. 定义容器注解 @ 职业
public @interface Job {
Person[] value();
}
<-- 容器注解介绍 -->
// 定义：本身也是一个注解
// 作用：存放其它注解
// 具体使用：必须有一个 value 属性；类型 = 被 @Repeatable 注解的注解数组
// 如本例中，被 @Repeatable 作用 = @Person ，所以value属性 = Person []数组

// 2. 定义@Person
// 3. 使用@Repeatable 注解 @Person
// 注：@Repeatable 括号中的类 = 容器注解
@Repeatable（Job.class）
public @interface Person{
String role default “”;
}

// 在使用@Person（被@Repeatable 注解）时，可以取多个值来解释Java代码
// 下面注解表示：Carson类即是产品经理，又是程序猿
@Person(role=“coder”)
@Person(role=“PM”)
public class Carson{

}

注：一个注解可以被多个元注解作用
@Inherited
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Carson_Annotation {
}
1
2
3
4
5
3.1.4 元注解类型总结
示意图
3.2 Java内置的注解
定义：即Java内部已经实现好的注解
类型：Java中内置的注解有5类，具体包括：

下面我将对这5类内置注解进行讲解

@Deprecated
定义：过时注解
作用：标记已过时 & 被抛弃的元素（类、方法等）
具体使用
// 用注解@Deprecated 标记类中已过时的方法Hello()
public class Buyer2 {

@Deprecated
public void Hello(){
    System.out.println("Hello 2015!");
}

}

使用该类中被 @Deprecated 作用的方法时，IDE会提示该方法已过时 / 抛弃

@Override
定义：复写注解
作用：标记该方法需要被子类复写
具体使用：该方法大家很熟悉了，此处不作过多描述
@SuppressWarnings
定义：阻止警告注解
作用：标记的元素会阻止编译器发出警告提醒
主要应用于开发者需要忽略警告时
具体使用
// 在括号内传入需要忽略警告的属性
@SuppressWarnings(“deprecation”)
public void test(){
Buyer2 mBuyer2 = new Buyer2();
mBuyer2.hello（）；
// IDE将不会发出警告（即不会在hello（）出现划线）
}

@SafeVarargs
定义：参数安全类型注解
Java 1.7 后引入
作用：提醒开发者不要用参数做不安全的操作 & 阻止编译器产生 unchecked警告
具体使用
// 以下是官方例子
// 虽然编译阶段不报错，但运行时会抛出 ClassCastException 异常
// 所以该注解只是作提示作用，但是实际上还是要开发者自己处理问题
@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!
}

@FunctionalInterface
定义：函数式接口注解

Java 1.8 后引入的新特性

作用：表示该接口 = 函数式接口

函数式接口 (Functional Interface) = 1个具有1个方法的普通接口

具体使用

// 多线程开发中常用的 Runnable 就是一个典型的函数式接口（被 @FunctionalInterface 注解）
@FunctionalInterface
public interface Runnable {

public abstract void run();

}

<–额外：为什么要用函数式接口标记 -->
// 原因：函数式接口很容易转换为 Lambda 表达式
// 这是另外一个很大话题，此处不作过多讲解，感兴趣的同学可自行了解

Java内置注解类型总结

3.3 自定义注解
定义：开发者自定义注解
具体使用：下面第4节将这种介绍。
4. 使用介绍
注解的基础使用包括定义、属性 & 具体使用

4.1 注解的定义
// 通过 @interface 关键字进行定义
// 形式类似于接口，区别在于多了一个 @ 符号

public @interface Carson_Annotation {

}

// 上面的代码创建了一个名为 Carson_Annotaion 的注解

4.2 注解的属性
<-- 1. 定义注解的属性 -->
// 注解的属性在定义该注解本身时进行定义
public @interface Carson_Annotation {
// 注解的属性 = 成员变量
// 注解只有成员变量，没有方法

// 注解@Carson_Annotation中有2个属性：id 和 msg  
int id();
String msg() default "Hi" ;

// 说明：
  // 注解的属性以 “无形参的方法” 形式来声明
  // 方法名 = 属性名
  // 方法返回值 = 属性类型 = 8 种基本数据类型 + 类、接口、注解及对应数组类型
  // 用 default 关键值指定 属性的默认值，如上面的msg的默认值 = ”Hi“

}

<-- 2. 赋值注解的属性 -->
// 注解的属性在使用时进行赋值
// 注解属性的赋值方式 = 注解括号内以 “value=”xx” “ 形式；用 ”，“隔开多个属性

// 注解Carson_Annotation 作用于A类
// 在作用 / 使用时对注解属性进行赋值
@Carson_Annotation(id=1,msg=“hello,i am Carson”)
public class A {
}

// 特别说明：若注解只有一个属性，则赋值时”value“可以省略

// 假设注解@Carson_Annotation只有1个msg属性
// 赋值时直接赋值即可
@Carson_Annotation(“hello,i am Carson”)
public class A {
}

4.3 注解的应用
// 在类 / 成员变量 / 方法定义前加上 “@注解名” 就可以使用该注解
@Carson_Annotation
public class Carson {

@Carson_Annotation
int a;

@Carson_Annotation
public void bMethod(){}

}

// 即注解@Carson_Annotation 用于标识解释 Carson类 / a变量 / b方法

4.4 获取注解
定义：即获取某个对象上的所有注解。
实现手段：Java 反射技术
由于反射需要较高时间成本，所以注解使用时要谨慎考虑时间成本
具体使用
<-- 步骤1：判断该类是否应用了某个注解 -->
// 手段：采用 Class.isAnnotationPresent()
public boolean isAnnotationPresent(Class<? extends Annotation> annotationClass) {}

<-- 步骤2：获取注解对象（Annotation）–>
// 手段1：采用getAnnotation() ；返回指定类型的注解
public A getAnnotation(Class annotationClass) {}
// 手段2：采用getAnnotations() ；返回该元素上的所有注解
public Annotation[] getAnnotations() {}

使用实例
下面我将用一个例子展示如何获取一个类、方法 & 成员变量上的注解类型
步骤1：自定义2个注解

Carson_Annotation.java

// 因为注解@Carson_Annotation需要在程序运行时使用
// 所以必须采用元注解Retention(RetentionPolicy.RUNTIME)
@Retention(RetentionPolicy.RUNTIME)
public @interface Carson_Annotation {

// 注解@Carson_Annotation中有2个属性：id 和 msg
int id();
String msg() default "Hi";

}

Carson_Annotation2.java

// 因为注解@Carson_Annotation2需要在程序运行时使用
// 所以必须采用元注解Retention(RetentionPolicy.RUNTIME)
@Retention(RetentionPolicy.RUNTIME)
public @interface Carson_Annotation2 {

// 注解@Carson_Annotation2中有2个属性：id 和 msg
int id();
String msg() default "Hi";

}

步骤2：定义1个被注解的类

Test.java

// 1个注解作用于Test类
@Carson_Annotation(id = 1,msg=“我是类Test”)
public class Test {

// 1个注解 作用于Test类成员变量a
@Carson_Annotation(id = 2,msg="我是变量a")
int a;

// 2个注解 作用于Test类方法
@Carson_Annotation(id = 3,msg="我是方法b")
@Carson_Annotation2(id = 4,msg="我是方法bb（来自第2个注解）")
public void bMethod(){}

}

步骤3：分别获取一个类、方法 & 成员变量上的注解

private static final String TAG = "Annotation";

    /**
     * 讲解1：获取类上的注解
     */

    // 1. 判断Test类是否应用了注解@Carson_Annotation
    boolean hasAnnotation = Test.class.isAnnotationPresent(Carson_Annotation.class);

    // 2. 如果应用了注解 = hasAnnotation = true
    //    则获取类上的注解对象
    if ( hasAnnotation ) {
        Carson_Annotation classAnnotation = Test.class.getAnnotation(Carson_Annotation.class);

        // 3. 获取注解对象的值
        Log.d(TAG, "我是Test类上的注解");
        Log.d(TAG, "id:" + classAnnotation.id());
        Log.d(TAG, "msg:" + classAnnotation.msg());
    }

    /**
     * 讲解2：获取类成员变量a上的注解
     */
    try {
        // 1. 获取类上的成员变量a
        Field a = Test.class.getDeclaredField("a");
        a.setAccessible(true);

        // 2. 获取成员变量a上的注解@Carson_Annotation
        Carson_Annotation variableAnnotation = a.getAnnotation(Carson_Annotation.class);

        // 3. 若成员变量应用了注解 = hasAnnotation = true
        //    则获取注解对象上的值 = id & msg
        if ( variableAnnotation != null ) {
            Log.d(TAG, "我是类成员变量a上的注解");
            Log.d(TAG, "id:" + variableAnnotation.id());
            Log.d(TAG, "msg:" + variableAnnotation.msg());

        }

        /**
         * 讲解3：获取类方法bMethod上的注解
         */

        // 1. 获取类方法bMethod
        Method testMethod = Test.class.getDeclaredMethod("bMethod");


        // 2. 获取方法上的注解
        if ( testMethod != null ) {
            // 因为方法上有2个注解，所以采用getAnnotations()获得所有类型的注解
            Annotation[] ans = testMethod.getAnnotations();

            Log.d(TAG, "我是类方法bMethod的注解");

            // 3. 获取注解的值（通过循环）
            for( int i = 0;i < ans.length  ;i++) {


                Log.d(TAG, "类方法bMethod的" + "注解"+ i+ 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());
    }
}

测试结果

Demo地址
Carson的Github地址：Java_Annotation

实例演练
下面，我将通过注解实现一个最常见的应用场景：测试代码

5.1 实例说明
通过注解，检查一个类中的方法是否存在异常

5.2 具体步骤
步骤1：自定义测试注解
Carson_Test.java

// 因为注解@Carson_Test需要在程序运行时使用
// 所以必须采用元注解Retention(RetentionPolicy.RUNTIME)
@Retention(RetentionPolicy.RUNTIME)
public @interface Carson_Test {

}

步骤2：定义需要测试的类
Test.java

public class Test {

@Carson_Test
public void method1(){
    System.out.println("method1正常运行 = " + (1+1));
}
@Carson_Test
public void method2(){
    System.out.println("method2正常运行 = " + (2*3));
}

@Carson_Test
public void method3(){
    System.out.println("method3正常运行 = " + (2/0));
}

}

步骤3：采用注解测试类的方法是否存在 Bug
MainActivity.java

public class MainActivity extends AppCompatActivity {

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    // 1. 获取测试类Test对象
    Test mTest = new Test();
    Class mTest_Class = mTest.getClass();

    // 2. 获取测试类Test的所有方法（通过数组存放）
    Method[] method = mTest_Class.getDeclaredMethods();

    // 3. 通过注解@Carson_Test 测试类中的方法

    // a. 遍历类中所有方法
    for ( Method m: method ) {
        // b. 只有被 @Carson_Test 标注过的方法才允许进行测试
        if ( m.isAnnotationPresent( Carson_Test.class )) {
            try {
                m.setAccessible(true);
                // c. 通过反射调用测试类中的方法
                m.invoke(mTest);
                // d. 捕捉方法出现的异常 & 输出异常信息
            } catch (Exception e) {
                System.out.println( "Test类出现Bug了！！！");
                System.out.println( "出现Bug的方法：" + m.getName());
                System.out.println( "Bug类型：" + e.getCause().getClass().getSimpleName());
                System.out.println( "Bug信息：" + e.getCause().getMessage());
            }
        }
    }

}

5.3 测试结果

5.4 Demo地址
Carson_Ho的Github地址：Annation_Debug

总结
本文全面讲解了Java注解（Annotation）的相关知识，相信您对Java注解已经了解深刻。

作者：Carson_Ho
来源：CSDN
原文：https://blog.csdn.net/carson_ho/article/details/80728428
版权声明：本文为博主原创文章，转载请附上博文链接！
https://blog.csdn.net/javazejian/article/details/71860633

理解Java注解
实际上Java注解与普通修饰符(public、static、void等)的使用方式并没有多大区别，下面的例子是常见的注解：

public class AnnotationDemo {
//@Test注解修饰方法A
@Test
public static void A(){
System.out.println(“Test…”);
}

//一个方法上可以拥有多个不同的注解
@Deprecated
@SuppressWarnings("uncheck")
public static void B(){

}

}

通过在方法上使用@Test注解后，在运行该方法时，测试框架会自动识别该方法并单独调用，@Test实际上是一种标记注解，起标记作用，运行时告诉测试框架该方法为测试方法。而对于@Deprecated和@SuppressWarnings(“uncheck”)，则是Java本身内置的注解，在代码中，可以经常看见它们，但这并不是一件好事，毕竟当方法或是类上面有@Deprecated注解时，说明该方法或是类都已经过期不建议再用，@SuppressWarnings 则表示忽略指定警告，比如@SuppressWarnings(“uncheck”)，这就是注解的最简单的使用方式，那么下面我们就来看看注解定义的基本语法

基本语法
声明注解与元注解
我们先来看看前面的Test注解是如何声明的：

//声明Test注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Test {

}

我们使用了@interface声明了Test注解，并使用@Target注解传入ElementType.METHOD参数来标明@Test只能用于方法上，@Retention(RetentionPolicy.RUNTIME)则用来表示该注解生存期是运行时，从代码上看注解的定义很像接口的定义，确实如此，毕竟在编译后也会生成Test.class文件。对于@Target和@Retention是由Java提供的元注解，所谓元注解就是标记其他注解的注解，下面分别介绍

@Target 用来约束注解可以应用的地方（如方法、类或字段），其中ElementType是枚举类型，其定义如下，也代表可能的取值范围

public enum ElementType {
/*标明该注解可以用于类、接口（包括注解类型）或enum声明/
TYPE,

/** 标明该注解可以用于字段(域)声明，包括enum实例 */
FIELD,

/** 标明该注解可以用于方法声明 */
METHOD,

/** 标明该注解可以用于参数声明 */
PARAMETER,

/** 标明注解可以用于构造函数声明 */
CONSTRUCTOR,

/** 标明注解可以用于局部变量声明 */
LOCAL_VARIABLE,

/** 标明注解可以用于注解声明(应用于另一个注解上)*/
ANNOTATION_TYPE,

/** 标明注解可以用于包声明 */
PACKAGE,

/**
 * 标明注解可以用于类型参数声明（1.8新加入）
 * @since 1.8
 */
TYPE_PARAMETER,

/**
 * 类型使用声明（1.8新加入)
 * @since 1.8
 */
TYPE_USE

}

请注意，当注解未指定Target值时，则此注解可以用于任何元素之上，多个值使用{}包含并用逗号隔开，如下：

@Target(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE})
1
@Retention用来约束注解的生命周期，分别有三个值，源码级别（source），类文件级别（class）或者运行时级别（runtime），其含有如下：

SOURCE：注解将被编译器丢弃（该类型的注解信息只会保留在源码里，源码经过编译后，注解信息会被丢弃，不会保留在编译好的class文件里）

CLASS：注解在class文件中可用，但会被VM丢弃（该类型的注解信息会保留在源码里和class文件里，在执行的时候，不会加载到虚拟机中），请注意，当注解未定义Retention值时，默认值是CLASS，如Java内置注解，@Override、@Deprecated、@SuppressWarnning等

RUNTIME：注解信息将在运行期(JVM)也保留，因此可以通过反射机制读取注解的信息（源码、class文件和执行的时候都有注解的信息），如SpringMvc中的@Controller、@Autowired、@RequestMapping等。

注解元素及其数据类型
通过上述对@Test注解的定义，我们了解了注解定义的过程，由于@Test内部没有定义其他元素，所以@Test也称为标记注解（marker annotation），但在自定义注解中，一般都会包含一些元素以表示某些值，方便处理器使用，这点在下面的例子将会看到：

/**

Created by wuzejian on 2017/5/18.
对应数据表注解
*/
@Target(ElementType.TYPE)//只能应用于类上
@Retention(RetentionPolicy.RUNTIME)//保存到运行时
public @interface DBTable {
String name() default “”;
}

上述定义一个名为DBTable的注解，该用于主要用于数据库表与Bean类的映射（稍后会有完整案例分析），与前面Test注解不同的是，我们声明一个String类型的name元素，其默认值为空字符，但是必须注意到对应任何元素的声明应采用方法的声明方式，同时可选择使用default提供默认值，@DBTable使用方式如下：

//在类上使用该注解
@DBTable(name = “MEMBER”)
public class Member {
//…
}

关于注解支持的元素数据类型除了上述的String，还支持如下数据类型

所有基本类型（int,float,boolean,byte,double,char,long,short）

String

Class

enum

Annotation

上述类型的数组

倘若使用了其他数据类型，编译器将会丢出一个编译错误，注意，声明注解元素时可以使用基本类型但不允许使用任何包装类型，同时还应该注意到注解也可以作为元素的类型，也就是嵌套注解，下面的代码演示了上述类型的使用过程：

package com.zejian.annotationdemo;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**

Created by wuzejian on 2017/5/19.
数据类型使用Demo
*/

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Reference{
boolean next() default false;
}

public @interface AnnotationElementDemo {
//枚举类型
enum Status {FIXED,NORMAL};

//声明枚举
Status status() default Status.FIXED;

//布尔类型
boolean showSupport() default false;

//String类型
String name()default "";

//class类型
Class<?> testCase() default Void.class;

//注解嵌套
Reference reference() default @Reference(next=true);

//数组类型
long[] value();

}

编译器对默认值的限制
编译器对元素的默认值有些过分挑剔。首先，元素不能有不确定的值。也就是说，元素必须要么具有默认值，要么在使用注解时提供元素的值。其次，对于非基本类型的元素，无论是在源代码中声明，还是在注解接口中定义默认值，都不能以null作为值，这就是限制，没有什么利用可言，但造成一个元素的存在或缺失状态，因为每个注解的声明中，所有的元素都存在，并且都具有相应的值，为了绕开这个限制，只能定义一些特殊的值，例如空字符串或负数，表示某个元素不存在。

注解不支持继承
注解是不支持继承的，因此不能使用关键字extends来继承某个@interface，但注解在编译后，编译器会自动继承java.lang.annotation.Annotation接口，这里我们反编译前面定义的DBTable注解

package com.zejian.annotationdemo;

import java.lang.annotation.Annotation;
//反编译后的代码
public interface DBTable extends Annotation
{
public abstract String name();
}

虽然反编译后发现DBTable注解继承了Annotation接口，请记住，即使Java的接口可以实现多继承，但定义注解时依然无法使用extends关键字继承@interface。

快捷方式
所谓的快捷方式就是注解中定义了名为value的元素，并且在使用该注解时，如果该元素是唯一需要赋值的一个元素，那么此时无需使用key=value的语法，而只需在括号内给出value元素所需的值即可。这可以应用于任何合法类型的元素，记住，这限制了元素名必须为value，简单案例如下

package com.zejian.annotationdemo;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**

Created by zejian on 2017/5/20.
Blog : http://blog.csdn.net/javazejian [原文地址,请尊重原创]
*/
//定义注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface IntegerVaule{
int value() default 0;
String name() default “”;
}

//使用注解
public class QuicklyWay {

//当只想给value赋值时,可以使用以下快捷方式
@IntegerVaule(20)
public int age;

//当name也需要赋值时必须采用key=value的方式赋值
@IntegerVaule(value = 10000,name = "MONEY")
public int money;

}

Java内置注解与其它元注解
接着看看Java提供的内置注解，主要有3个，如下：

@Override：用于标明此方法覆盖了父类的方法，源码如下

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

@Deprecated：用于标明已经过时的方法或类，源码如下，关于@Documented稍后分析：

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE})
public @interface Deprecated {
}
@SuppressWarnnings:用于有选择的关闭编译器对类、方法、成员变量、变量初始化的警告，其实现源码如下：

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

其内部有一个String数组，主要接收值如下：

deprecation：使用了不赞成使用的类或方法时的警告；
unchecked：执行了未检查的转换时的警告，例如当使用集合时没有用泛型 (Generics) 来指定集合保存的类型;
fallthrough：当 Switch 程序块直接通往下一种情况而没有 Break 时的警告;
path：在类路径、源文件路径等中有不存在的路径时的警告;
serial：当在可序列化的类上缺少 serialVersionUID 定义时的警告;
finally：任何 finally 子句不能正常完成时的警告;
all：关于以上所有情况的警告。

这个三个注解比较简单，看个简单案例即可：

//注明该类已过时，不建议使用
@Deprecated
class A{
public void A(){ }

//注明该方法已过时，不建议使用
@Deprecated()
public void B(){ }

}

class B extends A{

@Override //标明覆盖父类A的A方法
public void A() {
    super.A();
}

//去掉检测警告
@SuppressWarnings({"uncheck","deprecation"})
public void C(){ } 
//去掉检测警告
@SuppressWarnings("uncheck")
public void D(){ }

}

前面我们分析了两种元注解，@Target和@Retention，除了这两种元注解，Java还提供了另外两种元注解，@Documented和@Inherited，下面分别介绍：

@Documented 被修饰的注解会生成到javadoc中

/**

Created by zejian on 2017/5/20.
Blog : http://blog.csdn.net/javazejian [原文地址,请尊重原创]
*/
@Documented
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface DocumentA {
}

//没有使用@Documented
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface DocumentB {
}

//使用注解
@DocumentA
@DocumentB
public class DocumentDemo {
public void A(){
}
}

使用javadoc命令生成文档：

zejian@zejiandeMBP annotationdemo$ javadoc DocumentDemo.java DocumentA.java DocumentB.java
1
如下：

可以发现使用@Documented元注解定义的注解(@DocumentA)将会生成到javadoc中,而@DocumentB则没有在doc文档中出现，这就是元注解@Documented的作用。

@Inherited 可以让注解被继承，但这并不是真的继承，只是通过使用@Inherited，可以让子类Class对象使用getAnnotations()获取父类被@Inherited修饰的注解，如下：

@Inherited
@Documented
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface DocumentA {
}

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

@DocumentA
class A{ }

class B extends A{ }

@DocumentB
class C{ }

class D extends C{ }

//测试
public class DocumentDemo {

public static void main(String... args){
    A instanceA=new B();
    System.out.println("已使用的@Inherited注解:"+Arrays.toString(instanceA.getClass().getAnnotations()));

    C instanceC = new D();

    System.out.println("没有使用的@Inherited注解:"+Arrays.toString(instanceC.getClass().getAnnotations()));
}

/**
 * 运行结果:
 已使用的@Inherited注解:[@com.zejian.annotationdemo.DocumentA()]
 没有使用的@Inherited注解:[]
 */

}

注解与反射机制
前面经过反编译后，我们知道Java所有注解都继承了Annotation接口，也就是说　Java使用Annotation接口代表注解元素，该接口是所有Annotation类型的父接口。同时为了运行时能准确获取到注解的相关信息，Java在java.lang.reflect 反射包下新增了AnnotatedElement接口，它主要用于表示目前正在 VM 中运行的程序中已使用注解的元素，通过该接口提供的方法可以利用反射技术地读取注解的信息，如反射包的Constructor类、Field类、Method类、Package类和Class类都实现了AnnotatedElement接口，它简要含义如下（更多详细介绍可以看深入理解Java类型信息(Class对象)与反射机制）：

Class：类的Class对象定义　
Constructor：代表类的构造器定义　
Field：代表类的成员变量定义
Method：代表类的方法定义　
Package：代表类的包定义

下面是AnnotatedElement中相关的API方法，以上5个类都实现以下的方法

返回值方法名称说明
getAnnotation(Class annotationClass) 该元素如果存在指定类型的注解，则返回这些注解，否则返回 null。
Annotation[] getAnnotations() 返回此元素上存在的所有注解，包括从父类继承的
boolean isAnnotationPresent(Class<? extends Annotation> annotationClass) 如果指定类型的注解存在于此元素上，则返回 true，否则返回 false。
Annotation[] getDeclaredAnnotations() 返回直接存在于此元素上的所有注解，注意，不包括父类的注解，调用者可以随意修改返回的数组；这不会对其他调用者返回的数组产生任何影响，没有则返回长度为0的数组
简单案例演示如下：

package com.zejian.annotationdemo;

import java.lang.annotation.Annotation;
import java.util.Arrays;

/**

Created by zejian on 2017/5/20.
Blog : http://blog.csdn.net/javazejian [原文地址,请尊重原创]
*/
@DocumentA
class A{ }

//继承了A类
@DocumentB
public class DocumentDemo extends A{

public static void main(String... args){

    Class<?> clazz = DocumentDemo.class;
    //根据指定注解类型获取该注解
    DocumentA documentA=clazz.getAnnotation(DocumentA.class);
    System.out.println("A:"+documentA);

    //获取该元素上的所有注解，包含从父类继承
    Annotation[] an= clazz.getAnnotations();
    System.out.println("an:"+ Arrays.toString(an));
    //获取该元素上的所有注解，但不包含继承！
    Annotation[] an2=clazz.getDeclaredAnnotations();
    System.out.println("an2:"+ Arrays.toString(an2));

    //判断注解DocumentA是否在该元素上
    boolean b=clazz.isAnnotationPresent(DocumentA.class);
    System.out.println("b:"+b);

    /**
     * 执行结果:
     A:@com.zejian.annotationdemo.DocumentA()
     an:[@com.zejian.annotationdemo.DocumentA(), @com.zejian.annotationdemo.DocumentB()]
     an2:@com.zejian.annotationdemo.DocumentB()
     b:true
     */
}

}

运行时注解处理器
了解完注解与反射的相关API后，现在通过一个实例（该例子是博主改编自《Tinking in Java》）来演示利用运行时注解来组装数据库SQL的构建语句的过程

/**

Created by wuzejian on 2017/5/18.
表注解
*/
@Target(ElementType.TYPE)//只能应用于类上
@Retention(RetentionPolicy.RUNTIME)//保存到运行时
public @interface DBTable {
String name() default “”;
}

/**

Created by wuzejian on 2017/5/18.
注解Integer类型的字段
*/
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface SQLInteger {
//该字段对应数据库表列名
String name() default “”;
//嵌套注解
Constraints constraint() default @Constraints;
}

/**

Created by wuzejian on 2017/5/18.
注解String类型的字段
*/
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface SQLString {

//对应数据库表的列名
String name() default “”;

//列类型分配的长度，如varchar(30)的30
int value() default 0;

Constraints constraint() default @Constraints;
}

/**

Created by wuzejian on 2017/5/18.
约束注解
*/

@Target(ElementType.FIELD)//只能应用在字段上
@Retention(RetentionPolicy.RUNTIME)
public @interface Constraints {
//判断是否作为主键约束
boolean primaryKey() default false;
//判断是否允许为null
boolean allowNull() default false;
//判断是否唯一
boolean unique() default false;
}

/**

Created by wuzejian on 2017/5/18.
数据库表Member对应实例类bean
*/
@DBTable(name = “MEMBER”)
public class Member {
//主键ID
@SQLString(name = “ID”,value = 50, constraint = @Constraints(primaryKey = true))
private String id;

@SQLString(name = “NAME” , value = 30)
private String name;

@SQLInteger(name = “AGE”)
private int age;

@SQLString(name = “DESCRIPTION” ,value = 150 , constraint = @Constraints(allowNull = true))
private String description;//个人描述

//省略set get…
}

上述定义4个注解，分别是@DBTable(用于类上)、@Constraints(用于字段上)、 @SQLString(用于字段上)、@SQLString(用于字段上)并在Member类中使用这些注解，这些注解的作用的是用于帮助注解处理器生成创建数据库表MEMBER的构建语句，在这里有点需要注意的是，我们使用了嵌套注解@Constraints，该注解主要用于判断字段是否为null或者字段是否唯一。必须清楚认识到上述提供的注解生命周期必须为@Retention(RetentionPolicy.RUNTIME)，即运行时，这样才可以使用反射机制获取其信息。有了上述注解和使用，剩余的就是编写上述的注解处理器了，前面我们聊了很多注解，其处理器要么是Java自身已提供、要么是框架已提供的，我们自己都没有涉及到注解处理器的编写，但上述定义处理SQL的注解，其处理器必须由我们自己编写了，如下

package com.zejian.annotationdemo;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;

/**

Created by zejian on 2017/5/13.
Blog : http://blog.csdn.net/javazejian [原文地址,请尊重原创]
运行时注解处理器，构造表创建语句
*/
public class TableCreator {

public static String createTableSql(String className) throws ClassNotFoundException {
Class<?> cl = Class.forName(className);
DBTable dbTable = cl.getAnnotation(DBTable.class);
//如果没有表注解，直接返回
if(dbTable == null) {
System.out.println(
"No DBTable annotations in class " + className);
return null;
}
String tableName = dbTable.name();
// If the name is empty, use the Class name:
if(tableName.length() < 1)
tableName = cl.getName().toUpperCase();
List columnDefs = new ArrayList();
//通过Class类API获取到所有成员字段
for(Field field : cl.getDeclaredFields()) {
String columnName = null;
//获取字段上的注解
Annotation[] anns = field.getDeclaredAnnotations();
if(anns.length < 1)
continue; // Not a db table column

  //判断注解类型
  if(anns[0] instanceof SQLInteger) {
    SQLInteger sInt = (SQLInteger) anns[0];
    //获取字段对应列名称，如果没有就是使用字段名称替代
    if(sInt.name().length() < 1)
      columnName = field.getName().toUpperCase();
    else
      columnName = sInt.name();
    //构建语句
    columnDefs.add(columnName + " INT" +
            getConstraints(sInt.constraint()));
  }
  //判断String类型
  if(anns[0] instanceof SQLString) {
    SQLString sString = (SQLString) anns[0];
    // Use field name if name not specified.
    if(sString.name().length() < 1)
      columnName = field.getName().toUpperCase();
    else
      columnName = sString.name();
    columnDefs.add(columnName + " VARCHAR(" +
            sString.value() + ")" +
            getConstraints(sString.constraint()));
  }


}
//数据库表构建语句
StringBuilder createCommand = new StringBuilder(
        "CREATE TABLE " + tableName + "(");
for(String columnDef : columnDefs)
  createCommand.append("\n    " + columnDef + ",");

// Remove trailing comma
String tableCreate = createCommand.substring(
        0, createCommand.length() - 1) + ");";
return tableCreate;

}

/**
 * 判断该字段是否有其他约束
 * @param con
 * @return
 */

private static String getConstraints(Constraints con) {
String constraints = “”;
if(!con.allowNull())
constraints += " NOT NULL";
if(con.primaryKey())
constraints += " PRIMARY KEY";
if(con.unique())
constraints += " UNIQUE";
return constraints;
}

public static void main(String[] args) throws Exception {
String[] arg={“com.zejian.annotationdemo.Member”};
for(String className : arg) {
System.out.println(“Table Creation SQL for " +
className + " is :\n” + createTableSql(className));
}

/**
 * 输出结果：
 Table Creation SQL for com.zejian.annotationdemo.Member is :
 CREATE TABLE MEMBER(
 ID VARCHAR(50) NOT NULL PRIMARY KEY,
 NAME VARCHAR(30) NOT NULL,
 AGE INT NOT NULL,
 DESCRIPTION VARCHAR(150)
 );
 */

}
}

如果对反射比较熟悉的同学，上述代码就相对简单了，我们通过传递Member的全路径后通过Class.forName()方法获取到Member的class对象，然后利用Class对象中的方法获取所有成员字段Field，最后利用field.getDeclaredAnnotations()遍历每个Field上的注解再通过注解的类型判断来构建建表的SQL语句。这便是利用注解结合反射来构建SQL语句的简单的处理器模型，是否已回想起Hibernate？

Java 8中注解增强
元注解@Repeatable
元注解@Repeatable是JDK1.8新加入的，它表示在同一个位置重复相同的注解。在没有该注解前，一般是无法在同一个类型上使用相同的注解的

//Java8前无法这样使用
@FilterPath("/web/update")
@FilterPath("/web/add")
public class A {}

Java8前如果是想实现类似的功能，我们需要在定义@FilterPath注解时定义一个数组元素接收多个值如下

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface FilterPath {
String [] value();
}

//使用
@FilterPath({"/update","/add"})
public class A { }

但在Java8新增了@Repeatable注解后就可以采用如下的方式定义并使用了

package com.zejian.annotationdemo;

import java.lang.annotation.*;

/**

Created by zejian on 2017/5/20.
Blog : http://blog.csdn.net/javazejian [原文地址,请尊重原创]
*/
//使用Java8新增@Repeatable原注解
@Target({ElementType.TYPE,ElementType.FIELD,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Repeatable(FilterPaths.class)//参数指明接收的注解class
public @interface FilterPath {
String value();
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface FilterPaths {
FilterPath[] value();
}

//使用案例
@FilterPath("/web/update")
@FilterPath("/web/add")
@FilterPath("/web/delete")
class AA{ }

我们可以简单理解为通过使用@Repeatable后，将使用@FilterPaths注解作为接收同一个类型上重复注解的容器，而每个@FilterPath则负责保存指定的路径串。为了处理上述的新增注解，Java8还在AnnotatedElement接口新增了getDeclaredAnnotationsByType() 和 getAnnotationsByType()两个方法并在接口给出了默认实现，在指定@Repeatable的注解时，可以通过这两个方法获取到注解相关信息。但请注意，旧版API中的getDeclaredAnnotation()和 getAnnotation()是不对@Repeatable注解的处理的(除非该注解没有在同一个声明上重复出现)。注意getDeclaredAnnotationsByType方法获取到的注解不包括父类，其实当 getAnnotationsByType()方法调用时，其内部先执行了getDeclaredAnnotationsByType方法，只有当前类不存在指定注解时，getAnnotationsByType()才会继续从其父类寻找，但请注意如果@FilterPath和@FilterPaths没有使用了@Inherited的话，仍然无法获取。下面通过代码来演示：

/**

Created by zejian on 2017/5/20.
Blog : http://blog.csdn.net/javazejian [原文地址,请尊重原创]
*/
//使用Java8新增@Repeatable原注解
@Target({ElementType.TYPE,ElementType.FIELD,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Repeatable(FilterPaths.class)
public @interface FilterPath {
String value();
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface FilterPaths {
FilterPath[] value();
}

@FilterPath("/web/list")
class CC { }

//使用案例
@FilterPath("/web/update")
@FilterPath("/web/add")
@FilterPath("/web/delete")
class AA extends CC{
public static void main(String[] args) {

    Class<?> clazz = AA.class;
    //通过getAnnotationsByType方法获取所有重复注解
    FilterPath[] annotationsByType = clazz.getAnnotationsByType(FilterPath.class);
    FilterPath[] annotationsByType2 = clazz.getDeclaredAnnotationsByType(FilterPath.class);
    if (annotationsByType != null) {
        for (FilterPath filter : annotationsByType) {
            System.out.println("1:"+filter.value());
        }
    }

    System.out.println("-----------------");

    if (annotationsByType2 != null) {
        for (FilterPath filter : annotationsByType2) {
            System.out.println("2:"+filter.value());
        }
    }


    System.out.println("使用getAnnotation的结果:"+clazz.getAnnotation(FilterPath.class));


    /**
     * 执行结果(当前类拥有该注解FilterPath,则不会从CC父类寻找)
     1:/web/update
     1:/web/add
     1:/web/delete
     -----------------
     2:/web/update
     2:/web/add
     2:/web/delete
     使用getAnnotation的结果:null
     */
}

}

从执行结果来看如果当前类拥有该注解@FilterPath,则getAnnotationsByType方法不会从CC父类寻找，下面看看另外一种情况，即AA类上没有@FilterPath注解

/**

Created by zejian on 2017/5/20.
Blog : http://blog.csdn.net/javazejian [原文地址,请尊重原创]
*/
//使用Java8新增@Repeatable原注解
@Target({ElementType.TYPE,ElementType.FIELD,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited //添加可继承元注解
@Repeatable(FilterPaths.class)
public @interface FilterPath {
String value();
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Inherited //添加可继承元注解
@interface FilterPaths {
FilterPath[] value();
}

@FilterPath("/web/list")
@FilterPath("/web/getList")
class CC { }

//AA上不使用@FilterPath注解,getAnnotationsByType将会从父类查询
class AA extends CC{
public static void main(String[] args) {

    Class<?> clazz = AA.class;
    //通过getAnnotationsByType方法获取所有重复注解
    FilterPath[] annotationsByType = clazz.getAnnotationsByType(FilterPath.class);
    FilterPath[] annotationsByType2 = clazz.getDeclaredAnnotationsByType(FilterPath.class);
    if (annotationsByType != null) {
        for (FilterPath filter : annotationsByType) {
            System.out.println("1:"+filter.value());
        }
    }

    System.out.println("-----------------");

    if (annotationsByType2 != null) {
        for (FilterPath filter : annotationsByType2) {
            System.out.println("2:"+filter.value());
        }
    }


    System.out.println("使用getAnnotation的结果:"+clazz.getAnnotation(FilterPath.class));


    /**
     * 执行结果(当前类没有@FilterPath,getAnnotationsByType方法从CC父类寻找)
     1:/web/list
     1:/web/getList
     -----------------
     使用getAnnotation的结果:null
     */
}

}

注意定义@FilterPath和@FilterPath时必须指明@Inherited，getAnnotationsByType方法否则依旧无法从父类获取@FilterPath注解，这是为什么呢，不妨看看getAnnotationsByType方法的实现源码：

//接口默认实现方法
default <T extends Annotation> T[] getAnnotationsByType(Class<T> annotationClass) {
//先调用getDeclaredAnnotationsByType方法
T[] result = getDeclaredAnnotationsByType(annotationClass);

//判断当前类获取到的注解数组是否为0
if (result.length == 0 && this instanceof Class && 
//判断定义注解上是否使用了@Inherited元注解 
 AnnotationType.getInstance(annotationClass).isInherited()) { // Inheritable
        //从父类获取
       Class<?> superClass = ((Class<?>) this).getSuperclass();
   if (superClass != null) {
      result = superClass.getAnnotationsByType(annotationClass);
       }
   }

   return result;

新增的两种ElementType
在Java8中 ElementType 新增两个枚举成员，TYPE_PARAMETER 和 TYPE_USE ，在Java8前注解只能标注在一个声明(如字段、类、方法)上，Java8后，新增的TYPE_PARAMETER可以用于标注类型参数，而TYPE_USE则可以用于标注任意类型(不包括class)。如下所示

//TYPE_PARAMETER 标注在类型参数上
class D<@Parameter T> { }

//TYPE_USE则可以用于标注任意类型(不包括class)
//用于父类或者接口
class Image implements @Rectangular Shape { }

//用于构造函数
new @Path String("/usr/bin")

//用于强制转换和instanceof检查,注意这些注解中用于外部工具，它们不会对类型转换或者instanceof的检查行为带来任何影响。
String path=(@Path String)input;
if(input instanceof @Path String)

//用于指定异常
public Person read() throws @Localized IOException.

//用于通配符绑定
List<@ReadOnly ? extends Person>
List<? extends @ReadOnly Person>

@NotNull String.class //非法，不能标注class
import java.lang.@NotNull String //非法，不能标注import

这里主要说明一下TYPE_USE，类型注解用来支持在Java的程序中做强类型检查，配合第三方插件工具（如Checker Framework），可以在编译期检测出runtime error（如UnsupportedOperationException、NullPointerException异常），避免异常延续到运行期才发现，从而提高代码质量，这就是类型注解的主要作用。总之Java 8 新增加了两个注解的元素类型ElementType.TYPE_USE 和ElementType.TYPE_PARAMETER ，通过它们，我们可以把注解应用到各种新场合中。

ok~，关于注解暂且聊到这，实际上还有一个大块的知识点没详细聊到，源码级注解处理器，这个话题博主打算后面另开一篇分析。

作者：zejian_
来源：CSDN
原文：https://blog.csdn.net/javazejian/article/details/71860633
版权声明：本文为博主原创文章，转载请附上博文链接！

猜你喜欢