控制反转（Inversion of Control，英文缩写为IoC）是一个重要的面向对角编程的法则来削减计算机程序的耦合问题，也是轻量级的Spring框架的核心。 控制反转一般分为两种类型，依赖注入（Dependency Injection，简称DI）和依赖查找（Dependency Lookup）。依赖注入应用比较广泛。

通俗点讲什么是IOC呢？

很久很久以前，我们创建某件物品都是用双手在流水线上创建的，当我们有了机器后，这个机器就替代了人，帮助人创造物品，这个过程倒置了反转。在Android中，你获取控件，都需要自己手动获取，那么反转过来顾名思义就是程序自动获取控件。

相信在系统学习过Java Web的Spring框架的人对IOC应该一点也不陌生，那你们知道在Android中怎么应用吗，这可能设及的知识有点多，包括反射，Java注解类，设计模式之代理模式等知识。下面我将演示怎么运行IOC来获取控件，设置回调方法的应用。

1.在Android中获取控件

我们知道，Android手机界面的所有布局都配置在资源文件XML中，如果想要获取某个布局，一般情况下，我们是使用如下方法获取的：

setContentView(R.layout.activity_main);

现在我们来颠覆你对这个的应用，下面来看看应用IOC框架是怎么获取这个应用的。

①首先我们创建我们的注解类ContentView。

在Android Studio的创建流程如下：

㈠点击包名创建类

㈡选中注解类并创建

㈢与一个方法，获取等下传进来的ID

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface ContentView { int value();
}

@Target表示注解可以用于什么地方，这里用于类，其他参数如：FILED(成员)，METHOD(方法)，PACKAGE(包)，ANNOTATION_TYPE（注解的注解），CONSTRUCTOR（构造函数），PARAMETER（参数），LOCAL_VARIABLE（局部变更）

@Retention什么时候加载注解类，一般都是RetentionPolicy.RUNTIME运行的时候。

②新建一个注入工具类InjectUtils.class：

public class InjectUtils { public static final String ACTIVITY_MAIN_CONTENTVIEW="setContentView";

 /**
 * 注入所有
 * @param activity
 */
 public static void injectAll(Activity activity){ injectContentView(activity);
 } /**
 * 注入ContentView
 * @param activity
 */
 public static void injectContentView(Activity activity){ Class<? extends Activity> clazz = activity.getClass();//获取该类信息
 ContentView contentView = clazz.getAnnotation(ContentView.class);//获取该类ContentView的注解
 //如果有注解
 if(contentView!=null){ int viewId=contentView.value();//获取注解类参数
 try { Method method=clazz.getMethod(ACTIVITY_MAIN_CONTENTVIEW,int.class);//获取该方法的信息
 method.setAccessible(true);//获取该方法的访问权限
 method.invoke(activity,viewId);//调用该方法的，并设置该方法参数
 } catch (Exception e) { e.printStackTrace();
 } } }
}

注解虽然详细，有可能不写点，有的人理解method.invoke有点困难。下面我来解释一下。

method.invoke(activity,viewId);你可能这样理解，activity调用了method设置了viewID，如果还不够形象，看方法下面：

setContentView.invoke(MainActivity.this,R.layout.activity_main)这样虽然不伦不类，但是你应该理解了，就是invoke的第一个参数调用method方法，该方法的参数就是invoke的第二个参数。

获取注解类的参数，如下代码中：

@ContentView(R.layout.activity_main)
public class MainActivity extends AppCompatActivity { @Override
 protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState);
 InjectUtils.injectAll(MainActivity.this);
 }
}

@ContentView(R.layout.activity_main)中的R.layout.activity_main的值。然后用调用工具类调用设置其setContentView方法，这样布局文件就加载进来了。

运行后得到如下图所示：

2.用IOC加载控件

相信大家加载控件的方法，基本上都是千篇一律，如下所示：

this.but=(Button)findViewById(R.id.but);

假如现在有N个控件，估计你整个屏幕都被控件包围，写其他代码还需要滑动滚动条。这样是不是重复劳动是不是不值得？

下面我们来使用IOC框架来获取控件。

①创建注解类InjectControl，代码如下：

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface InjectControl { int value();
}

相信经过上面的介绍，这个很容易理解。

②在MainActivity配置注解类。

代码如下：

@InjectControl(value = R.id.content)
private TextView content;
@InjectControl(value = R.id.myBut1)
private Button myBut1;
@InjectControl(value = R.id.myBut2)
private Button myBut2;

③最后就是注入所有控件。

代码在InjectUtils中，如下：

public static final String ACTIVITY_MAIN_FINDVIEWBYID="findViewById";
/**
 *注入控件
 * @param activity
 */
public static void injectControl(Activity activity){ Class<? extends Activity> clazz = activity.getClass();//获取该类信息
 Field[] fields=clazz.getDeclaredFields();//获致所有成员变更
 for (Field field:fields) { InjectControl injectControl = field.getAnnotation(InjectControl.class);
 if(injectControl!=null){ int viewId=injectControl.value();
 try { Method method=clazz.getMethod(ACTIVITY_MAIN_FINDVIEWBYID, int.class);
 method.setAccessible(true);
 field.setAccessible(true);
 Object object=method.invoke(activity, viewId);
 field.set(activity,object);
 } catch (Exception e) { e.printStackTrace();
 } } }
}

这里几点需要解释一下，为什么用getDeclaredFields()获取成员变更，不用getFields()，因为getFields只能获取类中公有的成员变量，如果要获取包括私有的成员变量，就需要使用上面的方法，而我们定义的都是私有，故必须使用该方法，

这里调用了再次invoke的方法，一次是方法调用的，一次是成员变量调用的，为什么这样设计，因为，这里必须用二步才能完成。

我们就算直接调用findViewById也是两步，首先我们要调用this.findViewById()等到View后才赋值给某个变量，虽然看上去只有一条语句，但是却是两个部分。同理，我们必须调用activity.findViewById()方法获取到View后，才能把View赋值给field。所以这里有两步。

为了验证代码，我在MainActivity的onCreate()方法里面加入了如下代码：

if(myBut1!=null && myBut2!=null){ Toast.makeText(this,"按钮已经获取到了",Toast.LENGTH_SHORT).show();
}

运行结果如下：

其他的上面的解释了，这里就不在叙述了。下面难点来了。

3.给按钮设置点击监听事件

平常我们给按钮设置监听事件的代码如下：

this.myBut2.setOnClickListener(new View.OnClickListener() { @Override
 public void onClick(View v) { }
});

马上颠覆你的所见，步骤如下：

①创建注解类InjectOnClick。

代码如下：

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface InjectOnClick { int[] value();
}

你会发现，少了什么对吗？没错，接口类型，需要实现的方法，以及要调用设置的方法，这就需要下面第二步。

②设置注解类的注解类OnClickEvent。

代码如下：

@Target(ElementType.ANNOTATION_TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface OnClickEvent { Class<?> listenerType();//接口类型
 String listenerSetter();//设置的方法
 String methodName();//接口里面要实现的方法
}

修改InjectOnClick:

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@OnClickEvent(listenerType = View.OnClickListener.class,listenerSetter = "setOnClickListener",methodName = "onClick")
public @interface InjectOnClick { int[] value();
}

③在MainActivity里设置注解。

代码如下：

@InjectOnClick({R.id.myBut1,R.id.myBut2})
public void setButtonOnClickListener(View view){ switch (view.getId()){ case R.id.myBut1: Toast.makeText(this,"你好",Toast.LENGTH_SHORT).show();
 break;
 case R.id.myBut2: Toast.makeText(this,"我很帅",Toast.LENGTH_SHORT).show();
 break;
 default: break;
 }
}

④注入点击事件

代码在InjectUtils中，如下：

/**
 * 注入点击事件
 * @param activity
 */
public static void injectOnClickListener(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();//获取具体的注解类
 OnClickEvent onClickEvent = annotationType.getAnnotation(OnClickEvent.class);//取出注解的onClickEvent注解
 if(onClickEvent!=null){//如果不为空
 try { Method valueMethod=annotationType.getDeclaredMethod("value");//获取注解InjectOnClick的value方法
 int[] viewIds= (int[]) valueMethod.invoke(annotation,null);//获取控件值
 Class<?> listenerType = onClickEvent.listenerType();//获取接口类型
 String listenerSetter = onClickEvent.listenerSetter();//获取set方法
 String methodName = onClickEvent.methodName();//获取接口需要实现的方法
 MyInvocationHandler handler=new MyInvocationHandler(activity);//自己实现的代码，负责调用
 handler.setMethodMap(methodName,method);//设置方法及设置方法
 Object object= Proxy.newProxyInstance(listenerType.getClassLoader(),new Class<?>[]{listenerType},handler);//创建动态代理对象类
 for (int viewId:viewIds){//遍历要设置监听的控件
 View view=activity.findViewById(viewId);//获取该控件
 Method m=view.getClass().getMethod(listenerSetter, listenerType);//获取方法
 m.invoke(view,object);//调用方法
 } } catch (Exception e) { e.printStackTrace();
 } } } }
}

虽然注解很详细，但还是有必要说明一下：

㈠关于因为我们用的是Java的动态代理，每一个动态代理类都必须要实现InvocationHandler这个接口，并且每个代理类的实例都关联到了一个handler，当我们通过代理对象调用一个方法的时候，这个方法的调用就会被转发为由InvocationHandler这个接口的 invoke 方法来进行调用。我们来看看InvocationHandler这个接口的唯一一个方法invoke方法：

Object invoke(Object proxy, Method method, Object[] args) throws Throwable

proxy:　　指代我们所代理的那个真实对象
method:　　指代的是我们所要调用真实对象的某个方法的Method对象
args:　　指代的是调用真实对象某个方法时接受的参数

㈡Proxy这个类的作用就是用来动态创建一个代理对象的类，它提供了许多的方法，但是我们用的最多的就是newProxyInstance这个方法：

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException

loader:　　一个ClassLoader对象，定义了由哪个ClassLoader对象来对生成的代理对象进行加载

interfaces:　　一个Interface对象的数组，表示的是我将要给我需要代理的对象提供一组什么接口，如果我提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法了

h:　　一个InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上

㈢getFields()与getDeclaredFields()区别:getFields()只能访问类中声明为公有的字段,私有的字段它无法访问，能访问从其它类继承来的公有方法.getDeclaredFields()能访问类中所有的字段,与public,private,protect无关，不能访问从其它类继承来的方法 

getMethods()与getDeclaredMethods()区别:getMethods()只能访问类中声明为公有的方法,私有的方法它无法访问,能访问从其它类继承来的公有方法.getDeclaredFields()能访问类中所有的字段,与public,private,protect无关,不能访问从其它类继承来的方法

我们实现的InvocationHandler接口，代码如下：

public class MyInvocationHandler implements InvocationHandler { private Object object;
 private Map<String, Method> methodMap = new HashMap<String, Method>(1);
 public MyInvocationHandler(Object object) { this.object = object;
 } public void setMethodMap(String name, Method method) { this.methodMap.put(name, method);
 } @Override
 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { if (object != null) { String name = method.getName();
 method= this.methodMap.get(name);
 if (method != null) { return method.invoke(object, args);
 } } return null;
 }
}

这就不用我过多的注释了，因为，大部分代码与前面的并无不同，代理顾名思义就是帮你调用一些方法。

其代码难点就在这个代理里面，其他的代码与上面获取布局，控件一样，唯一不同的是这个代码用到了注释的注释，嵌套层级有点多，所以用到了许两层For循环，时间复杂度可能增加一个数量级，但这在手机上也是可以忽略不计的。

把方法加入InjectUtils的injectAll中。

/**
 * 注入所有
 * @param activity
 */
public static void injectAll(Activity activity){ injectContentView(activity);
 injectControl(activity);
 injectOnClickListener(activity);
}

运行效果如下：

4.看一下代码有多简洁

代码如下：

@ContentView(R.layout.activity_main)
public class MainActivity extends AppCompatActivity { @InjectControl(value = R.id.content) private TextView content;
 @InjectControl(value = R.id.myBut1) private Button myBut1;
 @InjectControl(value = R.id.myBut2) private Button myBut2;
 @Override
 protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState);
 InjectUtils.injectAll(MainActivity.this);
 } @InjectOnClick({R.id.myBut1,R.id.myBut2}) public void setButtonOnClickListener(View view){ switch (view.getId()){ case R.id.myBut1: Toast.makeText(this,"你好",Toast.LENGTH_SHORT).show();
 break;
 case R.id.myBut2: Toast.makeText(this,"我很帅",Toast.LENGTH_SHORT).show();
 break;
 default: break;
 } }
}

可能有的人会问，我用一句findViewById或者一句setOnClickListener就可以解决的事，没事给自己找这复杂的代码写，我是不是有病啊。可是你忽略了一点，一但我将这个代码打包，这代码就可能复用到我所有的项目中，如果，你只开发小项目或一个项目，这样写确实不划算，但是如果你总是换项目就算不换，增加新界面的时候，总是需要写findViewById,那么当累计的一定的数量时，这样写是一定节省很多时间的。

文章来源: liyuanjinglyj.blog.csdn.net，作者：李元静，版权归原作者所有，如需转载，请联系作者。

原文链接：liyuanjinglyj.blog.csdn.net/article/details/48653273