一、IOC简单科普

所谓IOC，即控制反转（Inversion of Control，英文缩写为IoC）

假如你的一个类A里面需要用到很多个成员变量F1、F2等。

传统的写法:你要用这些成员变量，那么那你就new F1()、new F2()等。

IOC的原则却是：No！我们不要new，这样耦合度太高，一旦被依赖的F1、F2的构造方法有了变动，所有需要new F1()、new F2()的地方都需要修改！

根据这一原则，为了解耦依赖调用者(A)和依赖提供者（F1、F2等），IOC解耦的思路有两种： 1.写配置文件 2.使用注解

当然了，有了配置文件和注解，那么怎么注入呢？也就是如何把配置或注解的信息变成所需要的类呢？

OK，反射上场了！话说，很久很久以前，反射很慢啊，嗯，那是很久很久以前，现在已经不是太慢了，我简单测试了一下，一个反射大概需要2ms左右的时间吧，基本可以忽略不计。PS：不要说你使用一万个注解的话会怎么样？因为你不可能同时调用一万个方法吧。所以，性能方面可以放心。

正所谓：无反射，不框架！

而关于注解呢，又有两种方式：运行时注解、编译时注解。

运行时注解就是就是运行时运用反射，动态获取对象、属性、方法等，一般的IOC框架就是这样，可能会牺牲一点效率。
编译时注解就是在程序编译时根据注解进行一些额外的操作，大名鼎鼎的ButterKnife运用的就是编译时注解,ButterKnife在我们编译时，就根据注解，自动生成了一些辅助类。要玩编译时注解呢，你得先依赖apt，r然后自己写一个类继承AbstractProcessor,重写process方法，在里面实现如何把配置或注解的信息变成所需要的类。

比如Butterknife的实现方式：就是调用APT，用JavaFileObject在编译时根据注解创建了一个辅助类，也就是传说中代码生成器：用代码生成代码！

二、自定义IOC框架的使用

1.使用说明

(1) 类注解：

IContentView:注入ContentView

(2) 字段注解：

IView：注入View

IString：注入String

IColor：注入Colo

(3) 方法注解：

IClick：注入点击事件

(4) 工具类：

InjectUtil.bind(this):绑定Activity

InjectUtil.unbind(this):解绑Activity

2.示例代码

package com.che.baseutil;



import android.app.Activity;

import android.content.Intent;

import android.os.Bundle;

import android.view.View;

import android.widget.Button;

import android.widget.TextView;



import com.che.fast_ioc.InjectUtil;

import com.che.fast_ioc.annotation.IClick;

import com.che.fast_ioc.annotation.IColor;

import com.che.fast_ioc.annotation.IContentView;

import com.che.fast_ioc.annotation.IString;

import com.che.fast_ioc.annotation.IView;



import java.util.Random;



@IContentView(R.layout.activity_main)

public class MainActivity extends Activity {

    @IView(R.id.tv)

    TextView tv;

    @IView(R.id.bt)

    Button bt;

    @IString(R.string.text_home)

    String title;

    @IColor(R.color.turquoise)

    int turquoiseColor;

    @IColor(R.color.moccasin)

    int moccasinColor;

    private Random random;



    @Override

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        InjectUtil.bind(this);

        random = new Random();

        tv.setText(title);

        tv.setBackgroundColor(turquoiseColor);

        bt.setBackgroundColor(moccasinColor);

    }



    @Override

    protected void onDestroy() {

        InjectUtil.unbind(this);

        super.onDestroy();

    }



    @IClick({R.id.tv, R.id.bt})

    public void onClick(View view) {

        switch (view.getId()) {

            case R.id.tv:

                bt.setText(random.nextInt(100) + "");

                break;

            case R.id.bt:

                tv.setText("我要变");

                Intent intent = new Intent();

                intent.setAction(IntentKey.ACTIVITY_SECOND);

                startActivity(intent);

                break;

        }



    }

}

三、如何实现自定义IOC框架

1.定义你所需要的注解

注入布局：

@Target({ElementType.TYPE})

@Retention(RetentionPolicy.RUNTIME)

@Inherited

@Documented

public @interface IContentView {

    //默认字段，使用时：@IView(R.id.tv)

    int value();



    //其它字段，使用时：@IView(id=R.id.tv)

//    int id() default 0;

}

注入视图：

@Target({ElementType.FIELD})

@Retention(RetentionPolicy.RUNTIME)

@Inherited

@Documented

public @interface IView {

    int value();

注入字符串

@Target({ElementType.FIELD})

@Retention(RetentionPolicy.RUNTIME)

@Inherited

@Documented

public @interface IString {

    int value();

}

注入色值

@Target({ElementType.FIELD})

@Retention(RetentionPolicy.RUNTIME)

@Inherited

@Documented

public @interface IColor {

    int value();

}

注入点击事件

@Target({ElementType.METHOD})

@Retention(RetentionPolicy.RUNTIME)

@Inherited

@Documented

public @interface IClick {

    int[] value();

}

2.编写注入工具类

备用知识：

获取类：activity.getClass();
获取字段：activity.getDeclaredFields();
获取方法：activity.getDeclaredMethods();
判断是否存在某注解：isAnnotationPresent()
获取注解：getAnnotation()
获取注解的字段：annotation.value()，其他字段同理
设置某字段可读写：field.setAccessible(true);
修改对象的字段值：field.set(object，value);

* * *

思路分析：

获取类注解、字段注解的值，根据该注解值，执行相关的操作：例如setContentView(value)、findViewById(value)等。
获取方法注解的值，根据该注解值，生成动态代理类，调用setOnClickListener()等

package com.che.fast\_ioc;



import android.app.Activity;

import android.view.View;



import com.che.base\_util.LogUtil;

import com.che.fast\_ioc.annotation.IClick;

import com.che.fast\_ioc.annotation.IColor;

import com.che.fast\_ioc.annotation.IContentView;

import com.che.fast\_ioc.annotation.IString;

import com.che.fast\_ioc.annotation.IView;



import java.lang.annotation.Annotation;

import java.lang.reflect.Field;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;

import java.util.ArrayList;

import java.util.List;



/\*\*

 \* 注解工具类

 \* <p>

 \*/

public class InjectUtil {



    /\*\*

     \* 绑定

     \*

     \* @param activity

     \*/

    public static void bind(Activity activity) {

        Class<? extends Activity> clazz = activity.getClass();

        //处理类

        processType(activity, clazz);

        //遍历所有的字段

        for (Field field : clazz.getDeclaredFields()) {

            //处理字段

            processField(activity, field);

        }

        //遍历所有的方法

        for (Method method : clazz.getDeclaredMethods()) {

            //处理方法

            processMethod(activity, method);

        }

    }



    /\*\*

     \* 解绑

     \*

     \* @param activity

     \*/

    public static void unbind(Activity activity) {

        try {

            Class<? extends Activity> clazz = activity.getClass();

            //遍历所有的字段

            for (Field field : clazz.getDeclaredFields()) {

                LogUtil.print("field=" + field.getName() + "\t" + field.getType());

                //将所有字段置空

                boolean accessible = field.isAccessible();

                field.setAccessible(true);

                field.set(activity, null);

                field.setAccessible(accessible);

            }

        } catch (IllegalAccessException e) {

            e.printStackTrace();

        }

    }



    /\*\*

     \* 处理类注解

     \*/

    private static void processType(Activity activity, Class<? extends Activity> clazz) {

        List<Class<? extends Annotation>> annoList = new ArrayList<>();

        annoList.add(IContentView.class);



        for (Class<? extends Annotation> annotationType : annoList) {

            //判断是否存在IContentView注解

            if (clazz.isAnnotationPresent(annotationType)) {

                dispatchType(activity, clazz, annotationType);

            }

        }

    }



    /\*\*

     \* 分发类注解

     \*/

    private static void dispatchType(Activity activity, Class<? extends Activity> clazz, Class<? extends Annotation> annotationType) {

        if (annotationType == IContentView.class) {

            IContentView annotation = clazz.getAnnotation(IContentView.class);

            int value = annotation.value();

            activity.setContentView(value);

        }

    }



    /\*\*

     \* 处理字段注解

     \*/

    private static void processField(Activity activity, Field field) {

        List<Class<? extends Annotation>> annoList = new ArrayList<>();

        annoList.add(IView.class);

        annoList.add(IColor.class);

        annoList.add(IString.class);



        for (Class<? extends Annotation> annotationType : annoList) {

            if (field.isAnnotationPresent(annotationType)) {

                boolean accessible = field.isAccessible();

                field.setAccessible(true);

                dispatchFiled(activity, field, annotationType);

                field.setAccessible(accessible);

            }

        }

    }



    /\*\*

     \* 分发字段注解

     \*/

    private static void dispatchFiled(Activity activity, Field field, Class<?> annotationType) {

        try {

            if (annotationType == IView.class) {

                IView anno = field.getAnnotation(IView.class);

                int value = anno.value();

                field.set(activity, activity.findViewById(value));

            }

            if (annotationType == IString.class) {

                IString anno = field.getAnnotation(IString.class);

                int value = anno.value();

                field.set(activity, activity.getString(value));

            }

            if (annotationType == IColor.class) {

                IColor anno = field.getAnnotation(IColor.class);

                int value = anno.value();

                field.set(activity, activity.getResources().getColor(value));

            }

        } catch (IllegalAccessException e) {

            e.printStackTrace();

        }



    }



    /\*\*

     \* 处理方法注解

     \*/

    private static void processMethod(Activity activity, Method method) {

        List<Class<? extends Annotation>> annoList = new ArrayList<>();

        annoList.add(IClick.class);



        for (Class<? extends Annotation> annotationType : annoList) {

            //判断是否存在IContentView注解

            if (method.isAnnotationPresent(annotationType)) {

                dispatchMethod(activity, method, annotationType);

            }

        }

    }



    /\*\*

     \* 分发方法注解

     \*/

    private static void dispatchMethod(Activity activity, Method method, Class<? extends Annotation> annotationType) {

        try {

            if (annotationType == IClick.class) {

                IClick annotation = method.getAnnotation(IClick.class);

                // 获取注解里面的id

                int[] ids = annotation.value();

                // 当有注解的时候生成动态代理

                ClassLoader classLoader = View.OnClickListener.class.getClassLoader();

                Class<?>[] interfaces = {View.OnClickListener.class};

                Object proxy = Proxy.newProxyInstance(classLoader, interfaces, new DynaHandler(activity, method));

                for (int id : ids) {

                    View view = activity.findViewById(id);

                    Method onClickMethod = view.getClass().getMethod("setOnClickListener", View.OnClickListener.class);

                    // 调用setOnClickListener方法回调在动态类里面

                    onClickMethod.invoke(view, proxy);

                }

            }

        } catch (NoSuchMethodException e) {

            e.printStackTrace();

        } catch (IllegalAccessException e) {

            e.printStackTrace();

        } catch (InvocationTargetException e) {

            e.printStackTrace();

        }

    }

}

3.方法注解的动态代理类

/\*\*

 \* 动态代理，调用activity里面的method：例如：onClick等

 \* <p>

 \*/

public class DynaHandler implements InvocationHandler {



    private Activity activity;

    private Method method;



    public DynaHandler(Activity activity, Method method) {

        this.activity = activity;

        this.method = method;

    }



    @Override

    public Object invoke(Object o, Method method, Object[] args) throws Throwable {

        // 这里调用动态注入的方法

        return this.method.invoke(activity, args);

    }

}

文章来源于互联网:自定义Android IOC框架

阅读全文

下载说明：
1、本站所有资源均从互联网上收集整理而来，仅供学习交流之用，因此不包含技术服务请大家谅解！
2、本站不提供任何实质性的付费和支付资源，所有需要积分下载的资源均为网站运营赞助费用或者线下劳务费用！
3、本站所有资源仅用于学习及研究使用，您必须在下载后的24小时内删除所下载资源，切勿用于商业用途，否则由此引发的法律纠纷及连带责任本站和发布者概不承担！
4、本站站内提供的所有可下载资源，本站保证未做任何负面改动（不包含修复bug和完善功能等正面优化或二次开发），但本站不保证资源的准确性、安全性和完整性，用户下载后自行斟酌，我们以交流学习为目的，并不是所有的源码都100%无错或无bug！如有链接无法下载、失效或广告，请联系客服处理！
5、本站资源除标明原创外均来自网络整理，版权归原作者或本站特约原创作者所有，如侵犯到您的合法权益，请立即告知本站，本站将及时予与删除并致以最深的歉意！
6、如果您也有好的资源或教程，您可以投稿发布，成功分享后有站币奖励和额外收入！
7、如果您喜欢该资源，请支持官方正版资源，以得到更好的正版服务！
8、请您认真阅读上述内容，注册本站用户或下载本站资源即您同意上述内容！
原文链接：https://www.dandroid.cn/archives/21139，转载请注明出处。

自定义Android IOC框架

一、IOC简单科普

二、自定义IOC框架的使用

1.使用说明

2.示例代码

三、如何实现自定义IOC框架

1.定义你所需要的注解

2.编写注入工具类

3.方法注解的动态代理类

评论0

在线客服

升级VIP

返回顶部

自定义Android IOC框架

一、IOC简单科普

二、自定义IOC框架的使用

1.使用说明

2.示例代码

三、如何实现自定义IOC框架

1.定义你所需要的注解

2.编写注入工具类

3.方法注解的动态代理类

猜你喜欢

评论0

在线客服

升级VIP

返回顶部