平时开发的时候，用了不少注解，但是一直没有研究过，今天抽了点时间来深入了解注解的原理
什么是注解
先上两张图帮助大家理解，一张是JAVA源代码编译成字节码的过程，另一张是注解的树图
注解也叫元数据，例如我们常见的@Override和@Deprecated，注解是JDK1.5版本开始引入的一个特性，用于对代码进行说明，可以对包、类、接口、字段、方法参数、局部变量等进行注解。
深入理解注解：
在注解的源码中，我们可以看到有这么一句话来介绍注解：
The common interface extended by all annotation types。
所有注解的类型都继承公共接口
这段话有点抽象，我们可以看看实例，我们平时用的最多的@Override注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}这是注解 @Override 的定义，其实它本质上就是：
public interface Override extends Annotation{
}我们来验证一下：
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface TestAnnotation {
String value() default "default";
}这是我们测试的注解，反编译之后，无图无真相：
可以看到，这个测试注解就是一个继承了Annotation类的接口
它主要的作用有以下四方面：
- 生成文档，通过代码里标识的元数据生成javadoc文档。
- 编译检查，通过代码里标识的元数据让编译器在编译期间进行检查验证。
- 编译时动态处理，编译时通过代码里标识的元数据动态处理，例如动态生成代码
- 运行时动态处理，运行时通过代码里标识的元数据动态处理，例如使用反射注入实例。
- 生成文档，通过代码里标识的元数据生成javadoc文档。
一般注解可以分为三类：
- 一类是Java自带的标准注解，包括@Override、@Deprecated和@SuppressWarnings，分别用于标明重写某个方法、标明某个类或方法过时、标明要忽略的警告，用这些注解标明后编译器就会进行检查。
- 一类为元注解，元注解是用于定义注解的注解，包括@Retention、@Target、@Inherited、@Documented，@Retention用于标明注解被保留的阶段，@Target用于标明注解使用的范围，@Inherited用于标明注解可继承，@Documented用于标明是否生成javadoc文档。
- 一类为自定义注解，可以根据自己的需求定义注解，并可用元注解对自定义注解进行注解。
一个注解准确意义上来说，只不过是一种特殊的注释而已，如果没有解析它的代码，它可能连注释都不如。
而解析一个类或者方法的注解往往有两种形式，一种是编译期直接的扫描，一种是运行期反射。反射的事情我们待会说，而编译器的扫描指的是编译器在对 java 代码编译字节码的过程中会检测到某个类或者方法被一些注解修饰，这时它就会对于这些注解进行某些处理。
典型的就是注解 @Override，一旦编译器检测到某个方法被修饰了 @Override 注解，编译器就会检查当前方法的方法签名是否真正重写了父类的某个方法，也就是比较父类中是否具有一个同样的方法签名。
这一种情况只适用于那些编译器已经熟知的注解类，比如 JDK 内置的几个注解，而你自定义的注解，编译器是不知道你这个注解的作用的，当然也不知道该如何处理，往往只是会根据该注解的作用范围来选择是否编译进字节码文件，仅此而已。
注解类型
元注解：
『元注解』是用于修饰注解的注解，通常用在注解的定义上，那我们最通用的@Override注解为例：
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}这是我们 @Override 注解的定义，你可以看到其中的 @Target，@Retention 两个注解就是我们所谓的『元注解』，『元注解』一般用于指定某个注解生命周期以及作用目标等信息。
JAVA 中有以下几个『元注解』：
- @Target：注解的作用目标
- @Retention：注解的生命周期
- @Documented：注解是否应当被包含在 JavaDoc 文档中
- @Inherited：是否允许子类继承该注解
其中，@Target 用于指明被修饰的注解最终可以作用的目标是谁，也就是指明，你的注解到底是用来修饰方法的？修饰类的？还是用来修饰字段属性的。
@Target 的定义如下：
* @since 1.5
* @jls 9.6.4.1 @Target
* @jls 9.7.4 Where Annotations May Appear
*/
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Target {
/**
* Returns an array of the kinds of elements an annotation type
* can be applied to.
* @return an array of the kinds of elements an annotation type
* can be applied to
*/
ElementType[] value();
}我们可以通过以下的方式来为这个 value 传值：
@Target(value = {ElementType.FIELD})被这个 @Target 注解修饰的注解将只能作用在成员字段上，不能用于修饰方法或者类。其中，ElementType 是一个枚举类型，有以下一些值，直接贴源码，不长：
public enum ElementType {
/** Class, interface (including annotation type), or enum declaration */
允许被修饰的注解作用在类、接口和枚举上
TYPE,
/** Field declaration (includes enum constants) */
允许作用在属性字段上
FIELD,
/** Method declaration */
允许作用在方法上
METHOD,
/** Formal parameter declaration */
允许作用在方法参数上
PARAMETER,
/** Constructor declaration */
允许作用在构造器上
CONSTRUCTOR,
/** Local variable declaration */
允许作用在本地局部变量
LOCAL_VARIABLE,
/** Annotation type declaration */、
允许作用在注解上
ANNOTATION_TYPE,
/** Package declaration */
允许作用在包上
PACKAGE,
/**
* Type parameter declaration
*
* @since 1.8
*/
TYPE_PARAMETER,
/**
* Use of a type
*
* @since 1.8
*/
TYPE_USE
}@Retention 用于指明当前注解的生命周期，它的基本定义如下：
* @author Joshua Bloch
* @since 1.5
* @jls 9.6.3.2 @Retention
*/
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Retention {
/**
* Returns the retention policy.
* @return the retention policy
*/
RetentionPolicy value();
}同样的，它也有一个 value 属性：
@Retention(value = RetentionPolicy.RUNTIME这里的 RetentionPolicy 依然是一个枚举类型，它有以下几个枚举值可取，一样，我们直接看源码，东西不多
* @author Joshua Bloch
* @since 1.5
*/
public enum RetentionPolicy {
/**
* Annotations are to be discarded by the compiler.
*/
当前注解编译期可见，不会写入类文件
SOURCE,
/**
* Annotations are to be recorded in the class file by the compiler
* but need not be retained by the VM at run time. This is the default
* behavior.
*/
编译期记录在类文件中，但是不会再虚拟机中保存，就是类加载阶段丢弃，会写入 class 文件，这是默认的
CLASS,
/**
* Annotations are to be recorded in the class file by the compiler and
* retained by the VM at run time, so they may be read reflectively.
*
* @see java.lang.reflect.AnnotatedElement
*/
编译的时候记录在类文件中，也会随类一起加载，这种方式可以被反射调用
RUNTIME
}@Retention 注解指定了被修饰的注解的生命周期，一种是只能在编译期可见，编译后会被丢弃，一种会被编译器编译进 class 文件中，无论是类或是方法，乃至字段，他们都是有属性表的，而 JAVA 虚拟机也定义了几种注解属性表用于存储注解信息，但是这种可见性不能带到方法区，类加载时会予以丢弃，最后一种则是永久存在的可见性。
剩下两种类型的注解我们日常用的不多，也比较简单，这里不再详细的进行介绍了，你只需要知道他们各自的作用即可。@Documented 注解修饰的注解，当我们执行 JavaDoc 文档打包时会被保存进 doc 文档，反之将在打包时丢弃。@Inherited 注解修饰的注解是具有可继承性的，也就说我们的注解修饰了一个类，而该类的子类将自动继承父类的该注解
JAVA 的内置三大注解
除了上述四种元注解外，JDK 还为我们预定义了另外三种注解，它们是：
- @Override
- @Deprecated
- @SuppressWarnings
@Override 注解想必是大家很熟悉的了，它的定义如下：
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}它没有任何的属性，所以并不能存储任何其他信息。它只能作用于方法之上，编译结束后将被丢弃。
所以你看，它就是一种典型的『标记式注解』，仅被编译器可知，编译器在对 java 文件进行编译成字节码的过程中，一旦检测到某个方法上被修饰了该注解，就会去匹对父类中是否具有一个同样方法签名的函数，如果不是，自然不能通过编译。
@Deprecated 的基本定义如下：
* @author Neal Gafter
* @since 1.5
* @jls 9.6.3.6 @Deprecated
*/
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE})
public @interface Deprecated {
}依然是一种『标记式注解』，永久存在，可以修饰所有的类型，作用是，标记当前的类或者方法或者字段等已经不再被推荐使用了，可能下一次的 JDK 版本就会删除。
当然，编译器并不会强制要求你做什么，只是告诉你 JDK 已经不再推荐使用当前的方法或者类了，建议你使用某个替代者
@SuppressWarnings 主要用来压制 java 的警告，它的基本定义如下：
* @author Josh Bloch
* @since 1.5
* @jls 4.8 Raw Types
* @jls 4.12.2 Variables of Reference Type
* @jls 5.1.9 Unchecked Conversion
* @jls 5.5.2 Checked Casts and Unchecked Casts
* @jls 9.6.3.5 @SuppressWarnings
*/
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.SOURCE)
public @interface SuppressWarnings {
/**
* The set of warnings that are to be suppressed by the compiler in the
* annotated element. Duplicate names are permitted. The second and
* successive occurrences of a name are ignored. The presence of
* unrecognized warning names is <i>not</i> an error: Compilers must
* ignore any warning names they do not recognize. They are, however,
* free to emit a warning if an annotation contains an unrecognized
* warning name.
*
* <p> The string {@code "unchecked"} is used to suppress
* unchecked warnings. Compiler vendors should document the
* additional warning names they support in conjunction with this
* annotation type. They are encouraged to cooperate to ensure
* that the same names work across multiple compilers.
* @return the set of warnings to be suppressed
*/
String[] value();
}它有一个 value 属性需要你主动的传值，这个 value 代表一个什么意思呢，这个 value 代表的就是需要被压制的警告类型
而如果我们不希望程序启动时，编译器检查代码中过时的方法，就可以使用 @SuppressWarnings 注解并给它的 value 属性传入一个参数值来压制编译器的检查。
这样你就会发现，编译器不再检查 main 方法下是否有过时的方法调用，也就压制了编译器对于这种警告的检查。
当然，JAVA 中还有很多的警告类型，他们都会对应一个字符串，通过设置 value 属性的值即可压制对于这一类警告类型的检查。
注解的使用
注解的使用非常简单，只需在需要注解的地方标明某个注解即可，例如在方法上注解：
public class Test {
@Override
public String tostring() {
return "override it";
}
}例如在类上注解：
@Deprecated
public class Test {
}所以Java内置的注解直接使用即可，但很多时候我们需要自己定义一些注解，例如常见的spring就用了大量的注解来管理对象之间的依赖关系。下面看看如何定义一个自己的注解，下面实现这样一个注解：通过@Test向某类注入一个字符串，通过@TestMethod向某个方法注入一个字符串。
①创建Test注解，声明作用于类并保留到运行时，默认值为default。
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Test {
String value() default "default";
}②创建TestMethod注解，声明作用于方法并保留到运行时。
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface TestMethod {
String value();
}③测试类，运行后输出default和tomcat-method两个字符串，因为@Test没有传入值，所以输出了默认值，而@TestMethod则输出了注入的字符串。
@Test()
public class AnnotationTest {
@TestMethod("tomcat-method")
public void test(){
}
public static void main(String[] args){
Test t = AnnotationTest.class.getAnnotation(Test.class);
System.out.println(t.value());
TestMethod tm = null;
try {
tm = AnnotationTest.class.getDeclaredMethod("test",null).getAnnotation(TestMethod.class);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println(tm.value());
}
}注解的原理
前面介绍了如何使用Java内置的注解以及如何自定义一个注解，接下去看看注解实现的原理，看看在Java的大体系下面是如何对注解的支持的。还是回到上面自定义注解的例子，对于注解Test，如下，如果对AnnotationTest类进行注解，则运行时可以通过AnnotationTest.class.getAnnotation(Test.class)获取注解声明的值，从上面的句子就可以看出，它是从class结构中获取出Test注解的，所以肯定是在某个时候注解被加入到class结构中去了。
@Test("test")
public class AnnotationTest {
public void test(){
}
}从java源码到class字节码是由编译器完成的，编译器会对java源码进行解析并生成class文件，而注解也是在编译时由编译器进行处理，编译器会对注解符号处理并附加到class结构中，根据jvm规范，class文件结构是严格有序的格式，唯一可以附加信息到class结构中的方式就是保存到class结构的attributes属性中。我们知道对于类、字段、方法，在class结构中都有自己特定的表结构，而且各自都有自己的属性，而对于注解，作用的范围也可以不同，可以作用在类上，也可以作用在字段或方法上，这时编译器会对应将注解信息存放到类、字段、方法自己的属性上。
在我们的AnnotationTest类被编译后，在对应的AnnotationTest.class文件中会包含一个RuntimeVisibleAnnotations属性，由于这个注解是作用在类上，所以此属性被添加到类的属性集上。即Test注解的键值对value=test会被记录起来。而当JVM加载AnnotationTest.class文件字节码时，就会将RuntimeVisibleAnnotations属性值保存到AnnotationTest的Class对象中，于是就可以通过AnnotationTest.class.getAnnotation(Test.class)获取到Test注解对象，进而再通过Test注解对象获取到Test里面的属性值。
这里可能会有疑问，Test注解对象是什么？本文初就已经做了解释，其实注解被编译后的本质就是一个继承Annotation接口的接口，所以@Test其实就是“public interface Test extends Annotation”，当我们通过AnnotationTest.class.getAnnotation(Test.class)调用时，JDK会通过动态代理生成一个实现了Test接口的对象，并把将RuntimeVisibleAnnotations属性值设置进此对象中，此对象即为Test注解对象，通过它的value()方法就可以获取到注解值。
参考：
JAVA 注解的基本原理注解机制及其原理
