EventBus原理解析笔记以及案例实战（结合demo）#笔记概述 ####EventBus简介 ####EventBu

#笔记概述

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

#EventBus简介

开源项目地址：github.com/greenrobot/…
EventBus主页：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架构 ![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/e29b123037fa4d02af74a4e9bca32c10~tplv-k3u1fbpfcp-zoom-1.image) - 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时，该做的对应的逻辑；

参考资料：慕课网