Android进阶 教你打造 Android中的IOC框架(下)

1、目标效果

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

[java]  view plain copy

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

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

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

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

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

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

[java]  view plain copy

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

2、injectEvents

[java]  view plain copy

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

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、关于代理

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

[java]  view plain copy

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 plain copy

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

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

OnClickListenerHandler ， InvocationHandler的实现类

[java]  view plain copy

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

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

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