对于注解相信大家都不陌生，因为初学者第一个注解就是@Override，用于标识重载方法。在Java EE开发过程中，注解更是无处不在，像经典的MVC设计模式就至少使用到了4个注解：@Component、@Repository、@Service和@Controller。现在问题来了，为什么要学习注解？它有什么优点，能解决什么问题？通过阅读本篇文章相信读者会有一个比较清晰的认识。

一个经常会遇到的例子

在Java Web开发中，最早是使用XML的配置方式。举个例子来说，当开发者在Servlet中定义了LoginServlet类，接下来应该是去web.xml配置文件中增加LoginServlet类的访问映射，可能会使用如下代码：

1
2
3
4
5
6
7
8
<servlet>
  <servlet-name>LoginServlet</servlet-name>
  <servlet-class>com.envy.servlet.LoginServlet</servlet-class>
</servlet>
<servlet-mapping>
  <servlet-name>LoginServlet</servlet-name>
  <url-pattern>/LoginServlet</url-pattern>
</servlet-mapping>

这样当用户访问诸如http://localhost:8080/LoginServlet链接时，就会执行这个类中定义的方法逻辑。但是针对这种配置方式，有人觉得这种太麻烦了，于是提出了一种新的配置方式：在LoginServlet类上添加@WebServlet注解，并结合value="/LoginServlet"这种属性值的方式也实现了同样的目的，毫无疑问后面这种方式使用起来更加方便，而这种方式就是今天的主角—注解。

注解

什么是注解？

Java注解(Annotation)自Java1.5引入，用于描述Java代码的元信息，通常情况下注解不会直接影响代码的执行，但某些注解可以用来影响代码的执行。初学者可能被这句话给搞晕了，什么是元信息，一会儿不会影响代码的执行，一会儿又可以影响代码的执行。其实不用着急，相信通过本文的学习，你一定会对这句话有新的理解。

其实注解就像是代码中的特殊标记，这些特殊标记可以在类编译、加载、运行时被读取，并执行对应的逻辑。

注解的定义

注解虽然不像class和interface那样，自一开始就出现在大家的眼前，但是自从它诞生以来，它的地位却在一直提升。注解也是一种类型，因此它和class、interface一样值得被人记住。

定义注解非常简单，只需使用@interface关键词声明即可，比如下面就定义了一个属于开发者自己的注解@MyAnnotation：

1
2
public @interface MyAnnotation {
}

是不是觉得和接口非常相似，仅仅在前面添加了一个@符号而已。那么这个注解如何使用呢？先定义一个Hello类，然后将自定义的@MyAnnotation添加到这个Hello类上面这样就完成了一个最简单的注解使用案例，里面的代码为：

1
2
3
@MyAnnotation
public class Hello {
}

由于自定义的@MyAnnotation内不包含任何成员变量，因此该注解被称为标记注解，最常见的标记注解就是@Overried。但是实际上注解内往往是需要定义成员变量的，因此需要学习另一个概念：元注解。元注解是对注解进行注解的注解，用于解释说明被作用的注解的作用，因此它是一种非常基本的注解。

在JDK的java.lang.annotation包下定义了6个元注解：@Documented、@Inherited、@Native、@Repeatable、@Retention和@Target，如下图所示：

后续会依次解释一下这6个元注解的作用，了解和熟悉它们对于提升编程水平有极大的帮助。

元数据

不过在此之前先学习一下带有成员变量的注解，通常称之为元数据。在注解中定义成员变量，它的语法非常类似于方法的声明：

1
2
3
4
public @interface MyAnnotation {
    String username();
    String password();
}

这样就在之前自定义的MyAnnotation注解内添加了两个成员变量，username和password。请注意在注解上定义的成员变量只能是String、数组、Class、枚举类和注解。

在注解中定义成员变量其实是为了携带信息，通常在XML中可能一个标签中包含子标签：

1
2
3
4
<博客>
    <作者>余思</作者>
    <网址>www.envyzhan.club</网址>
</博客>

子标签就是一些信息，而这里在注解中定义的成员变量其实就相当于子标签。

不过由于前面的自定义注解@MyAnnotation中定义的成员变量没有默认值，因此在使用的时候需要添加默认值：

1
2
3
@MyAnnotation(username = "envy",password = "1234")
   public void test(){
   }

通常情况下会在声明一个注解的时候，给予它的成员变量一个默认值，这样便于后续使用：

1
2
3
4
public @interface MyAnnotation {
    String username() default "envy";
    String password() default "1234";
}

这样在使用的时候可以根据实际情况来选择是否修改注解的默认值：

1
2
3
@MyAnnotation()
public void test(){
}

注意这里面存在一个特殊情况：当一个注解内只存在一个成员属性，且属性值为value，那么开发者可以在声明该注解的时候不给予它默认值，且在使用的时候不需要指出value属性，而是直接赋值即可。举一个例子来说，现在有一个注解@MyAnnotation，它的内部结构为：

1
2
3
public @interface MyAnnotation {
    String value();
}

那么使用的时候可以采取如下的方式进行：

1
2
3
@MyAnnotation("envy")
    public void test(){
    }

注意这里的写法是@MyAnnotation("envy")，当然也可以采用@MyAnnotation(value="envy")的通用写法，但是不建议这么做，因为这本身就是一个语法糖而已。那有人觉得是不是只要一个注解内只要满足只要一个成员属性这一条件就可以呢？往下看，这里定义了一个@OneAnnotation，它的内部结构为：

1
2
3
public @interface OneAnnotation {
    String name();
}

然后使用的时候也按照语法糖来写，那是会报错的，只要属性值为value才可以，这一点需要引起特别注意：

内置7个元注解

@Documented注解

首先查看一下@Documented注解的源码信息，如下所示：

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

可以看到@Documented注解自jdk1.5引入，顾名思义@Documented注解是一个用于修饰的注解，被此注解修饰的注解可以被javadoc等工具文档化，注意它只负责标记，没有成员取值。通常javadoc中不包括注解，但是当某个注解被@Documented修饰时，那么它会被 javadoc工具处理，之后该注解类型信息会存在于生成的文档中。

举一个例子，前面自定义了一个注解@MyAnnotation，现在尝试在该注解上添加@Documented注解，

1
2
3
4
@Documented
public @interface MyAnnotation {

}

然后新建一个Hello.java文件，在该类上使用该注解：

1
2
3
@MyAnnotation
public class Hello {
}

接着进入dos命令行，切换到该注解所在的文件夹，然后执行javadoc -d doc *.java，该命令的作用是使用javadoc工具生成一个对该目录下所有java文件的说明文档。运行命令后可以发现当前目录下多了一个doc目录，进入该目录，然后使用浏览器打开其中的index.html文件：

可以发现这个文档中出现了对注释类型的说明（注解其实是一种类型，成为注释类型，但是通常大家都称之为注解）

现在尝试删除这个doc目录，且去掉MyAnnotation注释上的@Documented注解，再来运行一下上述命令，可以发现此时生成的index.html文件中就没有对注释类型的说明了：

这就是@Documented注解的使用方法，继续下一个注解。

@Native 注解

首先查看一下@Native注解的源码信息，如下所示：

1
2
3
4
5
@Documented
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.SOURCE)
public @interface Native {
}

可以看到@Native注解自jdk1.8引入，用于注释该字段是一个常量，其值引用native code，可以发现它的保留时间为SOURCE阶段，这个用的不是很多。

@Target 注解

首先查看一下@Target 注解的源码信息，如下所示：

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

可以看到@Target注解自jdk1.5引入，用于指明被修饰注解的使用范围，即用来描述被修饰的注解可以在哪里使用。定义在ElementType枚举类中，一共有10种策略(1.8之前存在前8种，jdk1.8新增后2种)：
枚举常量 | 注解使用范围
-|-
TYPE| 类，接口（包括注解类型），和枚举 |
FIELD| 字段（包括枚举常量）|
METHOD| 方法 |
PARAMETER| 形式参数 |
CONSTRUCTOR| 构造函数 |
LOCAL_VARIABLE| 局部变量 |
ANNOTATION_TYPE| 注解类型 |
PACKAGE| 包 |
TYPE_PARAMETER （jdk1.8引入）| 类型参数 |
TYPE_USE （jdk1.8引入）| 使用类型 |

请注意这里的PACKAGE，不是使用在一般类中，而是用在固定的package-info.java文件中，注意名称必须是package-info不能修改。举个例子来说，新建一个WeAnnotation注解，其中的代码为：

1
2
3
4
@Target({ElementType.PACKAGE,ElementType.METHOD})
@Documented
public @interface WeAnnotation {
}

接着再创建一个package-info.java文件，注意必须使用类似于文件创建的方式，否则IDEA不允许创建：

1
2
@WeAnnotation
package com.envy.annotation;

这样就成功的使用了该注解。请注意在@Target注解内定义的成员变量是一个数组，因此必须使用诸如@Target({ElementType.PACKAGE})形式：

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

@Retention 注解

首先查看一下@Retention注解的源码信息，如下所示：

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

可以看到@Retention注解自jdk1.5引入，用于指明被修饰注解的保留时间。定义在RetentionPolicy枚举类中，一共有三种策略：SOURCE、CLASS和RUNTIME。

1
2
3
4
5
6
7
8
9
10
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Retention {
    /**
     * Returns the retention policy.
     * @return the retention policy
     */
    RetentionPolicy value();
}

SOURCE，顾名思义就是源码阶段，该注解只存在于.java源文件中，当.Java文件编译成.class字节码文件的时候，该注解即被遗弃，被编译器忽略。CLASS，顾名思义就是字节码阶段，该注解保留到.class字节码文件中，当.class字节码文件被jvm加载时即被遗弃，这是默认的生命周期。RUNTIME，注解不仅被保存到.class字节码文件中，且被jvm加载后，仍然存在，因此这个时候就有一种非常厉害的技术–反射。

其实这三个生命周期分别对应于三个阶段：.java源文件—> .class字节码文件 —> 内存中的字节码。也就是说生命周期长度顺序为SOURCE< CLASS< RUNTIME，因此前者能作用的地方后者一定也能作用。

一般的，如果开发者想要做一些检查性的操作，如是否方法重载，禁止编译器警告等，可以选择SOURCE生命周期。如果想要在编译时进行一些预处理操作，如生成一些辅助代码等，可以选择CLASS生命周期。如果想要在运行时去动态获取注解信息，那此时必须选择RUNTIME生命周期。

反射技术demo演示@Retention和@Target注解使用。前面提到的反射技术就是在运行时动态获取类的相关信息，下面就结合反射来介绍如何使用@Retention和@Target注解，便于demo演示，这里仅仅获取类的常用信息，如Class、Field和Method 。

第一步，新建3个自定义注解。新建myannotation包，并在其中依次创建3个自定义运行时注解，且作用范围依次为Class、Field和Method：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//ClassAnno.java
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
public @interface ClassAnno {
    String value();
}

//MethodAnno.java
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface MethodAnno {
    String name() default "envy";
    String data();
    int age() default 22;
}

//FieldAnno.java
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface FieldAnno {
    int[] value();
}

第二步，新建测试类RunTimeTest。新建RunTimeTest测试类，其中的代码为：

1
2
3
4
5
6
7
8
9
10
11
@ClassAnno("RunTime")
public class RunTimeTest {
    @FieldAnno(value = {66,88})
    public String word = "hello";
    @FieldAnno(value = {1024})
    public int number = 2018;
    @MethodAnno(data = "good",name="envy", age = 22)
    public static void sayHello(){
        System.out.println("this is sayHello method.");
    }
}

第三步，获取注解内部信息。新建GetRunTimeTest类，用于运行时获取注解内部信息，相应的代码为：

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
41
42
43
44
45
46
47
48
public class GetRunTimeTest {
    public static void outInfo(){
        StringBuilder builder = new StringBuilder();
        Class<?> aClass = RunTimeTest.class;
        /**获取ClassAnno注解信息*/
        builder.append("ClassAnno注解：").append("\n");
        ClassAnno classAnno = aClass.getAnnotation(ClassAnno.class);
        if(classAnno!=null){
            builder.append(Modifier.toString(aClass.getModifiers())).append(" ")
                    .append(aClass.getSimpleName()).append("\n");
            builder.append("注解值为：").append(classAnno.value()).append("\n\n");
        }

        /**获取MethodAnno注解信息*/
        builder.append("MethodAnno注解：").append("\n");
        Method[] methods = aClass.getDeclaredMethods();
        for(Method method:methods){
            MethodAnno methodAnno = method.getAnnotation(MethodAnno.class);
            if(methodAnno !=null){
                builder.append(Modifier.toString(method.getModifiers())).append(" ")
                        .append(method.getReturnType().getSimpleName()).append(" ")
                        .append(method.getName()).append("\n");
                builder.append("注解值为：").append("\n");
                builder.append("name--->").append(methodAnno.name()).append("\n");
                builder.append("data--->").append(methodAnno.data()).append("\n");
                builder.append("age--->").append(methodAnno.age()).append("\n\n");
            }
        }

        /**获取FieldAnno注解信息*/
        builder.append("FieldAnno注解：").append("\n");
        Field[] fields = aClass.getDeclaredFields();
        for(Field field:fields){
            FieldAnno fieldAnno = field.getAnnotation(FieldAnno.class);
            if(fieldAnno != null){
                builder.append(Modifier.toString(field.getModifiers())).append(" ")
                        .append(field.getType().getSimpleName()).append(" ")
                        .append(field.getName()).append("\n");
                builder.append("注解值为：").append(Arrays.toString(fieldAnno.value())).append("\n\n");
            }
        }
        System.out.println(builder.toString());
    }

    public static void main(String[] args){
        outInfo();
    }
}

运行该方法后，结果如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
ClassAnno注解：
public RunTimeTest
注解值为：RunTime

MethodAnno注解：
public static void sayHello
注解值为：
name--->envy
data--->good
age--->22

FieldAnno注解：
public String word
注解值为：[66, 88]

public int number
注解值为：[1024]

可以发现使用反射技术，成功的在程序运行时动态地获取到了注解中的信息，其实在Spring框架内的@Autowried注解就是起这个作用，在类运行时将需要的Bean注入Spring容器，以供后续程序的调用。

@Inherited 注解

首先查看一下@Inherited 注解的源码信息，如下所示：

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

可以看到@Inherited注解自jdk1.5引入，顾名思义@Inherited注解允许子类继承父类的注解。举个例子来说，假设你使用@Inherited注解修饰了自定义的@HeyAnnotation注解，如果此时自定义的@HeyAnnotation注解修饰一个类Book后，而又一个TechBook类又继承了Book类，那么此时的TechBook类则默认也拥有你自定义的@HeyAnnotation注解。

HeyAnnotation.java注解中的代码：

1
2
3
4
@Inherited
@Retention(RetentionPolicy.RUNTIME)
public @interface HeyAnnotation {
}

请注意后续是通过反射来判断子类中是否存在@HeyAnnotation注解，而注解默认的保留时间为CLASS，这使得该注解无法进入RUNTIME时期，因此必须加上@Retention(RetentionPolicy.RUNTIME)。接下来是Book.java文件中的代码：

1
2
3
@HeyAnnotation
public class Book {
}

然后是Book子类TechBook类中的代码：

1
2
3
4
5
public class TechBook extends Book {
    public static void main(String[] args){
        System.out.println(TechBook.class.isAnnotationPresent(HeyAnnotation.class));
    }
}

然后运行该main方法，可以发现输出结果为true。

@Repeatable 注解

首先查看一下@Repeatable注解的源码信息，如下所示：

1
2
3
4
5
6
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Repeatable {
    Class<? extends Annotation> value();
}

可以看到@Repeatable 注解自jdk1.8引入，Repeatable是重复的意思，因此被该注解修饰的注解可以多次应用于相同的声明或类型中。那么什么样的注解可以被多次使用呢？当然是注解的值可以同时取多个了。

举个例子来说，一个男人可能是父亲，可能是儿子，也有可能是丈夫。首先定义一个@Persons注解：

1
2
3
public @interface Persons {
    Person[] value();
}

注意这里面的成员变量Person也是注解，该注解中的代码为：

1
2
3
4
@Repeatable(Persons.class)
public @interface Person {
    String role() default "";
}

可以看到在该注解上使用了@Repeatable(Persons.class)注解，这个其实就相当于一个容器注解，容器注解顾名思义就是存放其他注解的注解，注意容器注解也是一个注解。然后定一个Male类来使用这个@Person注解，相应的代码为：

1
2
3
4
5
@Person(role = "husband")
@Person(role = "son")
@Person(role = "father")
public class Male {
}

回过头再来看一下@Persons注解内的代码：

1
2
3
public @interface Persons {
    Person[] value();
}

可以看到它的成员变量是一个被@Repeatable(Persons.class)注解修饰的注解，注意它是一个数组。

接下来通过一张图片来总结一下这6个元注解：

基本注解

在介绍完了元注解后，接下来了解一下Java中默认提供的5个基本注解，它们存在于java.lang包下：@Deprecated、@FunctionalInterface、@Override、@SafeVarargs和@SuppressWarnings。

请注意不要和java.lang.annotation包下的6个元注解搞混淆了：

@Deprecated注解

首先查看一下@Deprecated注解的源码信息，如下所示：

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

可以看到@Deprecated注解自jdk1.5引入，它用来标记过时的元素，这个注解在日常开发中会经常碰到。如果编译器在编译阶段遇到这个注解时会自动发出提醒警告，用于告诉开发人员正在调用一个过时的元素，如过时的方法、过时的类、过时的成员变量等（可以参看它的Target注解）。

举个例子，新建一个Envy类，里面的代码为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Envy {
    @Deprecated
    public void hello(){
        System.out.println("hello");
    }
    public void world(){
        System.out.println("world");
    }
    
    public static void main(String[] args){
        new Envy().hello();
        new Envy().world();
    }
}

可以看到目前在该hello方法山添加了@Deprecated注解，然后在main方法内新建一个Envy对象去调用这个hello方法，可以发现编译器此时自动给该方法中间添加了横线：

注意这个效果是编译器添加的，并不是程序具有的效果。注意过时方法不是不能使用，而是不建议使用。

@FunctionalInterface注解

首先查看一下@FunctionalInterface注解的源码信息，如下所示：

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

可以看到@FunctionalInterface注解自jdk1.8引入，它是一个函数式接口注解，这是1.8的一个新特性。所谓的函数式接口 (Functional Interface) 其实就是一个只具有一个方法的普通接口。看到这里，笔者立马就想到了多进程中的Runnable接口，它就是一个只含有run方法的函数式接口：

1
2
3
4
@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

此时你可能有一个疑惑，函数式接口有什么用，等下一篇介绍Lambda表达式的时候就会深深体会到它的用处。

@Override注解

首先查看一下@Override注解的源码信息，如下所示：

1
2
3
4
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}

可以看到@Override注解自jdk1.5引入，它是一个重写注解，这是使用最多的注解。当某个方法添加@Override注解后，编译器会去检查该方法是实现父类的对应方法，可以避免一些低级错误，如单词拼写错误等。举个例子，这里有一个Movie类：

1
2
3
4
5
public class Movie {
    public void watch(){
        System.out.println("watch");
    }
}

然后有一个ActionMovie类，该类继承了Movie类，并实现了其中的watch方法，但是由于粗心将watch写成了wath，此时编译器就会抛出提示信息：

根据这个信息就能知道出错原因是方法单词拼错了。

@SafeVarargs注解

首先查看一下@SafeVarargs注解的源码信息，如下所示：

1
2
3
4
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.CONSTRUCTOR, ElementType.METHOD})
public @interface SafeVarargs {}

可以看到@SafeVarargs注解自jdk1.7引入，它是一个参数安全类型注解，大家也称之为Java 7“堆污染”警告，所谓的堆污染其实就是把一个非泛型集合赋值给一个泛型集合的时候，这时就很容易发生堆污染。如果使用@SafeVarargs注解后，它会提醒开发者不要用参数做一些不安全的操作，它的存在会阻止编译器产生unchecked这样的警告。这个用的不是很多。

@SuppressWarnings注解

首先查看一下@SuppressWarnings注解的源码信息，如下所示：

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

可以看到@SuppressWarnings注解自jdk1.5引入，它是一个抑制编译器警告注解。前面说过调用被@Deprecated注解修饰的方法后，编译器会发出提醒，如果开发者想忽略这种警告，那么可以在调用时添加@SuppressWarnings注解来实现这个目的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Envy {
    @Deprecated
    public void hello(){
        System.out.println("hello");
    }
    public void world(){
        System.out.println("world");
    }

    @SuppressWarnings("deprecation")
    public static void main(String[] args){
        new Envy().hello();
        new Envy().world();
    }
}

这样编辑器就不会去检测hello方法是否过期。同样通过一张图片来总结一下这5个基本注解：

自定义注解的使用

将自定义信息注入到方法中

在前面介绍了如何在运行时获取注解中的信息，接下来介绍如何将自定义信息注入到方法中。这里就不再自定义获取注解中信息的方法了，而是直接使用内置的方法。自定义一个@EnvyThink注解，里面的代码为：

1
2
3
4
5
6
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE,ElementType.METHOD,ElementType.FIELD})
public @interface EnvyThink {
    String name() default "envy";
    int age() default 22;
}

接着新建一个Envy类，其中的代码为：

1
2
3
4
5
6
public class Envy {
    @EnvyThink()
    public void hey(String name,int age){
        System.out.println("name--->"+name+"\n"+ "age--->"+age);
    }
}

然后新建一个测试类EnvyTest，里面的代码为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class EnvyTest {
    public static void main(String[] args){
        try {
            /**第一步，通过反射得到该类被注解修饰的方法*/
            Class<?> aClass = Envy.class;
            Method method = aClass.getDeclaredMethod("hey",String.class,int.class);

            /**第二步，通过该方法来得到注解的信息*/
            EnvyThink envyThink = method.getAnnotation(EnvyThink.class);
            String name = envyThink.name();
            int age = envyThink.age();

            /**第三步，将注解的信息注入到方法内*/
            Object object = aClass.newInstance();
            method.invoke(object,name,age);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

然后运行该方法，可以知道该方法的结果为：

1
2
name--->envy
age--->22

将自定义对象注入到方法中

可以看到前面注入的是注解内自定义的成员属性，接下来尝试将自定义对象注入到方法中。首先解释一下什么是将自定义对象注入到方法中？举一个例子，首先定义Book实体类，里面的代码为：

1
2
3
4
5
6
7
8
9
10
public class Book {
    private String name;
    private double price;
    public Book(){};
    public Book(String name,double price){
        this.name=name;
        this.price=price;
    }
    //getter/setter/toString方法
}

其次再定义一个Author类，里面的代码为：

1
2
3
4
5
6
7
8
9
10
public class Author {
    private Book book;

    public Book getBook(){
        return book;
    }
    public void setBook(Book book){
        this.book = book;
    }
}

大家肯定知道这个setBook方法内的参数book对象其实是外界传进来的，所以如果需要调用这个方法则必须使用类似如下操作：

1
2
3
4
5
public class AuthorTest {
    public static void main(String[] args){
        new Author().setBook(new Book("三国演义",128));
    }
}

现在想通过注解的方式来将该Book对象注入到Author中，也就是如下方式：

1
2
3
4
@BookAnno(name = "三国演义", price = 128)
public void setBook(Book book){
    this.book = book;
}

应该如何实现呢？往下看，首先定义一个@BookAnno注解，里面定义两个属性name和price（注意属性数量和名称必须与Book完全保持一致），里面的代码为：

1
2
3
4
5
@Retention(RetentionPolicy.RUNTIME)
public @interface BookAnno {
    String name() default "三国演义";
    double price() default 128;
}

注意该注解必须添加@Retention(RetentionPolicy.RUNTIME)注解语句，否则无法通过反射实现相应的功能。

接着定义一个AuthorAnnoTest类，用于实现将Book对象注入到Author的setBook方法中。在该类中，需要通过内省(Introspector)来对JavaBean类属性、事件进行缺省处理。关于内省的相关介绍，后续会专门出一篇文章进行说明。AuthorAnnoTest类中的代码为：

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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
public class AuthorAnnoTest {
  public static void main(String[] args) {
    try {
      /** 1.使用内省机制来获取想要注入的属性 */

      /** 第一个参数为待注入属性，第二个参数为该属性所依附的类 */
      PropertyDescriptor descriptor = new PropertyDescriptor("book", Author.class);

      /** 2.获取该属性的setPerson方法（写方法）*/
      Method method = descriptor.getWriteMethod();

      /** 3.获取写方法的注解*/
      Annotation annotation = method.getAnnotation(BookAnno.class);

      /** 4.获取注解上的信息（注意必须是方法，因为注解内成员变量的定义就是采用方法形式）*/
      Method[] methods = annotation.getClass().getMethods();

      /** 5.获取待注入属性的实例对象*/
      Book book = (Book) descriptor.getPropertyType().newInstance();

      /** 6.将注解上的信息添加到book对象上*/
      for (Method meth : methods) {

        /** 7.获取注解内相关属性的名称（注意这里的name不仅仅只是name属性，而是一个属性别称） */
        String name = meth.getName();

        /** 8.判断Book对象中是否存在各属性对应的setter方法*/
        try {
          /** 8.1.1 假设存在相对应的setter方法，则采用内省机制来获取对应的setter方法*/
          PropertyDescriptor descriptor1 = new PropertyDescriptor(name, Book.class);

          /** 8.1.2 获取各属性相对应的setter写方法 */
          Method method1 = descriptor1.getWriteMethod();

          /** 8.1.3 获取注解中的值*/
          Object o = meth.invoke(annotation, null);

          /** 8.1.4 调用Book对象的setter写方法，将前面获取的注解的值设置进去*/
          method1.invoke(book, o);
        } catch (Exception e) {

          /** 8.2 如果Book对象中不存在各属性对应的setter方法，那么会跳过当前循环，继续遍历注解*/
          continue;
        }
      }

      /** 9、遍历完成，book对象中的各个setter方法已经成功写入了注解中的值*/

      /** 9.1 通过setter方法将book对象写入到author对象中*/
      Author author = new Author();
      method.invoke(author, book);

      /** 10.输出author对象中的name和price的信息 */
      System.out.println(author.getBook().getName());
      System.out.println(author.getBook().getPrice());
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

运行该方法，可以得到输出结果为：

1
2
三国演义
128.0

接下来总结一下该步骤：
1、使用内省机制来获取想要注入的属性；2、获取该属性的写方法；3、获取写方法的注解；4、获取注解上的信息（注意必须是方法，因为注解内成员变量的定义就是采用方法形式）；5、获取待注入属性的实例对象；6、将注解上的信息添加到对象上；7、调用属性的写方法将已添加数据的对象注入到方法中；8、验证对象是否成功注入方法中。

Spring内置的@Autowried注解就是完成了类似的功能才使得用户可以直接在方法中就能使用对象。

将自定义对象注入到属性中

将自定义对象注入到属性中，这也是一个常见的使用场景，通过前面的介绍，开发者可以尝试照葫芦画瓢来实现这一功能。也就是当开发者使用如下方式：

1
2
3
4
5
6
7
8
9
10
11
12
public class Author {
    @BookAnno(name = "三国演义", price = 128)
    private Book book;

    public Book getBook(){
        return book;
    }

    public void setBook(Book book){
        this.book = book;
    }
}

的代码配置时，我们依然可以像前面那样在author对象中获取注解的值。接着定义一个AuthorAnnoFiledTest类，用于实现将Book对象注入到Author的book属性中。需要注意的是首先需要使用反射机制来获取对应的属性，其次使用内省机制来获取对应的写方法。AuthorAnnoFiledTest类中的代码为：

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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
public class AuthorAnnoFiledTest {
    public static void main(String[] args){
        try {
            /** 1.使用反射机制来获取想要注入的属性 */
            Field field = Author.class.getDeclaredField("book");

            /** 2.获取属性的注解*/
            Annotation annotation = field.getAnnotation(BookAnno.class);

            /** 3.获取注解上的信息（注意必须是方法，因为注解内成员变量的定义就是采用方法形式）*/
            Method[] methods = annotation.getClass().getMethods();

            /** 4.获取待注入属性的实例对象*/
            Book book = (Book) field.getType().newInstance();

            /** 5.将注解上的信息添加到book对象上*/
            for (Method meth : methods) {

                /** 6.获取注解内相关属性的名称（注意这里的name不仅仅只是name属性，而是一个属性别称） */
                String name = meth.getName();

                /** 7.判断Book对象中是否存在各属性对应的setter方法*/
                try {
                    /** 7.1.1 假设存在相对应的setter方法，则采用内省机制来获取对应的setter方法*/
                    PropertyDescriptor descriptor = new PropertyDescriptor(name, Book.class);

                    /** 7.1.2 获取各属性相对应的setter写方法 */
                    Method method1 = descriptor.getWriteMethod();

                    /** 7.1.3 获取注解中的值*/
                    Object o = meth.invoke(annotation, null);

                    /** 7.1.4 调用Book对象的setter写方法，将前面获取的注解的值设置进去*/
                    method1.invoke(book, o);
                } catch (Exception e) {

                    /** 7.2 如果Book对象中不存在各属性对应的setter方法，那么会跳过当前循环，继续遍历注解*/
                    continue;
                }
            }

            /** 8、遍历完成，book对象中的各个setter方法已经成功写入了注解中的值*/

            /** 8.1 通过setter方法将book对象写入到author对象中*/
            Author author = new Author();
            field.setAccessible(true);
            field.set(author,book);

            /** 10.输出author对象中的name和price的信息 */
            System.out.println(author.getBook().getName());
            System.out.println(author.getBook().getPrice());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行该方法，可以得到输出结果为：

1
2
三国演义
128.0

接下来总结一下该步骤：
1、使用反射机制来获取想要注入的属性；2、获取该属性的注解；3、获取注解上的信息（注意必须是方法，因为注解内成员变量的定义就是采用方法形式）；4、获取待注入属性的实例对象；5、将注解上的信息添加到对象上；6、调用属性的写方法将已添加数据的对象注入到方法中；7、验证对象是否成功注入方法中。

注解总结

接下来对注解进行总结，注解其实就两个作用：（1）在适当的时候将数据注入到方法、成员变量、类或者其他组件中；（2）让编译器检查代码，进而发出提示信息。关于注解就先介绍到这里，后续会出一篇文章来总结Spring框架中常用的注解。