IOC注解实现流程，实现butterknife的注解功能

最新推荐文章于 2022-04-02 14:38:30 发布
最新推荐文章于 2022-04-02 14:38:30 发布
阅读量180 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： android开发 文章标签： IOC注解
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_20489601/article/details/88793596
本文介绍Android开发中使用IOC注解框架实现布局、控件及事件注入的原理与方法，包括自定义注解、反射机制的应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

目前市场上比较火的Android注解框架有butterknife，dagger等，IOC的核心是解耦，修改耦合对象时不影响另外一个对象，降低模块之间的关联。IOC注解的优缺点：
1.代码量少，加速开发
2.产生性能消耗

开发过程中，经常会使用findviewById的方式去实例化一个控件的id，比如获取一个Button的id
Button btn = findviewById(R.id.btn);
如果你学会了注解的方式，就可以这样实现
@InjectView(R.id.btn)
Button btn
本文主要从三个方面讲解如何实现IOC注解功能：

1、布局注入

原理：通过放射，获得类→布局注解→注解的值→获取指定方法→执行方法，具体的步骤如下：

  1. 新建一个布局注解Annotation，代码如下
   /**
    * @author zhengjun
    * @desc   布局的注解
    * @create at 2019/3/22 16:26
    */
     @Target(ElementType.TYPE) //该注解作用在类上
     @Retention(RetentionPolicy.RUNTIME) //运行时通过反射获取该注解的值
     public @interface ContentView {
        int value();
     }
  1. 实现注入过程，获得类→布局注解→注解的值→获取指定方法→执行方法
    //注入布局layout
    private static void injectLayout(Activity activity) {
        //获取类
        Class<? extends Activity> aClass = activity.getClass();
        //获取类的注解
        ContentView contentView = aClass.getAnnotation(ContentView.class);
        if (contentView != null) {
            //获取当前类的布局R.layout.activity_main
            int layoutId = contentView.value();
            //1.第一种方法注解，直接调用setContentView方法
            //activity.setContentView(layoutId);
            try {
                //2.第二种方法注解，通过反射机制
                Method method = aClass.getMethod("setContentView", int.class);
                method.invoke(activity, layoutId);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
  1. 在activity中使用此注解
    用@ContentView(R.layout.activity_main)的方式代替setContentView(）方法

2、控件注入

原理:通过放射，获得类→获取所有属性→遍历属性→每个属性的注解→每个注解的→获取指定方法→执行方法→设置访问私有→赋值

  1. 新建一个控件注解Annotation，代码如下
   /**
    * @author zhengjun
   * @desc   view的注解
   * @create at 2019/3/22 16:54
   */
   @Target(ElementType.FIELD) //该注解作用在属性上
   @Retention(RetentionPolicy.RUNTIME)
   public @interface InjectView {
       int value();
   }
  1. 实现注入过程，获得类→获取所有属性→遍历属性→每个属性的注解→每个注解的→获取指定方法→执行方法→设置访问私有→赋值
   //控件注入
    private static void injectViews(Activity activity) {
        //获取类
        Class<? extends Activity> aClass = activity.getClass();
        //获取类所有的属性
        Field[] fields = aClass.getDeclaredFields();
        //遍历属性
        for (Field filed : fields) {
            //获取属性上的注解
            InjectView injectView = filed.getAnnotation(InjectView.class);
            if (injectView != null) { //并不是每个属性都有这个注解，所有要做非空判断
                //获取这个属性注解的值R.id.btn
                int viewId = injectView.value();
                try {
                    //获取方法
                    Method method = aClass.getMethod("findViewById", int.class);
                    //执行方法,得到view对象
                    Object view = method.invoke(activity, viewId);
                    //设置改属性可以访问，哪怕是private类型
                    filed.setAccessible(true);
                    //属性的值赋给控件，在当前的activity
                    filed.set(activity, view);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
  1. 在activity中使用此注解
    用@InjectView(R.id.btn)的方式代替findViewById(）方法

3、事件注入

原理:通过放射，获得类→获取所有方法→遍历方法→每个方法的注解→遍历所有注解→获取指定的注解（类型，判空）→获取最终注解的三大成员→获得最终注解的值→遍历注解的值→赋值控件→控件获得指定方法→执行方法

  1. 新建一个布局注解Annotation，代码如下
    /**
     * @author zhengjun
     * @desc
     * @create at 2019/3/25 09:53
     */
    @Target(ElementType.METHOD) //该注解作用在方法上
    @Retention(RetentionPolicy.RUNTIME)
    @EventBase(listenerSet = "setOnClickListener", listenerType = View.OnClickListener.class, callBackListener =     "onClick")
    public @interface OnClick {
        int[] value();
    }
  1. 新建一个作用在注解上的注解
    /**
     * @author zhengjun
     * @desc
     * @create at 2019/3/25 10:34
     */
    @Target(ElementType.ANNOTATION_TYPE) //元注解 作用在注解之上
    @Retention(RetentionPolicy.RUNTIME)
    public @interface EventBase {
         //事件的三个重要成员
        
         //1.setOnxxxListener方法名
         String listenerSet();

         //2.监听的对象 View.OnxxxListener()
         Class<?> listenerType();

         //3.回调方法
         String callBackListener();
}
  1. 新建一个类实现InvocationHandler实现方法的拦截
    /**
 * @author zhengjun
 * @desc
 * @create at 2019/3/25 11:06
 */
public class ListenerInvocationHandler implements InvocationHandler {
    //需要拦截mainactivity中的某些方法
    private Object target;

    //拦截的键值对
    private HashMap<String, Method> methodHashMap = new HashMap<>();

    public ListenerInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if (target != null) {
            String name = method.getName();
            //重新赋值，拦截了onClick方法
            method = methodHashMap.get(name);
            //如果找到了 就执行自定义的onClick方法
            if (method != null) {
                return method.invoke(target, args);
            }
        }
        return null;
    }

    /**
     * @desc 拦截方法
     * methodName 要拦截的方法 onClick
     * method     自定义要执行的方法
     * @author zhengjun
     * @created at 2019/3/25 11:12
     */
    public void addMethod(String methodName, Method method) {
        methodHashMap.put(methodName, method);
    }
}
  1. 实现注入过程，获得类→获取所有方法→遍历方法→每个方法的注解→遍历所有注解→获取指定的注解（类型，判空）→获取最终注解的三大成员→获得最终注解的值→遍历注解的值→赋值控件→控件获得指定方法→执行方法
   //事件注入
    private static void injectEvents(Activity activity) {
        //获取当前类
        Class<? extends Activity> aClass = activity.getClass();
        //获取所有方法
        Method[] declaredMethods = aClass.getDeclaredMethods();
        //遍历方法
        for (Method method : declaredMethods) {
            //获取方法注解，可能一个方法会有多个注解
            Annotation[] annotations = method.getAnnotations();
            //遍历注解
            for (Annotation annotation : annotations) {
                //获取注解类型
                Class<? extends Annotation> annotationType = annotation.annotationType();
                if (annotationType != null) {
                    EventBase eventBase = annotationType.getAnnotation(EventBase.class);
                    //事件三个重要成员
                    String listenerSet = eventBase.listenerSet();
                    Class<?> listenerType = eventBase.listenerType();
                    String callBackListener = eventBase.callBackListener();
                    try {
                        //通过annotationType获取onClick注解的value值
                        Method valueMethod = annotationType.getDeclaredMethod("value");
                        //R.id.tv  R.id.btn
                        int[] viewIds = (int[]) valueMethod.invoke(annotation);
                        ListenerInvocationHandler invocationHandler = new ListenerInvocationHandler(activity);
                        invocationHandler.addMethod(callBackListener, method);
                        Object listener = Proxy.newProxyInstance(listenerType.getClassLoader(), new Class[]{listenerType}, invocationHandler);
                        for (int viewId : viewIds) {
                            //得到当前控件view
                            View view = activity.findViewById(viewId);
                            Method setter = view.getClass().getMethod(listenerSet, listenerType);
                            setter.invoke(view, listener);
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
  1. 在activity中使用此注解
    用@OnClick({R.id.btn，R.id.tv})的方式代替setOnclickListener()方法

最后，贴出整个注解过程的代码，全部封装到InjectManager类中，可以在activity的基类中调用InjectManager.init（this）方法进行注入，代码如下：

 package me.zhengjun.injectview;
import android.app.Activity;
import android.view.View;

import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

import me.zhengjun.injectview.annotation.ContentView;
import me.zhengjun.injectview.annotation.EventBase;
import me.zhengjun.injectview.annotation.InjectView;
import me.zhengjun.injectview.listener.ListenerInvocationHandler;

/**
 * @author zhengjun
 * @desc   注入的管理类
 * @create at 2019/3/22 16:26
 */
public class InjectManager {
    public static void inject(Activity activity) {
        //布局注入
        injectLayout(activity);

        //控件注入
        injectViews(activity);

        //事件注入
        injectEvents(activity);
    }

    //注入布局layout
    private static void injectLayout(Activity activity) {
        //获取类
        Class<? extends Activity> aClass = activity.getClass();
        //获取类的注解
        ContentView contentView = aClass.getAnnotation(ContentView.class);
        if (contentView != null) {
            //获取当前类的布局R.layout.activity_main
            int layoutId = contentView.value();
            //1.第一种方法注解，直接调用setContentView方法
            //activity.setContentView(layoutId);
            try {
                //2.第二种方法注解，通过反射机制
                Method method = aClass.getMethod("setContentView", int.class);
                method.invoke(activity, layoutId);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    //控件注入
    private static void injectViews(Activity activity) {
        //获取类
        Class<? extends Activity> aClass = activity.getClass();
        //获取类所有的属性
        Field[] fields = aClass.getDeclaredFields();
        //遍历属性
        for (Field filed : fields) {
            //获取属性上的注解
            InjectView injectView = filed.getAnnotation(InjectView.class);
            if (injectView != null) { //并不是每个属性都有这个注解，所有要做非空判断
                //获取这个属性注解的值R.id.btn
                int viewId = injectView.value();
                try {
                    //获取方法
                    Method method = aClass.getMethod("findViewById", int.class);
                    //执行方法,得到view对象
                    Object view = method.invoke(activity, viewId);
                    //设置改属性可以访问，哪怕是private类型
                    filed.setAccessible(true);
                    //属性的值赋给控件，在当前的activity
                    filed.set(activity, view);
                } catch (Exception e) {
                    e.printStackTrace();
                }

            }
        }
    }

    //事件注入
    private static void injectEvents(Activity activity) {
        //获取当前类
        Class<? extends Activity> aClass = activity.getClass();
        //获取所有方法
        Method[] declaredMethods = aClass.getDeclaredMethods();
        //遍历方法
        for (Method method : declaredMethods) {
            //获取方法注解，可能一个方法会有多个注解
            Annotation[] annotations = method.getAnnotations();
            //遍历注解
            for (Annotation annotation : annotations) {
                //获取注解类型
                Class<? extends Annotation> annotationType = annotation.annotationType();
                if (annotationType != null) {
                    EventBase eventBase = annotationType.getAnnotation(EventBase.class);
                    //时间三个重要成员
                    String listenerSet = eventBase.listenerSet();
                    Class<?> listenerType = eventBase.listenerType();
                    String callBackListener = eventBase.callBackListener();
                    try {
                        //通过annotationType获取onClick注解的value值
                        Method valueMethod = annotationType.getDeclaredMethod("value");
                        //R.id.tv  R.id.btn
                        int[] viewIds = (int[]) valueMethod.invoke(annotation);
                        ListenerInvocationHandler invocationHandler = new ListenerInvocationHandler(activity);
                        invocationHandler.addMethod(callBackListener, method);
                        Object listener = Proxy.newProxyInstance(listenerType.getClassLoader(), new Class[]{listenerType}, invocationHandler);
                        for (int viewId : viewIds) {
                            //得到当前控件view
                            View view = activity.findViewById(viewId);
                            Method setter = view.getClass().getMethod(listenerSet, listenerType);
                            setter.invoke(view, listener);
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}
IOC实现ButterKnife（一）之注入布局与注入控件
张无影的博客
01-09 236
IOC是什么？ 是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度，其中最常见的便是依赖注入。简单点说就是如果你在一个类A中实例化一个对象B，那么久需要在A类中使用new来进行实例化对象B，这样A和B的耦合度就很高，而IOC是通过注解让其进行动态生成，而不需要自己去实例化，以此来降低耦合度。（依赖注入核心） 需要用到的知识： 反射 注解 如果不熟悉上面两个知识，可百度找一篇如果...
手动实现IOC注解框架视频版
05-13
1.IOC概念描述 2.Butterknife源码解析 3.手动实现IOC 框架 内容丰富，视频长度大于5小时，一步步解析源码以及手敲代码实现框架核心代码
IOC框架设计----Butterknife
用技术改变世界
04-22 195
什么是IOC？ 核心思想就是： IOC是原来由程序代码中主动获取的资源，转变由第三方获取，并使原来的代码被动接收的方式，以达到解耦的效果，称为控制翻转。 举个生活中的例子： 你–>穿衣服—>出门 （ioc以前） 你—》一个眼神—>女朋友给你拿衣服，再给你穿上—>出门 （ioc以后） 采用APT注解处理器，替我们写代码。 注解处理器写法： 1、AnnotationC...
Android 仿ButterKnife写自己的IOC注解框架
带你装逼带你飞的专栏
05-06 668
1 前言一般我们在Android 的开发中，我们在Activity中都会涉及到大量的findViewById操作，这个时候我们可以采用一些开源的框架来帮我们省很多的苦力，例如大名鼎鼎的ButterKnife就是我经常使用的。ButterKnife是一种非常流行的注解框架。主要有以下几个优点：1.强大的View绑定和Click事件处理功能，简化代码，提升开发效率 2.方便的处理Adapter里的Vi
Android开源框架——依赖注入ButterKnife
笑口常开
06-07 1005
若对依赖注入不熟悉，请阅读博客中的另外一篇IOC控制反转浅析介绍：ButterKnife是Square公司员工JakeWharton开发的一款针对View视图对象的依赖注入库。目的是通过依赖注入方式，将View对象的初始化简化，并极大地改进了代码之间的耦合度。 特点 用预编译方法替代了反射机制（注意：反射机制极大地浪费资源，包括空间与时间资源） 在编译的过程中就创建了视图对象，编译采用的是Anno
使用注解与反射实现Butterknife
qq_27844985的博客
06-04 312
butterknife是一个在android上实现ioc（控制反转）的一个库。ioc的核心是解耦。解耦的目的是修改耦合对象时不影响另外一个对象，降低模块之间的关联。在Spring中ioc更多的是依靠xml的配置。而android上的IOC框架可以不使用xml配置。 实现butterknife需要了解的知识点：java反射 注解。 ...
java注解的实现机制_注解的实现原理
weixin_32085599的博客
02-26 860
一、注解的底层实现原理注解的底层也是使用反射实现的，我们可以自定义一个注解来体会下。注解和接口有点类似，不过申明注解类需要加上@interface，注解类里面，只支持基本类型、String及枚举类型，里面所有属性被定义成方法，并允许提供默认值。@Target — —注解用于什么地方ANNOTATION_TYPE,//给注解注解(这貌似把自己不当类来看)ElementType.FIELD //注...
自定义实现的bindview框架（Butterknife）
05-07
自定义实现的bindview框架（Butterknife），通过编译时注解处理（APT）+JavaPoet（生成java代码）+反射（调用bind方法），来在框架中实现了，事件的自动绑定和视图的自动绑定。
简单实现BufferKnife注解功能与ioc原理
资源摘要信息:"ioc原理及其应用，简单实现BufferKnife注解功能" 一、IOC原理 1、什么是IOC？ IOC（Inversion of Control，控制反转）是一种设计思想，用于减少代码间的耦合度。其核心思想是将创建对象的控制权从...
ButterKnife注解处理器进阶使用教程
ioc注解处理器结合了这两种概念，它通过注解和注解处理技术，实现了依赖注入的自动化，从而使开发者可以更加专注于业务逻辑的实现，而不是繁琐的依赖管理。 ButterKnife利用注解处理器在编译时期处理相关注解，例如...
自定义注解在Android中实现IOC依赖注入
Android中的ButterKnife和Dagger都是通过自定义注解处理器来实现依赖注入的。 #### 4. IOC（Inversion of Control）控制反转 控制反转是依赖注入的一种实现方式，它将对象的创建和管理从应用程序代码转移到外部容器...
Android主流IOC框架浅析（Java注解反射原理）
coding
07-06 1876
Android主流IOC框架浅析
手写ButterKnife视图注入，解决findViewById
wangwo1991的博客
12-16 370
在上一篇手写IOC注解，解决findViewById和点击事件（http://blog.youkuaiyun.com/wangwo1991/article/details/78811831） 博客中就实现了IOC注解，不过那里采用的是运行时注解的方式实现的，这里的手写ButterKnife将采用编译时注解的方式实现；运行时注解的方式实现过程中使用了不少反射，会对运行效率有影响，而编译时注解的方式实现对运行效率
珍惜生命 远离 Butter Knife
longtaoge的专栏
05-16 4129
Butter Knife 是什么呢？      Bind Android views and callbacks to fields and methods. http://jakewharton.github.io/butterknife/       没错，Butter Knife 就是 大名鼎鼎的 Android 大神 Jake Wharton  开源的View 注入
Android Studio使用svn配置忽略文件和解决提交时一直performing的问题
qq_20489601的博客
01-19 7277
一.配置忽略文件 1.方法一： 配置忽略文件，在file-settings-version Control-ignored Files,然后如图所示依次添加以下忽略文件图1.1.1：需要添加的忽略文件重点内容图1.1.2：添加忽略文件的步骤2.方法二 但是有时候根据方法一配置忽略文件并不能成功，所有我们还可以用方法二，如下： 在你的项目中新建.gitignore忽略文件，鼠标右击项目点击ne
java实现Android一键打包，秒秒钟生成上百个渠道包
qq_20489601的博客
09-28 4676
要实现java一键生成渠道包功能，事先我们需要做好准备工作，大概有以下3点 1.准备好所以需要生成的渠道号放在excel文档中 2.需要下载两个jar包，commons-compress-1.16.1.jar和 jxl.jar 3.得准备你需要生成渠道包的apk，也就是说你需要在你的Android开发工具中先打 一个包，然后代码会根据这个包生成不同的渠道包 注：这些资料我都将在文章结尾给出，好废话...
自定义可滑动的tab选项卡，可切换选项卡样式(下划线，仿小米三角形，方形背景)
qq_20489601的博客
12-07 3394
下载demo链接：http://download.youkuaiyun.com/detail/qq_20489601/9704356 由于在项目开发过程中经常使用到viewPager+fragment实现选项卡的切换功能，每次用的时候都要在activity中重新写一遍相同的代码，所以在空闲时间，我自己自定义了一个各种样式的可滑动的选项卡控件，在实际项目中使用非常方便，下面是此控件的主要代码： 1.要实
Android studio上传库到mavenCentral
qq_20489601的博客
04-02 3288
前言 本编文章将较大家如何上传库到mavenCenter仓库 如果你是一个第三方库开发者，且之前没有上传库到 MavenCentral 经验的话，本文可以助你早日上传库到 MavenCentral。 一、Sonatype 账号 1、注册 Sonatype 在上传库到 MavenCentral 之前，需要先注册登录 Sonatype，访问 https://issues.sonatype.org 链接根据提示进行账户注册，注册成功后再登录 Sonatype。 注意：注册时填写的邮箱很重要，建议是你常用的邮箱，
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值