Android 进阶 教你打造 Android 中的 IOC 框架 【ViewInject】 （下）

1、目标效果

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

[java] view plaincopy

  1. package com.zhy.zhy_xutils_test;
  2. import android.app.Activity;
  3. import android.os.Bundle;
  4. import android.view.View;
  5. import android.view.View.OnClickListener;
  6. import android.widget.Button;
  7. import android.widget.Toast;
  8. import com.zhy.ioc.view.ViewInjectUtils;
  9. import com.zhy.ioc.view.annotation.ContentView;
  10. import com.zhy.ioc.view.annotation.ViewInject;
  11. @ContentView(value = R.layout.activity_main)
  12. public class MainActivity extends Activity implements OnClickListener
  13. {
  14. @ViewInject(R.id.id_btn)
  15. private Button mBtn1;
  16. @ViewInject(R.id.id_btn02)
  17. private Button mBtn2;
  18. @Override
  19. protected void onCreate(Bundle savedInstanceState)
  20. {
  21. super.onCreate(savedInstanceState);
  22. ViewInjectUtils.inject(this);
  23. mBtn1.setOnClickListener(this);
  24. mBtn2.setOnClickListener(this);
  25. }
  26. @Override
  27. public void onClick(View v)
  28. {
  29. switch (v.getId())
  30. {
  31. case R.id.id_btn:
  32. Toast.makeText(MainActivity.this, "Why do you click me ?",
  33. Toast.LENGTH_SHORT).show();
  34. break;
  35. case R.id.id_btn02:
  36. Toast.makeText(MainActivity.this, "I am sleeping !!!",
  37. Toast.LENGTH_SHORT).show();
  38. break;
  39. }
  40. }
  41. }

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

[java] view plaincopy

  1. package com.zhy.zhy_xutils_test;
  2. import android.view.View;
  3. import android.widget.Button;
  4. import android.widget.Toast;
  5. import com.zhy.ioc.view.annotation.ContentView;
  6. import com.zhy.ioc.view.annotation.OnClick;
  7. import com.zhy.ioc.view.annotation.ViewInject;
  8. @ContentView(value = R.layout.activity_main)
  9. public class MainActivity extends BaseActivity
  10. {
  11. @ViewInject(R.id.id_btn)
  12. private Button mBtn1;
  13. @ViewInject(R.id.id_btn02)
  14. private Button mBtn2;
  15. @OnClick({ R.id.id_btn, R.id.id_btn02 })
  16. public void clickBtnInvoked(View view)
  17. {
  18. switch (view.getId())
  19. {
  20. case R.id.id_btn:
  21. Toast.makeText(this, "Inject Btn01 !", Toast.LENGTH_SHORT).show();
  22. break;
  23. case R.id.id_btn02:
  24. Toast.makeText(this, "Inject Btn02 !", Toast.LENGTH_SHORT).show();
  25. break;
  26. }
  27. }
  28. }

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

2、实现

1、注解文件

[java] view plaincopy

  1. package com.zhy.ioc.view.annotation;
  2. import java.lang.annotation.ElementType;
  3. import java.lang.annotation.Retention;
  4. import java.lang.annotation.RetentionPolicy;
  5. import java.lang.annotation.Target;
  6. @Target(ElementType.ANNOTATION_TYPE)
  7. @Retention(RetentionPolicy.RUNTIME)
  8. public @interface EventBase
  9. {
  10. Class<?> listenerType();
  11. String listenerSetter();
  12. String methodName();
  13. }

[java] view plaincopy

  1. package com.zhy.ioc.view.annotation;
  2. import java.lang.annotation.ElementType;
  3. import java.lang.annotation.Retention;
  4. import java.lang.annotation.RetentionPolicy;
  5. import java.lang.annotation.Target;
  6. import android.view.View;
  7. @Target(ElementType.METHOD)
  8. @Retention(RetentionPolicy.RUNTIME)
  9. @EventBase(listenerType = View.OnClickListener.class, listenerSetter = "setOnClickListener", methodName = "onClick")
  10. public @interface OnClick
  11. {
  12. int[] value();
  13. }

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

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

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

[java] view plaincopy

  1. @OnClick({ R.id.id_btn, R.id.id_btn02 })
  2. public void clickBtnInvoked(View view)

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

[java] view plaincopy

  1. public static void inject(Activity activity)
  2. {
  3. injectContentView(activity);
  4. injectViews(activity);
  5. injectEvents(activity);
  6. }

2、injectEvents

[java] view plaincopy

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

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

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

3、DynamicHandler

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

[java] view plaincopy

  1. package com.zhy.ioc.view;
  2. import java.lang.ref.WeakReference;
  3. import java.lang.reflect.InvocationHandler;
  4. import java.lang.reflect.Method;
  5. import java.util.HashMap;
  6. public class DynamicHandler implements InvocationHandler
  7. {
  8. private WeakReference<Object> handlerRef;
  9. private final HashMap<String, Method> methodMap = new HashMap<String, Method>(
  10. 1);
  11. public DynamicHandler(Object handler)
  12. {
  13. this.handlerRef = new WeakReference<Object>(handler);
  14. }
  15. public void addMethod(String name, Method method)
  16. {
  17. methodMap.put(name, method);
  18. }
  19. public Object getHandler()
  20. {
  21. return handlerRef.get();
  22. }
  23. public void setHandler(Object handler)
  24. {
  25. this.handlerRef = new WeakReference<Object>(handler);
  26. }
  27. @Override
  28. public Object invoke(Object proxy, Method method, Object[] args)
  29. throws Throwable
  30. {
  31. Object handler = handlerRef.get();
  32. if (handler != null)
  33. {
  34. String methodName = method.getName();
  35. method = methodMap.get(methodName);
  36. if (method != null)
  37. {
  38. return method.invoke(handler, args);
  39. }
  40. }
  41. return null;
  42. }
  43. }

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

效果图：

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

3、关于代理

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

[java] view plaincopy

  1. //通过InvocationHandler设置代理
  2. DynamicHandler handler = 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

[java] view plaincopy

  1. package com.zhy.invocationhandler;
  2. public class Button
  3. {
  4. private OnClickListener listener;
  5. public void setOnClickLisntener(OnClickListener listener)
  6. {
  7. this.listener = listener;
  8. }
  9. public void click()
  10. {
  11. if (listener != null)
  12. {
  13. listener.onClick();
  14. }
  15. }
  16. }

OnClickListener接口

[java] view plaincopy

  1. package com.zhy.invocationhandler;
  2. public interface OnClickListener
  3. {
  4. void onClick();
  5. }

OnClickListenerHandler ， InvocationHandler的实现类

[java] view plaincopy

  1. package com.zhy.invocationhandler;
  2. import java.lang.reflect.InvocationHandler;
  3. import java.lang.reflect.Method;
  4. import java.util.HashMap;
  5. import java.util.Map;
  6. public class OnClickListenerHandler implements InvocationHandler
  7. {
  8. private Object targetObject;
  9. public OnClickListenerHandler(Object object)
  10. {
  11. this.targetObject = object;
  12. }
  13. private Map<String, Method> methods = new HashMap<String, Method>();
  14. public void addMethod(String methodName, Method method)
  15. {
  16. methods.put(methodName, method);
  17. }
  18. @Override
  19. public Object invoke(Object proxy, Method method, Object[] args)
  20. throws Throwable
  21. {
  22. String methodName = method.getName();
  23. Method realMethod = methods.get(methodName);
  24. return realMethod.invoke(targetObject, args);
  25. }
  26. }

我们的Main

[java] view plaincopy

  1. package com.zhy.invocationhandler;
  2. import java.lang.reflect.InvocationTargetException;
  3. import java.lang.reflect.Method;
  4. import java.lang.reflect.Proxy;
  5. public class Main
  6. {
  7. private Button button = new Button();
  8. public Main() throws SecurityException, IllegalArgumentException, NoSuchMethodException, IllegalAccessException, InvocationTargetException
  9. {
  10. init();
  11. }
  12. public void click()
  13. {
  14. System.out.println("Button clicked!");
  15. }
  16. public void init() throws SecurityException,
  17. NoSuchMethodException, IllegalArgumentException,
  18. IllegalAccessException, InvocationTargetException
  19. {
  20. OnClickListenerHandler h = new OnClickListenerHandler(this);
  21. Method method = Main.class.getMethod("click", null);
  22. h.addMethod("onClick", method);
  23. Object clickProxy = Proxy.newProxyInstance(
  24. OnClickListener.class.getClassLoader(),
  25. new Class<?>[] { OnClickListener.class }, h);
  26. Method clickMethod = button.getClass().getMethod("setOnClickLisntener",
  27. OnClickListener.class);
  28. clickMethod.invoke(button, clickProxy);
  29. }
  30. public static void main(String[] args) throws SecurityException,
  31. IllegalArgumentException, NoSuchMethodException,
  32. IllegalAccessException, InvocationTargetException
  33. {
  34. Main main = new Main();
  35. main.button.click();
  36. }

我们模拟按钮点击：调用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 plaincopy

  1. //通过InvocationHandler设置代理
  2. DynamicHandler handler = 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这个框架，毕竟想很完善的实现一个完整的注入不是一两篇博客就可以搞定，但是核心和骨架已经实现了~~大家有兴趣的可以继续去完善~

时间： 2024-10-11 08:03:30

Android 进阶 教你打造 Android 中的 IOC 框架 【ViewInject】 （下）的相关文章

Android 进阶 教你打造 Android 中的 IOC 框架 【ViewInject】

1.概述 首先我们来吹吹牛,什么叫IoC,控制反转(Inversion of Control,英文缩写为IoC),什么意思呢? 就是你一个类里面需要用到很多个成员变量,传统的写法,你要用这些成员变量,那么你就new 出来用呗~~ IoC的原则是:NO,我们不要new,这样耦合度太高:你配置个xml文件,里面标明哪个类,里面用了哪些成员变量,等待加载这个类的时候,我帮你注入(new)进去: 这样做有什么好处呢? 回 答这个问题,刚好可以回答另一个问题,很多人问,项目分层开发是吧,分为控制层.业务层

Android 进阶 教你打造 Android 中的 IOC 框架 【ViewInject】 （上）

转载请标明出处:http://blog.csdn.net/lmj623565791/article/details/39269193,本文出自:[张鸿洋的博客] 1.概述 首先我们来吹吹牛,什么叫IoC,控制反转(Inversion of Control,英文缩写为IoC),什么意思呢? 就是你一个类里面需要用到很多个成员变量,传统的写法,你要用这些成员变量,那么你就new 出来用呗~~ IoC的原则是:NO,我们不要new,这样耦合度太高:你配置个xml文件,里面标明哪个类,里面用了哪些成员变

10年Android老司机教你打造独一无二的刷新加载框架

首先我们给出如下几个参数,后面要用: 10年Android老司机教你打造独一无二的刷新加载框架既然是刷新,我们的滚动肯定是在 父view 之前的.所以我们需要在 onNestedPreScroll 这个方法里面写上我们所需要改动的x,y值. 我们需要用 父view 去拦截它.我们需要判断 dy 的值是否大于0,因为大于0是刷新操作,小于0是加载操作.然后我们需要判断 recyclerview 是否是纵向的而不是横向的. 10年Android老司机教你打造独一无二的刷新加载框架上拉加载 上面我也说

c#中创建IOC框架的步骤（无参，Ninject容器）

创建无参的IOC框架 步骤: 1. 一个接口 2. 通过创建一个实体类显示接口 3. 再创建一个类制造构造函数(并将接口作为参数传递),再此类中创建一个无返回值的方法,调用接口里的方法 4. 在Main里面写代码: 1) 用接口new出创建接口实体的类. 2) 把创建构造函数的类名new出来,将1)的对象写入括号中. 3) 调用2)的无返回值方法. 第一步,定义一个接口: namespace NInjectEmail { interface ISendMsg { void SendEmail()

Android开发面试经——4.常见Android进阶笔试题（更新中...）

Android开发(29)  版权声明:本文为寻梦-finddreams原创文章,请关注:http://blog.csdn.net/finddreams 关注finddreams博客:http://blog.csdn.net/finddreams/article/details/44301359 上一篇文章我们已经了解了Android笔试的一些基础题目, [<Android开发面试经——2.常见Android基础笔试题> ] (http://blog.csdn.net/finddreams/a

我的Android进阶之旅------&amp;gt;Android中android:windowSoftInputMode的使用方法

面试题:怎样在显示某个Activity时马上弹出软键盘? 答案:在AndroidManifest.xml文件里设置<activity>标签的android:windowSoftInputMode属性能够在显示Activity时马上弹出当前输入法的软键盘(无论是否有获得焦点的空间). 设置为:android:windowSoftInputMode="stateVisible|adjustPan"   代码例如以下: <activity android:name=&quo

Android进阶笔记04：Android进程间通讯之Messenger （ 区别于AIDL）

一. Android进程间通讯之Messenger 的引入 (1)引言:      平时一说进程间通讯,大家都会想到AIDL,其实messenger和AIDL作用一样,都可以进行进程间通讯.它是基于消息的进程间通信,就像子线程和UI线程发送消息那样,是不是很简单,还不用去写AIDL文件,是不是有点小爽.哈哈.此外,还支持记录客户端对象的Messenger,然后可以实现一对多的通信:甚至作为一个转接处,任意两个进程都能通过服务端进行通信. (2) Messenger 与 AIDL 比较:    

Android进阶笔记10：Android 万能适配器

1. Android 万能适配器      项目中Listview GridView几乎是必用的组件,Android也提供一套机制,为这些控件绑定数据,那就是Adapter.用起来虽然还不错,但每次都需要去继承一个BaseAdapter,然后实现里面的一大堆方法,而我们每次最关心的无非就是getView方法,其余的方法几乎都是相同代码.这里是不是就可以优化起来呢?在其次,我们在使用Adapter的时候,为了优化性能,常常会创建一个Holder.而Holder里面每次存放的都是View,对Hole

我的Android进阶之旅------&amp;gt;android Button上面的英文字符串自己主动大写的问题解决

今天碰到一个关于Button的问题:android Button上面的英文字符串会自己主动变成大写,执行的Android 5.1版本号,例如以下图所看到的: 图1:Button 图2:TextView 这个Button的定义代码例如以下 <Button android:id="@+id/addContacts" android:layout_width="match_parent" android:layout_height="wrap_conten