本篇博客将带大家实现View的事件的注入。
1、目标效果
上篇博客，我们的事件的代码是这么写的：
1. package com.zhy.zhy_xutils_test;
2.
3. import .Activity;
4. import android.os.Bundle;
5. import android.view.View;
6. import android.view.View.OnClickListener;
7. import android.widget.Button;
8. import android.widget.Toast;
9.
10. import com.zhy.ioc.view.ViewInjectUtils;
11. import com.zhy.ioc.view.annotation.ContentView;
12. import com.zhy.ioc.view.annotation.ViewInject;
13.
14. @ContentView(value = R.layout.activity_main)
15. public class MainActivity extends Activity implements OnClickListener
16. {
17. @ViewInject(.id_btn)
18. private Button mBtn1;
19. @ViewInject(.id_btn02)
20. private Button mBtn2;
21.
22. @Override
23. protected void onCreate(Bundle savedInstanceState)
24. {
25. super.onCreate(savedInstanceState);
26.
27. this);
28.
29. this);
30. this);
31. }
32.
33. @Override
34. public void onClick(View v)
35. {
36. switch (v.getId())
37. {
38. case .id_btn:
39. this, "Why do you click me ?",
40. Toast.LENGTH_SHORT).show();
41. break;
42.
43. case .id_btn02:
44. this, "I am sleeping !!!",
45. Toast.LENGTH_SHORT).show();
46. break;
47. }
48. }
49.
50. }
光有View的注入能行么，我们写View的目的，很多是用来交互的，得可以点击神马的吧。摒弃传统的神马，setOnClickListener，然后实现匿名类或者别的方式神马的，我们改变为：
1. package com.zhy.zhy_xutils_test;
2.
3. import android.view.View;
4. import android.widget.Button;
5. import android.widget.Toast;
6.
7. import com.zhy.ioc.view.annotation.ContentView;
8. import com.zhy.ioc.view.annotation.OnClick;
9. import com.zhy.ioc.view.annotation.ViewInject;
10.
11. @ContentView(value = R.layout.activity_main)
12. public class MainActivity extends BaseActivity
13. {
14. @ViewInject(.id_btn)
15. private Button mBtn1;
16. @ViewInject(.id_btn02)
17. private Button mBtn2;
18.
19. @OnClick({ .id_btn, .id_btn02 })
20. public void clickBtnInvoked(View view)
21. {
22. switch (view.getId())
23. {
24. case .id_btn:
25. this, "Inject Btn01 !", Toast.LENGTH_SHORT).show();
26. break;
27. case .id_btn02:
28. this, "Inject Btn02 !", Toast.LENGTH_SHORT).show();
29. break;
30. }
31. }
32.
33. }
直接通过在Activity中的任何一个方法上，添加注解，完成1个或多个控件的事件的注入。这里我把onCreate搬到了BaseActivity中，里面调用了ViewInjectUtils.inject(this);
2、实现
1、注解文件
1. package com.zhy.ioc.view.annotation;
2.
3. import java.lang.annotation.ElementType;
4. import java.lang.annotation.Retention;
5. import java.lang.annotation.RetentionPolicy;
6. import java.lang.annotation.Target;
7.
8. @Target(ElementType.ANNOTATION_TYPE)
9. @Retention(RetentionPolicy.RUNTIME)
10. public @interface EventBase
11. {
12. Class<?> listenerType();
13.
14. String listenerSetter();
15.
16. String methodName();
17. }
1. package com.zhy.ioc.view.annotation;
2.
3. import java.lang.annotation.ElementType;
4. import java.lang.annotation.Retention;
5. import java.lang.annotation.RetentionPolicy;
6. import java.lang.annotation.Target;
7.
8. import android.view.View;
9.
10. @Target(ElementType.METHOD)
11. @Retention(RetentionPolicy.RUNTIME)
12. @EventBase(listenerType = View.OnClickListener.class, listenerSetter = "setOnClickListener", methodName = "onClick")
13. public @interface OnClick
14. {
15. int[] value();
16. }
EventBase主要用于给OnClick这类注解上添加注解，毕竟事件很多，并且设置监听器的名称，监听器的类型，调用的方法名都是固定的，对应上面代码的：
listenerType = View.OnClickListener.class, listenerSetter = "setOnClickListener", methodName = "onClick"
Onclick是用于写在Activity的某个方法上的：
1. @OnClick({ .id_btn, .id_btn02 })
2. public void clickBtnInvoked(View view)
如果你还记得，上篇博客我们的ViewInjectUtils.inject(this);里面已经有了两个方法，本篇多了一个：
1. public static void inject(Activity activity)
2. {
3. injectContentView(activity);
4. injectViews(activity);
5. injectEvents(activity);
6. }
2、injectEvents
1. /**
2. * 注入所有的事件
3. *
4. * @param activity
5. */
6. private static void injectEvents(Activity activity)
7. {
8.
9. extends Activity> clazz = activity.getClass();
10. Method[] methods = clazz.getMethods();
11. //遍历所有的方法
12. for (Method method : methods)
13. {
14. Annotation[] annotations = method.getAnnotations();
15. //拿到方法上的所有的注解
16. for (Annotation annotation : annotations)
17. {
18. extends Annotation> annotationType = annotation
19. .annotationType();
20. //拿到注解上的注解
21. EventBase eventBaseAnnotation = annotationType
22. class);
23. //如果设置为EventBase
24. if (eventBaseAnnotation != null)
25. {
26. //取出设置监听器的名称，监听器的类型，调用的方法名
27. String listenerSetter = eventBaseAnnotation
28. .listenerSetter();
29. Class<?> listenerType = eventBaseAnnotation.listenerType();
30. String methodName = eventBaseAnnotation.methodName();
31.
32. try
33. {
34. //拿到Onclick注解中的value方法
35. Method aMethod = annotationType
36. "value");
37. //取出所有的viewId
38. int[] viewIds = (int[]) aMethod
39. null);
40. //通过InvocationHandler设置代理
41. new DynamicHandler(activity);
42. handler.addMethod(methodName, method);
43. Object listener = Proxy.newProxyInstance(
44. listenerType.getClassLoader(),
45. new Class<?>[] { listenerType }, handler);
46. //遍历所有的View，设置事件
47. for (int viewId : viewIds)
48. {
49. View view = activity.findViewById(viewId);
50. Method setEventListenerMethod = view.getClass()
51. .getMethod(listenerSetter, listenerType);
52. setEventListenerMethod.invoke(view, listener);
53. }
54.
55. catch (Exception e)
56. {
57. e.printStackTrace();
58. }
59. }
60.
61. }
62. }
63.
64. }
嗯，注释尽可能的详细了，主要就是遍历所有的方法，拿到该方法省的OnClick注解，然后再拿到该注解上的EventBase注解，得到事件监听的需要调用的方法名，类型，和需要调用的方法的名称；通过Proxy和InvocationHandler得到监听器的代理对象，显示设置了方法，最后通过反射设置监听器。
这里有个难点，就是关于DynamicHandler和Proxy的出现，如果不理解没事，后面会详细讲解。
3、DynamicHandler
这里用到了一个类DynamicHandler，就是InvocationHandler的实现类：
1. package com.zhy.ioc.view;
2.
3. import java.lang.ref.WeakReference;
4. import java.lang.reflect.InvocationHandler;
5. import java.lang.reflect.Method;
6. import java.util.HashMap;
7.
8. public class DynamicHandler implements InvocationHandler
9. {
10. private WeakReference<Object> handlerRef;
11. private final HashMap<String, Method> methodMap = new HashMap<String, Method>(
12. 1);
13.
14. public DynamicHandler(Object handler)
15. {
16. this.handlerRef = new WeakReference<Object>(handler);
17. }
18.
19. public void addMethod(String name, Method method)
20. {
21. methodMap.put(name, method);
22. }
23.
24. public Object getHandler()
25. {
26. return handlerRef.get();
27. }
28.
29. public void setHandler(Object handler)
30. {
31. this.handlerRef = new WeakReference<Object>(handler);
32. }
33.
34. @Override
35. public Object invoke(Object proxy, Method method, Object[] args)
36. throws Throwable
37. {
38. Object handler = handlerRef.get();
39. if (handler != null)
40. {
41. String methodName = method.getName();
42. method = methodMap.get(methodName);
43. if (method != null)
44. {
45. return method.invoke(handler, args);
46. }
47. }
48. return null;
49. }
50. }
好了，代码就这么多，这样我们就实现了，我们事件的注入~~
效果图：
效果图其实没撒好贴的，都一样~~~
3、关于代理
那么，本文结束了么，没有~~~关于以下几行代码，相信大家肯定有困惑，这几行干了什么？
1. //通过InvocationHandler设置代理
2. new DynamicHandler(activity);
3. handler.addMethod(methodName, method);
4. Object listener = Proxy.newProxyInstance(
5. listenerType.getClassLoader(),
6. new Class<?>[] { listenerType }, handler);
InvocationHandler和Proxy成对出现，相信大家如果对Java比较熟悉，肯定会想到Java的动态代理~~~
关于InvocationHandler和Proxy的文章，大家可以参考：http://www.ibm.com/developerworks/cn/java/j-lo-proxy1/ ps:IBM的技术文章还是相当不错的，毕竟有人审核还有奖金~
但是我们的实现有一定的区别，我为什么说大家疑惑呢，比如反射实现：
mBtn2.setOnClickListener(this);这样的代码，难点在哪呢？
1、mBtn2的获取？so easy
2、调用setOnClickListener ？ so easy
but , 这个 this，这个this是OnClickListener的实现类的实例，OnClickListener是个接口~~你的实现类怎么整，听说过反射newInstance对象的，但是你现在是接口！
是吧~现在应该明白上述几行代码做了什么了？实现了接口的一个代理对象，然后在代理类的invoke中，对接口的调用方法进行处理。
4、代码是最好的老师
光说谁都理解不了，你在这xx什么呢？？下面看代码，我们模拟实现这样一个情景：
Main类中实现一个Button，Button有两个方法，一个setOnClickListener和onClick，当调用Button的onClick时，触发的事件是Main类中的click方法
涉及到4个类：
Button
1. package com.zhy.invocationhandler;
2.
3. public class Button
4. {
5. private OnClickListener listener;
6.
7. public void setOnClickLisntener(OnClickListener listener)
8. {
9.
10. this.listener = listener;
11. }
12.
13. public void click()
14. {
15. if (listener != null)
16. {
17. listener.onClick();
18. }
19. }
20. }
OnClickListener接口
1. package com.zhy.invocationhandler;
2.
3. public interface OnClickListener
4. {
5. void onClick();
6. }
OnClickListenerHandler ， InvocationHandler的实现类
1. package com.zhy.invocationhandler;
2.
3. import java.lang.reflect.InvocationHandler;
4. import java.lang.reflect.Method;
5. import java.util.HashMap;
6. import java.util.Map;
7.
8. public class OnClickListenerHandler implements InvocationHandler
9. {
10. private Object targetObject;
11.
12. public OnClickListenerHandler(Object object)
13. {
14. this.targetObject = object;
15. }
16.
17. private Map<String, Method> methods = new HashMap<String, Method>();
18.
19. public void addMethod(String methodName, Method method)
20. {
21. methods.put(methodName, method);
22. }
23.
24. @Override
25. public Object invoke(Object proxy, Method method, Object[] args)
26. throws Throwable
27. {
28.
29. String methodName = method.getName();
30. Method realMethod = methods.get(methodName);
31. return realMethod.invoke(targetObject, args);
32. }
33.
34. }
我们的Main
1. package com.zhy.invocationhandler;
2.
3. import java.lang.reflect.InvocationTargetException;
4. import java.lang.reflect.Method;
5. import java.lang.reflect.Proxy;
6.
7. public class Main
8. {
9. private Button button = new Button();
10.
11. public Main() throws SecurityException, IllegalArgumentException, NoSuchMethodException, IllegalAccessException, InvocationTargetException
12. {
13. init();
14. }
15.
16. public void click()
17. {
18. "Button clicked!");
19. }
20.
21. public void init() throws SecurityException,
22. NoSuchMethodException, IllegalArgumentException,
23. IllegalAccessException, InvocationTargetException
24. {
25. new OnClickListenerHandler(this);
26. class.getMethod("click", null);
27. "onClick", method);
28. Object clickProxy = Proxy.newProxyInstance(
29. class.getClassLoader(),
30. new Class<?>[] { OnClickListener.class }, h);
31. "setOnClickLisntener",
32. class);
33. clickMethod.invoke(button, clickProxy);
34.
35. }
36.
37. public static void main(String[] args) throws SecurityException,
38. IllegalArgumentException, NoSuchMethodException,
39. IllegalAccessException, InvocationTargetException
40. {
41.
42. new Main();
43.
44. main.button.click();
45. }
46.
47. }
我们模拟按钮点击：调用main.button.click()，实际执行的却是Main的click方法。
看init中，我们首先初始化了一个OnClickListenerHandler，把Main的当前实例传入，然后拿到Main的click方法，添加到OnClickListenerHandler中的Map中。
然后通过Proxy.newProxyInstance拿到OnClickListener这个接口的一个代理，这样执行这个接口的所有的方法，都会去调用OnClickListenerHandler的invoke方法。
但是呢？OnClickListener毕竟是个接口，也没有方法体~~那咋办呢？这时候就到我们OnClickListenerHandler中的Map中大展伸手了：
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable
{String methodName = method.getName();
Method realMethod = methods.get(methodName);
return realMethod.invoke(targetObject, args);
}我们显示的把要执行的方法，通过键值对存到Map里面了，等调用到invoke的时候，其实是通过传入的方法名，得到Map中存储的方法，然后调用我们预设的方法~。
这样，大家应该明白了，其实就是通过Proxy得到接口的一个代理，然后在InvocationHandler中使用一个Map预先设置方法，从而实现Button的onClick，和Main的click关联上。
现在看我们InjectEvents中的代码：
1. //通过InvocationHandler设置代理
2. new DynamicHandler(activity);
3. //往map添加方法
4. handler.addMethod(methodName, method);
5. Object listener = Proxy.newProxyInstance(
6. listenerType.getClassLoader(),
7. new Class<?>[] { listenerType }, handler);
是不是和我们init中的类似~~
好了，关于如何把接口的回调和我们Activity里面的方法关联上我们也解释完了~~~
注：部分代码参考了xUtils这个框架，毕竟想很完善的实现一个完整的注入不是一两篇博客就可以搞定，但是核心和骨架已经实现了~~大家有兴趣的可以继续去完善~
