移动架构<第六篇>：EventBus事件总线框架

在Android的实际开发中，消息的通信是非常频繁的。结合Android的基础知识，常用的通信方式有Intent、Handler、Broadcast，它们都可以在Activity、Fragment、Service之间相互通信，但是呢？从架构的思维考虑，Android本身的通信方式会增加代码架构的复杂度。为了解决这个问题，必须要重新定制一个新的通信方案。
通信方式有两种：线程间通信和跨进程通信
本文主要讲解EventBus框架的使用，它只能实现线程间的通信，不支持跨进程通信。

[github地址]

首先，EventBus对应的github地址需要记住，如下：

https://github.com/greenrobot/EventBus

EventBus的版本会被更新的，所以，想要知道EventBus的最新版本，需要打开对应的github地址查看。

[简单演示]

首先贴一下演示代码：

public class MainActivity extends AppCompatActivity {

    private Button button;

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

        //注册
        EventBus.getDefault().register(this);

        button = findViewById(R.id.button);
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        //发送消息
                        EventBus.getDefault().post(new MessageEvent(100));
                    }
                }).start();
            }
        });
    }

    /**
     * 接收消息
     * @param event
     */
    @Subscribe(threadMode = ThreadMode.MAIN)
    public void onMessageEvent(MessageEvent event) {
        /* Do something */
        Log.d("yunchong", "MessageEvent的flag值为："+event.getFlag());
    }

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

EventBus的使用非常简单，如上代码所示，在onCreate方法里面注册，在onDestroy方法里面解注册，代码EventBus.getDefault().post发送消息，以及onMessageEvent方法接收消息。这种写法类似于Android的BroadCast，但和Android的BroadCast有本质的区别。

在一些项目中，我经常看到Activity和Fragment之间的通信使用广播来实现，我对广播的理解分为以下几点：

• 常用的广播分为Broadcast（常规广播）和LocalBroadcast（本地广播）。前者发送的消息，整个系统都能收到，后者发送的消息只能当前应用可以收到。但是，由于大型项目中可能存在无数消息的传递，这样会导致广播的泛滥，可读性变差，如果非要使用广播的话建议使用后者；
• 广播的注册方式有两种：动态注册和静态注册，本人不推荐静态注册方式，因为静态注册方式使广播常驻内存，广播是非常消耗内存的，静态注册方式不可取；
• Android的广播机制不仅可以跨线程也能跨进程，但是广播的代码实在不能用优雅这个词来形容，从后期项目的维护成本出发，广播的代码还是比较紊乱的，加大了项目的维护成本。

所以，EventBus完全可以替代Android的广播，不仅如此，任何跨线程的通信都可以使用EventBus。那么，跨进程怎么玩？Android的跨进程常常使用AIDL机制，但考虑到代码的简洁性，推荐使用Hermes框架，Hermes框架不是本章的重点，所以把思路重新回到EventBus上。

要使用EventBus，一般需要注册，register方法的参数传递一个对象，大部分情况下，这个对象是当前Activity对象。

    //注册
    EventBus.getDefault().register(this);

为了防止内存泄漏，对应的还有反注册，代码如下：

    EventBus.getDefault().unregister(this);

发送消息（发布者Publisher），post方法后面的参数可以传递基本数据类型或者对象，建议传递一个对象。

         EventBus.getDefault().post(new MessageEvent(100));

接收消息（发布者Subscriber），onMessageEvent是接收消息的方法，这个方法必须添加注解@Subscribe，不然发送消息时找不到内存中注解对应的onMessageEvent方法，其次onMessageEvent方法必须有且只有一个形式参数，这个参数表示要接收的消息类型，如果发送的消息对象非MessageEvent对象，那么onMessageEvent方法是无法被执行的。

/**
 * 接收消息
 * @param event
 */
@Subscribe(threadMode = ThreadMode.MAIN)
public void onMessageEvent(MessageEvent event) {
    /* Do something */
    Log.d("yunchong", "MessageEvent的flag值为："+event.getFlag());
}

[线程模式]

接收消息的方法被@Subscribe修饰，它是EventBus框架的自定义注解，源码如下：

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface Subscribe {
    ThreadMode threadMode() default ThreadMode.POSTING;

    /**
     * If true, delivers the most recent sticky event (posted with
     * {@link EventBus#postSticky(Object)}) to this subscriber (if event available).
     */
    boolean sticky() default false;

    /** Subscriber priority to influence the order of event delivery.
     * Within the same delivery thread ({@link ThreadMode}), higher priority subscribers will receive events before
     * others with a lower priority. The default priority is 0. Note: the priority does *NOT* affect the order of
     * delivery among subscribers with different {@link ThreadMode}s! */
    int priority() default 0;
}

从源码中得到的信息可以看出，该注解只能作用于方法上，并且该方法在运行时被常驻到内存中。
它有三个成员：threadMode、sticky、priority

priority：消息接收的优先级，默认为0，优先级越高就越快收到消息；
sticky：粘性事件的开关，默认值是false
threadMode：线程模式，默认模式是ThreadMode.POSTING，线程模式分为：POSTING、MAIN、MAIN_ORDERED、BACKGROUND、ASYNC

• POSTING：
  默认的模式,开销最小的模式，因为声明为POSTING的订阅者会在发布的同一个线程调用，发布者在主线程那么订阅者也就在主线程，反之亦，避免了线程切换，如果不确定是否有耗时操作，谨慎使用，因为可能是在主线程发布。

• MAIN
  主线程调用，视发布线程不同处理不同，如果发布者在主线程那么直接调用(非阻塞式)，如果发布者不在主线程那么阻塞式调用。

• MAIN_ORDERED
  和MAIN差不多，主线程调用，和MAIN不同的是他保证了post是非阻塞式的(默认走MAIN的非主线程的逻辑，所以可以做到非阻塞)

• BACKGROUND
  在子线程调用，如果发布在子线程那么直接在发布线程调用，如果发布在主线程那么将开启一个子线程来调用，这个子线程是阻塞式的,按顺序交付所有事件，所以也不适合做耗时任务，因为多个事件共用这一个后台线程。

• ASYNC
  在子线程调用，总是开启一个新的线程来调用，适用于做耗时任务，比如数据库操作，网络请求等，不适合做计算任务，会导致开启大量线程。

[粘性事件]

EventBus的一般用法是：先注册，再定义接收事件的方法，之后发送的事件才能接收到。
但是，在Android中有写场景不符合EventBus的一般用法，比如：Fragment之间切换时，将数据从一个Fragment传递到另一个Fragment。还有一个场景是，从一个Activity跳转到另一个Activity，将数据从一个Activity传递到另一个Activity。

为了解决这个问题，EventBus推出了粘性事件。假如ActivityA跳转到ActivityB时，将数据从A发送到B，那么该如何实现呢？

第一步，在ActivityA中发送粘性事件

            //发送消息
            EventBus.getDefault().postSticky(new MessageEvent(100));

postSticky方法发送一个粘性事件。

第二步，在ActivityB中注册和反注册

    //注册
    EventBus.getDefault().register(this);

    //反注册
    EventBus.getDefault().unregister(this);

第三步，在ActivityB中定义接收事件的方法

/**
 * 接收消息
 * @param event
 */
@Subscribe(threadMode = ThreadMode.MAIN, sticky = true)
public void onMessageEvent(MessageEvent event) {
    /* Do something */
    Log.d("yunchong", "MessageEvent的flag值为："+event.getFlag());
}

其中，sticky属性必须设置为true。

[代码混淆]

根据EventBus作者的意思，如果项目开启混淆功能的话，还需要添加以下混淆代码：

-keepattributes *Annotation*
-keepclassmembers class * {
    @org.greenrobot.eventbus.Subscribe <methods>;
}
-keep enum org.greenrobot.eventbus.ThreadMode { *; }

# And if you use AsyncExecutor:
-keepclassmembers class * extends org.greenrobot.eventbus.util.ThrowableFailureEvent {
    <init>(java.lang.Throwable);
}

[本章完...]