Annotation 类

java.lang.reflect.AccessibleObject 类的子类（Constructor、Method、Field）获取 Annotation 的方法：

1. T getAnnotation(Class annotationClass)：返回修饰该程序元素的指定类型的注解，不存在返回 null
2. T getDeclaredAnnotation(Class annotationClass)：返回直接修饰该程序元素的指定类型的注解，不存在则返回 null（java8新增）
3. Annotation[] getDeclaredAnnotations()：返回直接存在于此元素上的所有注解
4. boolean isAnnotationPresent (Class< ? extends Annotation> annotationClass)：如果指定类型的注解存在于此元素上，则返回 true

java 8新增重复注解功能，因此产生了如下的两个方法：

1. T[] getAnnotationsByType(Class annotationClass)：返回修饰该程序元素的指定类型的多个注解，不存在则返回 null
2. T[] getDeclaredAnnotationsByType(Class annotationClass)：返回直接修饰该程序元素的指定类型的多个注解，不存在则返回 null ```java / 自定义 @Value 注解 / @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.FIELD) public @interface Value { String value() default “”; }

/ User类 / public class User implements Serializable { @Value(“张三”) @Deprecated private String name; @Value(“18”) private Integer age; @Value(“true”) private boolean man; @Value(“18.75”) private Double money; / setter / }

/ 测试 / public static void main(String[] args) throws Exception { // 1. 获取Class实例 Class<?> clazz = Class.forName(“top.songfang.refelect.User”); // 2. 创建对象 User user = (User) clazz.getDeclaredConstructor().newInstance(); // 3. 获取所有的属性 Field[] fields = clazz.getDeclaredFields(); for (Field field : fields) { // 获取所有注解，然后选择注解中的 Value 注解的实例 Annotation[] annotations = field.getDeclaredAnnotations(); String value = null; for (Annotation annotation : annotations) { // 判断当前注解是否是 @Value 注解的实例 if (annotation instanceof Value){ value = ((Value)annotation).value(); } } // 或者直接获取 Value 注解 // Value annotation = field.getAnnotation(Value.class); // String value = annotation.value();

    // 获取属性类型
    Class<?> type = field.getType();
    // 获取属性的名称
    String name = field.getName();
    // 构造set方法名
    String set = "set" + (name.length() == 1 ?
                          name.toUpperCase() :
                          name.substring(0, 1).toUpperCase() + name.substring(1));
    // 获取 set 方法
    Method method = clazz.getDeclaredMethod(set, type);
    if ("string".equalsIgnoreCase(field.getType().getSimpleName())) {
        method.invoke(user, value);
    } else if ("integer".equalsIgnoreCase(field.getType().getSimpleName()) && value.matches("\\d+")) {
        method.invoke(user, Integer.parseInt(value));
    } else if ("double".equalsIgnoreCase(field.getType().getSimpleName()) && value.matches("\\d+(\\.\\d{1,2})?")) {
        method.invoke(user, Double.parseDouble(value));
    } else if ("boolean".equalsIgnoreCase(field.getType().getSimpleName())){
        method.invoke(user, "true".equalsIgnoreCase(value));
    } else {
        throw new RuntimeException("属性无法完成转换！");
    }
}
System.out.println(user);

}

<a name="goXOg"></a>
#### 重复注解
java 8 之前注解不允许重复，因此如果需要使用重复注解，可以使用注解容器，即：
1. 新定义一个注解如 @Container
1. 然后使这个注解的成员变量为 @Repeat 注解的数组，这样可以通过使用 @Container 间接使用 @Repeat 注解的重复
**注：”容器“注解的保留期Retention必须比它所包含注解的保留期更长，否则编译报错**
```java
/* 需要重复的注解 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Repeat {
    String value() default "";
}
/* 注解容器 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Container {
    Repeat[] value() default {};
}
/* 容器注解使用 */
@Container({@Repeat("世界"),@Repeat("无垠")})
public class User implements Serializable {
}
/* 获取重复注解 */
public static void main(String[] args) {
    // 直接获取指定注解
    Repeat[] value = User.class.getAnnotation(Container.class).value();
    for (Repeat repeat : value) {
        System.out.println(repeat.value());
    }
    // 从全部注解中筛选
    Annotation[] annotations = User.class.getAnnotations();
    for (Annotation annotation : annotations) {
        if (annotation instanceof Container){
            for (Repeat repeat : ((Container) annotation).value()) {
                System.out.println(repeat);
            }
        }
    }
}
/* 输出 */
@top.songfang.reflect.Repeat(value="世界")
    @top.songfang.reflect.Repeat(value="无垠")

java 8 之后，新增了元注解 @Repeatable ，用来开发重复注解，开发步骤：

1. 定义重复注解，@Repeatable注解中的 value 用来指示容器注解
2. 编写容器注解 ```java / 定义重复注解 / @Repeatable(value = Combination.class) @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE) public @interface Repeat { String value() default “”; }

/ 容器注解 / @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE) public @interface Combination { Repeat[] value(); }

/ 使用 / @Repeat(“世界”) @Repeat(“天才”) public class New { public static void main(String[] args) { // java 8 推荐的方式 Repeat[] repeats = New.class.getAnnotationsByType(Repeat.class); for (Repeat repeat : repeats) { System.out.println(repeat.value()); } } }

/ 输出 / 世界 天才

<a name="GZe67"></a>
#### 类型注解
java 8 之前，注解只能用在包、类、构造器、方法、成员变量、参数、局部变量。<br />java 8 之后，java 8 新增类型注解（Type Annotation），可以作用在创建对象（通过new创建）、类型转换、使用implements实现接口、使用throws声明抛出异常的位置。
- java 为 ElementType 枚举增加了 TYPE_PARAMETER、TYPE_USE 两个枚举值
- @Target(TYPE_USE) 修饰的注解称为 Type Annotation（类型注解），Type Annotation 可以用在任何用到类型的地方
```java
/* 定义一个类型注解 @NotNull */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE_USE)
public @interface NotNull {
    String value() default "";
}
/* 使用 */
//implements实现接口中使用Type Annotation
public class Test implements @NotNull("Serializable")Serializable {
    // 泛型中使用 Type Annotation
    // 抛出异常中使用 Type Annotation
    public void test(List<@NotNull String> list) throws @NotNull(value = "ClassNotFoundException") ClassNotFoundException{
        // 创建对象中使用 Type Annotation
        Object obj = new @NotNull String("annotation.Test");
        // 强制类型转换中使用 Type Annotation
        String str = (@NotNull String) obj;
    }
}
/* 编写处理注解的处理器 */
public class  NotNullProcessor {
    public static void process(String className) throws ClassNotFoundException{
        try {
            Class<?> clazz = Class.forName(className);
            // 获取类继承的、带注解的接口
            AnnotatedType[] interfaces = clazz.getAnnotatedInterfaces();
            print(interfaces);
            Method method = clazz.getMethod("test", List.class);
            // 获取方法上抛出的带注解的异常
            AnnotatedType[] annotatedTypes = method.getAnnotatedExceptionTypes();
            print(annotatedTypes);
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
    }
    private static void print(AnnotatedType[] array){
        for (AnnotatedType annotatedType : array) {
            // 1.获取基础类型
            Type type = annotatedType.getType();
            // 2.获取注解
            Annotation[] annotations = annotatedType.getAnnotations();
            System.out.println(type);
            for (Annotation annotation : annotations) {
                System.out.println(annotation);
            }
        }
    }
    public static void main(String[] args) throws ClassNotFoundException {
        NotNullProcessor.process("top.songfang.refelect.type.Test");
    }
}

java 8 提供 AnnotatedType 接口，该接口用来代表被注解修饰的类型，继承了 AnnotatedElement 接口，同时存在一个 public Type getType() 方法，用于返回注解修饰的类型。

获取 AnnotatedType：

1. Class.getAnnotatedInterfaces()：获取类继承的、带注解的接口
2. Method.getAnnotatedExceptionTypes()：获取方法上抛出的带注解的异常