EventBus原理解析笔记以及案例实战(结合demo)

笔记概述

  • EventBus简介
  • EventBus方法介绍
  • EventBus实际运用

EventBus简介

  • 开源项目地址:https://github.com/greenrobot/EventBus
  • EventBus主页:http://greenrobot.org/eventBus/
  • github项目地址中关于EventBus的简介: Event bus for Android and Java that simplifies communication between Activities, Fragments, Threads, Services, etc. Less code, better quality. 即, Event 简化了活动、碎片、进程、服务等之间的通讯方式; 使APP项目用更少的代码量实现更好的质量;

  • 关于EventBus的优势
  • 简化组件间的通讯方式
    • 解耦合事件发送者和接收者
    • 使活动、碎片和后台的线程实现更高的执行效率
    • 防止复杂的有错误(倾向)的依赖以及生命周期的问题
  • 让你的代码简洁
  • 运行快
  • 库小
  • EventBus主页简洁: EventBus is an open-source library for Android and Java using the publisher/subscriber pattern for loose coupling. EventBus enables central communication to decoupled classes with just a few lines of code – simplifying the code, removing dependencies, and speeding up app development. 即, EventBus是一个开源库, 使用发布/订阅机制来对代码进行解耦。 简化项目的集中通讯(仅仅通过几行代码就可以解耦各个类), 移除了一些不必要的依赖,加速移动应用的开发。

关于大项目,如果还是用Java/Android原生的调用, 两个Activity之间的通讯, 还用startActivity()/startActivityForResult()这类通信方式的话, 代码会非常的冗余 例如Activity和Fragment之间的通讯就需要不断地调用相关的函数 使用EventBus可以解除这些耦合; 否则如果代码耦合性非常大的话, 会大大增加后期维护的难度!


EventBus架构

  • Publisher 调用post()方法, 把Event发送到EventBus;
  • EventBus(类似于快递中心) 分发Publisher发布的Event 给对应的Subscriber(订阅者);
  • Subscriber接收Event;

EventBus概述

  • EventBus是一个Android端优化的 publish/subscribe消息总线;
  • 简化了应用程序内各组件间、组件与后台线程间的通讯;
  • 举例一个EventBus可简化代码的场景: 请求网络时候,等网络返回时通过Handler或Broadcast通知UI; 两个Fragment之间需要通过Listener通讯; 以上都可以用EventBus来代替;
  • EventBus作为一个消息总线,有三个主要的元素:
    • Event:事件 Event可以是任意对象, 用来描述传递的数据事件类型; 一般Event是由开发者按照需求自己定义的, 里面封装要传递的事件类型和数据
    • Subscriber:事件订阅者,接收待定的事件 在Event中,使用约定制定事件订阅者简化使用在3.0之前,EventBus还没使用注解的方式, 消息处理的方法也仅限于: onEventonEventMainThreadonEventBackgroundThreadonEventSync, 分别代表四种线程模型在3.0之后消息处理的方法可以随便取名, 但是需要 添加一个注解@Subscribe, 并且要指定线程的模型
    • Publisher:事件发布者,用于通知Subscriber有事件发生 可以在任意线程、任意位置发送事件, 直接调用EventBuspost(Object)方法即可;
    • 调用EventBus.getDefault()方法,实例化EventBus对象

EventBus线程模型

ThreadMode ThreadMode指定了会调用的函数, 只能有以下四种(因为每个订阅事件都是和一个线程模型相关的): PostThread、 BackgroundThread、 MainThread、 Async

PostThread: 在相同的进程中做EventBus通信

  • 事件的处理事件的发送相同的进程, 所以事件的处理时间不应太长, 不然会影响事件的发送线程而这个线程可能是UI线程
  • 对应的函数名是onEvent一般在UI线程使用, 如果堵塞时间较长则会影响其他线程的刷新 引起界面的卡顿 打个比方说你在UI线程中卡了两秒等下UI就不动,不刷新了

相关地举一个案例

  • 这里有两个Activity:

按下Activity1中的Button, 会跳转到Activity2; 按下Activity2中的button, 会通过EventBus去通知Activity1; Activity1会通过OnEvent接收, 如果接收到Activity2发送过来消息, 然后触发Toast;

接下来新建一个项目,根据官方GitHub添加依赖,

implementation 'org.greenrobot:eventbus:3.1.1'

下面是主布局(Activity1):

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

    <Button
        android:id="@+id/bt_toAc2"
        android:text="跳转到Activity2"
        android:layout_width="match_parent"
        android:layout_height="wrap_content" />

</LinearLayout>
  • 然后根据需求定义Event(类似于Module类), 这里没什么特别需求, 定义一个简单的Event就可以了:
public class MyEvent {

    public String msg;

    public MyEvent() {}

    public MyEvent(String msg) {
        this.msg = msg;
    }
}
  • 接下来, 要在我们这个“Activity1”里面注册 OnEvent , 这个OnEvent 是在跟 发送事件的线程 同一个线程里面 接收事件的, 我们这里虽然是分开两个Activity, 但是Activity本身就都是在主线程里面的; 所以这里 事件的发送(在Activity2), 事件的接收(在Activity1) 都在同一个线程中; 即,以上所说的PostThread线程类型中, 事件的发送 跟 事件的接收 是在同一个线程里面的; 下面注册一个onEvent(), 如果接收到Activity2发送过来消息,触发Toast;
    /**
     * 注册onEvent(),
     * 注意写上注解!
     */
    @Subscribe
    public void onEvent(MyEvent event) {
        popOutToast("接收到Event:" + event.msg);
    }
    /**
     * 封装弹出短时Toast提示
     * @param text 企图弹出的文本内容
     *
     */
    private void popOutToast(String text) {
        Toast.makeText(MainActivity.this,text,Toast.LENGTH_SHORT).show();
    }
  • 使用EventBus的接收方法的活动,需要在onCreate中注册
        EventBus.getDefault().register(this);
  • 反注册
    @Override
    protected void onDestroy() {
        super.onDestroy();
        EventBus.getDefault().unregister(this);
    }
  • 整个Activity1的java代码:
public class MainActivity extends AppCompatActivity {

    private Button mButton;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        //使用EventBus的接收方法的活动,需要注册
        EventBus.getDefault().register(this);

        mButton = findViewById(R.id.bt_toAc2);
        mButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent intent = new Intent(MainActivity.this, SecondActivity.class);
                startActivity(intent);
            }
        });
    }

    /**
     * 注册onEvent(),
     * 注意写上注解!
     */
    @Subscribe
    public void onEvent(MyEvent event) {
        popOutToast("接收到Event:" + event.msg);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        EventBus.getDefault().unregister(this);
    }

    /**
     * 封装弹出短时Toast提示
     * @param text 企图弹出的文本内容
     *
     */
    private void popOutToast(String text) {
        Toast.makeText(MainActivity.this,text,Toast.LENGTH_SHORT).show();
    }
}

创建第二个活动SecondActivity,布局:

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

    <Button
        android:id="@+id/bt_sendMsg"
        android:text="发送消息"
        android:layout_width="match_parent"
        android:layout_height="wrap_content" />

</LinearLayout>

java:

public class SecondActivity extends AppCompatActivity {

    private Button mButton;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_second);

        mButton = findViewById(R.id.bt_sendMsg);
        mButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                EventBus.getDefault().post(new MyEvent("洞妖洞妖我是栋二!!!"));
            }
        });
    }
}

运行效果图:

Activity1:

跳到Activity2,点击按钮,弹出Toast:

补充

  • 以上这种场景, 如果不用EventBus, 我们可能需要用到Handler + Runnable的方式, 但是如果有十个Activity向Activity1发消息, 我们就需要写十个Handler了, 这样子相当繁琐; 而使用EventBus, 这里只要稍微用代码注册一下就可以了, 明显方便很多, 一个方post、一个onEvent,也很轻松地解耦了;

  • 另外一个需要注意的地方就是, EventBus.getDefault().register(this);系列的注册与反注册代码, onEvent()系列的接收函数是紧密绑定的; 用时缺一不可,不用时存一不可,同生同灭; 也就是说一个活动注册onEvent()系列的接收函数了, 则必须用EventBus.getDefault().register(this);去注册, 不然会报错; 而一个活动它没有写onEvent()系列的接收函数, 却用EventBus.getDefault().register(this);去注册了, 同样也会报错!
  • onEvent()处理时间比较长,会导致线程堵塞; 如以下再onEvent()中挂起线程3秒,模拟3秒处理时间:
    @Subscribe
    public void onEvent(MyEvent event) {

        //消耗时间模拟
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        popOutToast("接收到Event:" + event.msg);
    }

接着运行项目的话, 会发现我们在Activity2中点击发送消息的按钮之后, 要等到3秒钟,主线程才会刷新UI(弹出Toast), 这样子在实际运用中用户体验很差;

MainThread

  • 其机制同onEvent()其实是差不多的, 即发送接收都是在同一个线程 主线程 / UI线程中进行;

使用:基于PostThread的代码, 加多一行(threadMode = ThreadMode.MAIN)即可:

    //MainThread
    @Subscribe(threadMode = ThreadMode.MAIN)
    public void onEvent(MyEvent event) {

        //消耗时间模拟
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        popOutToast("接收到Event:" + event.msg);
    }

BackgroundThread

  • 事件的处理会在一个后台线程中执行, 对应的函数名是onEventBackgroundThread
  • 虽然名字是BackgroundThread, 事件的处理是在后台线程, 但事件的处理时间还是不宜太长;
  • 如果发送事件的线程是在后台线程, 会直接执行事件;
  • 如果当前线程是UI线程, 事件会被加到一个队列中, 由一个线程依次处理这些事件, 如果某个事件处理时间太长, 会阻塞队列中 排在后面的事件的派发或处理;

图解

对于PostThread和MainThread

一次执行
  • 当只有一个线程的时候, post(发送)和onEvent()是在同一个线程中去跑的, 一个线程里面的话, 宏观上来说,其代码便是一次执行的:

对于BackgroundThread

一一对应
  • 这里有两个线程,UI主线程和后台线程, 这个后台线程 专门用来 处理onEventBackgroundThread方法及其对应的事件的; 也就是说, 比如现在主线程里面有一个post, 它会对应执行到后台的一个onEventBackgroundThread()
顺序执行,前者执行,后者等待阻塞
  • 一个前台线程的post 会对应执行到一个后台线程的onEventBackgroundThread(); 来了第二个post, 就对应第二个onEventBackgroundThread()
  • 后台线程中的onEventBackgroundThread(); 是按照post顺序依次执行的; 如果前面一个post对应的onEventBackgroundThread();没有执行完, 这时候又post了一下, 那么对应的后面的这个onEventBackgroundThread()会等待前面一个onEventBackgroundThread()执行完,它才执行;
  • 来个例子,修改MainActivity代码:
    //BackgroundThread
    @Subscribe(threadMode = ThreadMode.BACKGROUND)
    public void onEvent(MyEvent event) {

        Log.d(TAG, "onEvent Start!!!!!!!! ");
        //消耗时间模拟
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        Log.d(TAG, "onEvent End!!!!!!!! ");

//        popOutToast("接收到Event:" + event.msg);
    }
  • 接着运行代码, 老规矩,Activity1跳转到Activity2, 点击“发送信息”按钮, 连续点击两次(根据以上SecondActivity中写的按钮点击事件, 这里可以理解成连续post两次,一前一后), 观察logcat:
  • 我们可以观察到两对Start和End是顺序执行的;
  • 执行时候没有交叉,先第一对,后第二对; 这里也便验证了以上理论—— 即, 一一对应,一个post对应一个event, event顺序执行, 前post者对应的event执行中, 则后post者对应的event等待阻塞;
  • 其实把代码改成MainThread的, 再运行,连续点击三次, 同样是能体现一一对应,顺序执行,前者执行,后者等待阻塞的特性:
    @Subscribe(threadMode = ThreadMode.MAIN)
    public void onEvent(MyEvent event) {

        Log.d(TAG, "onEvent Start!!!!!!!! ");
        //消耗时间模拟
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        Log.d(TAG, "onEvent End!!!!!!!! ");

//        popOutToast("接收到Event:" + event.msg);
    }
  • 但区别在于, Main是执行在主线程, 而Background是执行在后台线程, 而且我们前面说过, 在主线程中执行占用资源多、占用时间长的任务是不合适的, 既不规范,也影响体验;

  • PostThread/MainThread缺点: 执行在主线程, 事件的个数,事件的耗时, 都需要做比较严格的限制
  • BackgroundThread缺点: 运行在后台线程,不占用主线程资源, 比PostThread/MainThread好那么一点, 但是还是没有解决—— 多个(>= 2 个)事件时, 一次处理一个,依次处理, 前者执行,后者等待阻塞的问题, 不适合事件中有耗时较长的任务

Async adj.异步的;

sync n.同时,同步;
  • 事件处理会在单独的线程中执行, 主要用于在后台线程中执行耗时操作, 每个事件会开启一个线程 (程序初始化时,已经帮我们创建好一个线程池, 每次POST一下框架都会去取一个线程来执行), 但最好限制线程的数目 (线程过多,CPU使用大,设备耗电快); 每次POST一下框架都会去取一个线程来执行 线程池中线程之间互相不干扰,可以同时运行

更改代码:

    //AsyncThread
    @Subscribe(threadMode = ThreadMode.ASYNC)
    public void onEvent(MyEvent event) {

        Log.d(TAG, "onEvent Start!!!!!!!! ");
        //消耗时间模拟
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        Log.d(TAG, "onEvent End!!!!!!!! ");
    }

执行效果:

这次我们可以看到, 事件的处理就没有—— 一次处理一个,依次处理,前者执行中,后者等待阻塞的特性了, 因为各个post的事件, 都有各自独立的线程去处理, 所以事件的处理运行是同时的、异步的;

小结

  • PostThread:发送和接收在同一个线程;
  • MainThread:发送和接收同在主线程; (应用范围上被PostThread包括)
  • BackgroundThread

  • PostThread/MainThread缺点: 一般执行在主线程, 事件的个数,事件的耗时, 都需要做比较严格的限制
  • BackgroundThread缺点: 运行在后台线程,不占用主线程资源, 比PostThread/MainThread好那么一点, 但是还是没有解决—— 多个(>= 2 个)事件时, 一次处理一个,依次处理, 前者执行,后者等待阻塞的问题, 不适合事件中有耗时较长的任务

以上三种线程都是不适合跑耗时操作的;

Async adj.异步的; 核心:异步,同时,高效

  • 事件处理会在单独的线程中执行, 主要用于在后台线程中执行耗时操作, 每个事件会开启一个线程 (程序初始化时,已经帮我们创建好一个线程池, 每次POST一下框架都会去取一个线程来执行), 但最好限制线程的数目 (线程过多,CPU使用大,设备耗电快); 每次POST一下框架都会去取一个线程来执行 线程池中线程之间互相不干扰,可以同时运行

补充:

  • 优先级(priority)就是字面上的意义, 值越高,优先级越高;
  • sticy即粘性发送, 发送方法EventBus.getDefault().postSticky(new MyEvent()); 注销粘性event的方法EventBus.getDefault().removeStickyEvent(new MyEvent()); 发送(postSticky)的时候, 项目中有多少Fragment、Activity等载体, 事件MyEvent就发送多少份; 粘性其意义在于, 无论项目中载体类中 是否使用EventBus.getDefault().register(this);对EventBus注册过, 都会对其发送事件, 若载体注册了,则接收处理该粘性事件; 若载体未注册,则该粘性事件会缓存起来, 一旦载体注册,马上接收处理事件

但由于这种粘性发送在项目比较大的时候 需要占用一定量的缓存资源, 所以一般使用较少;

  • 另外一个需要注意的地方就是, EventBus.getDefault().register(this);系列的注册与反注册代码, onEvent()系列的接收函数是紧密绑定的; 用时缺一不可,不用时存一不可,同生同灭; 也就是说一个活动注册onEvent()系列的接收函数了, 则必须用EventBus.getDefault().register(this);去注册, 不然会报错; 而一个活动它没有写onEvent()系列的接收函数, 却用EventBus.getDefault().register(this);去注册了, 同样也会报错!

使用技巧

  • 事件只需要传递一个状态 / 指令,无需传递数据时, event自定义类内容可以为空; 比如一个只需要传递“清空位置信息列表”这个指令的事件, 可以这么定义:

就是定义一个Event类,但是内容为空; 即 无需传递数据, 仅仅event类的类名已经具备传递的事件、指令意义;

  • 一个Fragment或者Activity需要接收处理多个Event时候, 通过建立多个注解方法,并以不同的event 形参 区分处理,接收到不同的event时,该做的对应的逻辑

参考资料:慕课网

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

扫码关注云+社区

领取腾讯云代金券