夯实Java基础（十七）——注解(Annotation)

1、注解概述

从jdk5.0开始，java增加对元数据(metadata)的支持，也就是注解(annotation)。其实我们早就已经接触过注解了，例如我们经常在java代码中可以看到 “@override”，“@test”等等这样的东西，它们就是java中的注解。注解可以像修饰符一样使用，可以用于修饰包、类、构造器、方法、成员变量、参数、局部变量的声明。

我们需要注意的是，注解与注释是有一定区别的，注解就是代码里面的特殊标记，这些标记可以在编译，类加载，运行时被读取，并执行相应的处理。通过注解开发人员可以在不改变原有代码和逻辑的情况下在源代码中嵌入补充信息。而注释则是用以说明某段代码的作用，或者说明某个类的用途、某个方法的功能和介绍，以及该方法的参数和返回值的数据类型及意义等等。

2、java内置注解

在javase部分，注解的使用往往比较简单，java中提供了5个内置注解，它们分别是：

①、@override：标注该方法是重写父类中的方法。

这个注解一个是我们见得最多的一个了，提示这个方法是重写于父类的方法。

②、@deprecated：标记某个功能已经过时，用于定义过时的类、方法、成员变量等。

这个注解想必大家应该都有碰到过，在使用date日期类的时候，里面有大量过时的方法，我们来定义一个date类来调用一个方法。

这个getday()方法就是过时的，我们点击进去看一下这个方法的源码：

果然这个方法是用@deprecated修饰过的。同时也可以发现我们在调用过时元素时，编译器在编译阶段遇到这个注解时会发出提醒警告，告诉开发者正在调用一个过时的元素，当然如果不想看到警告我们可以抑制它的出现。

③、@suppresswarnings：抑制编译器警告。

上面说到用@deprecated修饰过的元素在调用时会有警告，我们可以用@suppresswarnings注解来抑制警告的出现。

可以发现左边的警告没有了。@suppresswarnings这个注解中参数非常的多，这里介绍几个常见的参数：

• all：抑制所有警告。
• deprecation：抑制过期方法警告。
• null：忽略对null的操作。
• unchecked：抑制没有进行类型检查操作的警告。
• unused：抑制没被使用过的代码的警告。

如果需要了解更多的可以去查看官方文档。

④、@functionainterface：指定接口必须为函数式接口。

这个注解是java8出现的新特性。这个函数式接口的意思就是接口中有一个且仅有一个抽象方法，但是可以有多个非抽象方法，如果不定义或定义多个抽象方法就会报错。

正式因为jdk 8中lambda表达式的引入，使得函数式接口在java中变得越来越流行。因为这些特殊类型的接口可以用lambda表达式、方法引用或构造函数引用轻松替换。

⑤、@safevarargs：抑制"堆污染警告"。

这个注解是在java7中引入，主要目的是处理可变长参数中的泛型，此注解告诉编译器：在可变长参数中的泛型是类型安全的。可变长参数是使用数组存储的，而数组和泛型不能很好的混合使用。因为数组元素的数据类型在编译和运行时都是确定的，而泛型的数据类型只有在运行时才能确定下来，因此当把一个泛型存储到数组中时，编译器在编译阶段无法检查数据类型是否匹配，因此会给出警告信息。

我们来看下面这个示例：

public class test {
    @safevarargs//这里告诉编译器类型安全，不让有警告。其实方法体内容类型不安全
    public static void show(list<string>...lists){
        object[] arry=lists;
        list<integer> intlist=arrays.aslist(11,22,33);
        arry[0]=intlist;//这里就是堆污染，这里没有警告，是因为只针对于可变长参数泛型
        string str=lists[0].get(0);//java.lang.classcastexception
    }

    public static void main(string[] args) {
        list<string> list1=arrays.aslist("aa","bb","cc");
        list<string> list2=arrays.aslist("dd","ee","dd");
        show(list1,list2);
    }
}

通过上述的示例，我们将intlist赋给array[0]，array[0]的类型是list<string>，但是储引用到实际为list<integer>类型的值，这个无效的引用被称为堆污染。由于直到运行时才能确定此错误，因此它会在编译时显示为警告，这里没有警告，是因为只针对于可变长参数泛型，并在运行时出现classcastexception。

注意：@safevarargs注解只能用在参数长度可变的方法或构造方法上，且方法必须声明为static或final，否则会出现编译错误。

3、自定义注解

我们在享受注解给我们带来方便地同时，我们自己应该要知道怎么去定义注解。注解的自定义非常的简单，通过 @interface关键字进行定义，可以发现这个关键字和接口interface很相似，就在前面加了一个 @符号，但是它和接口没有任何关系。自定义注解还需要注意的一点是：所有的自定义注解都自动继承了java.lang.annotation.annotation这个接口。自定义注解的格式：

public @interface 注解名 {
       //属性
}    

同样我们可以在注解中定义属性，它的定义有点类似于方法，但又不是方法，在注解中是不能声明普通方法的。注解的属性在注解定义中以无参数方法的形式来声明，其方法名定义了属性的名字，其返回值定义了该属性的类型，我们称为配置参数。它们的类型只能是八种基本数据类型、string类型、class类型、enum类型、annotation类型以上所有类型的数组。例如：

//定义了一个myannotation注解
public @interface myannotation {
    string[] value();
}

@myannotation(value = "hello")
class test{

}

上面注解代码中，定义了一个string的value数组。然后我们在使用的时候，就可以使用 属性名称=“xxx” 的形式赋值。

注解中属性还可以有默认值，默认值需要用 default 关键值指定。比如：.

//定义了一个myannotation注解
public @interface myannotation {
    string id();
    string[] value() default {"aa","bb"};
}

@myannotation(id="one")
class test{

}

上面定义了 id 属性没有默认值，而value属性中则设置了默认值，所以在使用注解的时候只需给 id 属性赋值即可，value可以不用写。

通过以上形式自定义的注解暂时都还没有任何实用的价值，因为自定义注解必须配上注解的信息处理流程（使用反射）才有意义。如何让注解真真的发挥作用，主要就在于注解处理方法，所以接下来我们将学习元注解和注解的反射。

4、元注解

元注解就是用来修饰其他注解的注解。我们随便点进一个注解的源码都可以发现有元注解。

java5.0中定义了4个标准的元注解类型，它们被用来提供对其它注解类型作说明：

• @retention
• @target
• @documented
• @inherited

而java8.0中又增加了一个新的元注解类型：

• @repeatable

所以接下来我们将逐个分析它们的作用和使用方法。

1、@retention：用于指定该annotation的生命周期。

这个元注解只能用于修饰一个annotation定义，它的内部包含了一个retentionpolicy枚举类型的属性，而这个枚举类中定义了三个枚举实例，source、class、runtime。它们各个值的意思如下：

• retentionpolicy.source：在源文件中有效（即源文件保留），在编译器进行编译时它将被丢弃忽视。
• retentionpolicy.class：在class文件中有效（即class保留），当java程序运行时，它并不会被加载到 jvm 中，只保留在class文件中。这个是默认值。
• retentionpolicy.runtime：在运行时有效（即运行时保留），当java程序运行时，注解会被加载进入到 jvm 中，所以我们可以使用反射获取到它们。

 

比较典型的是@suppresswarnings注解，如果我们用 javap -c去反编译它是看到这个注解的，因为在编译的时候就已经被丢弃了。

②、@target：用于指定该annotation能够用在哪些地方。

@target内部定义了一个枚举类型的数组elementtype[] value()，在elementtype这个枚举类中参数有很多，我们来看一下：

• type:用于描述类、接口(包括注解类型) 或enum声明
• field:用于描述域即类成员变量
• method:用于描述方法
• parameter:用于描述参数
• constructor:用于描述构造器
• local_variable:用于描述局部变量
• annotation_type：由于描述注解类型
• package:用于描述包
• type_parameter:1.8版本开始，描述类、接口或enum参数的声明
• type_use:1.8版本开始，描述一种类、接口或enum的使用声明

③、@document：表示annotation可以被包含到javadoc中去。默认情况下javadoc是不包含注解的。

由于这个比较简单所以不细说。

④、@inherited：被它修饰的annotation将具有继承性。

@inherited修饰过的annotation其子类会自动具有该注解。在实际应用中，使用情况非常少。

⑤、@repeatable：用于指示它修饰的注解类型是可重复的。

这个注解是在java8中新出的特性，说到这个可重复注解可能有点不理解。我们通过示例来理解一下：

先定义一个myannotation注解：

@inherited
@documented
@repeatable(myannotations.class)
@retention(retentionpolicy.runtime)
@target({elementtype.type,elementtype.field,elementtype.method,elementtype.parameter})
public @interface myannotation {
    string value() default "hello";
}

这里需要说明@repeatable(myannotations.class)，它表示在同一个类中@myannotation注解是可以重复使用的，重复的注解被存放至@myannotations注解中。

然后再定义一个myannotations注解：

@inherited
@documented
@retention(retentionpolicy.runtime)
@target({elementtype.type,elementtype.field,elementtype.method,elementtype.parameter})
public @interface myannotations {
    myannotation[] value();
}

这个myannotations注解里面的属性必须要声明为要重复使用注解的类型数组myannotation[] value();，而且相应的生命周期和使用地方都需要同步。否则就会编译报错！

进行测试：

@myannotation(value = "world")
@myannotation(value = "world")
public class test{

}

而在java8之前没有@repeatable注解是这样写的：

@myannotations({@myannotation(value = "world"),@myannotation(value = "world")})
public class test{

}

5、注解处理器(使用反射)

以上讲的所以注解的定义都只是一个形式，实际上还并没有什么可使用的价值，而注解的核心就是使用反射来获取到它们，所以下面我们要来学习注解处理器(使用反射)的使用。

下面参考：

java.lang.reflect 包下主要包含一些实现反射功能的工具类，实际上，java.lang.reflect 包所有提供的反射api扩充了读取运行时annotation信息的能力。当一个annotation类型被定义为runtime的注解后，该注解才能是运行时可见，当class文件被装载时被保存在class文件中的annotation才会被虚拟机读取。
annotatedelement 接口是所有程序元素（class、method和constructor）的父接口，所以程序通过反射获取了某个类的annotatedelement对象之后，程序就可以调用该对象的如下四个个方法来访问annotation信息：

• 方法1：<t extends annotation> t getannotation(class<t> annotationclass): 返回改程序元素上存在的、指定类型的注解，如果该类型注解不存在，则返回null。
• 方法2：annotation[] getannotations():返回该程序元素上存在的所有注解。
• 方法3：boolean is annotationpresent(class<?extends annotation> annotationclass):判断该程序元素上是否包含指定类型的注解，存在则返回true，否则返回false.
• 方法4：annotation[] getdeclaredannotations()：返回直接存在于此元素上的所有注释。与此接口中的其他方法不同，该方法将忽略继承的注释。（如果没有注释直接存在于此元素上，则返回长度为零的一个数组。）该方法的调用者可以随意修改返回的数组；这不会对其他调用者返回的数组产生任何影响。

一个简单的注解处理器：　　

@target(elementtype.type)
@retention(retentionpolicy.runtime)//这里必须定义为runtime
public @interface myannotation {
    string id();
    string[] value() default {"aa","bb"};
}

@myannotation(id = "hello")
class test{
    public static void main(string[] args) {
        boolean annotationpresent = test.class.isannotationpresent(myannotation.class);
        system.out.println(annotationpresent);
        if ( annotationpresent ) {
            myannotation myannotation = test.class.getannotation(myannotation.class);

            system.out.println("id:"+myannotation.id());
            system.out.println("value:"+ arrays.tostring(myannotation.value()));
        }
    }
}

程序运行结果：

上面的例子只是作用在类上面的注解，如果要作用在属性、方法等上面的注解我们应该怎么获取呢？

定义作用于类上面的myannotation注解：

//作用于类上面的注解
@target({elementtype.type, elementtype.field, elementtype.method})
@retention(retentionpolicy.runtime)//这里必须定义为runtime
public @interface myannotation {
    string[] value() default "";
}

定义作用于属性上面的attributeannotation注解：

//作用于属性上的注解
@target(elementtype.field)
@retention(retentionpolicy.runtime)//这里必须定义为runtime
public @interface attributeannotation {
    string value();
}

定义作用于方法上面的methodannotation注解：

//作用于方法上的注解
@target(elementtype.method)
@retention(retentionpolicy.runtime)//这里必须定义为runtime
public @interface methodannotation {
    string value();
}

然后就是测试了：

@myannotation(value = "myannotation")
class test{

    @attributeannotation(value = "attributeannotation")
    string str;

    @methodannotation(value = "methodannotation_show")
    public void show(){
        system.out.println("methodannotation_show");
    }

    @methodannotation(value = "methodannotation_display")
    public void display(){
        system.out.println("methodannotation_display");
    }

    public static void main(string[] args) {
        //获取类上面的注解
        boolean annotationpresent = test.class.isannotationpresent(myannotation.class);
        system.out.println(annotationpresent);
        if ( annotationpresent ) {
            myannotation myannotation = test.class.getannotation(myannotation.class);
            system.out.println("class-annotation："+arrays.tostring(myannotation.value()));
        }

        try {
            //获取单个属性中的注解
            field str = test.class.getdeclaredfield("str");
            attributeannotation attributeannotation = str.getannotation(attributeannotation.class);
            if (attributeannotation!=null){
                system.out.println("attribute-annotation："+attributeannotation.value());
            }

            //获取多个方法中的注解
            method[] declaredmethods = test.class.getdeclaredmethods();
            for (method declaredmethod : declaredmethods) {
                    methodannotation methodannotation = declaredmethod.getannotation(methodannotation.class);
                    if (methodannotation!=null){
                        system.out.println("method-annotation："+methodannotation.value());
                    }
            }

        } catch (nosuchfieldexception e) {
            e.printstacktrace();
        }

    }
}

程序运行结果：

小弟菜鸟只能领悟这么多了，如果有错误或者需要补充的地方欢迎大家留言指出。谢谢！！！