关于android:自定义Android-IOC框架

47次阅读

共计 8057 个字符，预计需要花费 21 分钟才能阅读完成。

一、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：不要说你应用一万个注解的话会怎么样？因为你不可能同时调用一万个办法吧。所以，性能方面能够释怀。

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

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

  1. 运行时注解就是就是运行时使用反射，动静获取对象、属性、办法等，个别的 IOC 框架就是这样，可能会就义一点效率。
  2. 编译时注解就是在程序编译时依据注解进行一些额定的操作，赫赫有名的 ButterKnife 使用的就是编译时注解,ButterKnife 在咱们编译时，就依据注解，主动生成了一些辅助类。要玩编译时注解呢，你得先依赖 apt，r 而后本人写一个类继承 AbstractProcessor, 重写 process 办法，在外面实现如何把配置或注解的信息变成所须要的类。

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

二、自定义 IOC 框架的应用

1. 应用阐明

(1) 类注解：

IContentView: 注入 ContentView

(2) 字段注解：

IView：注入 View

IString：注入 String

IColor：注入 Color

(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. 编写注入工具类

备用常识：

  1. 获取类：activity.getClass();
  2. 获取字段：activity.getDeclaredFields();
  3. 获取办法：activity.getDeclaredMethods();
  4. 判断是否存在某注解：isAnnotationPresent()
  5. 获取注解：getAnnotation()
  6. 获取注解的字段：annotation.value()，其余字段同理
  7. 设置某字段可读写：field.setAccessible(true);
  8. 批改对象的字段值：field.set(object，value);

思路剖析：

  1. 获取类注解、字段注解的值，依据该注解值，执行相干的操作：例如 setContentView(value)、findViewById(value)等。
  2. 获取办法注解的值，依据该注解值，生成动静代理类，调用 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);
    }
}

相干视频举荐

【AndroidIOC 框架设计】什么是 IOC？什么是 DI？
Android(安卓)开发零根底从入门到精通

本文转自 https://juejin.cn/post/6955771529342746638，如有侵权，请分割删除。

正文完
android
发表至： android
2021-11-29
 0
关于android:Android-金三银四战役打响我们该如何准备Android面试呢
关于android:做Android开发怎么才能不被淘汰kotlin语言就是你最好的选择
关于android:Android-Activity
关于android:有奖调研华为分析服务诚邀您参与您的真实反馈可以让我们变得更好