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

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 plain copy

1. @ContentView(value = R.layout.activity_main)  
2. public class MainActivity extends BaseActivity  
3. {  
4.     @ViewInject(R.id.id_btn)  
5.     private Button mBtn1;  
6.     @ViewInject(R.id.id_btn02)  
7.     private Button mBtn2;  

3、编码

1、定义注解

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

[java] view plain copy

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.TYPE)  
9. @Retention(RetentionPolicy.RUNTIME)  
10. public @interface ContentView  
11. {  
12.     int value();  
13. }  

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

[java] view plain copy

1. @ContentView(value = R.layout.activity_main)  
2. public class MainActivity  

[java] view plain copy

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.FIELD)  
9. @Retention(RetentionPolicy.RUNTIME)  
10. public @interface ViewInject  
11. {  
12.     int value();  
13. }  

在成员变量上使用，用于指定View的Id

[java] view plain copy

1. @ViewInject(R.id.id_btn)  
2.     private Button mBtn1;  

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

[java] view plain copy

1. public enum ElementType {  
2.     /** 
3.      * Class, interface or enum declaration. 
4.      */  
5.     TYPE,  
6.     /** 
7.      * Field declaration. 
8.      */  
9.     FIELD,  
10.     /** 
11.      * Method declaration. 
12.      */  
13.     METHOD,  
14.     /** 
15.      * Parameter declaration. 
16.      */  
17.     PARAMETER,  
18.     /** 
19.      * Constructor declaration. 
20.      */  
21.     CONSTRUCTOR,  
22.     /** 
23.      * Local variable declaration. 
24.      */  
25.     LOCAL_VARIABLE,  
26.     /** 
27.      * Annotation type declaration. 
28.      */  
29.     ANNOTATION_TYPE,  
30.     /** 
31.      * Package declaration. 
32.      */  
33.     PACKAGE  
34. }  

就是这些个枚举。

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

可能的类型：

[java] view plain copy

1. public enum RetentionPolicy {  
2.     /** 
3.      * Annotation is only available in the source code. 
4.      */  
5.     SOURCE,  
6.     /** 
7.      * Annotation is available in the source code and in the class file, but not 
8.      * at runtime. This is the default policy. 
9.      */  
10.     CLASS,  
11.     /** 
12.      * Annotation is available in the source code, the class file and is 
13.      * available at runtime. 
14.      */  
15.     RUNTIME  
16. }  

这些个枚举~

2、MainActivity

[java] view plain copy

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. }  

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

3、ViewInjectUtils

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

[java] view plain copy

1. /** 
2.      * 注入主布局文件 
3.      *  
4.      * @param activity 
5.      */  
6.     private static void injectContentView(Activity activity)  
7.     {  
8.         Class<? extends Activity> clazz = activity.getClass();  
9.         // 查询类上是否存在ContentView注解  
10.         ContentView contentView = clazz.getAnnotation(ContentView.class);  
11.         if (contentView != null)// 存在  
12.         {  
13.             int contentViewLayoutId = contentView.value();  
14.             try  
15.             {  
16.                 Method method = clazz.getMethod(METHOD_SET_CONTENTVIEW,  
17.                         int.class);  
18.                 method.setAccessible(true);  
19.                 method.invoke(activity, contentViewLayoutId);  
20.             } catch (Exception e)  
21.             {  
22.                 e.printStackTrace();  
23.             }  
24.         }  
25.     }  

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

有个常量：

[java] view plain copy

1. private static final String METHOD_SET_CONTENTVIEW = "setContentView";  

2、接下来是注入Views

[java] view plain copy

1. private static final String METHOD_FIND_VIEW_BY_ID = "findViewById";  
2.     /** 
3.      * 注入所有的控件 
4.      *  
5.      * @param activity 
6.      */  
7.     private static void injectViews(Activity activity)  
8.     {  
9.         Class<? extends Activity> clazz = activity.getClass();  
10.         Field[] fields = clazz.getDeclaredFields();  
11.         // 遍历所有成员变量  
12.         for (Field field : fields)  
13.         {  
14.               
15.             ViewInject viewInjectAnnotation = field  
16.                     .getAnnotation(ViewInject.class);  
17.             if (viewInjectAnnotation != null)  
18.             {  
19.                 int viewId = viewInjectAnnotation.value();  
20.                 if (viewId != -1)  
21.                 {  
22.                     Log.e("TAG", viewId+"");  
23.                     // 初始化View  
24.                     try  
25.                     {  
26.                         Method method = clazz.getMethod(METHOD_FIND_VIEW_BY_ID,  
27.                                 int.class);  
28.                         Object resView = method.invoke(activity, viewId);  
29.                         field.setAccessible(true);  
30.                         field.set(activity, resView);  
31.                     } catch (Exception e)  
32.                     {  
33.                         e.printStackTrace();  
34.                     }  
35.   
36.                 }  
37.             }  
38.   
39.         }  
40.   
41.     }  

获取声明的所有的属性，遍历，找到存在ViewInject注解的属性，或者其value，然后去调用findViewById方法，最后把值设置给field~~~

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

[java] view plain copy

1. public static void inject(Activity activity)  
2.     {  
3.           
4.         injectContentView(activity);  
5.         injectViews(activity);  
6.           
7.     }  

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

效果图：

源码点击下载