Java注解

注解概述

从 JDK 5.0 开始, Java 增加了对元数据(MetaData) 的支持, 也就是 Annotation(注解)

Annotation 其实就是代码里的特殊标记，这些标记可以在编译，类加载， 运行时被读取，并执行相应的处理。通过使用 Annotation，程序员可以在不改变原有逻辑的情况下，在源文件中嵌入一些补充信息。

注解本质上就是一个接口，所有注解默认继承Annotation这个接口，就像所有类默认继承Object

总之注释是写给人看的，注解写给程序看的（程序获取注解信息进行相应的动作）。

Annotation 可以像修饰符一样被使用，可用于修饰包、类、构造器、方法、成员变量、参数、局部变量的声明，这些信息被保存在 Annotation 的 “name=value” 对中。

在JavaSE中，注解的使用目的比较简单，例如标记过时的功能，忽略警告等。在JavaEE/Android中注解占据了更重要的角色，例如用来配置应用程序的任何切面，代替JavaEE旧版中所遗留的繁冗代码和XML配置等。

未来的开发模式都是基于注解的，注解是一种趋势，一定程度上可以说：框架 = 注解 + 反射 + 设计模式

注解的使用

使用 Annotation 时要在其前面增加 @ 符号, 并把该 Annotation 当成 一个修饰符使用。用于修饰它支持的程序元素

生成文档相关的注解

@author 标明开发该类模块的作者，多个作者之间使用,分割
@version 标明该类模块的版本
@see 参考某个类
@since 从哪个版本开始增加的
@param 对方法中某参数的说明，如果没有参数就不能写
@return 对方法返回值的说明，如果方法的返回值类型是void就不能写
@exception 对方法可能抛出的异常进行说明 ，如果方法没有用throws显式抛出的异常就不能写

注意：
@param @return 和 @exception 这三个标记都是只用于方法的。
@param的格式要求：@param 形参名 形参类型 形参说明
@return 的格式要求：@return 返回值类型 返回值说明
@exception的格式要求：@exception 异常类型 异常说明
@param和@exception可以并列多个

这些注解都是在文档注释中使用！！！

例如：

/**
 * @author 小王子
 * @version 1.0
 * @see String
 */
public class Person {
    private String name;
    private int age;

    /**
     * @since version 1.0
     * @param id 测试
     * @return 返回信息
     * @exception Exception
     */
    public String getInfo(String id) throws Exception{
        name = name + id;
        return "名字为："+name+",年龄为："+age;
    }
}

使用Javadoc命令即可：(其中index.html就是手册)

JDK内置的三个基本注解

这几个注解都是在编译时进行格式检查：

• @Override: 限定重写父类方法, 该注解只能用于方法
• @Deprecated: 用于表示所修饰的元素(类, 方法等)已过时。通常是因为所修饰的结构危险或存在更好的选择
• @SuppressWarnings: 抑制编译器警告

例如：(在这里看不出效果，需要在开发工具环境中查看)

public class AnnotationTest{
    public static void main(String[] args) {
        @SuppressWarnings("unused")
        int a = 10;
    }
    @Deprecated
    public void print(){
    	System.out.println("过时的方法");
    }
    @Override
    public String toString() {
    	return "重写的toString方法()";
    }
}

JDK 中的元注解

JDK 的元 Annotation 用于修饰其他 Annotation 定义。注意元这个字，很多时候都会提到这个字，比如说元数据，就是修饰数据的数据。打个比方一个文件就是一堆数据，那么这个文件的格式，大小等等数据就是这个文件的元数据。

JDK5.0提供了4个标准的meta-annotation类型，分别是：

• @Retention
• @Target
• @Documented
• @Inherited

@Retention注解

只能用于修饰一个 Annotation 定义, 用于指定该 Annotation 的生命周期，@Retention 包含一个 RetentionPolicy 类型的成员变量，使用 @Rentention 时必须为该 value 成员变量指定值:

@Documented
@Retention(RetentionPolicy.RUNTIME)		//例如这里就是可以给JVM加载使用
@Target(ElementType.ANNOTATION_TYPE)
public @interface Retention {
    //源码
    RetentionPolicy value();
}
//RetentionPolicy就是一个枚举类型
public enum RetentionPolicy {
    SOURCE,	//这个注解只在文件中保留，编译成class时候不回家再这个部分
    CLASS,	//这个注解会被保留到class中，但是运行程序不会被JVM加载
    RUNTIME	//这个注解可以被加载识别，程序可以通过反射获取该注释。
}

@Target注解

用于修饰 Annotation 定义, 用于指定被修饰的 Annotation 能用于修饰哪些程序元素。 @Target 也包含一个名为 value 的成员变量。

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Target {
    ElementType[] value();
}

public enum ElementType {
    /** 用于描述类，接口和枚举 */
    TYPE,

    /** 用于描述域 */
    FIELD,

    /** 用于描述方法 */
    METHOD,

    /** 用于描述草书 */
    PARAMETER,

    /** 用于描述构造器 */
    CONSTRUCTOR,

    /** 用于描述局部变量 */
    LOCAL_VARIABLE,

    /** Annotation type declaration */
    ANNOTATION_TYPE,

    /** 用于描述包 */
    PACKAGE,

    /**
     * 可以写在方法声明过程中
     *
     * @since 1.8
     */
    TYPE_PARAMETER,

    /**
     * 写在使用类型的任何语句中，就是相当于上面的集合
     *
     * @since 1.8
     */
    TYPE_USE
}

对于最后两个1-8新出的：
public class TestTypeDefine<@TypeDefine() U> {
    private U u;
    public <@TypeDefine() T> void test(T t){
    }
}

@Target({ElementType.TYPE_PARAMETER})
@interface TypeDefine{
}

@MyAnnotation
public class TestAnnotation<U>{
    @MyAnnotation
    private String name;
    public static void main(String[] args) {
         TestAnnotation <@MyAnnotation String> t = null;
         int a = (@MyAnnotation int)2L;
         @MyAnnotation int b = 10;
    }
    public static <@MyAnnotation T> void method(T t){
    }
    public static void test(@MyAnnotation String arg)throws @MyAnnotation Exception{
    }
}
@Target(ElementType.TYPE_USE)
@interface MyAnnotation{
}

@Documented注解

用于指定被该元 Annotation 修饰的 Annotation 类将被 javadoc 工具提取成文档。默认情况下，javadoc是不包括注解的。定义为Documented的注解必须设置Retention值为RUNTIME。

@Inherited注解

被它修饰的 Annotation 将具有继承性。如果某个类使用了被 @Inherited 修饰的 Annotation, 则其子类将自动具有该注解。

使用的很少

自定义注解

基本知识点

定义新的 Annotation 类型使用 @interface 关键字，自定义注解自动继承了java.lang.annotation.Annotation接口。

Annotation 的成员变量在 Annotation 定义中以无参数方法的形式来声明。其方法名和返回值定义了该成员的名字和类型。我们称为配置参数。类型只能是八种基本数据类型、String类型、Class类型、enum类型、Annotation类型、 以上所有类型的数组。

可以在定义 Annotation 的成员变量时为其指定初始值，指定成员变量的初始值可使用 default 关键字

如果只有一个参数成员，建议使用参数名为value

如果定义的注解含有配置参数，那么使用时必须指定参数值，除非它有默认值。格式是“参数名 = 参数值” ，如果只有一个参数成员，且名称为value， 可以省略“value=”

没有成员定义的 Annotation 称为标记; 包含成员变量的 Annotation 称为元数据 Annotation

一个基本的定义格式如下：

@Target(ElementType.TYPE)	//表明这个注解可以用在哪
@Retention(RetentionPolicy.RUNTIME)	//表明这个注解可保留到哪
public @interface MyAnnotation {
    //属性值后边有一个括号！！！这个是和之前定义属性不一样的地方
    String value() default "sheep";	//定义这个注解可指定的参数，具有默认值
}

//使用这个注解：
@MyAnnotation(value = "覆盖默认值")
public class Person {}

JDK 5.0 在 java.lang.reflect 包下新增了 AnnotatedElement 接口, 该接口代表程序中可以接受注解的程序元素

当一个 Annotation 类型被定义为运行时 Annotation 后（也就是@Retention(RetentionPolicy.RUNTIME)）, 该注解才是运行时可见, 当 class 文件被载入时保存在 class 文件中的 Annotation 才会被虚拟机读取

手写注解解析

就用上面这个注解，我们定义如下：（目标，使标了这个注解的方法打印指定的类名和方法名）

@Target({ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
    String className();
    String methodName();
}

//使用反射机制
@MyAnnotation(className = "指定类名",methodName = "指定的方法名")
public class TestMyAnnotation {
    public static void main(String[] args) {
        //反射加载该类的信息
        Class<TestMyAnnotation> myclass = TestMyAnnotation.class;
        //获取注解信息 , 这个是获取所有的注解对象
        Annotation[] annotations = myclass.getAnnotations();
        //获取指定的注解对象
        MyAnnotation annotation = myclass.getAnnotation(MyAnnotation.class);

        //调用注解的方法
        String className = annotation.className();
        String methodName = annotation.methodName();
        System.out.println(methodName+"=="+className);	//指定的方法名==指定类名
    }
}

过程说明，我们定义了自己的注解MyAnnotation，然后用在了TestMyAnnotation上，然后，我们使用反射获取到运行时候的信息，Class这个类有操作注解的相关方法，然后我们获取了这个注解运行时候的信息，其中两个属性的值是我们指定的值，调用的方法名字和属性名字一样的。这样就可以使用到定义的注解的信息！

实战一下

定义注解@Check，用来检测方法运行结果是否有异常，有则显示异常信息。

@Target(value = ElementType.METHOD)     //表明这个注解可以作用在方法上
@Retention(value = RetentionPolicy.RUNTIME) //可以被加载到内存中
    public @interface Check {
}

然后写一个待测试的类：

public class Calculate {
    @Check
    public void add(){
        System.out.println("1 + 1" + "=" + (1+1));
    }

    @Check
    public void sub(){
        System.out.println("1 - 0" + "=" + (1-0));
    }

    @Check
    public void mul(){
        System.out.println("1 * 0" + "=" + (1*0));
    }

    @Check
    public void div(){
        System.out.println("1 / 1" + "=" + (1/0));
    }
}

最重要的一环，手写自己的逻辑：

public class TestMyAnnotation2 {
    public static void main(String[] args) {
        //创建待测试的类
        Calculate calculate = new Calculate();
        //反射加载该类的信息
        Class<Calculate> myclass = Calculate.class;
        //获取方法对象
        Method[] methods = myclass.getMethods();
        for (Method method : methods) {
            //遍历这些方法，对标记了注解的方法进行特殊处理,isAnnotationPresent(Check.class)判断是否标注这个注解
            if (method.isAnnotationPresent(Check.class)){
                try {
                    //执行这个方法
                    method.invoke(calculate);
                } catch (Exception e) {
                    System.out.println(method.getName() + "出现了异常！");
                }
            }
        }
    }
}

这个时候，这些方法执行就会做出相应的输出！