Android 框架学习1：EventBus 3.0 的特点与如何使用

末蓝、 2022-06-09 10:36 163阅读 0赞

转载自：http://blog.csdn.net/u011240877/article/details/73015939

前面总结了几篇基础，在这过程中看着别人分享自定义 View、[架构][Link 1]或者源码分析，看起来比我写的“高大上”多了，内心也有点小波动。

但是自己的水平自己清楚，基础不扎实画再多源码流程图也没什么意思，还是老老实实打好基础吧，技术这东西不能心急。

在复习了 [Android][] 跨进程、多线程通信的几种方式的基础上，为了调节下心情，我们接下来一起来学以致用，分析分析一些有名的 [android][Android] 事件总线框架。

首先拿 `EventBus` 开刀！

读完本文你将了解：

*   *  [EventBus 30 简介][EventBus 30]
     *  [EventBus 30 关键介绍][EventBus 30 1]
        
         *  [Subscribe 注解][Subscribe]
         *  [四种 ThreadMode][ThreadMode]
         *  [粘性事件 Sticky Event][Sticky Event]
         *  [优先级][Link 2]
         *  [配置][Link 3]
         *  [AsyncExecutor][]
     *  [EventBus 的使用][EventBus]
     *  [运行效果][Link 4]
     *  [总结][Link 5]
     *  [代码地址][Link 6]
     *  [Thanks][]

## EventBus 3.0 简介 ##

首先打开官方文档：[http://greenrobot.org/eventbus/][http_greenrobot.org_eventbus]，一张嚣张的大图吸引了我的目光：

![这里写图片描述][SouthEast]

“Android 第一的事件库”，看起来很牛逼的样子啊，是不是真的这么牛呢？

首先看看介绍：

> EventBus 是一个使用“观察者模式”的、松耦合的开源框架。它使用少量的几句代码就可以实现核心类之间的通讯，帮助我们简化代码、松依赖、加速开发。

![这里写图片描述][SouthEast 1]

观察者模式的确符合这个事件订阅、发布的场景，不了解这个模式的同学可以看看我之前写的两篇文章：

*  [观察者模式 : 一支穿云箭，千军万马来相见][Link 7]
 *  [最熟悉的陌生人：ListView 中的观察者模式][ListView]

在 EventBus 之前，有什么事件通信的方法：

*  `startActivityForResult()` 发出请求 , `onActivityResult()` 接收回调  
    
    
     *  Activity 多层嵌套调用，多次 startActivityForResult，繁琐 = 易出错
     *  嵌套 Fragement 调用，依赖外层 Activity 进行，还是繁琐
 *  回调  
    
    
     *  子线程运行，生命周期不同步
 *  线程间通信

EventBus 提出是为了解决什么问题呢：

*  简化关键组件间的通讯（Activity, Fragment, 线程通信）  
    
    
     *  不管什么组件，都可以通讯
 *  避免复杂的依赖其他类，以及生命周期问题  
    
    
     *  内存 泄漏？
 *  效率很高，优化了性能（重点关注）
 *  体积小
 *  被 一亿 多 app 使用，很吓人
 *  线程间通信，也可以设置订阅者优先级

## EventBus 3.0 关键介绍 ##

1.  方便的注解  
    
    
     *  使用 `@Subscribe` 注解描述方法，可以在编译时获取信息，不需要在运行反射
2.  事件执行线程多种选择  
    
    
     *  主线程
     *  子线程
3.  事件的继承  
    
    
     *  发送给订阅事件 A 的消息，也会发给订阅了 A 的子类的方法
     *  简化事件
4.  不需要在 Application 或者其他部分配置，直接使用 `EventBus.getDefault()` 进行操作即可  
    
    
     *  `EventBus.getDefault()` 做了什么呢？
5.  可配置的  
    
    
     *  可以通过 `Builder` 配置 EventBus

[http://greenrobot.org/eventbus/documentation/][http_greenrobot.org_eventbus_documentation]

### @Subscribe 注解 ###

EventBus 3.0 之后使用 `@Subscribe` 注解来描述一个注册的方法

@Documented
    @Retention(RetentionPolicy.RUNTIME)
    @Target({ElementType.METHOD})
    public @interface Subscribe {
        
        //注册方法所在线程
        ThreadMode threadMode() default ThreadMode.POSTING;    //默认与发生方法在同一线程
    
        //是否为粘性事件
        boolean sticky() default false;
    
        //注册方法接收消息的优先级，当同一线程有多个注册方法时有效
        int priority() default 0;
    }
     
      
       1 
       2 
       3 
       4 
       5 
       6 
       7 
       8 
       9 
       10 
       11 
       12 
       13 
      
     
      
       1 
       2 
       3 
       4 
       5 
       6 
       7 
       8 
       9 
       10 
       11 
       12 
       13

### 四种 ThreadMode ###

@Subscribe(threadMode = ThreadMode.POSTING)
    public void onMessage(MessageEvent event) {
        log(event.message);
    }
     
      
       1 
       2 
       3 
       4 
      
     
      
       1 
       2 
       3 
       4

EventBus 提供了四种 ThreadMode 值：

1.  POSTING  
    
    
     *  订阅方法将和发送者执行在同一线程，默认的值
     *  订阅方法最好不要执行耗时操作，因为它可能会影响发送者的线程
     *  尤其是发送者在主线程的时候
2.  MAIN  
    
    
     *  订阅方法执行在主线程
     *  用于更新 UI
     *  也要注意不执行耗时操作
3.  BACKGROUND  
    
    
     *  订阅方法执行在单一的一个子线程
     *  如果发送者不要主线程，那订阅方法就会执行在发送者线程
     *  否则，使用一个单线程发送所有消息，所有消息串行执行
     *  也要注意避免耗时操作，影响到在同一线程的其他订阅方法
4.  ASYNC  
    
    
     *  订阅方法会在一个新开的子线程（不是主线程、也不是发送者所在线程）执行（类似每次都新建一个线程）
     *  在执行耗时操作时需要使用这个，不会影响其他线程
     *  但是要控制数量，避免创建大量线程导致的开销
     *  EventBus 使用线程池控制

### 粘性事件 Sticky Event ###

EventBus 还支持 粘性事件。

*  普通事件是说，先注册，然后发送事件才能收到
 *  而粘性事件，在发送事件之后再订阅该事件也能收到
 *  此外，粘性事件在发送后会被保存在内存中，每次进入都会去内存中获取最新的粘性事件数据，除非你手动解除注册

可以看到，粘性事件实现了对一些关键信息的缓存与更新，一般用于保存那些经常变化的信息，比如定位信息、传感器信息等等。

@Subscribe(sticky = true)
    public void readStickyMsg(MessageEvent event){
        //...
    }
     
      
       1 
       2 
       3 
       4 
      
     
      
       1 
       2 
       3 
       4

### 优先级 ###

我们可以设置一个注册方法的优先级：

@Subscribe(priority = 1);
    public void onEvent(MessageEvent event) {
        ...
    }
     
      
       1 
       2 
       3 
       4 
      
     
      
       1 
       2 
       3 
       4

默认优先级是 0，同一 线程（ThreadMode） 中优先级高的订阅者会先于低的接收到消息。

注意，只有在同一线程中的订阅者优先级才有作用。

有优先级后 ，高优先级的订阅者就可以取消消息往后的传播，这也符合生活和一些场景的需求。

这通过调用 `cancelEventDelivery(event)` 方法：

@Subscribe
    public void onEvent(MessageEvent event){
        // Process the event
        ...
        // Prevent delivery to other subscribers
        EventBus.getDefault().cancelEventDelivery(event) ;
    }
    Pasted from: http://greenrobot.org/eventbus/documentation/priorities-and-event-cancellation/
     
      
       1 
       2 
       3 
       4 
       5 
       6 
       7 
       8 
      
     
      
       1 
       2 
       3 
       4 
       5 
       6 
       7 
       8

注意，只有 ThreadMode 为 POSTING 的订阅方法可以拦截消息。

> 优先级设置后，界面上显示不明显，因为 EventBus 的消息发送效率很高，但是如果打断点的话就可以看到，的确是高优先级的方法先被调用。

### 配置 ###

我们一般调用 EventBus 直接使用 `EventBus.getDefault()` 方法即可。如果你想要自己配置 EventBus，它也支持。

通过 `EventBus.builder()` 方法我们得到 `EventBusBuilder` 对象，然后配置 EventBus 的各种属性，比如这样：

EventBus eventBus = EventBus.builder()
        .logNoSubscriberMessages(false)
        .sendNoSubscriberEvent(false)
        .build();
     
      
       1 
       2 
       3 
       4 
      
     
      
       1 
       2 
       3 
       4

`EventBusBuilder` 中可以配置的内容如下：

boolean logSubscriberExceptions = true;
    boolean logNoSubscriberMessages = true;
    boolean sendSubscriberExceptionEvent = true;
    boolean sendNoSubscriberEvent = true;
    boolean throwSubscriberException;
    boolean eventInheritance = true;
    boolean ignoreGeneratedIndex;
    boolean strictMethodVerification;
    ExecutorService executorService = DEFAULT_EXECUTOR_SERVICE;
    List<Class<?>> skipMethodVerificationForClasses;
    List<SubscriberInfoIndex> subscriberInfoIndexes;
     
      
       1 
       2 
       3 
       4 
       5 
       6 
       7 
       8 
       9 
       10 
       11 
      
     
      
       1 
       2 
       3 
       4 
       5 
       6 
       7 
       8 
       9 
       10 
       11

可以看到，默认 EventBus 中以下属性是设为 true 的：

*  logSubscriberExceptions： 记录订阅异常
 *  logNoSubscriberMessages ：记录没有目标订阅者的消息
 *  sendSubscriberExceptionEvent ：订阅方法异常时发送 `SubscriberExceptionEvent` 事件
 *  sendNoSubscriberEvent ：发送的消息没有订阅者时发送 `NoSubscriberEvent` 事件
 *  eventInheritance ：事件允许继承

### AsyncExecutor ###

EventBus 还提供了一个异步线程池 `AsyncExecutor`，使用它创建的线程，如果抛出异常，它会自动捕获，然后将异常信息包裹成一个 Event 发送出去。

> AsyncExecutor 只是一个帮我们省去处理子线程抛出异常的工具类，不是 EventBus 的核心类。

我们可以在全局范围内调用 `AsyncExector.create()` 方法创建一个实例，然后调用 `execute` 方法执行异步任务，它的参数是 `AsyncExecutor.RunnableEx`：

AsyncExecutor.create().execute(
        new AsyncExecutor.RunnableEx() {
            @Override
            public void run() throws LoginException {
                // No need to catch any Exception (here: LoginException)
                remote.login();
                EventBus.getDefault().postSticky(new LoggedInEvent());
            }
        }
    );
    Pasted from: http://greenrobot.org/eventbus/documentation/asyncexecutor/
     
      
       1 
       2 
       3 
       4 
       5 
       6 
       7 
       8 
       9 
       10 
       11 
      
     
      
       1 
       2 
       3 
       4 
       5 
       6 
       7 
       8 
       9 
       10 
       11

如果 `RunnableEx` 中抛出异常，`AsyncExecutor` 会捕获这个异常，然后包裹成 `ThrowableFailureEvent` 发送出去，注册了这个事件的方法将会得到调用。

订阅这个异常的例子如下：

@Subscribe(threadMode = ThreadMode.MAIN)
    public void handleFailureEvent(ThrowableFailureEvent event) {
        // do something
    }
     
      
       1 
       2 
       3 
       4 
      
     
      
       1 
       2 
       3 
       4

## EventBus 的使用 ##

> 原文地址：[http://blog.csdn.net/u011240877][http_blog.csdn.net_u011240877]

下面我们演示一下 EventBus 的基本使用。

首先 gradle 引入依赖 EventBus 以及它的注解处理器：

根目录下的 gradle 的 dependencies 中添加 apt 依赖：

classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8'
     
      
       1 
      
     
      
       1

app 目录下的 gradle 中添加：

apply plugin: 'android-apt'
    apt {
        arguments {
            eventBusIndex "top.shixinzhang.MyEventBusIndex"
        }
    }
    dependencies {
        compile 'org.greenrobot:eventbus:3.0.0'
        apt 'org.greenrobot:eventbus-annotation-processor:3.0.1'
    }
     
      
       1 
       2 
       3 
       4 
       5 
       6 
       7 
       8 
       9 
       10 
      
     
      
       1 
       2 
       3 
       4 
       5 
       6 
       7 
       8 
       9 
       10

其中 `eventBusIndex` 你可以随意设置包名和文件名。

然后就可以发车了！

创建要订阅的事件：

public class MessageEvent implements Serializable {
        
        private static final long serialVersionUID = -1371779234999786464L;
        private String message;
        private String time;
    
        public MessageEvent(String message, String time) {
            this.message = message;
            this.time = time;
        }
    
        public String getMessage() {
            return message;
        }
    
        public void setMessage(String message) {
            this.message = message;
        }
    
        public String getTime() {
            return time;
        }
    
        public void setTime(String time) {
            this.time = time;
        }
    }
     
      
       1 
       2 
       3 
       4 
       5 
       6 
       7 
       8 
       9 
       10 
       11 
       12 
       13 
       14 
       15 
       16 
       17 
       18 
       19 
       20 
       21 
       22 
       23 
       24 
       25 
       26 
      
     
      
       1 
       2 
       3 
       4 
       5 
       6 
       7 
       8 
       9 
       10 
       11 
       12 
       13 
       14 
       15 
       16 
       17 
       18 
       19 
       20 
       21 
       22 
       23 
       24 
       25 
       26

然后创建一个注册 EventBus 页面：

public class EventBusRegisterActivity extends AppCompatActivity {
        
    
        @BindView(R.id.tv_event_info)
        TextView mTvEventInfo;
        @BindView(R.id.tv_event_info_priority)
        TextView mTvEventInfoPriority;
        @BindView(R.id.btn_cancel_delivery)
        Button mBtnCancelDelivery;
        private boolean mCancelDelivery;
    
        @Override
        protected void onCreate(@Nullable Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_event_bus_test);
            ButterKnife.bind(this);
        }
    
        /**
         * 订阅方法，设置线程为 POSTING，优先级为 5
         * @param event
         */
        @Subscribe(threadMode = ThreadMode.POSTING, priority = 5)
        public void readMessageFirst(MessageEvent event) {
            mTvEventInfoPriority.setText("\n" + event.getMessage() + ", " + event.getTime());
            if (mCancelDelivery) {
                EventBus.getDefault().cancelEventDelivery(event);
            }
        }
    
        @Subscribe(threadMode = ThreadMode.POSTING, priority = 1)
        public void readMessage(MessageEvent event) {
            mTvEventInfo.setText("\n" + event.getMessage() + ", " + event.getTime());
        }
    
        /**
         * 为了演示效果，我们在按钮点击事件中注册事件
         */
        @OnClick(R.id.btn_register_normal)
        public void registerNormal() {
            if (!EventBus.getDefault().isRegistered(this)) {
                EventBus.getDefault().register(this);
            }
        }
    
        @OnClick(R.id.btn_unregister_normal)
        public void unregisterNormal() {
            EventBus.getDefault().unregister(this);
        }
    
    
        @OnClick(R.id.btn_cancel_delivery)
        public void cancelDelivery() {
            mCancelDelivery = !mCancelDelivery;
            mBtnCancelDelivery.setText(mCancelDelivery ? "已拦截事件传递" : "点击拦截事件传递");
        }
    
        @OnClick(R.id.btn_jump_next)
        public void jumpToNext() {
            startActivity(new Intent(this, EventBusPosterActivity.class));
        }
    
    
        @OnClick(R.id.btn_jump_sticky)
        public void jumpToSticky() {
            startActivity(new Intent(this, EventBusStickyActivity.class));
        }
    
    
        @Override
        protected void onDestroy() {
            super.onDestroy();
        }
    }
     
      
       1 
       2 
       3 
       4 
       5 
       6 
       7 
       8 
       9 
       10 
       11 
       12 
       13 
       14 
       15 
       16 
       17 
       18 
       19 
       20 
       21 
       22 
       23 
       24 
       25 
       26 
       27 
       28 
       29 
       30 
       31 
       32 
       33 
       34 
       35 
       36 
       37 
       38 
       39 
       40 
       41 
       42 
       43 
       44 
       45 
       46 
       47 
       48 
       49 
       50 
       51 
       52 
       53 
       54 
       55 
       56 
       57 
       58 
       59 
       60 
       61 
       62 
       63 
       64 
       65 
       66 
       67 
       68 
       69 
       70 
       71 
       72 
       73 
      
     
      
       1 
       2 
       3 
       4 
       5 
       6 
       7 
       8 
       9 
       10 
       11 
       12 
       13 
       14 
       15 
       16 
       17 
       18 
       19 
       20 
       21 
       22 
       23 
       24 
       25 
       26 
       27 
       28 
       29 
       30 
       31 
       32 
       33 
       34 
       35 
       36 
       37 
       38 
       39 
       40 
       41 
       42 
       43 
       44 
       45 
       46 
       47 
       48 
       49 
       50 
       51 
       52 
       53 
       54 
       55 
       56 
       57 
       58 
       59 
       60 
       61 
       62 
       63 
       64 
       65 
       66 
       67 
       68 
       69 
       70 
       71 
       72 
       73

![这里写图片描述][SouthEast 2]

这个页面的功能如图所示：

*  有两个优先级不同的订阅方法，有两个按钮用于注册和解除注册订阅
 *  一个用于高优先级订阅方法拦截事件向后传递的按钮
 *  还有一个按钮用于跳转到发送事件页面中，另一个按钮用于跳转到粘性事件订阅页面。

先看下粘性事件订阅页面：

public class EventBusStickyActivity extends AppCompatActivity {
        
    
        @BindView(R.id.tv_event_info)
        TextView mTvEventInfo;
        @BindView(R.id.btn_register_sticky_event)
        Button mBtnRegisterStickyEvent;
    
        @Override
        protected void onCreate(@Nullable Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_event_bus_sticky);
            ButterKnife.bind(this);
        }
    
        @Subscribe(threadMode = ThreadMode.MAIN, sticky = true)
        public void readStickyMsg(MessageEvent event){
            mTvEventInfo.setText(mTvEventInfo.getText() + "\n" + event.getMessage() + ", " + event.getTime());
        }
    
        @OnClick(R.id.btn_jump_next)
        public void jumpToNext(){
            startActivity(new Intent(this, EventBusPosterActivity.class));
        }
    
        @OnClick(R.id.btn_register_sticky_event)
        public void registerSticky(){
            EventBus.getDefault().register(this);
        }
    
        @OnClick(R.id.btn_unregister_sticky_event)
        public void unregisterSticky(){
            EventBus.getDefault().removeStickyEvent(MessageEvent.class);
        }
    
        @Override
        protected void onDestroy() {
            super.onDestroy();
        }
    }
     
      
       1 
       2 
       3 
       4 
       5 
       6 
       7 
       8 
       9 
       10 
       11 
       12 
       13 
       14 
       15 
       16 
       17 
       18 
       19 
       20 
       21 
       22 
       23 
       24 
       25 
       26 
       27 
       28 
       29 
       30 
       31 
       32 
       33 
       34 
       35 
       36 
       37 
       38 
       39 
      
     
      
       1 
       2 
       3 
       4 
       5 
       6 
       7 
       8 
       9 
       10 
       11 
       12 
       13 
       14 
       15 
       16 
       17 
       18 
       19 
       20 
       21 
       22 
       23 
       24 
       25 
       26 
       27 
       28 
       29 
       30 
       31 
       32 
       33 
       34 
       35 
       36 
       37 
       38 
       39

![这里写图片描述][SouthEast 3]

功能如图所示：

*  一个显示订阅方法接收信息的文字
 *  一个点击后跳转到发送事件页面的按钮
 *  两个用于注册和解除注册粘性事件的按钮

好，接着再看一下发送事件页面：

public class EventBusPosterActivity extends AppCompatActivity {
        
    
        @BindView(R.id.tv_event_info)
        TextView mTvEventInfo;
        @BindView(R.id.btn_post_normal)
        Button mBtnPostNormal;
        @BindView(R.id.btn_post_sticky_event)
        Button mBtnPostStickyEvent;
    
        @Override
        protected void onCreate(@Nullable Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_event_bus_post);
            ButterKnife.bind(this);
        }
    
        @OnClick(R.id.btn_post_normal)
        public void postNormalEvent(){
            EventBus.getDefault().post(new MessageEvent("另外界面的主线程，普通消息", DateUtils.getCurrentTime()));
            finish();
        }
    
        @OnClick(R.id.btn_post_sticky_event)
        public void postStickyEvent(){
            EventBus.getDefault().postSticky(new MessageEvent("另外界面的主线程，粘性消息", DateUtils.getCurrentTime()));
            finish();
        }
    }
     
      
       1 
       2 
       3 
       4 
       5 
       6 
       7 
       8 
       9 
       10 
       11 
       12 
       13 
       14 
       15 
       16 
       17 
       18 
       19 
       20 
       21 
       22 
       23 
       24 
       25 
       26 
       27 
       28 
      
     
      
       1 
       2 
       3 
       4 
       5 
       6 
       7 
       8 
       9 
       10 
       11 
       12 
       13 
       14 
       15 
       16 
       17 
       18 
       19 
       20 
       21 
       22 
       23 
       24 
       25 
       26 
       27 
       28

![这里写图片描述][SouthEast 4]

这个页面很简单，两个发送普通事件和粘性事件的按钮。

## 运行效果 ##

演示下普通事件的注册、解除注册、以及高优先级拦截事件的运行效果：

![这里写图片描述][SouthEast 5]

从上面的动图可以看到：

*  注册事件监听后，订阅的方法就可在 EventBus 发送事件后收到调用
 *  优先级高的会比低的先收到调用，界面上显示不明显，但是打断点就可以看到先后的调用顺序
 *  优先级高的拦截事件后，低优先级的就不会收到新的事件
 *  解除注册后，也不会收到新的事件

接着看一下 粘性事件的注册、解除注册的效果：

![这里写图片描述][SouthEast 6]

从上面的动图可以看到：

*  在发送粘性事件之后注册粘性监听，也可以得到消息
 *  发送的粘性事件会被缓存起来，以后只要注册这个事件就会得到消息
 *  当发送新的粘性事件后，订阅粘性事件的方法会更新到最新的值
 *  解除粘性事件的注册后，就不会再去获取值

可以看到，粘性事件的确适用于获取一些需要缓存的关键信息，比如城市、天气等等。

## 总结 ##

这篇文章介绍了 EventBus 3.0 的主要特点和使用，可以发现，它的确很容易使用，目前能想到的事件通讯基本都可以满足，代码耦合也不严重。

而 EventBus 的缺点就是，会导致业务逻辑比较分散，不直观。尤其是在运行时触发多种事件、多个订阅方法时。不过这应该是解耦的双刃剑吧。

下一篇文章我们分析下 EventBus 的核心功能是如何实现的。

> 有些之前不了解的内容，在写了 Sample 之后才发现错在哪儿，知行合一，知行合一啊！

## [代码地址][Link 8] ##

## Thanks ##

[http://greenrobot.org/eventbus/][http_greenrobot.org_eventbus]  
[http://greenrobot.org/eventbus/documentation/][http_greenrobot.org_eventbus_documentation]  
[https://github.com/greenrobot/EventBus][https_github.com_greenrobot_EventBus]  
[https://segmentfault.com/a/1190000005089229][https_segmentfault.com_a_1190000005089229]  
[http://www.jianshu.com/p/f057c460c77e][http_www.jianshu.com_p_f057c460c77e]  
[http://liuwangshu.cn/application/eventbus/1-eventbus.html][http_liuwangshu.cn_application_eventbus_1-eventbus.html]

[Link 1]: http://lib.csdn.net/base/architecture
[Android]: http://lib.csdn.net/base/android
[EventBus 30]: http://blog.csdn.net/u011240877/article/details/73015939#eventbus-30-%E7%AE%80%E4%BB%8B
[EventBus 30 1]: http://blog.csdn.net/u011240877/article/details/73015939#eventbus-30-%E5%85%B3%E9%94%AE%E4%BB%8B%E7%BB%8D
[Subscribe]: http://blog.csdn.net/u011240877/article/details/73015939#subscribe-%E6%B3%A8%E8%A7%A3
[ThreadMode]: http://blog.csdn.net/u011240877/article/details/73015939#%E5%9B%9B%E7%A7%8D-threadmode
[Sticky Event]: http://blog.csdn.net/u011240877/article/details/73015939#%E7%B2%98%E6%80%A7%E4%BA%8B%E4%BB%B6-sticky-event
[Link 2]: http://blog.csdn.net/u011240877/article/details/73015939#%E4%BC%98%E5%85%88%E7%BA%A7
[Link 3]: http://blog.csdn.net/u011240877/article/details/73015939#%E9%85%8D%E7%BD%AE
[AsyncExecutor]: http://blog.csdn.net/u011240877/article/details/73015939#asyncexecutor
[EventBus]: http://blog.csdn.net/u011240877/article/details/73015939#eventbus-%E7%9A%84%E4%BD%BF%E7%94%A8
[Link 4]: http://blog.csdn.net/u011240877/article/details/73015939#%E8%BF%90%E8%A1%8C%E6%95%88%E6%9E%9C
[Link 5]: http://blog.csdn.net/u011240877/article/details/73015939#%E6%80%BB%E7%BB%93
[Link 6]: http://blog.csdn.net/u011240877/article/details/73015939#%E4%BB%A3%E7%A0%81%E5%9C%B0%E5%9D%80
[Thanks]: http://blog.csdn.net/u011240877/article/details/73015939#thanks
[http_greenrobot.org_eventbus]: http://greenrobot.org/eventbus/
[SouthEast]: /images/20220609/03398dd2cea845bc9f03d82503f1c97b.png
[SouthEast 1]: /images/20220609/dea9f154196743db903c074c606c865c.png
[Link 7]: http://blog.csdn.net/u011240877/article/details/52683558
[ListView]: http://blog.csdn.net/u011240877/article/details/52683711
[http_greenrobot.org_eventbus_documentation]: http://greenrobot.org/eventbus/documentation/
[http_blog.csdn.net_u011240877]: http://blog.csdn.net/u011240877
[SouthEast 2]: /images/20220609/786202c0f36a4dea96a0f53d588f2de2.png
[SouthEast 3]: /images/20220609/cf5e7c77aed74c5ba78b05bdd15c1210.png
[SouthEast 4]: /images/20220609/1358c7b5fe854f79ad757735729cd97f.png
[SouthEast 5]: /images/20220609/e2da9fc2e5aa4b978c50c049219f36eb.png
[SouthEast 6]: /images/20220609/08b0b56489e1410ab6ef09de995bdd38.png
[Link 8]: https://github.com/shixinzhang/LearnAndroid/blob/dev/app/src/main/java/net/sxkeji/shixinandroiddemo2/activity/eventbus/EventBusRegisterActivity.java
[https_github.com_greenrobot_EventBus]: https://github.com/greenrobot/EventBus
[https_segmentfault.com_a_1190000005089229]: https://segmentfault.com/a/1190000005089229
[http_www.jianshu.com_p_f057c460c77e]: http://www.jianshu.com/p/f057c460c77e
[http_liuwangshu.cn_application_eventbus_1-eventbus.html]: http://liuwangshu.cn/application/eventbus/1-eventbus.html