Android应用开发中控制反转IoC设计模式使用教程
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;
于是乎我们的目标类是这样的：
@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)定义注解
首先我们需要两个注解文件：
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需要使用的布局文件。
@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
@ViewInject(R.id.id_btn) private Button mBtn1;
简单说一下注解：定义的关键字@interface ; @Target表示该注解可以用于什么地方，可能的类型TYPE（类）,FIELD（成员变量）,可能的类型：
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表示：表示需要在什么级别保存该注解信息；我们这里设置为运行时。
可能的类型：
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
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
A、首先是注入主布局文件的代码：
/**
* 注入主布局文件
*
* @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进行调用；
有个常量：
private static final String METHOD_SET_CONTENTVIEW = "setContentView";
B、接下来是注入Views
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里面就好了。
public static void inject(Activity activity)
{
injectContentView(activity);
injectViews(activity);
}
效果图：
4.View的事件的注入
光有View的注入能行么，我们写View的目的，很多是用来交互的，得可以点击神马的吧。摒弃传统的神马，setOnClickListener，然后实现匿名类或者别的方式神马的，我们改变为：
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）注解文件
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这类注解上添加注解，毕竟事件很多，并且设置监听器的名称，监听器的类型，调用的方法名都是固定的，对应上面代码的：
listenerType = View.OnClickListener.class, listenerSetter = "setOnClickListener", methodName = "onClick"Onclick是用于写在Activity的某个方法上的：
@OnClick({ R.id.id_btn, R.id.id_btn02 })
public void clickBtnInvoked(View view)
如果你还记得，上篇博客我们的ViewInjectUtils.inject(this);里面已经有了两个方法，本篇多了一个：
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得到监听器的代理对象，显示设置了方法，最后通过反射设置监听器。
这里有个难点，就是关于DynamicHandler和Proxy的出现，如果不理解没事，后面会详细讲解。
（3）DynamicHandler
这里用到了一个类DynamicHandler，就是InvocationHandler的实现类：
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）关于代理
那么，本文结束了么，没有~~~关于以下几行代码，相信大家肯定有困惑，这几行干了什么？
//通过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);这样的代码，难点在哪呢？
A、mBtn2的获取？so easy
B、调用setOnClickListener ？ so easy
but , 这个 this，这个this是OnClickListener的实现类的实例，OnClickListener是个接口~~你的实现类怎么整，听说过反射newInstance对象的，但是你现在是接口！
是吧~现在应该明白上述几行代码做了什么了？实现了接口的一个代理对象，然后在代理类的invoke中，对接口的调用方法进行处理。
（4）代码是最好的老师
光说谁都理解不了，你在这xx什么呢？？下面看代码，我们模拟实现这样一个情景：
Main类中实现一个Button，Button有两个方法，一个setOnClickListener和onClick，当调用Button的onClick时，触发的事件是Main类中的click方法
涉及到4个类：
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, Method method, 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,
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中的代码：
//通过InvocationHandler设置代理
DynamicHandler handler = new DynamicHandler(activity);
//往map添加方法
handler.addMethod(methodName, method);
Object listener = Proxy.newProxyInstance(
listenerType.getClassLoader(),
new Class<?>[] { listenerType }, handler);
是不是和我们init中的类似~~
好了，关于如何把接口的回调和我们Activity里面的方法关联上我们也解释完了~~~
注：部分代码参考了xUtils这个框架，毕竟想很完善的实现一个完整的注入不是一两篇博客就可以搞定，但是核心和骨架已经实现了~~大家有兴趣的可以继续去完善~
-
1. 前言 通过第一章第二小节，我们已经可以使用 Spring 框架实现对自定义的 Java 对象管理，由 Spring 框架加载对象，实例化对象，放入容器。其实这就是 Spirng 的核心功能之 IoC，那么什么是 IoC 呢？什么又是容器呢？ 跟我来，一步步揭开他们的神秘面纱。 2. 什么是 IoC？ 来自百度百科的解释 —— 控制反转（IoC）： （Inversion of Control，
-
本文向大家介绍.NET IoC模式依赖反转(DIP)、控制反转(Ioc)、依赖注入(DI)，包括了.NET IoC模式依赖反转(DIP)、控制反转(Ioc)、依赖注入(DI)的使用技巧和注意事项，需要的朋友参考一下 依赖倒置原则(DIP) 依赖倒置(Dependency Inversion Principle,缩写DIP)是面向对象六大基本原则之一。他是指一种特定的的解耦形式,使得高层次的模块不依
-
本文向大家介绍JavaScript设计模式开发中组合模式的使用教程，包括了JavaScript设计模式开发中组合模式的使用教程的使用技巧和注意事项，需要的朋友参考一下 我们平时开发过程中，一定会遇到这种情况：同时处理简单对象和由简单对象组成的复杂对象，这些简单对象和复杂对象会组合成树形结构，在客户端对其处理的时候要保持一致性。比如电商网站中的产品订单，每一张产品订单可能有多个子订单组合，比如操作系
-
1. 前言 上一节，我们通过注解的方式，实现了 Spring 对于 bean 的管理，那么如何实现的，是否还记得呢，我们回顾一下 两个重要点： 1. 注解实例化的类上，需要使用一个注解 @Repository； 2.Spring 的配置文件中，需要使用组件扫描 <context:component-scan> 。 疑问导出： 组件扫描的作用我们清楚，是为了扫描路径之下带有注解的类，但是为什么类上面
-
本文向大家介绍使用Kotlin开发Android应用教程，包括了使用Kotlin开发Android应用教程的使用技巧和注意事项，需要的朋友参考一下 使用Kotlin开发Android应用 1、Kotlin介绍 [Kotlin](https://kotlinlang.org/) Kotlin是一门基于JVM的编程语言，它正成长为Android开发中用于替代Java语言的继承者。Java是世界上使用
-
1. 前言 本小节目的在于带领大家熟练 xml 文件配置， 应用 xml 文件配置 IoC。 在第二节中我们通过一个入门工程简单地体验了一把 Spring 的使用。在第三节中梳理了一下 Spring 的工作流程。 大家有了一个初步认知，Spring 框架的工作脱离不了核心配置文件 applicationContext.xml。 在配置文件中我们目前只用到了一个 bean 标签，它的作用是用于描述
-
最近在一次采访中，我解释了我所研究的一个框架。我说过，我们通过使用模板方法设计模式提供扩展性，创建了一个控制反转。我说这是一个控制反转的例子，我们的框架调用框架用户实现的方法，采访者说模板方法设计模式不是IOC的例子。我想知道我对国际奥委会的理解是否有误？
-
本文向大家介绍详解JavaScript设计模式开发中的桥接模式使用，包括了详解JavaScript设计模式开发中的桥接模式使用的使用技巧和注意事项，需要的朋友参考一下 桥接模式将抽象部分与实现部分分离开来，使两者都可以独立的变化，并且可以一起和谐地工作。抽象部分和实现部分都可以独立的变化而不会互相影响，降低了代码的耦合性，提高了代码的扩展性。 按照GoF的定义，桥接模式的作用在于“将抽象与其实现隔