Ioc依赖注入，使你的项目告别findViewById

最新推荐文章于 2022-03-24 23:30:07 发布
最新推荐文章于 2022-03-24 23:30:07 发布
阅读量392 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 技巧代码 文章标签： ioc 依赖注入 提升代码效率
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/yuchen56/article/details/51200181
本文介绍了一种在Android开发中使用的视图注入技术，通过自定义注解和反射机制实现UI组件的自动绑定及事件监听。该方法简化了代码编写过程，提高了开发效率。

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

MainActivity

package test.dbing.com.ioctest;

import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;

import test.dbing.com.ioctest.ioc.IocView;

public class MainActivity extends BaseActivity {

    @IocView(id = R.id.main_name_bt,click="btnClick",longClick = "longClk")Button button;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
    public void btnClick(View v){
        Toast.makeText(MainActivity.this,"click",Toast.LENGTH_LONG).show();
    }

    public void longClk(View v){
        Toast.makeText(MainActivity.this,"longClk",Toast.LENGTH_LONG).show();
    }
}

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <Button
        android:id="@+id/main_name_bt"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello World!" />
</RelativeLayout>

BaseActivity

import android.app.Activity;
import android.text.TextUtils;
import android.view.View;
import android.view.ViewGroup;
import android.widget.AbsListView;
import java.lang.reflect.Field;
import test.dbing.com.ioctest.ioc.IocEventListener;
import test.dbing.com.ioctest.ioc.IocSelect;
import test.dbing.com.ioctest.ioc.IocView;

public class BaseActivity extends Activity {

    @Override
    public void setContentView(int layoutResID) {
        super.setContentView(layoutResID);
        initIocView();
    }

    @Override
    public void setContentView(View view) {
        super.setContentView(view);
        initIocView();
    }

    @Override
    public void setContentView(View view, ViewGroup.LayoutParams params) {
        super.setContentView(view, params);
    }

    public void initIocView(){
        Field[] fields = getClass().getDeclaredFields();
        if(fields!=null && fields.length>0){
            for(Field field : fields){
                try {
                    field.setAccessible(true);

                    if(field.get(this)!= null )
                        continue;

                    IocView viewInject = field.getAnnotation(IocView.class);
                    if(viewInject!=null){

                        int viewId = viewInject.id();
                        field.set(this,findViewById(viewId));

                        setListener(field,viewInject.click(), IocEventListener.CLICK);
                        setListener(field,viewInject.longClick(), IocEventListener.LONGCLICK);
                        setListener(field,viewInject.itemClick(), IocEventListener.ITEMCLICK);
                        setListener(field,viewInject.itemLongClick(), IocEventListener.ITEMLONGCLICK);

                        IocSelect select = viewInject.select();
                        if(!TextUtils.isEmpty(select.selected())){
                            setViewSelectListener(field,select.selected(),select.noSelected());
                        }

                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 设置view的监听器.
     *
     * @param field the field
     * @param methodName the method name
     * @param method the method
     * @throws Exception the exception
     */
    private void setListener(Field field,String methodName,int method)throws Exception{
        if(methodName == null || methodName.trim().length() == 0)
            return;

        Object obj = field.get(this);

        switch (method) {
            case IocEventListener.CLICK:
                if(obj instanceof View){
                    ((View)obj).setOnClickListener(new IocEventListener(this).click(methodName));
                }
                break;
            case IocEventListener.ITEMCLICK:
                if(obj instanceof AbsListView){
                    ((AbsListView)obj).setOnItemClickListener(new IocEventListener(this).itemClick(methodName));
                }
                break;
            case IocEventListener.LONGCLICK:
                if(obj instanceof View){
                    ((View)obj).setOnLongClickListener(new IocEventListener(this).longClick(methodName));
                }
                break;
            case IocEventListener.ITEMLONGCLICK:
                if(obj instanceof AbsListView){
                    ((AbsListView)obj).setOnItemLongClickListener(new IocEventListener(this).itemLongClick(methodName));
                }
                break;
            default:
                break;
        }
    }

    /**
     * 设置view的监听器.
     *
     * @param field the field
     * @param select the select
     * @param noSelect the no select
     * @throws Exception the exception
     */
    private void setViewSelectListener(Field field,String select,String noSelect)throws Exception{
        Object obj = field.get(this);
        if(obj instanceof View){
            ((AbsListView)obj).setOnItemSelectedListener(new IocEventListener(this).select(select).noSelect(noSelect));
        }
    }
}

将下面三个类copy到你的项目中即可

IocEventListener

import android.view.View;
import android.view.View.OnClickListener;
import android.view.View.OnLongClickListener;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.AdapterView.OnItemLongClickListener;
import android.widget.AdapterView.OnItemSelectedListener;

import java.lang.reflect.Method;

public class IocEventListener implements OnClickListener, OnLongClickListener, OnItemClickListener, OnItemSelectedListener,OnItemLongClickListener {

    /** The handler. */
    private Object handler;

    /** The click method. */
    private String clickMethod;

    /** The long click method. */
    private String longClickMethod;

    /** The item click method. */
    private String itemClickMethod;

    /** The item select method. */
    private String itemSelectMethod;

    /** The nothing selected method. */
    private String nothingSelectedMethod;

    /** The item long click mehtod. */
    private String itemLongClickMehtod;

    /**
     * Instantiates a new ab ioc event listener.
     *
     * @param handler the handler
     */
    public IocEventListener(Object handler) {
        this.handler = handler;
    }

    /**
     * Click.
     *
     * @param method the method
     * @return the ab ioc event listener
     */
    public IocEventListener click(String method){
        this.clickMethod = method;
        return this;
    }

    /**
     * Long click.
     *
     * @param method the method
     * @return the ioc event listener
     */
    public IocEventListener longClick(String method){
        this.longClickMethod = method;
        return this;
    }

    /**
     * Item long click.
     *
     * @param method the method
     * @return the ioc event listener
     */
    public IocEventListener itemLongClick(String method){
        this.itemLongClickMehtod = method;
        return this;
    }

    /**
     * Item click.
     *
     * @param method the method
     * @return the ioc event listener
     */
    public IocEventListener itemClick(String method){
        this.itemClickMethod = method;
        return this;
    }

    /**
     * Select.
     *
     * @param method the method
     * @return the ioc event listener
     */
    public IocEventListener select(String method){
        this.itemSelectMethod = method;
        return this;
    }

    /**
     * No select.
     *
     * @param method the method
     * @return the ioc event listener
     */
    public IocEventListener noSelect(String method){
        this.nothingSelectedMethod = method;
        return this;
    }

    public boolean onLongClick(View v) {
        return invokeLongClickMethod(handler,longClickMethod,v);
    }

    public boolean onItemLongClick(AdapterView<?> arg0, View arg1, int arg2,long arg3) {
        return invokeItemLongClickMethod(handler,itemLongClickMehtod,arg0,arg1,arg2,arg3);
    }

    public void onItemSelected(AdapterView<?> arg0, View arg1, int arg2,long arg3) {

        invokeItemSelectMethod(handler,itemSelectMethod,arg0,arg1,arg2,arg3);
    }

    public void onNothingSelected(AdapterView<?> arg0) {
        invokeNoSelectMethod(handler,nothingSelectedMethod,arg0);
    }

    public void onItemClick(AdapterView<?> arg0, View arg1, int arg2, long arg3) {

        invokeItemClickMethod(handler,itemClickMethod,arg0,arg1,arg2,arg3);
    }

    public void onClick(View v) {

        invokeClickMethod(handler, clickMethod, v);
    }


    /**
     * Invoke click method.
     *
     * @param handler the handler
     * @param methodName the method name
     * @param params the params
     * @return the object
     */
    private Object invokeClickMethod(Object handler, String methodName,  Object... params){
        if(handler == null) return null;
        Method method = null;
        try{   
            method = handler.getClass().getDeclaredMethod(methodName,View.class);
            if(method!=null)
                return method.invoke(handler, params);  
            else
                throw new Exception("no such method:"+methodName);
        }catch(Exception e){
            e.printStackTrace();
        }

        return null;

    }


    /**
     * Invoke long click method.
     *
     * @param handler the handler
     * @param methodName the method name
     * @param params the params
     * @return true, if successful
     */
    private boolean invokeLongClickMethod(Object handler, String methodName,  Object... params){
        if(handler == null) return false;
        Method method = null;
        try{   
            //public boolean onLongClick(View v)
            method = handler.getClass().getDeclaredMethod(methodName,View.class);
            if(method!=null){
                Object obj = method.invoke(handler, params);
                return obj==null?false:Boolean.valueOf(obj.toString()); 
            }
            else
                throw new Exception("no such method:"+methodName);
        }catch(Exception e){
            e.printStackTrace();
        }

        return false;

    }

    /**
     * Invoke item click method.
     *
     * @param handler the handler
     * @param methodName the method name
     * @param params the params
     * @return the object
     */
    private Object invokeItemClickMethod(Object handler, String methodName,  Object... params){
        if(handler == null) return null;
        Method method = null;
        try{   
            ///onItemClick(AdapterView<?> arg0, View arg1, int arg2, long arg3)
            method = handler.getClass().getDeclaredMethod(methodName,AdapterView.class,View.class,int.class,long.class);
            if(method!=null)
                return method.invoke(handler, params);  
            else
                throw new Exception("no such method:"+methodName);
        }catch(Exception e){
            e.printStackTrace();
        }

        return null;
    }


    /**
     * Invoke item long click method.
     *
     * @param handler the handler
     * @param methodName the method name
     * @param params the params
     * @return true, if successful
     */
    private boolean invokeItemLongClickMethod(Object handler, String methodName,  Object... params){

        Method method = null;
        try{   
            if(handler == null){
                throw new Exception("invokeItemLongClickMethod: handler is null :");
            }
            ///onItemLongClick(AdapterView<?> arg0, View arg1, int arg2,long arg3)
            method = handler.getClass().getDeclaredMethod(methodName,AdapterView.class,View.class,int.class,long.class);
            if(method!=null){
                Object obj = method.invoke(handler, params);
                return Boolean.valueOf(obj==null?false:Boolean.valueOf(obj.toString()));    
            }
            else
                throw new Exception("no such method:"+methodName);
        }catch(Exception e){
            e.printStackTrace();
        }

        return false;
    }


    /**
     * Invoke item select method.
     *
     * @param handler the handler
     * @param methodName the method name
     * @param params the params
     * @return the object
     */
    private Object invokeItemSelectMethod(Object handler, String methodName,  Object... params){
        if(handler == null) return null;
        Method method = null;
        try{   
            ///onItemSelected(AdapterView<?> arg0, View arg1, int arg2,long arg3)
            method = handler.getClass().getDeclaredMethod(methodName,AdapterView.class,View.class,int.class,long.class);
            if(method!=null)
                return method.invoke(handler, params);  
            else
                throw new Exception("no such method:"+methodName);
        }catch(Exception e){
            e.printStackTrace();
        }

        return null;
    }

    /**
     * Invoke no select method.
     *
     * @param handler the handler
     * @param methodName the method name
     * @param params the params
     * @return the object
     */
    private Object invokeNoSelectMethod(Object handler, String methodName,  Object... params){
        if(handler == null) return null;
        Method method = null;
        try{   
            //onNothingSelected(AdapterView<?> arg0)
            method = handler.getClass().getDeclaredMethod(methodName,AdapterView.class);
            if(method!=null)
                return method.invoke(handler, params);  
            else
                throw new Exception("no such method:"+methodName);
        }catch(Exception e){
            e.printStackTrace();
        }

        return null;
    }

}

IocSelect

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * The Interface IocSelect.
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME) 
public @interface IocSelect {

    /**
     * Selected.
     *
     * @return the string
     */
    public String selected();

    /**
     * No selected.
     *
     * @return the string
     */
    public String noSelected() default "";

}

IocView

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * The Interface IocView.
 */
/*
    @Retention用来声明注解的保留策略，
    有CLASS、RUNTIME和SOURCE这三种，
    分别表示注解保存在类文件、JVM运行时刻和源代码中只有当声明为RUNTIME的时候，
    才能够在运行时刻通过反射API来获取到注解的信息。
    @Target用来声明注解可以被添加在哪些类型的元素上，如类型、方法和域等
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME) 
public @interface IocView {

    /**
     * Id.
     *
     * @return the int
     */
    public int id();

    /**
     * Click.
     *
     * @return the string
     */
    public String click() default "";

    /**
     * Long click.
     *
     * @return the string
     */
    public String longClick() default "";

    /**
     * Item click.
     *
     * @return the string
     */
    public String itemClick() default "";

    /**
     * Item long click.
     *
     * @return the string
     */
    public String itemLongClick() default "";

    /**
     * Select.
     *
     * @return the ab ioc select
     */
    public IocSelect select() default @IocSelect(selected="") ;
}
IOC容器和依赖注入
噢~
08-16 646
1 依赖倒置 依赖倒置的核心价值： 如果没有依赖倒置，全部都是依赖细节，如果分层架构是 A层---B层--C层---D层---E层---F层，下层的修改，可能会导致上层随之改变，F层如果改变，E层要改，D层要改，C层要改......影响很大，成水波式向上影响，架构就的极度不稳定。 如果都是依赖于抽象的，抽象即接口或抽象类。 抽象是相对稳定的，修改下层不会影响上层。因为上层不是依赖于具体的，这让...
自定义注解实现IOC，代替findviewbyid，setcontentview，setListener
01-21
自定义注解实现IOC依赖注入，代替findviewbyid，setcontentview，setListener
实现依赖注入，省去重复写findViewById
qq_35134033的博客
04-26 167
在build.gradle(Module:app)文件中加入以下代码，记得加好后要Sync Now implementation 'org.xutils:xutils:3.5.0' 使用 @ContentView(R.layout.activity_main) public class MainAct{ @ViewInject(R.id.title) private Ti...
告别 findViewById
chongshe5515的博客
07-13 108
利用ButterKnife来实现利用注解绑定控件。 概述 开发环境：Android studio 依赖组件：butterknife 依赖插件 ：Android ButterKnife Zelezny 步骤： 在gradle中添加文件依赖： compile 'com.jakewhart...
DataBinding，告别findViewById
hizhangyuping的博客
04-30 240
参考：https://blog.youkuaiyun.com/a10615/article/details/52781956 1.gradle 设置 2.xml布局外面嵌套layout标签 3.使用build文件夹下生成的ViewDataBinding相关类对控件进行操作 可参照invokeDemo ...
告别 findViewById —— ButterKnife
Alpinist Wang
02-15 329
ButterKnife可以一键绑定View，从此告别findViewById。缺点是会有很多@BindView注解，笔者现在已经使用kotlin了，真正的告别了findViewById。现在我更加推荐kotlin，ButterKnife就用来学习一下Jake Wharton大神的编程思想吧。
Android Data Binding代码实践（告别findViewById）（四）
【博客地址迁移到】：https://zhengxiaoyong.com
08-06 3744
Data Binding实战（一） Data Binding语法解析（二） Data Binding高级用法（三） 好了，继前三篇学习了Data Binding之后，我们可以发现它的强大之处有这么几点： 1、使用MVVM模式，让整个项目结构清晰明了 2、通过ViewModel连接View和Model，使得View与Model层解耦，分层后各司其职，维护方便 3、易于项目的测试
Spring.Net IOC依赖注入原理流程解析
08-18
Spring.Net IOC依赖注入原理流程解析 本文将详细介绍Spring.Net IOC依赖注入原理流程解析，通过示例代码介绍了非常详细，对大家的学习或者工作具有一定的参考学习价值。 一、什么是IOC？ IOC（Inversion of ...
浅谈Spring IoC容器的依赖注入原理
08-27
浅谈Spring IoC容器的依赖注入原理 Spring IoC容器的依赖注入原理是Spring框架的核心机制之一，负责将服务对象（Bean）实例化并将其提供给客户端使用。依赖注入原理可以分为两个阶段：IoC容器初始化和Bean实例化。 ...
Spring Ioc 注解 依赖注入
05-26
### Spring IoC与注解依赖注入详解 #### 一、Spring框架简介 Spring框架是由Rod Johnson创建的一个开源项目，最初是为了解决企业级应用开发中的复杂性问题而诞生的。Spring框架的核心特性包括IoC（Inversion of ...
自定义注解，告别findViewById,你只需要这样做
知足常乐
03-14 1724
传统的项目中，为了从XML文件找到各个控件，findViewById，是不得不去写的代码，以致于太多的控件，太多的findViewId,使我们的代码变得繁琐，获取，强转，千篇一律的重复着某种机制，其实内心也是蛮崩溃的。 当然了，为了解决不必要的findViewById，互联网的世界里也涌现了很多出色的第三方，如ButterKnife，AndroidAnotations，还有XUt
android findviewbyid的简单注解实现
u014481698的专栏
08-19 502
public @interface AutoView { /** * UI主键的id，不填写自动识别名称 * @return */ int value() default -1; } 这个是注解接口 @Retention(RetentionPolicy.RUNTIME) public @interface AutoVIewForClass { /** * 需要注解
编译期注解学习四 简单的view注入框架
lidongxiu0714
07-25 1642
1 项目结构 本篇文章比较简单，如果熟悉apt的同学就不用看了，只是作为入门级功能。 经过前三篇的讲解，今天做一个简易版的View注入框架，功能类似黄油刀ButterKnife中的一小部分功能，Activity中view通过注解获取实例。 项目结构： processor_lib是一个java lib 项目，实现processor。 annotationlib 注解。 injectlib 供用户调...
使用InjectView和findViewById说拜拜
Hujun1994的博客
08-27 1205
使用InjectView和findViewById说拜拜 Posted on 2014-12-06 /Under Android /With 2 Comments Android的findViewById真是太烦人了，模板似的方法，要写在每个Activity，Fragment，Adapter里面。声明View和findView总是间隔着未知的行距；setOnClickL
Android：一键find控件，从此告别繁琐的findViewById
javy_codercoder的博客
10-30 9885
记得之前写过一篇博客叫做： 你还在苦逼地findViewById吗？使用ButterKnife从此轻松定义控件 此文是介绍在eclipse环境下使用ButterKnife的，相比传统的findViewById确实简单了点~但是笔者认为还不够简单~~ 在谷歌停止对ADT+Eclipse停止更新之后~笔者还苦苦在Eclipse坚持了几个月终于开始转移到Android Studio
Android 通过注解的方式代替findViewById操作
m0_57487205的博客
03-24 3231
Android在使用控件前需要先初始化控件，在以前我们一般都是通过fidViewById方法找到指定id的控件，使用这种方式定义控件时，如果控件的数量很多，就需要指定非常多的findViewById操作，现在我们来探究一下如何通过注解的方式代替findViewById操作。 我们都是到interface是定义了一个接口类，如果在interface前面加一个符号“@”，就成了自定义注解，如下：我们就定义了一个自定义注解， @Target(ElementType.FIELD) @Retention(Ret
ButterKnife
dangai0201的博客
10-08 278
ButterKnife是一个专注于Android系统的View注入框架,可以减少大量的findViewById以及setOnClickListener代码，可视化一键生成。 优势 1、强大的View绑定和Click事件处理功能，简化代码，提升开发效率 2、方便的处理Adapter里的ViewHolder绑定问题 3、运行时不会影响APP效率，使用配置方便 4、代码清晰，可读性强
自定义注解在Android中实现IOC依赖注入
依赖注入是一种设计模式，它允许将对象的创建和依赖关系的管理交由外部环境（通常是IoC容器）来处理。在Android中，通过自定义注解来实现依赖注入是其中一种常见的实践。 ### 自定义注解实现依赖注入的关键知识点：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

玉辰56

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值