码迷，mamicode.com
首页 > 移动开发 > 详细

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

时间：2014-09-22 20:37:03      阅读：308      评论：0      收藏：0      [点我收藏+]

标签：android   style   blog   http   io   os   使用   java   ar   

1、目标效果

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

[java] view plaincopy
  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 plaincopy
  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 plaincopy
  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 plaincopy
  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 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.           
  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 plaincopy
  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. }  

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

效果图：

bubuko.com,布布扣

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

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.   
  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 plaincopy
  1. package com.zhy.invocationhandler;  
  2.   
  3. public interface OnClickListener  
  4. {  
  5.     void onClick();  
  6. }  


OnClickListenerHandler ， InvocationHandler的实现类

[java] view plaincopy
  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 plaincopy
  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.   


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

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

标签：android   style   blog   http   io   os   使用   java   ar   

原文地址：http://www.cnblogs.com/yido9932/p/3986301.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！