教你打造 Android 中的 IOC 框架

最新推荐文章于 2021-06-25 20:02:33 发布

转载最新推荐文章于 2021-06-25 20:02:33 发布 · 571 阅读

本文详细阐述了AndroidIOC框架的核心概念，包括控制反转（IoC）的原理和实现方式，以及如何通过注解和配置文件实现组件的自动注入。进一步介绍了如何简化事件监听的代码，避免传统实现中的繁琐操作，最终通过示例展示了如何通过代理和反射技术实现接口回调与Activity方法的关联。文章最后提供了代码实现的示例和关键点解析，帮助开发者深入理解并实践Android框架中的依赖注入和事件处理机制。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1、概述

首先我们来吹吹牛，什么叫IoC，控制反转（Inversion of Control，英文缩写为IoC），什么意思呢？

就是你一个类里面需要用到很多个成员变量，传统的写法，你要用这些成员变量，那么你就new 出来用呗~~

IoC的原则是：NO，我们不要new，这样耦合度太高；你配置个xml文件，里面标明哪个类，里面用了哪些成员变量，等待加载这个类的时候，我帮你注入（new）进去；

这样做有什么好处呢？

回答这个问题，刚好可以回答另一个问题，很多人问，项目分层开发是吧，分为控制层、业务层、DAO层神马的。然后每一层为撒子要一个包放接口，一个包放实现呢？只要一个实现包不行么~刚好，如果你了解了IoC，你就知道这些个接口的作用了，上面不是说，你不用new，你只要声明了成员变量+写个配置文件，有人帮你new；此时，你在类中，就可以把需要使用到的成员变量都声明成接口，然后你会发现，当实现类发生变化的时候，或者切换实现类，你需要做什么呢？你只要在配置文件里面做个简单的修改。如果你用的就是实实在在的实现类，现在换实现类，你需要找到所有声明这个实现类的地方，手动修改类名；如果你遇到了一个多变的老大，是吧，呵呵~

当然了，很多会觉得，写个配置文件，卧槽，这多麻烦。于是乎，又出现了另一种方案，得，你闲配置文件麻烦，你用注解吧。你在需要注入的成员变量上面给我加个注解，例如：@Inject，这样就行了，你总不能说这么个单词麻烦吧~~

当然了，有了配置文件和注解，那么怎么注入呢？其实就是把字符串类路径变成类么，当然了，反射上场了；话说，很久很久以前，反射很慢啊，嗯，那是很久很久以前，现在已经不是太慢了，当然了肯定达不到原生的速度~~无反射，没有任何框架。

如果你觉得注解，反射神马的好高级。我说一句：Just Do It ，你会发现注解就和你写一个普通JavaBean差不多；反射呢？API就那么几行，千万不要被震慑住~

2、框架实现

得进入正题了，Android IOC框架，其实主要就是帮大家注入所有的控件，布局文件什么的。如果你用过xUtils，afinal类的框架，你肯定不陌生~

注入View

假设：我们一个Activity，里面10来个View。

传统做法：我们需要先给这个Activity设置下布局文件，然后在onCreate里面一个一个的findViewById把~

目标的做法：Activity类上添加个注解，帮我们自动注入布局文科；声明View的时候，添加一行注解，然后自动帮我们findViewById;

于是乎我们的目标类是这样的：

[java]view plaincopy 
   
 @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、编码

1、定义注解

首先我们需要两个注解文件：

[java]view plaincopy 
   
 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需要使用的布局文件。

[java]view plaincopy 
   
 @ContentView(value = R.layout.activity_main)  
 public class MainActivity  

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

[java]view plaincopy 
   
 @ViewInject(R.id.id_btn)  
     private Button mBtn1;  

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

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

就是这些个枚举。

@Retention表示：表示需要在什么级别保存该注解信息；我们这里设置为运行时。

可能的类型：

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

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

1、首先是注入主布局文件的代码：

[java]view plaincopy 
   
 /** 
      * 注入主布局文件 
      *  
      * @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进行调用；

有个常量：

[java]view plaincopy 
   
 private static final String METHOD_SET_CONTENTVIEW = "setContentView";  

2、接下来是注入Views

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

好了，把这两个方法写到inject里面就好了。

[java]view plaincopy 
   
 public static void inject(Activity activity)  
     {  
           
         injectContentView(activity);  
         injectViews(activity);  
           
     }  

本文主要了解了如何打造这么个框架，下一篇，将教大家如何注入事件，不要再写什么setXXXListener了~~~

效果图：

1、目标效果

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

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

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

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

2、实现

1、注解文件

[java]view plaincopy 
   
 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();  
 }  

[java]view plaincopy 
   
 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这类注解上添加注解，毕竟事件很多，并且设置监听器的名称，监听器的类型，调用的方法名都是固定的，对应上面代码的：

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

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

[java]view plaincopy 
   
 @OnClick({ R.id.id_btn, R.id.id_btn02 })  
     public void clickBtnInvoked(View view)  

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

[java]view plaincopy 
   
 public static void inject(Activity activity)  
     {  
         injectContentView(activity);  
         injectViews(activity);  
         injectEvents(activity);  
     }  

2、injectEvents

[java]view plaincopy 
   
 /** 
      * 注入所有的事件 
      *  
      * @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得到监听器的代理对象，显示设置了方法，最后通过反射设置监听器。

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

3、DynamicHandler

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

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

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

效果图：

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

3、关于代理

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

[java]view plaincopy 
   
 //通过InvocationHandler设置代理  
                         DynamicHandler handler = new DynamicHandler(activity);  
                         handler.addMethod(methodName, method);  
                         Object listener = Proxy.newProxyInstance(  
                                 listenerType.getClassLoader(),  
                                 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 
   
 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接口

[java]view plaincopy 
   
 package com.zhy.invocationhandler;  
   
 public interface OnClickListener  
 {  
     void onClick();  
 }  

OnClickListenerHandler ， InvocationHandler的实现类

[java]view plaincopy 
   
 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, Method method, Object[] args)  
             throws Throwable  
     {  
   
         String methodName = method.getName();  
         Method realMethod = methods.get(methodName);  
         return realMethod.invoke(targetObject, args);  
     }  
   
 }  

我们的Main

[java]view plaincopy 
   
 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,  
             NoSuchMethodException, IllegalArgumentException,  
             IllegalAccessException, 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,  
             IllegalArgumentException, NoSuchMethodException,  
             IllegalAccessException, InvocationTargetException  
     {  
   
         Main main = new Main();  
           
         main.button.click();  
     }  
   
 }  

我们模拟按钮点击：调用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 
   
 //通过InvocationHandler设置代理  
                         DynamicHandler handler = new DynamicHandler(activity);  
                         //往map添加方法  
                         handler.addMethod(methodName, method);  
                         Object listener = Proxy.newProxyInstance(  
                                 listenerType.getClassLoader(),  
                                 new Class<?>[] { listenerType }, handler);  