都说依赖注入，我就从实现的角度来一发，以android作为引子..

最新推荐文章于 2021-12-09 20:58:35 发布
最新推荐文章于 2021-12-09 20:58:35 发布
阅读量4.5k 收藏 3
点赞数
分类专栏： 点滴纪录 技术心得 文章标签： android 框架 class 注解 反射
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_15545283/article/details/51453135
版权

用过诸多的view注入的框架，例如xutils,butterknife,KJLibraray,Guice等，你了解过如何实现吗？
从零来一发， 今天老司机为新来者带带路~其他老司机略过
从demo上，我只实现两个功能@InjectView,@OnClick。前者注入view,后者注入点击事件。其他的实现角度上是一样的，大家可以一起探讨一下！

还是老套路，先分析：
1.我需要两个注解类@InjectView和@OnClick

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface InjectView {
    public @IdRes int value();
}
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface OnClick {
    public @IdRes int[] value();
}

简单提一下：
@Target的ElementType中

public enum ElementType {


    TYPE,  //加在类上的注解

    FIELD,  //加在类中属性上的注解

    METHOD, //加在类中方法上的注解

    PARAMETER, //加在参数上的注解，可以是方法内的参数

    CONSTRUCTOR, //加在构造函数上的注解

    LOCAL_VARIABLE, //加在方法内变量上的注解

    ANNOTATION_TYPE,
 //加在注解上的注解
    PACKAGE
        //加在包名上的注解
    }

@Retention中：

public enum RetentionPolicy {

    SOURCE, //只保留在源码中

    CLASS, //保留在类字节码中

    RUNTIME //保留在运行时（我们自定义注解一般都是在运行时检测的）
}

ok,继续，
@InjectView中只接收一个int类型的值，用于表示view的id,
@OnClick中接收一个int[]，表示可以接收多个view的id,绑定到同一个click执行方法上

既然有了注解，就少不了注解的解释者，
先分析一个view赋值的过程：

1. 首先要有一个rootView，用于findView
2. 还需要有目标view的id,这个就是@InjectView中的值
3. 需要目标对象
4. 把从rootView找到的view赋值给目标对象的目标变量

ok,看代码

public class InjectViewProcessor implements ProcessorIntf<Field>{
    @Override
    public boolean accept(AnnotatedElement e) {
        return e.isAnnotationPresent(InjectView.class);
    }

    @Override
    public void process(Object object, View view, Field field) {
        InjectView iv = field.getAnnotation(InjectView.class);
        final int viewId = iv.value();
        final View v = view.findViewById(viewId);
        field.setAccessible(true);
        try {
            field.set(object, v);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }
}

怎么还实现了一个接口呢？

public interface ProcessorIntf<T extends AnnotatedElement> {
    public boolean accept(AnnotatedElement t);

    public void process(Object object, View view, T t);
}

这个泛型接口接收一个AnnotatedElement的子类，它是什么呢？
在java中，Field,Method,Constructor…一切可注解的对象都实现了AnnotatedElement接口。ProcessorIntf用于给解析器提供一系列通用行为：

/*
 * 每个不同的处理器都会通过这个方法来告诉最终的调度者，这个注解是否由我来
 * 处理 
 */
public boolean accept(AnnotatedElement t);

process方法换个角度一想，无论是@InjectView,@InjectString,@OnClick等等任何注入的操作，是不是应该都需要这几个条件呢？所以：

/*这样看来，可以把处理行为抽象成这几个参数？
 *第一个object是目标对象，
 *第二个view是根view
 *第三个是加上注解的那个东西
 */
public void process(Object object, View view, T e);

所以在InjectViewProcessor中是这样实现的：

@Override
public boolean accept(AnnotatedElement e) {
//如果当前这个AnnotatedElement实例加有InjectView注解，则返回true
   return e.isAnnotationPresent(InjectView.class);
}

如果是返回true，说明这个它可以处理，则走到

@Override
    public void process(Object object, View view, Field field) {
        InjectView iv = field.getAnnotation(InjectView.class);
        final int viewId = iv.value();
        final View v = view.findViewById(viewId);
        field.setAccessible(true);
        try {
            field.set(object, v);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }

代码很简单，就简单说明下：

1.先拿到具体的注解类，并拿到里面的值比如R.id.txt等
2.从跟view中findViewById拿到指定的view
3.为防止目标属性是private的，将可访问设置为true,并赋值
-.ok,这样一个view就被注入到目标属性中了

接着再分析@OnClick的实现：

1.我需要知道要绑定点击事件的view的id，这个在@OnClick中的value指定
2.和之前的一样，也需要一个根view来拿到具体的view
3.要注入的对象，这个是必须的，
4.要把某个方法绑定为点击事件的回调，我还要知道是哪个方法
5.ok上述的条件都满足后，就可以拿到find来的view并设置setOnClickListener,在收到回调的时候，去调用指定方法，来实现间接的绑定

好了，分析就到这里面，看代码：

public class OnClickProcessor implements ProcessorIntf<Method> {
    @Override
    public boolean accept(AnnotatedElement e) {
        return e.isAnnotationPresent(OnClick.class);
    }

    @Override
    public void process(Object object,View view, Method method) {
        final OnClick oc = method.getAnnotation(OnClick.class);
        final int[] value = oc.value();
        for (int id : value) {
            view.findViewById(id).setOnClickListener(new InvokeOnClickListener(method,object));
        }
    }


    private static class InvokeOnClickListener implements View.OnClickListener {

        public Method method;
        public WeakReference<Object> obj;
        private boolean hasParam;

        InvokeOnClickListener(Method m, Object object) {
            this.method = m;
            this.obj = new WeakReference<Object>(object);
            final Class<?>[] parameterTypes = method.getParameterTypes();
            if (parameterTypes == null || parameterTypes.length == 0) {
                hasParam = false;
            } else if (parameterTypes.length > 1 || !View.class.isAssignableFrom(parameterTypes[0])) {
                throw new IllegalArgumentException(String.format("%s方法只能拥有0个或一个参数，且只接收View", m.getName()));
            } else {
                hasParam = true;
            }
        }

        @Override
        public void onClick(View v) {
            //点击事件触发了
            Object o = obj.get();
            if (o != null) {
                try {
                    if (hasParam) {
                        method.invoke(o, v);
                    } else {
                        method.invoke(o);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

再来分析代码：

//这个很简单，就是告诉管理器我响应OnClick注解
 @Override
    public boolean accept(AnnotatedElement e) {
        return e.isAnnotationPresent(OnClick.class);
    }
/*
* 这个也还是一样，
* 1.先拿到具体的注解对象 ，并拿到里面的值
* 2.因为存在多个id绑定到一个方法上的情况，所以一个循环不可少
* 3.就是拿到view,设置监听事件
* 4.但是，这个InvokeOnClickListener是个什么东西呢？
*/
@Override
    public void process(Object object,View view, Method method) {
        final OnClick oc = method.getAnnotation(OnClick.class);
        final int[] value = oc.value();
        for (int id : value) {
            view.findViewById(id).setOnClickListener(new InvokeOnClickListener(method,object));
        }
    }
//先说下，这里面的InvokeOnClickListener是一个中间件，注册给系统，系统在得到点击事件后，通知给InvokeOnClickListener，在这个里面再调用你所指定的方法。

private static class InvokeOnClickListener implements View.OnClickListener {

        public Method method;
        public WeakReference<Object> obj;
        private boolean hasParam;

        InvokeOnClickListener(Method m, Object object) {
            this.method = m;
            this.obj = new WeakReference<Object>(object);
            final Class<?>[] parameterTypes = method.getParameterTypes();
            if (parameterTypes == null || parameterTypes.length == 0) {
                hasParam = false;
            } else if (parameterTypes.length > 1 || !View.class.isAssignableFrom(parameterTypes[0])) {
                throw new IllegalArgumentException(String.format("%s方法只能拥有0个或一个参数，且只接收View", m.getName()));
            } else {
                hasParam = true;
            }
        }

        @Override
        public void onClick(View v) {
            //点击事件触发了
            Object o = obj.get();
            if (o != null) {
                try {
                    if (hasParam) {
                        method.invoke(o, v);
                    } else {
                        method.invoke(o);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

ok，构造函数中，拿到了要回调的方法，和目标对象。这是必须的。
然后就是几个简单的判断 ：
1.先拿到方法的参数，看看有没有参数 ， 没有就纪录下hasParam为false,
2.有参数的话，判断是几个参数，超过两个了直接就报错吧，那多的参数我从哪里给呢。
3.ok很听话的只接收一个View，hasParam为true

        @Override
        public void onClick(View v) {
            //点击事件触发了
            Object o = obj.get(); //为什么要用一个WeakReference,其实没有必要，因为activity消亡了，view也就消亡了，这个循环引用似乎不存在，但是我还是写下，假如有假如呢。
            if (o != null) {
                try {
                    if (hasParam) { //有参数，就把view传过去
                        method.invoke(o, v);
                    } else { //没有参数就直接调
                        method.invoke(o);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }

ok,InjectView和OnClick到这里就已经完工了， 但是直接拿来用，却是有点不方便的，于是加一个管理者：

public class Injector {

    private static List<? extends ProcessorIntf<? extends AccessibleObject>> chain = Arrays.asList(new InjectViewProcessor(), new OnClickProcessor());

    public static void inject(Activity act) {
        inject(act,act.getWindow().getDecorView());
    }

    public static void inject(Object obj, View rootView) {
        final Class<?> aClass = obj.getClass();
        final Field[] declaredFields = aClass.getDeclaredFields();
        for (Field f : declaredFields) {
           doChain(obj,f,rootView);
        }
        final Method[] declaredMethods = aClass.getDeclaredMethods();
        for (Method m : declaredMethods) {
            doChain(obj, m, rootView);
        }
    }

    private static void doChain(Object obj,AccessibleObject ao, View rootView) {
            for (ProcessorIntf p : chain) {
                if(p.accept(ao)) p.process(obj,rootView,ao);
            }
    }
}

管理者很简单，提供了两个静态方法，一个给activity用， 一个可以给fragment,viewholder等任何对象用。其实最终用的也是同一个方法。
这里我用了一个处理器链的方式，假如后面我还要实现注入@string/xx，@color/xxx , @Service private WindowManager wm;等等等，把实现好的处理器加入到chain链中即可。

//这个就是前面已经说过的，把每个遍历到的方法或者属性，甚至是构造方法，类等等通过处理器链来询问这个注解你accept吗？接受则交给它来处理，
private static void doChain(Object obj,AccessibleObject ao, View rootView) {
            for (ProcessorIntf p : chain) {
                if(p.accept(ao)) p.process(obj,rootView,ao);
            }
    }
}

好了，长篇大论结束，最后贴下最终的调用：

public class TestActivity extends AppCompatActivity {

    @InjectView(R.id.txt)
    private TextView txt;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.test_activity);
        Injector.inject(this);
    }


    @OnClick({R.id.btnTestOne,R.id.btnTestTwo})
    public void btnTestOne(Button view) {
        final int id = view.getId();
        if (id == R.id.btnTestOne) {
            txt.setText("按钮一被点击");
        }else{
            txt.setText("按钮二被点击");
        }

    }

}

ok，如果我要实现一个注入contentView怎么办呢？

留给读者。

a_blesslp
关注
专栏目录
Android中的依赖注入
LWJAVA的专栏
04-04 940
前言 最近在重构项目，用到依赖注入，查了很多资料，这里主要是记录一下自己的理解。 正文 依赖注入的优势： 1.代码的可复用性 2.便于重构 3.易于测试 什么是依赖注入? 依赖注入(DI)是一种广泛的应用编程的技术，非常适合Android开发，通过遵循DI的原则，您可以为良好的应用程序架构打下基础。 类通常需要对其他类的引用, 举个例子，Car(汽车)类可能需要对Eng...
android中的依赖注入
duanzeshan的博客
12-05 361
Annotation（注解）就是Java提供了一种元程序中的元素关联任何信息和着任何元数据（metadata）的途径和方法。Annotion(注解)是一个接口，程序可以通过反射来获取指定程序元素的 Annotion对象，然后通过 Annotion对象 来获取注解里面的元数据。        Annotation（注解）是JDK5.0及以后版本引入的。它可以用于创建文档，跟踪代码中的依赖性，甚
Android Dagger依赖注入框架浅析
热门推荐
快乐de胖虎
07-12 1万+
今天接触了Dagger这套android的依赖注入框架（DI框架），感觉跟Spring 的IOC差不多吧。这个框架它的好处是它没有采用反射技术（Spring是用反射的）,而是用预编译技术，因为基于反射的DI非常地耗用资源（空间，时间） 由于现在开发都是用Android Studio了，所以我这里大概讲下配置Dagger框架的开发环境，需要怎么做。 （由于Android Studio中用Grad...
Android 中的依赖注入框架
追风筝的吃货，汪～
11-20 720
Android 中的依赖注入框架 原文链接 : Dependency Injection on Android 原文作者 : Just Eat 译文出自 : 开发技术前线 www.devtf.cn。未经允许，不得转载! 译者 : chaossss 校对者: chaossss 状态 : 完成 09年我刚开发 App 那会，情况和现在不太一样。App 作为新生
浅析android中的依赖注入
weixin_34273046的博客
08-01 154
这几年针对Android推出了不少View注入框架,例如ButterKnife。我们首先来了解一下使用这些框架有什么好处，其实好处很明显：它可以减少大量的findViewById以及setOnClickListener代码，简化了代码，让我们的代码看起来条理更清晰，可读性变强。 可能大多数对于这一类框架，都只是停留在用的阶段，但是作为一个程序员，我们有必要去了解它是如何实现的。其实它...
一发一收通信示例.md
最新发布
01-05
当涉及到 TCP 通信时，一般有两种常见的通信模式：一发一收和多发多收。
Hilt依赖注入
qq_40014062的博客
12-16 1011
控制反转（IOC） 如果一个类A 的功能实现需要借助于类B，那么就称类B是类A的依赖，如果在类A的内部去实例化类B，那么两者之间会出现较高的耦合，一旦类B出现了问题，类A也需要进行改造，如果这样的情况较多，每个类之间都有很多依赖，那么就会出现牵一发而动全身的情况，程序会极难维护，并且很容易出现问题。要解决这个问题，就要把A类对B类的控制权抽离出来，交给一个第三方去做，把控制权反转给第三方，就称作控制反转（IOC Inversion Of Control）。控制反转是一种思想，是能够解决问题的一种可能的结果
VB.net 网络通信（一收一发，包通）.rar
03-23
VB.net 网络通信（一收一发，包通），非常短小，适合初学者 Imports System.Net.Sockets Imports System.Net Imports System.Text Public Class Form1 Private Sub Form1_Load(sender As Object, e As ...
si4464.7z实现了一收一发，移植方便
05-22
总的来说，这个项目提供了一个基于Si4464无线收发器的解决方案，具有灵活的引脚配置、SPI接口和易移植的代码，适合开发2.4GHz无线通信产品。开发者可以根据自身需求，调整IO引脚、SPI设置以及移植代码，快速地将无线...
Spring框架依赖注入
m0_58984702的博客
12-09 317
1.什么是spring框架? Spring是分层的 Java SE/EE应用 full-stack 轻量级开源框架，以 IoC（Inverse Of Control：反转控制）和 AOP（Aspect Oriented Programming：面向切面编程）为内核。 提供了展现层 SpringMVC 和持久层 Spring JDBCTemplate 以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的Java EE 企业应用开源框架。 2.sprin
Android-KOIN-一个智能的Kotlin依赖注入框架
08-13
KOIN是一个简单（但功能强大）的Android依赖注入框架。 它使用Kotlin及其功能来完成任务！ 没有代理/ CGLib，没有代码生成，没有内省。
android 依赖注入_Android中的依赖注入
weixin_26727575的博客
08-23 1718
android 依赖注入 什么是依赖注入？ (What is Dependency Injection?) Classes often require references to other classes. For example, a Car class might need a reference to an Engine class. These required classes are ...
android 依赖注入(Hilt, Koin)
prime的博客
08-18 1003
λ： 仓库地址: https://github.com/lzyprime/android_demos 开发分支dev加入了compose, 图片库由 glide 换为 coil, DataStore代替SharedPreference。 同时剔除掉LiveData, 用Flow代替。 本来想完全用compose完成UI实现。但是目前compose组件贫瘠，与其他库的配合库也都没有稳定。部分场景下实现反倒费力。所以开两个分支： dev: compose 只做部分控件实现，主体仍保留传统库和其他方式。 de
Android依赖注入：Google Guice on Android的使用及相关资源
weixin_34413103的博客
12-13 114
本文转自：http://blog.csdn.net/sangming/article/details/8878104 RoboGuice 使用谷歌自己的Guice库,给Android带来了简单和易用的依赖注入。如果你使用过Spring或Guice的话，你可能已经知道这种编程方式是多么的便捷。 RoboGuice 允许使用annotation 的方式来描述id于View之间的关系，其余的工作...
android 依赖注入_Android依赖注入和测试库
04-27 173
android 依赖注入 应该研究一切使生活更轻松地为Android开发的事物。 有几个库可以简化测试，提高代码的模块化并提供已经创建的模拟对象： RoboGuice –这是Google依赖注入库的改编，但适用于Android Robolectric-这是一个测试框架/平台，可消除对Android对象进行持续模拟的需要。 它也可以与RoboGuice一起使用。 我不能感谢最初向我...
Android依赖注入的实现
SUN
01-12 1306
通过Java注解代替常规的findViewById()初始化View，和setOnClickListener()设置监听器。
android 依赖注入原理,简单谈谈Hilt——依赖注入框架
weixin_29692653的博客
05-29 905
今天继续Jetpack专题，相信很多的朋友都使用过Dagger，也放弃过Dagger，由于实在太难用了。因此官方也是为了让咱们更好使用依赖注入框架，为咱们封装了一个新的框架——Hilt，今天一块儿来看看：框架依赖注入是啥？为何须要她？Hilt是啥，怎么用？Hilt支持哪些类的依赖注入。依赖注入是啥？为何须要她？简单的说，依赖注入就是内部的类在外部实例化了。也就是不须要本身去作实例化工做了，而是交给...
Android依赖注入
平凡的路
10-21 616
1.含义 1）依赖是指一个对象持有其他对象的引用。依赖注入则是将这些依赖对象传递给被依赖对象，而不是被依赖对象自己创建这些对象，说白了注入就是对象作为参数传递。 public class MyClass{ private AnotherClass mAnotherObject; public MyClass(){ mAnotherObject = new An
android的依赖注入
热爱生活热爱技术的专栏
05-12 291
本文介绍 了Android 中类似ButterKnife的依赖注入效果，可以简化代码，增强代码的易读性
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值