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

女爷i 2022-06-09 13:37 206阅读 0赞

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

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

# 1、目标效果 #

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

**\[java\]** [view plain][] [copy][view plain]

1.  **package** com.zhy.zhy\_xutils\_test; 
2.  
3.  **import** android.app.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(R.id.id\_btn) 
18. **private** Button mBtn1; 
19. @ViewInject(R.id.id\_btn02) 
20. **private** Button mBtn2; 
21. 
22. @Override
23. **protected****void** onCreate(Bundle savedInstanceState) 
24.  \{ 
25. **super**.onCreate(savedInstanceState); 
26. 
27.  ViewInjectUtils.inject(**this**); 
28. 
29.  mBtn1.setOnClickListener(**this**); 
30.  mBtn2.setOnClickListener(**this**); 
31.  \} 
32. 
33. @Override
34. **public****void** onClick(View v) 
35.  \{ 
36. **switch** (v.getId()) 
37.  \{ 
38. **case** R.id.id\_btn: 
39.  Toast.makeText(MainActivity.**this**, "Why do you click me ?", 
40.  Toast.LENGTH\_SHORT).show(); 
41. **break**; 
42. 
43. **case** R.id.id\_btn02: 
44.  Toast.makeText(MainActivity.**this**, "I am sleeping !!!", 
45.  Toast.LENGTH\_SHORT).show(); 
46. **break**; 
47.  \} 
48.  \} 
49. 
50. \}

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

**\[java\]** [view plain][] [copy][view plain]

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(R.id.id\_btn) 
15. **private** Button mBtn1; 
16. @ViewInject(R.id.id\_btn02) 
17. **private** Button mBtn2; 
18. 
19. @OnClick(\{ R.id.id\_btn, R.id.id\_btn02 \}) 
20. **public****void** clickBtnInvoked(View view) 
21.  \{ 
22. **switch** (view.getId()) 
23.  \{ 
24. **case** R.id.id\_btn: 
25.  Toast.makeText(**this**, "Inject Btn01 !", Toast.LENGTH\_SHORT).show(); 
26. **break**; 
27. **case** R.id.id\_btn02: 
28.  Toast.makeText(**this**, "Inject Btn02 !", Toast.LENGTH\_SHORT).show(); 
29. **break**; 
30.  \} 
31.  \} 
32. 
33. \}

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

# 2、实现 #

## 1、注解文件 ##

**\[java\]** [view plain][] [copy][view plain]

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. \}

**\[java\]** [view plain][] [copy][view plain]

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的某个方法上的：

**\[java\]** [view plain][] [copy][view plain]

1.  @OnClick(\{ R.id.id\_btn, R.id.id\_btn02 \}) 
2.  **public****void** clickBtnInvoked(View view)

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

**\[java\]** [view plain][] [copy][view plain]

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

## 2、injectEvents ##

**\[java\]** [view plain][] [copy][view plain]

1.  /\*\*
2.   \* 注入所有的事件
3.   \* 
4.   \* @param activity
5.   \*/
6.  **private****static****void** injectEvents(Activity activity) 
7.   \{ 
8.  
9.   Class<? **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.  Class<? **extends** Annotation> annotationType = annotation 
19.  .annotationType(); 
20. //拿到注解上的注解
21.  EventBase eventBaseAnnotation = annotationType 
22.  .getAnnotation(EventBase.**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.  .getDeclaredMethod("value"); 
37. //取出所有的viewId
38. **int**\[\] viewIds = (**int**\[\]) aMethod 
39.  .invoke(annotation, **null**); 
40. //通过InvocationHandler设置代理
41.  DynamicHandler handler = **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的实现类：

**\[java\]** [view plain][] [copy][view plain]

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. \}

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

效果图：

![20140914152641000][]

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

# 3、关于代理 #

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

**\[java\]** [view plain][] [copy][view plain]

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/][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][view plain]

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接口

**\[java\]** [view plain][] [copy][view plain]

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

OnClickListenerHandler ， InvocationHandler的实现类

**\[java\]** [view plain][] [copy][view plain]

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

**\[java\]** [view plain][] [copy][view plain]

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.  System.out.println("Button clicked!"); 
19.  \} 
20. 
21. **public****void** init() **throws** SecurityException, 
22.  NoSuchMethodException, IllegalArgumentException, 
23.  IllegalAccessException, InvocationTargetException 
24.  \{ 
25.  OnClickListenerHandler h = **new** OnClickListenerHandler(**this**); 
26.  Method method = Main.**class**.getMethod("click", **null**); 
27.  h.addMethod("onClick", method); 
28.  Object clickProxy = Proxy.newProxyInstance( 
29.  OnClickListener.**class**.getClassLoader(), 
30. **new** Class<?>\[\] \{ OnClickListener.**class** \}, h); 
31.  Method clickMethod = button.getClass().getMethod("setOnClickLisntener", 
32.  OnClickListener.**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.  Main main = **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中的代码：

**\[java\]** [view plain][] [copy][view plain]

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这个框架，毕竟想很完善的实现一个完整的注入不是一两篇博客就可以搞定，但是核心和骨架已经实现了~~大家有兴趣的可以继续去完善~

[源码点击下载][Link 1]

\---------------------------------------------------------------------------------------------------------------------------------------

最后贴个广告：

第一次录制视频~~~还望大家支持，共同进步~

[高仿微信5.2.1主界面及消息提醒][5.2.1]

[Android _ _ Android _ IOC _ _ViewInject_]: http://blog.csdn.net/lmj623565791/article/details/39269193
[view plain]: http://blog.csdn.net/lmj623565791/article/details/39275847#
[20140914152641000]: /images/20220609/dc7198af3e5b40818f3fbd8f520bba7c.png
[http_www.ibm.com_developerworks_cn_java_j-lo-proxy1]: http://www.ibm.com/developerworks/cn/java/j-lo-proxy1/
[Link 1]: http://download.csdn.net/detail/lmj623565791/7916541
[5.2.1]: http://www.imooc.com/learn/198