Android应用开发中控制反转IoC设计模式使用教程

概述1、概述首先我们来吹吹牛，什么叫IoC，控制反转（InversionofControl，英文缩写为IoC），什么意思呢？

1、概述@H_419_2@首先我们来吹吹牛，什么叫IoC，控制反转（Inversion of Control，英文缩写为IoC），什么意思呢？@H_419_2@就是你一个类里面需要用到很多个成员变量，传统的写法，你要用这些成员变量，那么你就new 出来用呗~~@H_419_2@IoC的原则是：NO，我们不要new，这样耦合度太高；你配置个xml文件，里面标明哪个类，里面用了哪些成员变量，等待加载这个类的时候，我帮你注入（new）进去；@H_419_2@这样做有什么好处呢？@H_419_2@ 回答这个问题，刚好可以回答另一个问题，很多人问，项目分层开发是吧，分为控制层、业务层、DAO层神马的。然后每一层为撒子要一个包放接口，一个包放实现呢？只要一个实现包不行么~刚好，如果你了解了IoC，你就知道这些个接口的作用了，上面不是说，你不用new，你只要声明了成员变量+写个配置文件，有人帮你new；此时，你在类中，就可以把需要使用到的成员变量都声明成接口，然后你会发现，当实现类发生变化的时候，或者切换实现类，你需要做什么呢？你只要在配置文件里面做个简单的修改。如果你用的就是实实在在的实现类，现在换实现类，你需要找到所有声明这个实现类的地方，手动修改类名；如果你遇到了一个多变的老大，是吧，呵呵~@H_419_2@ 当然了，很多会觉得，写个配置文件，卧槽，这多麻烦。于是乎，又出现了另一种方案，得，你闲配置文件麻烦，你用注解吧。你在需要注入的成员变量上面给我加个注解，例如：@Inject，这样就行了，你总不能说这么个单词麻烦吧~~@H_419_2@ 当然了，有了配置文件和注解，那么怎么注入呢？其实就是把字符串类路径变成类么，当然了，反射上场了；话说，很久很久以前，反射很慢啊，嗯，那是很久很久以前，现在已经不是太慢了，当然了肯定达不到原生的速度~~无反射，没有任何框架。@H_419_2@ 如果你觉得注解，反射神马的好高级。我说一句：Just Do It ，你会发现注解就和你写一个普通JavaBean差不多；反射呢？API就那么几行，千万不要被震慑住~

2、框架实现@H_419_2@得进入正题了，AndroID IOC框架，其实主要就是帮大家注入所有的控件，布局文件什么的。如果你用过xUtils，afinal类的框架，你肯定不陌生~@H_419_2@注入VIEw@H_419_2@假设：我们一个Activity，里面10来个VIEw。@H_419_2@传统做法：我们需要先给这个Activity设置下布局文件，然后在onCreate里面一个一个的findVIEwByID把~@H_419_2@目标的做法：Activity类上添加个注解，帮我们自动注入布局文科；声明VIEw的时候，添加一行注解，然后自动帮我们findVIEwByID;@H_419_2@于是乎我们的目标类是这样的：@H_419_2@ @H_419_2@

@ContentVIEw(value = R.layout.activity_main) public class MainActivity extends BaseActivity {  @VIEwInject(R.ID.ID_btn)  private button mBtn1;  @VIEwInject(R.ID.ID_btn02)  private button mBtn2; 

3、编码@H_419_2@(1)定义注解@H_419_2@首先我们需要两个注解文件：

package com.zhy.ioc.vIEw.annotation;  import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target;  @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) public @interface ContentVIEw {  int value(); } 

ContentVIEw用于在类上使用，主要用于标明该Activity需要使用的布局文件。@H_419_2@

 @ContentVIEw(value = R.layout.activity_main) public class MainActivity  package com.zhy.ioc.vIEw.annotation;  import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target;  @Target(ElementType.FIELD) @Retention(RetentionPolicy.RUNTIME) public @interface VIEwInject {  int value(); } 

在成员变量上使用，用于指定VIEw的ID@H_419_2@

@VIEwInject(R.ID.ID_btn)  private button mBtn1; 

简单说一下注解：定义的关键字@interface ; @Target表示该注解可以用于什么地方，可能的类型TYPE（类）,FIELD（成员变量）,可能的类型：@H_419_2@

public enum ElementType {  /**   * Class,interface or enum declaration.   */  TYPE,/**   * FIEld declaration.   */  FIELD,/**   * Method declaration.   */  METHOD,/**   * Parameter declaration.   */  ParaMETER,/**   * Constructor declaration.   */  CONSTRUCTOR,/**   * Local variable declaration.   */  LOCAL_VARIABLE,/**   * Annotation type declaration.   */  ANNOTATION_TYPE,/**   * Package declaration.   */  PACKAGE } 

就是这些个枚举。@H_419_2@@Retention表示：表示需要在什么级别保存该注解信息；我们这里设置为运行时。@H_419_2@可能的类型： @H_419_2@

public enum RetentionPolicy {  /**   * Annotation is only available in the source code.   */  SOURCE,/**   * Annotation is available in the source code and in the class file,but not   * at runtime. This is the default policy.   */  CLASS,/**   * Annotation is available in the source code,the class file and is   * available at runtime.   */  RUNTIME } 

这些个枚举~

(2)MainActivity@H_419_2@

package com.zhy.zhy_xutils_test;  import androID.app.Activity; import androID.os.Bundle; import androID.vIEw.VIEw; import androID.vIEw.VIEw.OnClickListener; import androID.Widget.button; import androID.Widget.Toast;  import com.zhy.ioc.vIEw.VIEwInjectUtils; import com.zhy.ioc.vIEw.annotation.ContentVIEw; import com.zhy.ioc.vIEw.annotation.VIEwInject;  @ContentVIEw(value = R.layout.activity_main) public class MainActivity extends Activity implements OnClickListener {  @VIEwInject(R.ID.ID_btn)  private button mBtn1;  @VIEwInject(R.ID.ID_btn02)  private button mBtn2;   @OverrIDe  protected voID onCreate(Bundle savedInstanceState)  {   super.onCreate(savedInstanceState);      VIEwInjectUtils.inject(this);    mBtn1.setonClickListener(this);   mBtn2.setonClickListener(this);  }   @OverrIDe  public voID onClick(VIEw v)  {   switch (v.getID())   {   case R.ID.ID_btn:    Toast.makeText(MainActivity.this,"Why do you click me ?",Toast.LENGTH_SHORT).show();    break;    case R.ID.ID_btn02:    Toast.makeText(MainActivity.this,"I am sleePing !!!",Toast.LENGTH_SHORT).show();    break;   }  }  } 

注解都写好了，核心的代码就是VIEwInjectUtils.inject(this)了~

(3)VIEwInjectUtils@H_419_2@A、首先是注入主布局文件的代码：@H_419_2@

/**   * 注入主布局文件   *   * @param activity   */  private static voID injectContentVIEw(Activity activity)  {   Class<? extends Activity> clazz = activity.getClass();   // 查询类上是否存在ContentVIEw注解   ContentVIEw contentVIEw = clazz.getAnnotation(ContentVIEw.class);   if (contentVIEw != null)// 存在   {    int contentVIEwLayoutID = contentVIEw.value();    try    {     Method method = clazz.getmethod(METHOD_SET_CONTENTVIEW,int.class);     method.setAccessible(true);     method.invoke(activity,contentVIEwLayoutID);    } catch (Exception e)    {     e.printstacktrace();    }   }  } 

通过传入的activity对象，获得它的Class类型，判断是否写了ContentVIEw这个注解，如果写了，读取它的value，然后得到setContentVIEw这个方法，使用invoke进行调用；@H_419_2@有个常量：@H_419_2@

private static final String METHOD_SET_CONTENTVIEW = "setContentVIEw"; 

B、接下来是注入VIEws@H_419_2@

private static final String METHOD_FIND_VIEW_BY_ID = "findVIEwByID";  /**   * 注入所有的控件   *   * @param activity   */  private static voID injectVIEws(Activity activity)  {   Class<? extends Activity> clazz = activity.getClass();   FIEld[] fIElds = clazz.getDeclaredFIElds();   // 遍历所有成员变量   for (FIEld fIEld : fIElds)   {        VIEwInject vIEwInjectAnnotation = fIEld      .getAnnotation(VIEwInject.class);    if (vIEwInjectAnnotation != null)    {     int vIEwID = vIEwInjectAnnotation.value();     if (vIEwID != -1)     {      Log.e("TAG",vIEwID+"");      // 初始化VIEw      try      {       Method method = clazz.getmethod(METHOD_FIND_VIEW_BY_ID,int.class);       Object resVIEw = method.invoke(activity,vIEwID);       fIEld.setAccessible(true);       fIEld.set(activity,resVIEw);      } catch (Exception e)      {       e.printstacktrace();      }      }    }    }   } 

获取声明的所有的属性，遍历，找到存在VIEwInject注解的属性，或者其value，然后去调用findVIEwByID方法，最后把值设置给fIEld~~~@H_419_2@好了，把这两个方法写到inject里面就好了。@H_419_2@

 public static voID inject(Activity activity)  {      injectContentVIEw(activity);   injectVIEws(activity);     } 

效果图：@H_419_2@

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

package com.zhy.zhy_xutils_test;  import androID.vIEw.VIEw; import androID.Widget.button; import androID.Widget.Toast;  import com.zhy.ioc.vIEw.annotation.ContentVIEw; import com.zhy.ioc.vIEw.annotation.OnClick; import com.zhy.ioc.vIEw.annotation.VIEwInject;  @ContentVIEw(value = R.layout.activity_main) public class MainActivity extends BaseActivity {  @VIEwInject(R.ID.ID_btn)  private button mBtn1;  @VIEwInject(R.ID.ID_btn02)  private button mBtn2;   @OnClick({ R.ID.ID_btn,R.ID.ID_btn02 })  public voID clickBtnInvoked(VIEw vIEw)  {   switch (vIEw.getID())   {   case R.ID.ID_btn:    Toast.makeText(this,"Inject Btn01 !",Toast.LENGTH_SHORT).show();    break;   case R.ID.ID_btn02:    Toast.makeText(this,"Inject Btn02 !",Toast.LENGTH_SHORT).show();    break;   }  }  } 

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

（1）注解文件@H_419_2@

package com.zhy.ioc.vIEw.annotation;  import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target;  @Target(ElementType.ANNOTATION_TYPE) @Retention(RetentionPolicy.RUNTIME) public @interface EventBase {  Class<?> ListenerType();   String ListenerSetter();   String methodname(); }  package com.zhy.ioc.vIEw.annotation;  import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target;  import androID.vIEw.VIEw;  @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) @EventBase(ListenerType = VIEw.OnClickListener.class,ListenerSetter = "setonClickListener",methodname = "onClick") public @interface OnClick {  int[] value(); } 

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

复制代码 代码如下:@H_419_2@ListenerType = VIEw.OnClickListener.class,methodname = "onClick"@H_419_2@

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

 @OnClick({ R.ID.ID_btn,R.ID.ID_btn02 })  public voID clickBtnInvoked(VIEw vIEw) 

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

public static voID inject(Activity activity)  {   injectContentVIEw(activity);   injectVIEws(activity);   injectEvents(activity);  } 

（2）injectEvents

/**   * 注入所有的事件   *   * @param activity   */  private static voID injectEvents(Activity activity)  {      Class<? extends Activity> clazz = activity.getClass();   Method[] methods = clazz.getmethods();   //遍历所有的方法   for (Method method : methods)   {    Annotation[] annotations = method.getAnnotations();    //拿到方法上的所有的注解    for (Annotation annotation : annotations)    {     Class<? extends Annotation> annotationType = annotation       .annotationType();     //拿到注解上的注解     EventBase eventBaseAnnotation = annotationType       .getAnnotation(EventBase.class);     //如果设置为EventBase     if (eventBaseAnnotation != null)     {      //取出设置监听器的名称，监听器的类型，调用的方法名      String ListenerSetter = eventBaseAnnotation        .ListenerSetter();      Class<?> ListenerType = eventBaseAnnotation.ListenerType();      String methodname = eventBaseAnnotation.methodname();       try      {       //拿到Onclick注解中的value方法       Method aMethod = annotationType         .getDeclaredMethod("value");       //取出所有的vIEwID       int[] vIEwIDs = (int[]) aMethod         .invoke(annotation,null);       //通过InvocationHandler设置代理       DynamicHandler handler = new DynamicHandler(activity);       handler.addMethod(methodname,method);       Object Listener = Proxy.newProxyInstance(         ListenerType.getClassLoader(),new Class<?>[] { ListenerType },handler);       //遍历所有的VIEw，设置事件       for (int vIEwID : vIEwIDs)       {        VIEw vIEw = activity.findVIEwByID(vIEwID);        Method setEventListenerMethod = vIEw.getClass()          .getmethod(ListenerSetter,ListenerType);        setEventListenerMethod.invoke(vIEw,Listener);       }       } catch (Exception e)      {       e.printstacktrace();      }     }     }   }   } 

嗯，注释尽可能的详细了，主要就是遍历所有的方法，拿到该方法省的OnClick注解，然后再拿到该注解上的EventBase注解，得到事件监听的需要调用的方法名，类型，和需要调用的方法的名称；通过Proxy和InvocationHandler得到监听器的代理对象，显示设置了方法，最后通过反射设置监听器。@H_419_2@这里有个难点，就是关于DynamicHandler和Proxy的出现，如果不理解没事，后面会详细讲解。

（3）DynamicHandler@H_419_2@这里用到了一个类DynamicHandler，就是InvocationHandler的实现类：@H_419_2@

package com.zhy.ioc.vIEw;  import java.lang.ref.WeakReference; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.util.HashMap;  public class DynamicHandler implements InvocationHandler {  private WeakReference<Object> handlerRef;  private final HashMap<String,Method> methodMap = new HashMap<String,Method>(    1);   public DynamicHandler(Object handler)  {   this.handlerRef = new WeakReference<Object>(handler);  }   public voID addMethod(String name,Method method)  {   methodMap.put(name,method);  }   public Object getHandler()  {   return handlerRef.get();  }   public voID setHandler(Object handler)  {   this.handlerRef = new WeakReference<Object>(handler);  }   @OverrIDe  public Object invoke(Object proxy,Method method,Object[] args)    throws Throwable  {   Object handler = handlerRef.get();   if (handler != null)   {    String methodname = method.getname();    method = methodMap.get(methodname);    if (method != null)    {     return method.invoke(handler,args);    }   }   return null;  } } 

好了，代码就这么多，这样我们就实现了，我们事件的注入~~@H_419_2@效果图：@H_419_2@

效果图其实没撒好贴的，都一样~~~@H_419_2@（3）关于代理@H_419_2@那么，本文结束了么，没有~~~关于以下几行代码，相信大家肯定有困惑，这几行干了什么？

//通过InvocationHandler设置代理       DynamicHandler handler = new DynamicHandler(activity);       handler.addMethod(methodname,handler); 

InvocationHandler和Proxy成对出现，相信大家如果对Java比较熟悉，肯定会想到Java的动态代理~~~@H_419_2@关于InvocationHandler和Proxy的文章，大家可以参考：http://www.ibm.com/developerworks/cn/java/j-lo-proxy1/ ps:IBM的技术文章还是相当不错的，毕竟有人审核还有奖金~@H_419_2@但是我们的实现有一定的区别，我为什么说大家疑惑呢，比如反射实现：@H_419_2@mBtn2.setonClickListener(this);这样的代码，难点在哪呢？@H_419_2@A、mBtn2的获取？so easy @H_419_2@B、调用setonClickListener ？ so easy @H_419_2@but,这个 this，这个this是OnClickListener的实现类的实例，OnClickListener是个接口~~你的实现类怎么整，听说过反射newInstance对象的，但是你现在是接口！@H_419_2@是吧~现在应该明白上述几行代码做了什么了？实现了接口的一个代理对象，然后在代理类的invoke中，对接口的调用方法进行处理。@H_419_2@（4）代码是最好的老师@H_419_2@光说谁都理解不了，你在这xx什么呢？？下面看代码，我们模拟实现这样一个情景：@H_419_2@Main类中实现一个button，button有两个方法，一个setonClickListener和onClick，当调用button的onClick时，触发的事件是Main类中的click方法@H_419_2@涉及到4个类：@H_419_2@button

package com.zhy.invocationhandler;  public class button {  private OnClickListener Listener;   public voID setonClicklisntener(OnClickListener Listener)  {    this.Listener = Listener;  }   public voID click()  {   if (Listener != null)   {    Listener.onClick();   }  } } 

OnClickListener接口

package com.zhy.invocationhandler;  public interface OnClickListener {  voID onClick(); } 

OnClickListenerHandler ， InvocationHandler的实现类

package com.zhy.invocationhandler;  import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.util.HashMap; import java.util.Map;  public class OnClickListenerHandler implements InvocationHandler {  private Object targetobject;   public OnClickListenerHandler(Object object)  {   this.targetobject = object;  }   private Map<String,Method> methods = new HashMap<String,Method>();   public voID addMethod(String methodname,Method method)  {   methods.put(methodname,method);  }   @OverrIDe  public Object invoke(Object proxy,Object[] args)    throws Throwable  {    String methodname = method.getname();   Method realMethod = methods.get(methodname);   return realMethod.invoke(targetobject,args);  }  } 

我们的Main

package com.zhy.invocationhandler;  import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.lang.reflect.Proxy;  public class Main {  private button button = new button();    public Main() throws SecurityException,IllegalArgumentException,NoSuchMethodException,illegalaccessexception,InvocationTargetException  {   init();  }   public voID click()  {   System.out.println("button clicked!");  }   public voID init() throws SecurityException,InvocationTargetException  {   OnClickListenerHandler h = new OnClickListenerHandler(this);   Method method = Main.class.getmethod("click",null);   h.addMethod("onClick",method);   Object clickProxy = Proxy.newProxyInstance(     OnClickListener.class.getClassLoader(),new Class<?>[] { OnClickListener.class },h);   Method clickMethod = button.getClass().getmethod("setonClicklisntener",OnClickListener.class);   clickMethod.invoke(button,clickProxy);     }   public static voID main(String[] args) throws SecurityException,InvocationTargetException  {    Main main = new Main();      main.button.click();  }  } 

我们模拟按钮点击：调用main.button.click()，实际执行的却是Main的click方法。@H_419_2@看init中，我们首先初始化了一个OnClickListenerHandler，把Main的当前实例传入，然后拿到Main的click方法，添加到OnClickListenerHandler中的Map中。@H_419_2@然后通过Proxy.newProxyInstance拿到OnClickListener这个接口的一个代理，这样执行这个接口的所有的方法，都会去调用OnClickListenerHandler的invoke方法。@H_419_2@但是呢？OnClickListener毕竟是个接口，也没有方法体~~那咋办呢？这时候就到我们OnClickListenerHandler中的Map中大展伸手了：@H_419_2@

@OverrIDe public Object invoke(Object proxy,Object[] args) throws Throwable { String methodname = method.getname(); Method realMethod = methods.get(methodname); return realMethod.invoke(targetobject,args); }

我们显示的把要执行的方法，通过键值对存到Map里面了，等调用到invoke的时候，其实是通过传入的方法名，得到Map中存储的方法，然后调用我们预设的方法~。@H_419_2@这样，大家应该明白了，其实就是通过Proxy得到接口的一个代理，然后在InvocationHandler中使用一个Map预先设置方法，从而实现button的onClick，和Main的click关联上。@H_419_2@现在看我们InjectEvents中的代码：

//通过InvocationHandler设置代理       DynamicHandler handler = new DynamicHandler(activity);       //往map添加方法       handler.addMethod(methodname,handler); 

是不是和我们init中的类似~~@H_419_2@好了，关于如何把接口的回调和我们Activity里面的方法关联上我们也解释完了~~~

注：部分代码参考了xUtils这个框架，毕竟想很完善的实现一个完整的注入不是一两篇博客就可以搞定，但是核心和骨架已经实现了~~大家有兴趣的可以继续去完善~

总结

以上是内存溢出为你收集整理的Android应用开发中控制反转IoC设计模式使用教程全部内容，希望文章能够帮你解决Android应用开发中控制反转IoC设计模式使用教程所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。