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

凌川江雪

发布于 2019-08-12 16:41:53

2K0

发布于 2019-08-12 16:41:53

文章被收录于专栏：李蔚蓬的专栏李蔚蓬的专栏

笔记概述

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还没使用注解的方式， 消息处理的方法也仅限于： onEvent、onEventMainThread、onEventBackgroundThread、onEventSync，分别代表四种线程模型； 在3.0之后，消息处理的方法可以随便取名，但是需要添加一个注解@Subscribe，并且要指定线程的模型；
- Publisher：事件发布者，用于通知Subscriber有事件发生 可以在任意线程、任意位置发送事件， 直接调用EventBus的post(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时，该做的对应的逻辑；

参考资料：慕课网

本文参与腾讯云自媒体分享计划，分享自作者个人站点/博客。

原始发表：2019.08.09 ，如有侵权请联系 cloudcommunity@tencent.com 删除

http

网站

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体分享计划，欢迎热爱写作的你一起参与！

http

网站

登录后参与评论

0 条评论

热度