android注解与反射、ButterKnife实现

之前面试被问到注解相关知识，无奈当时真是too young too simple，只知道注解的实现用到了反射，多问一句都心虚，对于它的定义都说不明白，对于反射也不能说出个所以然来。其实很多优秀的第三方框架都用到了注解，像Retrofit， ButterKnife, Dagger等，只是平时都是用别人造的轮子进行开发，自己并没有过多的了解，但是现在很多大公司，要的不是一个只会调用API的程序员，需要一个爱钻研技术，会思考的程序员，所以今天特意研究了一把注解的使用、实现。

一、注解（Annotation）

1. 定义

注解也叫元数据，它是一种代码级别的说明，JDK1.5及以后版本引入的一个特性，用来将任何的信息/元数据与程序元素（类／方法／成员变量等）进行关联。与类、接口、枚举是在同一个层次，可以声明在包、类、字段、方法、局部变量、方法参数等前面，用来对这些元素进行说明，注释。

2. 作用：

1) 编写文档：通过元数据生成文档
2) 代码分析：通过元数据对代码进行分析（使用反射）
3) 编译检查：通过元数据让编译器能实现基本的编译检查（Override)

3. 一些内置注解：

1) @Override –> 标记覆盖超类中方法的方法，若被标记的方法并没有实际覆盖超类中的方法，编译器会发生错误警告。
2) @Deprecated –> 标记对不应该再使用的方法
3) @SuppressWarnings(“unchecked”) –> 执行了未体检的转换时的警告

4. 自定义注解@interface

类似于创建一个接口文件，需要声明为@interface

public @interface NewAnnotation {
    String value();//为自定义注解添加变量
}

使用自定义注解：

public class AnnotationTest {
    @NewAnnotation("mainmethod")
    public static void main(String[]args) {
        saying();
    }

    @NewAnnotation(value = "saymethod")
    public static void saying() {
    }
}

5. 限定注解的使用范围@Target

TYPE: 用于类，接口，枚举但不能是注解
FIELD: 字段上，包括枚举值
METHOD: 方法，不包括构造方法
PARAMETER: 方法的参数
CONSTRUCTOR: 构造方法
LOCAL_VARIABLE: 本地变量或catch语句
ANNOTATION_TYPE: 注解类型（无数据）
PACKAGE: Java包
实例：

//限制注解使用范围
@Target({ElementType.METHOD, ElementType.CONSTRUCTOR})
public @interface Greeting {
    //使用枚举类型
    public enum FontColor {
        BLUE, RED, GREEN
    };
    String name();
    FontColor fontColor() default FontColor.RED;
}

6. 注解保持性策略RetentionPolicy

1) RUNITIME： 保留在编译的类文件中，并在第一次加载类时读取它；
2) CLASS： 保留在编译后的类文件中，但在运行时忽略它；
3) SOURCE： 按规定使用注解，但并不将它保留在编译后的类文件中；
如在类开头添加上

//让保持性策略为运行时态，将注解编码到class文件中，让虚拟机读取
@Retention(RetentionPolicy.RUNTIME)

7. 文档化功能@Documented

注解是否将包含在JavaDoc中，使用此注解时必须设置RententionPolicy为RUNTIME

8. 标注继承@Inherited

让它允许继承，可作用到子类

9. 读取注解信息的方法

要想使用反射去读取注解，必须将 Retention的值选为RUNTIME

10.实例来说明，用注解+反射实现Butterknife功能

（1)自定义注解

1) 先定义布局文件注入：

//注解的作用域在类上
@Target(ElementType.TYPE)
//让保持性策略为运行时态，将注解编码到class文件中，让虚拟机读取
@Retention(RetentionPolicy.RUNTIME)
public @interface ContentView {
    int value();//使用时直接@ContentView(R.layout.xxx)指定的R.layout.xxx就是布局文件，会自动注入布局文件
}

2) 布局中控件注入文件

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ViewInject {
    int value();
}

3) 控件的点击响应注入文件

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface OnClick {
    int[] value();
}

(2) 使用自定义注解

对一个成员变量使用@BindView注解，并传入一个View Id, ButterKnife就能够找到对应的View，并自动进行转换成所需控件类型。

@ContentView(R.layout.activity_login)
public class ExampleActivity extends AppCompatActivity {
    @ViewInject(R.id.ui_password_input)
    EditText password;
    @ViewInject(R.id.ui_username_input)
    EditText username;
    @OnClick(R.id.login_btn)
    private void onClick(View view) {
        Toast.makeText(this, "login password = " + password.getText().toString() + " name = " + username.getText().toString(), Toast.LENGTH_SHORT).show();
    }

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        ViewInjectUtils.inject(this);
    }
}

（3) 通过反射机制获取注解参数

1) 布局文件获取

private static void jnectContentView(Activity activity) {
        //获取activity的类实例
        Class<? extends Activity> clazz = activity.getClass();
        //获取到activity的ContentView注解
        ContentView contentView = clazz.getAnnotation(ContentView.class);
        if (contentView != null) {
            //如果activity上面存在这个注解的话，就取出这个注解对应的value值，就是前面设置的布局
            int layoutId = contentView.value();
            try {
                //利用反射调用setContentView方法，完成注入
                Method setViewMethod = clazz.getMethod("setContentView", int.class);
                setViewMethod.invoke(activity, layoutId);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

2) 控件获取实现

 private static void injectView(Activity activity) {
        Class<? extends Activity> clazz = activity.getClass();
        //获取activity的所有成员变量
        Field[] fields = clazz.getDeclaredFields();
        //遍历成员变量，获取成员变量上的ViewInject注解
        for (Field field : fields) {
            //获取字段上面的注解对象，同有则继续下一个字段
            ViewInject viewInject = field.getAnnotation(ViewInject.class);
            if (viewInject != null) {
                //获取ViewInject注解的View的id
                int viewId = viewInject.value();
                //获取控件
                View view = activity.findViewById(viewId);
                try {
                    //设置field为可访问，就算私有的也能访问到
                    field.setAccessible(true);
                    //将该控件设置给field对象
                    field.set(activity, view);
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }
    }

3)控件点击响应

private static void injectEvent(final Activity activity) {
        Class<? extends Activity> clazz = activity.getClass();
        //获取所有方法（私有方法也可以获取到）
        Method[] methods = clazz.getDeclaredMethods();
        for (Method method : methods) {
            //获取方法上面的OnClick注解
            OnClick click = method.getAnnotation(OnClick.class);
            //有则继续下面代码
            if (click != null) {
                //获取注解中的数据，因可以给多个button绑定点击事件，因此定义的注解类时使用的是int[]数据类型
                int[] viewId = click.value();
                method.setAccessible(true);
                //设置一个代理对象,当调用setOnClickListener时，把代理对象传进去，当点击发生时，就会invoke方法，可以调用带有onClick注解的method方法
                Object listener = Proxy.newProxyInstance(View.OnClickListener.class.getClassLoader(),
                        new Class[]{View.OnClickListener.class}, new InvocationHandler() {
                            @Override
                            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                                return method.invoke(activity, args);
                            }
                        });
                try {
                    for (int id : viewId) {
                        //获取相应的控件
                        View v = activity.findViewById(id);
                        Method setClickListener = v.getClass().getMethod("setOnClickListener", View.OnClickListener.class);
                        setClickListener.invoke(v, listener);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

上面三种方法实现类似，都是先通过类查找注解，获取注解的值，再调用相应方法

（4) 实现注解接口调用

采用Java动态代理机制实现注解接口调用，将定义接口与实现分离

public static void inject(Activity activity) {
        jnectContentView(activity);
        injectView(activity);
        injectEvent(activity);
    }

11.Butterknife的实现

上面的实现都是在运行时通过反射完成注入，但它会对性能有一定损耗，而Butterknife用的是APT（Annotation Processing Tool)编译时解析技术。它在Java代码编译成Java字节码时就已经处理了@Bind, @OnClick这些注解。它的原理是读入Java源代码，解析注解，生成新的Java代码，新生成的Java代码最后被编译成Java字节码。

（1)工作流程如下：

1) 扫描Java代码中所有的ButterKnife注解@Bind, @OnClick, @OnItemClicked等
2) 当发类中含有任何一个注解时，ButterKnifeProcessor会生成一个Java类， 名字类似$$ViewBinder,新生成的类实现了ViewBinder接口
3) ViewBinder类中包含了所有对应的代码，如@Bind注解对应findViewById(), @OnClick对应了view.setOnClickListener()
4) 当Activity启动ButterKnife.bind(this)执行时，ButterKnife会加载对应的ViewBinder类调用它们的bind()方法。

（2)实现

1) 注解类声明
注解类的声明，都是一样的，只是ButterKnife是在编译时生成Java字节码，所以两者声明注解时的类是一样的，只是实现不一样。下面我们来看看它的实现：
2) 解析注解
ButterKnife是用ButterKnifeProcessor来解析注解的

方法名	作用
init(ProcessingEnvironment env)	根据env得到一些工具类enementUtils, typeUtils，filter主要用于生成Java代码
getSupportedAnnotationTypes()	返回注解处理器所支持的注解集合
process(Set elements, RoundEnvironment env)	解析注解，主要有两项工作 1. findAndParseTargets(env):扫描所有注解，最后生成以TypeElement为键，BindingSet为值的bindingMap 2.brewJava(int sdk)根据遍历得到的bindingMap,利用binding中的信息生成相应的Java源码
bind(Activity target)	主要调用createBinding(Object obj, View source)方法根据target创建对应的targetClassName_ViewBinding。在findBindingConstructorForClass(Class cls)方法中也使用了Class.forName()反射来查找Class。但仅限于一个类的第一次查找，之后都会在BINDINGS缓存中获取。

具体的源码解析可以参考这篇文章ButterKnife源码分析

二、反射（Reflection)

1.定义：

在运行状态中，对于任何一个类，都能知道这个类的所有属性和方法；对于任保一个对象，都能调用它的任何一个方法和属性。这样动获取新的及动态调用对象的方法的功能就叫反射。

2.反射获取类、属性、方法：

如下面：

//获取类对象
Class c = Class.forName("com.example.annation.Greeting");
//获取Greeting类所有声明的方法
Method[] methods = c.getDeclaredMethods();
//获取类中所有属性
Field[] fields = c.getDeclaredFields();
for(Method method : methods) {
    //获取方法中所有的参数
    Parameter[] parameters = method.getParameters();
}

3.反射中Method类invoke方法

我们上面声明的BindView注解类中，调用了如下代码：

//利用反射调用setContentView方法，完成注入
 Method setViewMethod = clazz.getMethod("setContentView", int.class);
setViewMethod.invoke(activity, layoutId);

clazz.getMethod(“setContentView”, int.class)是 用来获取setContentView()方法，第一个传递的是要获取类中方法的方法名，第二个参数是该方法中接收的参数集合，Activity类中的setContentView()方法接收一个int类型参数。
setViewMethod.invoke(activity, layoutId)方法，第一个参数是执行这个方法的对象，第二个参数是方法参数，即执行activity的带有 layoutId的method方法，返回值是object。
要查看详情的反射机制可以参考【Android】 认识反射机制（Reflection）

三、总结

注解与反射可能在平时开发中用的比较少，但我们还是必须知道怎么用它，至少下次再看到第三方库中的注解时，不会觉得它高深莫测。利用注解可能减少我们写一些重复代码，利用反射可以让我们访问类的私有变量、成员、方法等，或是隐藏的方法。同时反射还可以结 hook实现一些其他功能。

下面总结一下注解的实现步骤：

1. 利用@interface关键字自定义注解类，并添加相应元注解用于说明注解的作用域、类生命周期等；
2. 通过反射机制获取注解参数，解析注解，并实现相应的功能；
3. 在实际类中使用自定义注解。

通过分析，我们还了解到ButterKnife之所以对性能影响不大，是因为它使用的APT（编译时解析技术），即注解类在编译时就被编译成实际的类，使用时只需要调用bind()方法查找，所以应用性能不会受影响。