注解框架源码分析（XUtils、ButterKnife）

1.前言

频繁的findViewById是一件挺烦人的事，IOC注解框架应运而生，Android中IOC框架就是注入控件和布局或者说是设置点击监听。

现在主流的有ButterKnife、xUtils、afinal等，IOC注解框架刚出来的时候，粗略看过源码后我是摒弃使用的，因为里面有反射、循环遍历寻找控件等操作，但是慢慢的接收了这种快捷方式，发现对实际性能影响并不大，不是在特别强迫症的情况下完全可行，特别是ButterKnife的出现，ButterKnife没有利用全反射，而是在同包下动态编译生成代码，性能几乎和自己findViewById性能是一样的！

2.源码分析

下面我们来实际分析xUtils和ButterKnife的源码：

2.1 xUtils 使用

xUtils源码地址：https://github.com/wyouflf/xUtils3

xUtils 包含了orm, http(s), image, view注解，下面我们重点讲解View注解（IOC注入）：

public class MainActivity extends AppCompatActivity {

    @ViewInject(R.id.test_tv)
    private TextView test_tv;

    @ViewInject(R.id.test_btn)
    private Button test_btn;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        x.view().inject(this);
        test_tv.setText("测试文本");
        test_btn.setText("测试按钮");
    }

    /**
     * 1. 方法必须私有限定,
     * 2. 方法参数形式必须和type对应的Listener接口一致.
     * 3. 注解参数value支持数组: value={id1, id2, id3}
     * 4. 其它参数说明见{@link org.xutils.view.annotation.Event}类的说明.
     **/
    @Event(value = R.id.test_btn,
            type = View.OnClickListener.class/*可选参数, 默认是View.OnClickListener.class*/)
    private void iconIvClick(View view) {
        test_tv.setText("点击了按钮，修改测试文本");
        Toast.makeText(this, "点击了按钮，修改测试文本", Toast.LENGTH_LONG).show();
    }
}

注解省去了findViewById和setOnClickListener等简单操作。

2.2 xUtils源码分析

我们挑一些关键的源码分析，先分析x.view().inject(this);这句代码做了什么：

点击进入查看是一个接口ViewInjector，看不到实现代码，我就Ctrl+鼠标左键查看实现类：

找到实现类ViewInjectorImpl中inject(Activity activity)方法代码：

 @Override
    public void inject(Activity activity) {
        //获取Activity的ContentView的注解
        Class handlerType = activity.getClass();
        try {
            // 找到ContentView这个注解，在activity类上面获取
            ContentView contentView = findContentView(handlerType);
            if (contentView != null) {
                int viewId = contentView.value();
                if (viewId > 0) {
                    // 如果有注解获取layoutId的值，利用反射调用activity的setContentView方法注入视图
                    Method setContentViewMethod = handlerType.getMethod("setContentView", int.class);
                    setContentViewMethod.invoke(activity, viewId);
                }
            }
        } catch (Throwable ex) {
            LogUtil.e(ex.getMessage(), ex);
        }
        // 处理 findViewById和setOnclickListener的注解
        injectObject(activity, handlerType, new ViewFinder(activity));
    }

根据源码可知，先判断是否有ContentView这个注解，在activity类上面获取，有则setContentView(R.layout.xxxx)，然后再处理 findViewById和setOnclickListener的注解（injectObject方法）：

@SuppressWarnings("ConstantConditions")
    private static void injectObject(Object handler, Class handlerType, ViewFinder finder) {

        if (handlerType == null || IGNORED.contains(handlerType)) {
            return;
        }

        // 从父类到子类递归
        injectObject(handler, handlerType.getSuperclass(), finder);

        // inject view
        Field[] fields = handlerType.getDeclaredFields();
        if (fields != null && fields.length > 0) {
            for (Field field : fields) {

                Class fieldType = field.getType();
                if (
                /* 不注入静态字段 */     Modifier.isStatic(field.getModifiers()) ||
                /* 不注入final字段 */    Modifier.isFinal(field.getModifiers()) ||
                /* 不注入基本类型字段 */  fieldType.isPrimitive() ||
                /* 不注入数组类型字段 */  fieldType.isArray()) {
                    continue;
                }

                ViewInject viewInject = field.getAnnotation(ViewInject.class);
                if (viewInject != null) {
                    try {
                        View view = finder.findViewById(viewInject.value(), viewInject.parentId());
                        if (view != null) {
                            field.setAccessible(true);
                            field.set(handler, view);
                        } else {
                            throw new RuntimeException("Invalid @ViewInject for "
                                    + handlerType.getSimpleName() + "." + field.getName());
                        }
                    } catch (Throwable ex) {
                        LogUtil.e(ex.getMessage(), ex);
                    }
                }
            }
        } // end inject view

        // inject event
        Method[] methods = handlerType.getDeclaredMethods();
        if (methods != null && methods.length > 0) {
            for (Method method : methods) {

                if (Modifier.isStatic(method.getModifiers())
                        || !Modifier.isPrivate(method.getModifiers())) {
                    continue;
                }

                //检查当前方法是否是event注解的方法
                Event event = method.getAnnotation(Event.class);
                if (event != null) {
                    try {
                        // id参数
                        int[] values = event.value();
                        int[] parentIds = event.parentId();
                        int parentIdsLen = parentIds == null ? 0 : parentIds.length;
                        //循环所有id，生成ViewInfo并添加代理反射
                        for (int i = 0; i < values.length; i++) {
                            int value = values[i];
                            if (value > 0) {
                                ViewInfo info = new ViewInfo();
                                info.value = value;
                                info.parentId = parentIdsLen > i ? parentIds[i] : 0;
                                method.setAccessible(true);
                                // EventListenerManager 动态代理执行相应的方法
                                EventListenerManager.addEventMethod(finder, info, event, handler, method);
                            }
                        }
                    } catch (Throwable ex) {
                        LogUtil.e(ex.getMessage(), ex);
                    }
                }
            }
        } // end inject event

    }

源码中利用类的反射循环获取属性的注解值然后通过findViewById之后，动态的注入到控件属性里面；事件注入也是类似首先findViewById然后利用动态代理去反射执行方法，动态代理代码如下：

    public static void addEventMethod(
            //根据页面或view holder生成的ViewFinder
            ViewFinder finder,
            //根据当前注解ID生成的ViewInfo
            ViewInfo info,
            //注解对象
            Event event,
            //页面或view holder对象
            Object handler,
            //当前注解方法
            Method method) {
        try {
            View view = finder.findViewByInfo(info);

            if (view != null) {
                // 注解中定义的接口，比如Event注解默认的接口为View.OnClickListener
                Class listenerType = event.type();
                // 默认为空，注解接口对应的Set方法，比如setOnClickListener方法
                String listenerSetter = event.setter();
                if (TextUtils.isEmpty(listenerSetter)) {
                    listenerSetter = "set" + listenerType.getSimpleName();
                }


                String methodName = event.method();

                boolean addNewMethod = false;
                /*
                    根据View的ID和当前的接口类型获取已经缓存的接口实例对象，
                    比如根据View.id和View.OnClickListener.class两个键获取这个View的OnClickListener对象
                 */
                Object listener = listenerCache.get(info, listenerType);
                DynamicHandler dynamicHandler = null;
                /*
                    如果接口实例对象不为空
                    获取接口对象对应的动态代理对象
                    如果动态代理对象的handler和当前handler相同
                    则为动态代理对象添加代理方法
                 */
                if (listener != null) {
                    dynamicHandler = (DynamicHandler) Proxy.getInvocationHandler(listener);
                    addNewMethod = handler.equals(dynamicHandler.getHandler());
                    if (addNewMethod) {
                        dynamicHandler.addMethod(methodName, method);
                    }
                }

                // 如果还没有注册此代理
                if (!addNewMethod) {

                    dynamicHandler = new DynamicHandler(handler);

                    dynamicHandler.addMethod(methodName, method);

                    // 生成的代理对象实例，比如View.OnClickListener的实例对象
                    listener = Proxy.newProxyInstance(
                            listenerType.getClassLoader(),
                            new Class[]{listenerType},
                            dynamicHandler);

                    listenerCache.put(info, listenerType, listener);
                }

                Method setEventListenerMethod = view.getClass().getMethod(listenerSetter, listenerType);
                setEventListenerMethod.invoke(view, listener);
            }
        } catch (Throwable ex) {
            LogUtil.e(ex.getMessage(), ex);
        }
    }

在实例化DynamicHandler的时候穿递的是Activity/Fragment。然后调用EventListenerManager.addEventMethod(finder, info, event, handler, method);法的时候，将method（当前注解方法）传递进去了。完整类名有，方法名字有。动态代理的实现如下：

    public static class DynamicHandler implements InvocationHandler {
        // 存放代理对象，比如Fragment或view holder
        private WeakReference