注解、自定义注解、处理自定义注解

注解概述

Java 注解（Annotation）又称 Java 标注，是 JDK5.0 引入的一种注释机制。

Java 语言中的类、构造器、方法、成员变量、参数等都可以被注解进行标注。

例如：

public class UserServiceTest {
    @Test
    public void testLogin(){
    }
    @Test
    public void testChu(){
    }
}

注解的作用

对Java中类、方法、成员变量做标记，然后进行特殊处理，至于到底做何种处理由业务需求来决定。 例如：JUnit框架中，标记了注解@Test的方法就可以被当成测试方法执行，而没有标记的就不能当成测试方法执行。

自定义注解

格式：

public @interface 注解名称 {
    public 属性类型 属性名() default 默认值;
}

特殊属性：

 value属性，如果只有一个value属性的情况下，使用value属性的时候可以省略value名称不写!! 但是如果有多个属性,  且多个属性没有默认值，那么value名称是不能省略的。

元注解

元注解：就是注解注解的注解。 

常见元注解：

@Target: 约束自定义注解只能在哪些地方使用

@Retention：Indicates how long annotations with the annotated type are to be retained. 

@Target中可使用的值定义在ElementType枚举类中，常用值如下

TYPE，类，接口
FIELD, 成员变量
METHOD, 成员方法
PARAMETER, 方法参数
CONSTRUCTOR, 构造器
LOCAL_VARIABLE, 局部变量

 @Retention中可使用的值定义在RetentionPolicy枚举类中，常用值如下

SOURCE： 注解只在源码中存在，生成的字节码文件中不存在
CLASS：  注解在源码、字节码文件中存在，运行阶段不存在，默认值.
RUNTIME：注解在源码、字节码文件、运行阶段都存在（开发常用）

注解解析：判断是否存在注解，存在注解就解析出内容。

与注解解析相关的接口

Annotation: 注解的顶级接口，注解都是Annotation类型的对象

AnnotatedElement:代表被注解的元素，该接口定义了与注解解析相关的解析方法

Annotation[]    getDeclaredAnnotations()	获得当前对象上使用的所有注解，返回注解数组。
T getDeclaredAnnotation(Class annotationClass)	根据注解类型获得对应注解对象
boolean isAnnotationPresent(Class annotationClass)	判断当前对象是否使用了指定的注解，如果使用了则返回true，否则false

所有的类成分Class, Method , Field , Constructor，都实现了AnnotatedElement接口，他们都拥有解析注解的能力。

解析注解的技巧

注解在哪个成分上，我们就先拿哪个成分对象。  

比如注解作用成员方法，则要获得该成员方法对应的Method对象，再来拿上面的注解  

比如注解作用在类上，则要该类的Class对象，再来拿上面的注解  

比如注解作用在成员变量上，则要获得该成员变量对应的Field对象，再来拿上面的注解

注解解析的案例

• 定义注解Book，要求如下：        

        - 包含属性：String value()   书名        

        - 包含属性：double price()  价格，默认值为 100        

        - 包含属性：String[] authors() 多位作者        

        - 限制注解使用的位置：类和成员方法上        

        - 指定注解的有效范围：RUNTIME

• 定义BookStore类，在类和成员方法上使用Book注解
• 定义AnnotationDemo测试类获取Book注解上的数据

代码：

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

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Book {
    String value();
    double price() default 100;
    String[] authors();
}

@Book(value = "xiyojji",price = 99.6,authors = {"aa","b"})
public class BookStore {
    @Book(value = "sanguoyanyi",price = 299.6,authors = {"cc","b"})
    public String getName(){
        return "xx";
    }
}

import java.lang.reflect.Method;
import java.util.Arrays;

public class AnnotationDemo {
    public static void main(String[] args) throws NoSuchMethodException {
        Class bookStoreClass = BookStore.class;
        if (bookStoreClass.isAnnotationPresent(Book.class)) {
            Book book = bookStoreClass.getAnnotation(Book.class);
            System.out.println( book.value());
            System.out.println( book.price());
            System.out.println(Arrays.toString(book.authors()));
        }
        Method getName = bookStoreClass.getMethod("getName");
        if (getName.isAnnotationPresent(Book.class)) {
            Book book = getName.getAnnotation(Book.class);
            System.out.println( book.value());
            System.out.println( book.price());
            System.out.println(Arrays.toString(book.authors()));

        }
    }
}

模拟junit框架

需求

        定义若干个方法，只要加了MyTest注解，就可以在启动时被触发执行

分析

        定义一个自定义注解MyTest，只能注解方法，存活范围是一直都在。

        定义若干个方法，只要有@MyTest注解的方法就能在启动时被触发执行，没有这个注解的方法不能执行。

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

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyTest {
}

public class C {
    @MyTest
    public void m1(){
        System.out.println("m1 invoked");
    }

    public void m2(){
        System.out.println("m2 invoked");
    }
    @MyTest
    public void m3(){
        System.out.println("m3 invoked");
    }
}

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

public class MyJunit {
    public static void main(String[] args) throws InvocationTargetException, IllegalAccessException {
        Class cClass = C.class;
        C c = new C();
        for (Method method : cClass.getMethods()) {
            if (method.isAnnotationPresent(MyTest.class)) {
                method.invoke(c);
            }
        }
    }
}