系列阅读

• Java基础：类加载器
• Java基础：反射
• Java基础：注解
• Java基础：动态代理

1. 概述

注解相当于一种标记，在程序中加了注解就等于为程序打上了某种标记，没加，则等于没有某种标记，以后，javac编译器，开发工具和其他程序可以用反射来了解你的类及各种元素上有无何种标记，看你有什么标记，就去干相应的事。标记可以加在包，类，字段，方法，方法的参数以及局部变量上

开发中常见注解：

• @Override：作用在方法上的注解。当方法不是重写父类的方法时会报错
• @Deprecated：作用在方法上。标记该方法为作废方法（已过时）
• @SuppressWarnings：作用在方法上，压制警告

2. 注解类型

8种基本数据类型，String，Class，enum，annotation，以上类型的数组类型

3. 定义注解

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ViewInject {
    int value();//当使用注解时，如果只给名为value的属性赋值时，可以省略“value=”
    String name() default "zhangsan";//默认值
}

@interface

使用@interface声明一个注解类

@Target

表示注解的作用目标，是一个枚举值

@Retention

表示注解的保存策略，也是一个枚举值

注解的保留策略是指，注解是只保留在源代码上，还是保留到class文件上，再或者是类在运行时，可以被类加载器加载到内存中。

如果希望注解被反射，那么注解就要保留到运行时，而不是源代码或类文件上。

指定注解的保留策略需要使用元注解@Retention，它有一个value属性，类型为RetentionPolicy类型，RetentionPolicy是枚举类型

注解的属性

String name() default "zhangsan";//默认值

定义注解的属性，有点像java类中的方法，上面的代码定义了一个类型为String类型，注解名为name的属性，default是给注解设置默认值

value属性

String value() default "xxx"; 

如果注解中有一个名称为value的属性，且你只想设置value属性（即其他属性都采用默认值或者你只有一个value属性），那么可以省略value=部分，例如：@MyAnnotation("AllenIverson")

数组类型的属性

int [] arrayAttr() default {1,2,3};//定义
@MyAnnotation(arrayAttr={2,3,4})//使用

如果数组属性中只有一个元素，这时候属性值部分可以省略大括

4. Annotation

4.1 注解的应用结构图

Annotation

4.2 反射注解

类上的注解：使用Class获取

• Class.getAnnotation()：获取指定类型的注解
• Class.getAnnotations()：获取所有的注解
• Class.getDeclaredAnnotations()：获取除了继承得到的所有注解

方法上的注解：使用Method获取

• Method.getAnnotation() ：获取方法上指定类型的注解
• Method.getAnnotations()：获取所有的注解
• Method.getDeclaredAnnotations()：获取除了继承得到的所有注解

构造方法上的注解：使用Constructor获取

• Constructor.getAnnotation()获取指定类型的注解
• Constructor.getAnnotations()获取所有的注解
• Constructor.getDeclaredAnnotations() 获取除了继承得到的所有注解

属性上的注解：使用Field获取

• Field.getAnnotation()：获取字段上指定类型的注解
• Field.getAnnotations()：获取所有的注解
• Field.getDeclaredAnnotations()：获取字段所有的注解

定义注解

@Retention(RetentionPolicy.RUNTIME) 
@Target({ElementType.TYPE, ElementType.METHOD})
public @interface MyAnn {
    String value() default "hello";
    int value1() default 100;
}

使用注解

@MyAnn(value="hello world", value1=200)
public class MyClass {
    private int a;
    
    @MyAnn("myMethod") 
    public void fun() {}
}

通过反射读取注解

public class Demo1 {
    public static void main(String[] args) throws Exception {
        Class clazz = MyClass.class;
        MyAnn myAnn = (MyAnn) clazz.getAnnotation(MyAnn.class); 
        System.out.println(myAnn.value()); 
        System.out.println(myAnn.value1()); 
        
        Method method = clazz.getMethod("fun");
        MyAnn myAnn1 = method.getAnnotation(MyAnn.class); 
        System.out.println(myAnn1.value());
        System.out.println(myAnn1.value1());
    }
}

4.3 实现注解小框架

public class ViewUtils {
    public static void inject(Activity activity) throws IllegalAccessException {
        bindView(activity);
    }

    private static void bindView(Activity activity) throws IllegalAccessException {
        Field[] fields = activity.getClass().getDeclaredFields();
        for (Field field : fields){
            ViewInject viewInject = field.getAnnotation(ViewInject.class);
            if (viewInject != null){
                int resId = viewInject.value();
                View view = activity.findViewById(resId);
                field.setAccessible(true);
                field.set(activity,view);
            }
        }
    }

    public static void onClick(final Activity activity){
        Method[] methods = activity.getClass().getDeclaredMethods();
        for (final Method method : methods){
            Onclick onclick = method.getAnnotation(Onclick.class);
            if (onclick != null){
                int resId = onclick.value();
                final View view = activity.findViewById(resId);
                view.setOnClickListener(new View.OnClickListener() {
                    @Override
                    public void onClick(View v) {
                        method.setAccessible(true);
                        try {
                            method.invoke(activity,view);
                        } catch (IllegalAccessException e) {
                            e.printStackTrace();
                        } catch (InvocationTargetException e) {
                            e.printStackTrace();
                        }
                    }
                });
            }
        }
    }
}

5. Annotation Processing Tool

编译时注解在项目编译的时候生成新的Java文件，这样可以减少手动的代码输入，而且可以不用使用反射，对程序不会造成性能影响。

Android公共技术点之二-Annotation Processing Tool

Annotation-Processing-Tool详解

6. javapoet

动态生成Java源码，ButterKnife使用了该框架，实现了编译时注解

javapoet——让你从重复无聊的代码中解放出来

7. 注解框架

• Dagger1
• Dagger2
• Guice
• Butterknife