上一篇博客我们已经带大家简单的吹了一下IoC，实现了Activity中View的布局以及控件的注入，如果你不了解，请参考：Android 进阶 教你打造 Android 中的 IOC 框架 【ViewInject】 （上）。

本篇博客将带大家实现View的事件的注入。

1、目标效果

上篇博客，我们的事件的代码是这么写的：

[java] view plain copy

1. packagecom.zhy.zhy_xutils_test;
3. importandroid.app.Activity;
4. importandroid.os.Bundle;
5. importandroid.view.View;
6. importandroid.view.View.OnClickListener;
7. importandroid.widget.Button;
8. importandroid.widget.Toast;
10. importcom.zhy.ioc.view.ViewInjectUtils;
11. importcom.zhy.ioc.view.annotation.ContentView;
12. importcom.zhy.ioc.view.annotation.ViewInject;
14. @ContentView(value=R.layout.activity_main)
15. publicclassMainActivityextendsActivityimplementsOnClickListener
16. {
17. @ViewInject(R.id.id_btn)
18. privateButtonmBtn1;
19. @ViewInject(R.id.id_btn02)
20. privateButtonmBtn2;
22. @Override
23. protectedvoidonCreate(BundlesavedInstanceState)
24. {
25. super.onCreate(savedInstanceState);
27. ViewInjectUtils.inject(this);
29. mBtn1.setOnClickListener(this);
30. mBtn2.setOnClickListener(this);
31. }
33. @Override
34. publicvoidonClick(Viewv)
35. {
36. switch(v.getId())
37. {
38. caseR.id.id_btn:
39. Toast.makeText(MainActivity.this,"Whydoyouclickme?",
40. Toast.LENGTH_SHORT).show();
41. break;
43. caseR.id.id_btn02:
44. Toast.makeText(MainActivity.this,"Iamsleeping!!!",
45. Toast.LENGTH_SHORT).show();
46. break;
47. }
48. }
50. }

光有View的注入能行么，我们写View的目的，很多是用来交互的，得可以点击神马的吧。摒弃传统的神马，setOnClickListener，然后实现匿名类或者别的方式神马的，我们改变为：

[java] view plain copy

1. packagecom.zhy.zhy_xutils_test;
3. importandroid.view.View;
4. importandroid.widget.Button;
5. importandroid.widget.Toast;
7. importcom.zhy.ioc.view.annotation.ContentView;
8. importcom.zhy.ioc.view.annotation.OnClick;
9. importcom.zhy.ioc.view.annotation.ViewInject;
11. @ContentView(value=R.layout.activity_main)
12. publicclassMainActivityextendsBaseActivity
13. {
14. @ViewInject(R.id.id_btn)
15. privateButtonmBtn1;
16. @ViewInject(R.id.id_btn02)
17. privateButtonmBtn2;
19. @OnClick({R.id.id_btn,R.id.id_btn02})
20. publicvoidclickBtnInvoked(Viewview)
21. {
22. switch(view.getId())
23. {
24. caseR.id.id_btn:
25. Toast.makeText(this,"InjectBtn01!",Toast.LENGTH_SHORT).show();
26. break;
27. caseR.id.id_btn02:
28. Toast.makeText(this,"InjectBtn02!",Toast.LENGTH_SHORT).show();
29. break;
30. }
31. }
33. }

直接通过在Activity中的任何一个方法上，添加注解，完成1个或多个控件的事件的注入。这里我把onCreate搬到了BaseActivity中，里面调用了ViewInjectUtils.inject(this);

2、实现

1、注解文件

[java] view plain copy

1. packagecom.zhy.ioc.view.annotation;
3. importjava.lang.annotation.ElementType;
4. importjava.lang.annotation.Retention;
5. importjava.lang.annotation.RetentionPolicy;
6. importjava.lang.annotation.Target;
8. @Target(ElementType.ANNOTATION_TYPE)
9. @Retention(RetentionPolicy.RUNTIME)
10. public@interfaceEventBase
11. {
12. Class<?>listenerType();
14. StringlistenerSetter();
16. StringmethodName();
17. }

[java] view plain copy

1. packagecom.zhy.ioc.view.annotation;
3. importjava.lang.annotation.ElementType;
4. importjava.lang.annotation.Retention;
5. importjava.lang.annotation.RetentionPolicy;
6. importjava.lang.annotation.Target;
8. importandroid.view.View;
10. @Target(ElementType.METHOD)
11. @Retention(RetentionPolicy.RUNTIME)
12. @EventBase(listenerType=View.OnClickListener.class,listenerSetter="setOnClickListener",methodName="onClick")
13. public@interfaceOnClick
14. {
15. int[]value();
16. }

EventBase主要用于给OnClick这类注解上添加注解，毕竟事件很多，并且设置监听器的名称，监听器的类型，调用的方法名都是固定的，对应上面代码的：

listenerType = View.OnClickListener.class, listenerSetter = "setOnClickListener", methodName = "onClick"

Onclick是用于写在Activity的某个方法上的：

[java] view plain copy

1. @OnClick({R.id.id_btn,R.id.id_btn02})
2. publicvoidclickBtnInvoked(Viewview)

如果你还记得，上篇博客我们的ViewInjectUtils.inject(this);里面已经有了两个方法，本篇多了一个：

[java] view plain copy

1. publicstaticvoidinject(Activityactivity)
2. {
3. injectContentView(activity);
4. injectViews(activity);
5. injectEvents(activity);
6. }

2、injectEvents

[java] view plain copy

1. /**
2. *注入所有的事件
3. *
4. *@paramactivity
5. */
6. privatestaticvoidinjectEvents(Activityactivity)
7. {
9. Class<?extendsActivity>clazz=activity.getClass();
10. Method[]methods=clazz.getMethods();
11. //遍历所有的方法
12. for(Methodmethod:methods)
13. {
14. Annotation[]annotations=method.getAnnotations();
15. //拿到方法上的所有的注解
16. for(Annotationannotation:annotations)
17. {
18. Class<?extendsAnnotation>annotationType=annotation
19. .annotationType();
20. //拿到注解上的注解
21. EventBaseeventBaseAnnotation=annotationType
22. .getAnnotation(EventBase.class);
23. //如果设置为EventBase
24. if(eventBaseAnnotation!=null)
25. {
26. //取出设置监听器的名称，监听器的类型，调用的方法名
27. StringlistenerSetter=eventBaseAnnotation
28. .listenerSetter();
29. Class<?>listenerType=eventBaseAnnotation.listenerType();
30. StringmethodName=eventBaseAnnotation.methodName();
32. try
33. {
34. //拿到Onclick注解中的value方法
35. MethodaMethod=annotationType
36. .getDeclaredMethod("value");
37. //取出所有的viewId
38. int[]viewIds=(int[])aMethod
39. .invoke(annotation,null);
40. //通过InvocationHandler设置代理
41. DynamicHandlerhandler=newDynamicHandler(activity);
42. handler.addMethod(methodName,method);
43. Objectlistener=Proxy.newProxyInstance(
44. listenerType.getClassLoader(),
45. newClass<?>[]{listenerType},handler);
46. //遍历所有的View，设置事件
47. for(intviewId:viewIds)
48. {
49. Viewview=activity.findViewById(viewId);
50. MethodsetEventListenerMethod=view.getClass()
51. .getMethod(listenerSetter,listenerType);
52. setEventListenerMethod.invoke(view,listener);
53. }
55. }catch(Exceptione)
56. {
57. e.printStackTrace();
58. }
59. }
61. }
62. }
64. }

嗯，注释尽可能的详细了，主要就是遍历所有的方法，拿到该方法省的OnClick注解，然后再拿到该注解上的EventBase注解，得到事件监听的需要调用的方法名，类型，和需要调用的方法的名称；通过Proxy和InvocationHandler得到监听器的代理对象，显示设置了方法，最后通过反射设置监听器。

这里有个难点，就是关于DynamicHandler和Proxy的出现，如果不理解没事，后面会详细讲解。

3、DynamicHandler

这里用到了一个类DynamicHandler，就是InvocationHandler的实现类：

[java] view plain copy

1. packagecom.zhy.ioc.view;
3. importjava.lang.ref.WeakReference;
4. importjava.lang.reflect.InvocationHandler;
5. importjava.lang.reflect.Method;
6. importjava.util.HashMap;
8. publicclassDynamicHandlerimplementsInvocationHandler
9. {
10. privateWeakReference<Object>handlerRef;
11. privatefinalHashMap<String,Method>methodMap=newHashMap<String,Method>(
12. 1);
14. publicDynamicHandler(Objecthandler)
15. {
16. this.handlerRef=newWeakReference<Object>(handler);
17. }
19. publicvoidaddMethod(Stringname,Methodmethod)
20. {
21. methodMap.put(name,method);
22. }
24. publicObjectgetHandler()
25. {
26. returnhandlerRef.get();
27. }
29. publicvoidsetHandler(Objecthandler)
30. {
31. this.handlerRef=newWeakReference<Object>(handler);
32. }
34. @Override
35. publicObjectinvoke(Objectproxy,Methodmethod,Object[]args)
36. throwsThrowable
37. {
38. Objecthandler=handlerRef.get();
39. if(handler!=null)
40. {
41. StringmethodName=method.getName();
42. method=methodMap.get(methodName);
43. if(method!=null)
44. {
45. returnmethod.invoke(handler,args);
46. }
47. }
48. returnnull;
49. }
50. }

好了，代码就这么多，这样我们就实现了，我们事件的注入~~

效果图：

效果图其实没撒好贴的，都一样~~~

3、关于代理

那么，本文结束了么，没有~~~关于以下几行代码，相信大家肯定有困惑，这几行干了什么？

[java] view plain copy

1. //通过InvocationHandler设置代理
2. DynamicHandlerhandler=newDynamicHandler(activity);
3. handler.addMethod(methodName,method);
4. Objectlistener=Proxy.newProxyInstance(
5. listenerType.getClassLoader(),
6. newClass<?>[]{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

[java] view plain copy

1. packagecom.zhy.invocationhandler;
3. publicclassButton
4. {
5. privateOnClickListenerlistener;
7. publicvoidsetOnClickLisntener(OnClickListenerlistener)
8. {
10. this.listener=listener;
11. }
13. publicvoidclick()
14. {
15. if(listener!=null)
16. {
17. listener.onClick();
18. }
19. }
20. }

OnClickListener接口

[java] view plain copy

1. packagecom.zhy.invocationhandler;
3. publicinterfaceOnClickListener
4. {
5. voidonClick();
6. }

OnClickListenerHandler ， InvocationHandler的实现类

[java] view plain copy

1. packagecom.zhy.invocationhandler;
3. importjava.lang.reflect.InvocationHandler;
4. importjava.lang.reflect.Method;
5. importjava.util.HashMap;
6. importjava.util.Map;
8. publicclassOnClickListenerHandlerimplementsInvocationHandler
9. {
10. privateObjecttargetObject;
12. publicOnClickListenerHandler(Objectobject)
13. {
14. this.targetObject=object;
15. }
17. privateMap<String,Method>methods=newHashMap<String,Method>();
19. publicvoidaddMethod(StringmethodName,Methodmethod)
20. {
21. methods.put(methodName,method);
22. }
24. @Override
25. publicObjectinvoke(Objectproxy,Methodmethod,Object[]args)
26. throwsThrowable
27. {
29. StringmethodName=method.getName();
30. MethodrealMethod=methods.get(methodName);
31. returnrealMethod.invoke(targetObject,args);
32. }
34. }

我们的Main

[java] view plain copy

1. packagecom.zhy.invocationhandler;
3. importjava.lang.reflect.InvocationTargetException;
4. importjava.lang.reflect.Method;
5. importjava.lang.reflect.Proxy;
7. publicclassMain
8. {
9. privateButtonbutton=newButton();
11. publicMain()throwsSecurityException,IllegalArgumentException,NoSuchMethodException,IllegalAccessException,InvocationTargetException
12. {
13. init();
14. }
16. publicvoidclick()
17. {
18. System.out.println("Buttonclicked!");
19. }
21. publicvoidinit()throwsSecurityException,
22. NoSuchMethodException,IllegalArgumentException,
23. IllegalAccessException,InvocationTargetException
24. {
25. OnClickListenerHandlerh=newOnClickListenerHandler(this);
26. Methodmethod=Main.class.getMethod("click",null);
27. h.addMethod("onClick",method);
28. ObjectclickProxy=Proxy.newProxyInstance(
29. OnClickListener.class.getClassLoader(),
30. newClass<?>[]{OnClickListener.class},h);
31. MethodclickMethod=button.getClass().getMethod("setOnClickLisntener",
32. OnClickListener.class);
33. clickMethod.invoke(button,clickProxy);
35. }
37. publicstaticvoidmain(String[]args)throwsSecurityException,
38. IllegalArgumentException,NoSuchMethodException,
39. IllegalAccessException,InvocationTargetException
40. {
42. Mainmain=newMain();
44. main.button.click();
45. }
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中的代码：

[java] view plain copy

1. //通过InvocationHandler设置代理
2. DynamicHandlerhandler=newDynamicHandler(activity);
3. //往map添加方法
4. handler.addMethod(methodName,method);
5. Objectlistener=Proxy.newProxyInstance(
6. listenerType.getClassLoader(),
7. newClass<?>[]{listenerType},handler);

是不是和我们init中的类似~~

好了，关于如何把接口的回调和我们Activity里面的方法关联上我们也解释完了~~~

注：部分代码参考了xUtils这个框架，毕竟想很完善的实现一个完整的注入不是一两篇博客就可以搞定，但是核心和骨架已经实现了~~大家有兴趣的可以继续去完善~

源码点击下载

更多相关文章

1. 浅谈Java中Collections.sort对List排序的两种方法
2. Python list sort方法的具体使用
3. python list.sort()根据多个关键字排序的方法实现
4. android上一些方法的区别和用法的注意事项
5. android实现字体闪烁动画的方法
6. Android(安卓)Wifi模块分析（三）
7. Android中dispatchDraw分析
8. Android四大基本组件介绍与生命周期
9. Android(安卓)MediaPlayer 常用方法介绍

随机推荐

1. Android(安卓)ADT 14 插件更新说明
2. Android ICS系统是支持通过互联网时间同
3. Android线程与异步消息处理机制
4. Android使用Bmob移动后端云Restful API需
5. 谈谈对Android定时任务中AlarmManager的
6. qq聊天界面七：表情的发送接收（用富文本现实
7. android系统裁剪方法
8. 【学习Android遇到的错误】Android 开发
9. Android(安卓)在代码中书写布局（xml）配置
10. android studio导入gbk编码的工程文件导