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;

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

  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、定义注解

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

  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需要使用的布局文件。
  1. @ContentView(value = R.layout.activity_main)  
  2. public class MainActivity  

  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
  1. @ViewInject(R.id.id_btn)  
  2.     private Button mBtn1;  

简单说一下注解:定义的关键字@interface ; @Target表示该注解可以用于什么地方,可能的类型TYPE(类),FIELD(成员变量),可能的类型:
  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表示:表示需要在什么级别保存该注解信息;我们这里设置为运行时。

可能的类型:

  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

  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、首先是注入主布局文件的代码:

  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进行调用;

有个常量:

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

2、接下来是注入Views
  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里面就好了。

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

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


效果图:



源码点击下载

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值