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

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

1、目标效果

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

[java] view plain copy print ?
  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 print ?
  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 print ?
  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 print ?
  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 print ?
  1. @OnClick({R.id.id_btn,R.id.id_btn02})
  2. publicvoidclickBtnInvoked(Viewview)

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

[java] view plain copy print ?
  1. publicstaticvoidinject(Activityactivity)
  2. {
  3. injectContentView(activity);
  4. injectViews(activity);
  5. injectEvents(activity);
  6. }

2、injectEvents

[java] view plain copy print ?
  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 print ?
  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 print ?
  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 print ?
  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 print ?
  1. packagecom.zhy.invocationhandler;
  3. publicinterfaceOnClickListener
  4. {
  5. voidonClick();
  6. }

OnClickListenerHandler ， InvocationHandler的实现类

[java] view plain copy print ?
  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 print ?
  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 print ?
  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. android中ListView异步加载图片时的图片错位问题解决方案
  2. 浅谈Android游戏开发基础和经验
  3. Android(安卓)View绘制回调方法流程
  4. windows中下载android源码的方法 附下载脚本
  5. Android日记之2012\01\13
  6. Android四大组件之服务
  7. Android的BroadcastReceiver简介
  8. Tiny4412——Android访问硬件的方法
  9. 你不知道的 Android(安卓)WebView 使用漏洞

随机推荐

  1. mysql_query会自动执行，但不会在onClick时
  2. php写app接口并返回json数据
  3. PHP环境搭建和编写API接口
  4. ajax php bomt头 utf-8带来的奇怪问题。
  5. MySQL错误1046：未选择数据库
  6. PHP 开发环境配置
  7. php使用gd库将文字转换成图片
  8. 纯php文件不加结束标记的好处
  9. php二维码/26行代码制作php二维码phpqrco
  10. 使用GMail SMTP服务器从PHP页面发送电子