笔记概述

• 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时，该做的对应的逻辑**；

参考资料：慕课网