前言

前面我们说过 ButterKnife 这个库，这个库实现不仅实现了 View 的绑定，而且还提供了大量的注解如 @BindView、@OnClick、@OnLongClick 等来简化开发过程中事件绑定。而这些功能的实现是通过 APT 也就是注解处理器，在编译期间生成 Java 代码来实现的。
关于这一部分，大家请看前面的这篇文章，这篇文章将 ButterKnife 讲解的非常好，可以跟着一步一步实现一个自己的简易版本：
制作自己的 ButterKnife（使用 AutoService 和 APT 注解处理器在编译期生成 Java 代码）

不过这一次，我们不再使用 APT，而是利用注解和反射的巧妙结合，在运行时进行事件和 View 的绑定，让我们告别 setOnClickListener 这类的方法 。这里我们拿 @OnClick 和 @OnLongClick 这两个注解为例，自己实现这两个注解的功能。

不过想要实现自己的绑定注解还是有一些前置条件的，需要学习注解，反射和动态代理这三个方面的知识，此处推荐下面的三篇文章，建议看完，并对刚说的三个知识点有一定认识，再来看本文。

• 由浅入深 带你了解 JAVA 注解
• Java Reflection 反射使用 完全指南
• 代理模式与静态代理、动态代理的实现（Proxy.newProxyInstance、InvocationHandler）

这里插播一下我的公众号，也是最近开始弄，希望多多关注，以后我会发更多的高质量内容：

确定目标

首先我们确定要实现的是两个注解的功能：@OnClick 和 @OnLongClick。在没有这两个注解时，我们做事件绑定的代码如下：

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        //为 id 为 button_1 的 View 设置 点击事件
        findViewById(R.id.button_1).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Toast.makeText(MainActivity.this, "点击", Toast.LENGTH_SHORT).show();
            }
        });
        //为 id 为 button_2 的 View 设置 长按事件
        findViewById(R.id.button_2).setOnLongClickListener(new View.OnLongClickListener() {
            @Override
            public boolean onLongClick(View v) {
                Toast.makeText(MainActivity.this, "长按", Toast.LENGTH_LONG).show();
                return true;
            }
        });
    }
}

而有了这两个事件绑定注解时，我们会将上面的代码改为下面这样，这也是我们最终效果的代码：

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        InjectUtils.inject(this);            //在此处处理此类中的时间绑定注解
    }

    @OnClick({R.id.button_1})                //为 id 为 button_1 的 View 设置 点击事件，
    public void click(View view) {           //当 button_1 点击时，将触发此函数
        Toast.makeText(this, "点击", Toast.LENGTH_SHORT).show();
    }

    @OnLongClick({R.id.button_2})            //为 id 为 button_2 的 View 设置 长按事件
    public boolean longClick(View view) {    当 button_2 长按时，将触发此函数
        Toast.makeText(this, "长按", Toast.LENGTH_LONG).show();
        return true;
    }
}

确定了目标之后，我们就一步一步来实现这两个功能。这里可以看到，有三个地方需要我们去实现：

• @OnClick 注解
• @OnLongClick 注解
• InjectUtils.inject(this) 代码

这三个只是我们现在看到的，如果要实现这个功能，要写的代码肯定只多不少。

实现 @OnClick 和 @OnLongClick 注解

我们先拿 @OnClick 来举个例子，正常情况下，根据要求，我们会写如下的注解：

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

这是没问题的，Target 设置为 METHOD 表明了这个注解是放到方法上的，RUNTIME 保证了我们能够在运行时拿到这个注解，里面设置了 int[] 类型的方法，使得其可以指定多个 View 的 ID。

到现在看似没什么问题，但是这里还是有问题。想象一下后续我们会使用反射来进行 View 的事件绑定，那么在事件的绑定时，需要什么信息呢？需要的信息有两个：

• 事件绑定的方法，例如 View.setOnClickListener() 这个方法
• 设置的事件的类型，例如 View.OnClickListener 这个类型

这里说需要者两个信息大家可能会一知半解，那么先放在这里，只知道需要这两个信息就行了。等看到后面自然就明白了。

现在知道需要这两个信息，那么我们添加这两个信息不就可以了？确实是这样的，但是问题又来了，这两个信息添加到哪里呢？如果我们直接添加到 @OnClick 这个注解的方法中，就像这样：

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface OnClick {
    int[] value();
    String listenerSetter() default "setOnClickListener";
    Class<?> listenerType() default View.OnClickListener.class;
}

也不是不行，但是这样外层在用的时候，还需要指定这两个参数。这会对使用方造成误解，而且对于每一个注解，这两个信息是固定的，外面再指定是多余的，即使用 default 设置默认值，外边再重新指定这两个参数，也是我们不想看到的。

那最好的办法是怎样的呢？那就是注解多态，也就是使用自定义元注解。此处我们为 @OnClick 和 @OnLongClick 自定义一个元注解 @EventBase。

自定义元注解 @EventBase

上面我们知道那两个额外的信息是跟注解相关的，也就是说相同的注解这两个值是相同的，这种情况，自定义一个元注解，然后来修饰这两个注解是最合适不过了。如下，我自定义了一个 @EventBase 的元注解，这个注解只能放到注解上，且两个属性值对应着上面的两个信息：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface EventBase {
    String listenerSetter();    //绑定事件的方法，例如 "setOnClickListener"
    Class<?> listenerType();    //绑定的事件的类型，例如 View.OnClickListener.class
}

那么后面我们用这个注解来修改 @OnClick 和 @OnLongClick 注解。

最终的 @OnClick 注解：

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@EventBase(listenerSetter = "setOnClickListener", listenerType = View.OnClickListener.class)
public @interface OnClick {
    int[] value();
}

最终的 @OnLongClick 注解：

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@EventBase(listenerSetter = "setOnLongClickListener", listenerType = View.OnLongClickListener.class)
public @interface OnLongClick {
    int[] value();
}

注意这两个注解虽然都使用了 @EventBase 来修改，但是传递给 @EventBase 的两个参数是不同的，都是与自己这个事件相关的方法和参数类型。

现在，这两个注解已经确定下来了，接下来我们就要去实现 InjectUtils 这个类，而且这个类也是实现这个功能的关键所在。

利用反射和动态代理绑定事件初期器

有人会问，你这个绑定的功能为什么会起个名字叫 InjectUtils，大家不要在意这个细节，只要知道这个类里的方法是实现 setOnClickListener 这个方法的就行，而且一般情况下，是在 MainActivity.onCreate 方法中调用的。

在最开始，我们确定了，这个类里面有 InjectUtils.inject(this) 方法，我们将会在 onCreate 中调用这个方法，就像调用 ButterKnife.bind(this) 一样。那么怎么写这个方法呢？我们一步一步来。

找到有 @OnClick、@OnLongClick 注解的函数

既然我么要处理带有绑定注解的函数，那我们肯定就要找到有哪些函数被标记了自定义的 @OnClick 和 @OnLongClick 注解。

这一步分的代码很简单，因为我们在 MainActivity.onCreate 方法中调用了 InjectUtils.inject(this)，而这个 this 就表示需要进行注解解析的类，通过它的 Class对象，我们就能够找到哪些函数添加了需要处理的注解。

这部分的代码如下：

public class InjectUtils {

    public static void inject(Object context) {
        Class<?> clazz = context.getClass();
        Method[] methods = clazz.getDeclaredMethods();

        for(Method method: methods) {
            Annotation[] annotations = method.getAnnotations();
            for(Annotation annotation : annotations) {
                Class<? extends Annotation> annotationClass = annotation.annotationType();
                EventBase eventBase = annotationClass.getAnnotation(EventBase.class);
                //判断这个注解有没有被 @EventBase 标记，如果标记了，那么就能获取到。是我们应该处理的注解
                if(eventBase == null)
                    continue;

                //走到这里就表示，这个方法是被 @OnClick 或 @OnLongClick 标记过的，应该处理绑定
                //TODO: binding
            }
        }
    }
}

这里主要有两个循环，外层循环是对这个类的所有方法循环，内层循环是对方法上的注解的循环。另外判断这个函数是否是事件处理的方法，则是判断注解是否被 @EventBase 注解标记，如果被这个注解标记，那么就是我们需要处理的方法了。

找到 View 并调用 setOnClickListener

接下来，走到上面 TODO 的地方，就是处理事件绑定。这里快到了全文的重点了，我们慢慢来看。

后面我们要做的其实就是调用 View.setOnClickListener(new OnClickListener())，那么用反射完成这个调用需要分几步呢？很简单，这就像要把大象装冰箱，总共要分三步：

1. 首先要找到 View 对象
2. 再找到 setOnClickListener 方法
3. 通过反射 invoke 这个方法

是不是很简单，下面就是代码了：

try {
    Method valueMethod = annotationClass.getMethod("value");
    int[] viewIds = (int[]) valueMethod.invoke(annotation);        //获取传递给 @OnClick 的所有 View 的 ID
    if(viewIds == null)
        continue;

    for(int viewId: viewIds) {                                    // 每一个 View 都要调用 setOnClickListener
        Method findViewByIdMethod = clazz.getMethod("findViewById", int.class);
        View view = (View) findViewByIdMethod.invoke(context, viewId);         // 找到这个 viewId 对应的 View 对象
        if(view == null)
            continue;

        String listenerSetter = eventBase.listenerSetter();
        Class<?> listenerType = eventBase.listenerType();
        Method setListenerMethod = view.getClass().getMethod(listenerSetter, listenerType);    //找到 setOnClickListener 方法
        setListenerMethod.invoke(view, /*TODO*/);            //通过反射 invoke 这个方法
    }

} catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException exception) {
    exception.printStackTrace(System.err);
}

对于这一段代码，如果看了 Java Reflection 反射使用 完全指南，就很容易看懂。简单来说，就是上面的三步，这里需要注意的一点就是，获取 setOnClickListener 这个方法的地方，因为我们有两个注解，一个处理点按 @OnClick，一个处理长按 @OnLongClick，因此这里不能写死。

那么怎么获取对应的方法呢？还记得上面说的 @EventBase 这个注解么，这个注解就是提供这两个信息的。这两个信息是在写 @OnClick 和 @OnLongClick 注解时就传递给 @EventBase 注解的，现在大家知道了为什么还要添加 @EventBase 这个注解了吧。一是能够通过它来判断哪些是我们写的注解，二是提供了这两个信息。

这样我们就拿到了对应的 setListenerMethod 方法，那么调用它即可。不过我们在调用时会发现一个很严重的问题（即代码中的 TODO 部分）：传什么参数过去？第一个参数当然是 View 对象，那第二个参数呢？是不是需要实现一个 OnClickListener 的对象？答案是否定的，这个时候，我们需要动态代理！

创建动态代理处理事件

在这里我们确实需要一个 OnClickListener 实例，但在这个地方是不可能的，我们只能使用动态代理来做这个事情。

为什么要用动态代理呢？因为这里需要代理掉 OnClickListener 中的 onClick 方法。
为什么能用动态代理？因为目标对象是 OnClickListener 接口的实例。

这里我先将代码贴上，咱们再解释。另外，强烈建议在看这一部分之前看完 代理模式与静态代理、动态代理的实现（Proxy.newProxyInstance、InvocationHandler）
这篇文章，否则再怎么解释也很难理解的。

Object proxy = Proxy.newProxyInstance(clazz.getClassLoader(), new Class[]{listenerType}, 
    new InvocationHandler() {
        @Override
        public Object invoke(Object proxy, Method proxyMethod, Object[] args) throws Throwable {
            return method.invoke(context, args);
        }
    }
);

setListenerMethod.invoke(view, proxy);

创建动态代理的三个参数，第一个选择当前 Activity 的 ClassLoader；第二个是要设置的对应的接口，@OnClick 是 OnClickListener 接口，@OnLongClick 是 OnLongClickListener 接口；重点是第三个 InvocationHandler。

当需要我们真的点击这个按钮的时候，点击事件会触发到 InvocationHandler.invoke 的方法，在这个方法中，我们必须通过反射调用被 @OnClick 或是 @OnLongClick 标记的函数，也就是在第一遍遍历中找到的那个 method。

这个 Proxy.newProxyInstance 返回的是一个 Object 对象，但由于我们传入的是 listenerType 这个接口，因此其实际返回的就是一个 OnClickListener 或是 OnLongClickListener 接口的对象。而这个返回的对象，就是我们要设置到 setListenerMethod.invoke 中的参数。

至此，大功告成。上面是三个代码片段，下面我把 inject 整个方法的代码全部贴出来，大家看看。

public static void injectClick(Object context) {
    Class<?> clazz = context.getClass();
    Method[] methods = clazz.getDeclaredMethods();

    for(Method method: methods) {
        Annotation[] annotations = method.getAnnotations();
        for(Annotation annotation : annotations) {
            Class<? extends Annotation> annotationClass = annotation.annotationType();
            EventBase eventBase = annotationClass.getAnnotation(EventBase.class);
            if(eventBase == null)
                continue;

            try {
                Method valueMethod = annotationClass.getMethod("value");
                int[] viewIds = (int[]) valueMethod.invoke(annotation);
                if(viewIds == null)
                    continue;

                for(int viewId: viewIds) {
                    Method findViewByIdMethod = clazz.getMethod("findViewById", int.class);
                    View view = (View) findViewByIdMethod.invoke(context, viewId);
                    if(view == null)
                        continue;

                    String listenerSetter = eventBase.listenerSetter();
                    Class<?> listenerType = eventBase.listenerType();

                    Object proxy = Proxy.newProxyInstance(clazz.getClassLoader(), new Class[]{listenerType},
                            (proxy1, method1, args) -> method.invoke(context, args));

                    Method setListenerMethod = view.getClass().getMethod(listenerSetter, listenerType);
                    setListenerMethod.invoke(view, proxy);
                }

            } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException exception) {
                exception.printStackTrace(System.err);
            }
        }
    }
}

总结

通过自定义 @OnClick 和 @OnLongClick 注解以及使用反射和动态代理技术，我们成功地简化了点击事件的处理代码。这样的实现不仅提高了代码的可读性和维护性，还展示了高级编程技术在实际项目中的应用。

虽然这种技术看起来很牛逼，但是里面使用了大量的反射，会慢一些。而且这种代码交接别人维护的话，肯定是一脸懵逼。所以我总结一下：

不如 setOnClickListener ，也就自己装逼用。