组件之间的通信

前言

EventBus可以很容易地实现组件与组件之间的通信，无论跨线程与否，简单的注册与监听，就可以让我们轻松实现。

EventBus是一个Android和Java的开源库，使用发布者/订阅者模式进行松散耦合。EventBus使中央通信能够仅用几行代码解耦类——简化代码，减少依赖项，并加快应用程序开发。

使用EventBus有什么好处？

简化组件之间的通信
事件发送方和接收方解耦
能够很好地使用UI组件（例如Activities, Fragments）和后台线程
避免复杂且容易出错的依赖关系和生命周期问题
速度快；专门为高性能而优化
很小（~60k jar）
实际安装量超过10,000,000个的应用程序证明了这一点
具有切换线程、订阅者优先级等高级功能

EventBus是一款针对Andoid优化的发布/订阅事件总线，主要功能是替Intent,Handler,BroadCast在Fragment，Activity，Service，线程之间传递消息，优点是开销小，代码更优雅，以及将发送者和接收者进行解耦。以观察者模式实现，用于简化程序的组件、线程通信，可以轻易切换线程、开辟线程。
在没有接触EventBus之前，也许在Android开发中，组件间的通信或者前后端线程之间的通信都是通过持有引用的回调或者Handler来实现的，但是过多回调势必带来一些副作用，比如：强引用，可能导致内存泄漏；多层回调的代码逻辑可读性差，调试时甚至使人摸不着头脑；直接用匿名内部类去实现很容易就出现多级缩进，长长的屏幕都看不完一行代码；要跨线程必须要用Handler或AsyncTask等等。
而EventBus是可以替代回调的。但替代的时候并不是那么简单地在原来调用回调方法的地方调用EventBus的post方法即可。具体的回调应有的步骤如下：

把回调里传的数据抽离成一个消息类Msg，一个回调方法对应一个消息类。
在调用回调方法的地方把调用改为EventBus的post方法，参数是上一步中抽取出来的Msg类。
把原来实现了的回调方法改为用Subscribe注解标明该在哪类线程运行，并把原参数改为抽取出来的Msg类，在具体实现里再从Msg实例取出对应的数据。
在添加回调的代码处改为EventBus的register方法；并在所处的组件销毁时的回调方法（如onDestroy、onDestroyView等，注意要和register方法所处的生命周期对称）内调用EventBus的unregister方法。

我们再来谈谈具体使用吧，这个地址：https://github.com/greenrobot/EventBus是EventBus的github地址，下载下来，依赖为我们要使用的库，其实使用起来，以上的步骤中诉述了，下面我举几个场景：

场景一：Activity之间进行传递消息

两个Activity,从第二个Activity接收返回来的参数，启动的时候用startActivityForResult，在onActivityResult里接收参数可以搞定，但是，从第一个Activity跳到第二个Activity再跳到第三个Activity,甚至跳到第N个Activity，来接收返回的参数，显示在第一个Activity上，你该如何操作呢亲？当然你可以是使用广播，来监听返回的消息，简单的参数你也可以直接使用SharedPreferences,当然了，你也完全可以每次跳转都startActivityForResult，然后在每个Activity里接收参数，直至第一个Activity,也许你会有各种各样的实现的方式，但是用了EventBus，你肯定会爱不释手。

简单四步走：

在需要接收参数的Activity中onCreate进行注册：

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        // 注册成为订阅者
        EventBus.getDefault().register(this)
    }

    override fun onDestroy() {
        super.onDestroy()
        // 解除注册 不再接收事件
        EventBus.getDefault().unregister(this)
    }
}

在需要接收参数的Activity中重写回调方法，一定要记住，添加@Subscribe，并且所接收的参数和发送时的参数保持一致：

/**
 * 通过[Subscribe]注解进行注册，并且可以指定[ThreadMode]该方法执行的线程类型
 */
@Subscribe(threadMode = ThreadMode.MAIN)
fun onEvent(event: SimpleEvent) {
    Log.d("qqq", "onEvent: ${event.message}")
}

在需要传递信息的地方发送：

/**
 * 自定义的事件类
 *
 * @property message String 消息
 *
 * @author Qu Yunshuo
 * @since 3/29/21 8:05 PM
 */
data class SimpleEvent(val message: String)

/**
 * 发布一个事件
 */
fun postEvent() {
    EventBus.getDefault().post(SimpleEvent("Hello EventBus!"))
}

在接收的Activity中进行onDestory中进行反注册：

1	@Overrideprotected void onDestroy() { super.onDestroy(); EventBus.getDefault().unregister(this);}

场景二：Activity和Fragment进行互相通信

两者之间进行通信，我们可以采取接口回调或者注册广播，当然了既然是描述EventBus，EventBus当然这一职责也必须可以胜任，具体的实现逻辑和场景一差不多，无非就是，在需要接收的页面进行注册，重写回调函数，在需要传递的地方进行post传递，具体大家可以自行揣摩。

也许还有很多场景，在这里就不一一说了，EventBus说的那么好，具体它有什么缺点呢，俗话说，金无足赤人无完人，十全十美也不太现实，EventBus的缺点可以总结如下：1、只要用得一多，那消息类的数量必然是会爆炸性增长。2、调试的时候除非熟悉整块逻辑，不然不跑起来你是没办法了解Subscribe的方法的数据来源。我们需要看清的现实是，其优点是远远大于它的缺点的，我们不能因为几个缺点就抛弃了它。

补充说明：

上面的文章中，介绍了一个回调函数获取参数的方法onEventMainThread，除了这个函数，其实EventBus还有几个，分别是：

onEvent:如果使用onEvent作为订阅函数，那么该事件在哪个线程发布出来的，onEvent就会在这个线程中运行，也就是说发布事件和接收事件线程在同一个线程。使用这个方法时，在onEvent方法中不能执行耗时操作，如果执行耗时操作容易导致事件分发延迟。

onEventMainThread:如果使用onEventMainThread作为订阅函数，那么不论事件是在哪个线程中发布出来的，onEventMainThread都会在UI线程中执行，接收事件就会在UI线程中运行，这个在Android中是非常有用的，因为在Android中只能在UI线程中跟新UI，所以在onEvnetMainThread方法中是不能执行耗时操作的。

onEventBackground:如果使用onEventBackgrond作为订阅函数，那么如果事件是在UI线程中发布出来的，那么onEventBackground就会在子线程中运行，如果事件本来就是子线程中发布出来的，那么onEventBackground函数直接在该子线程中执行。

onEventAsync：使用这个函数作为订阅函数，那么无论事件在哪个线程发布，都会创建新的子线程在执行onEventAsync.

这四种订阅函数都是使用onEvent开头的，它们的功能稍有不同,注意两个概念：

告知观察者事件发生时通过EventBus.post函数实现，这个过程叫做事件的发布，观察者被告知事件发生叫做事件的接收，是通过订阅函数实现的。

常见封装方式：

/**
 * 最常见的方式就是写在基类中，在[onCreate]方法中进行注册，在[onDestroy]方法中进行解除注册
 * 这样实现类就可以自动的完成注册与解除注册，完全不用考虑忘记解除注册这种低级错误🙅
 */
open class BaseActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        EventBus.getDefault().register(this)
    }

    override fun onDestroy() {
        super.onDestroy()
        EventBus.getDefault().unregister(this)
    }
}

这种方式简单粗暴有效，但是弊端也很明显，不管子类需不需要注册都会自动帮你注册完，简直快乐的一批，当然这不是我们想要的效果。
那其实可以在这种方式上进行优化，比如写一个hook方法，让子类重写决定是否进行初始化，这也是一个不错的方案。

open class BaseActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // 判断子类是否需要进行注册和解除注册
        if (isRegisterEventBus()) EventBus.getDefault().register(this)
    }

    override fun onDestroy() {
        super.onDestroy()
        // 判断子类是否需要进行注册和解除注册
        if (isRegisterEventBus()) EventBus.getDefault().unregister(this)
    }

    /**
     * 是否注册EventBus
     * @return Boolean
     */
    open fun isRegisterEventBus(): Boolean = false
}

这也是一个不错的方案，让子类决定是否进行注册，避免一刀切全部注册的情况，代价只是多重写一个方法。下面介绍另外一种方案，使用自定义注解+反射。

自定义注解+反射

整体思路就是我们自定义一个注解，在需要进行注册的类上添加注解，在基类里进行判断当前子类是否使用了该注解从而决定是否进行注册

/**
 * 进行标记需要进行注册EventBus
 *
 * @author Qu Yunshuo
 * @since 3/29/21 8:33 PM
 */
@Target(AnnotationTarget.CLASS)
@kotlin.annotation.Retention(AnnotationRetention.RUNTIME)
annotation class EventBusRegister


/**
 * Activity基类
 * 
 * @author Qu Yunshuo
 * @since 3/29/21 8:36 PM
 */
open class BaseActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // 获取到Class对象判断是否有EventBusRegister注解
        if (javaClass.isAnnotationPresent(EventBusRegister::class.java)) {
            EventBus.getDefault().register(this)
        }
    }

    override fun onDestroy() {
        super.onDestroy()
        // 获取到Class对象判断是否有EventBusRegister注解
        if (javaClass.isAnnotationPresent(EventBusRegister::class.java)) {
            EventBus.getDefault().unregister(this)
        }
    }
}

以上是注解和基类的逻辑，十分的简单，需要注册时，只需要在添加该注解就ok

@EventBusRegister
class MainActivity : BaseActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {...}
}

是不是使用起来也是十分的简单，并不是说这种方案是最优的，本文只是介绍通过自定义注解+反射来实现封装EventBus注册的逻辑，get到以后就可以进行举一反三。

简单封装Utils

/**
 * EventBus工具类
 * 
 * @author Qu Yunshuo
 * @since 3/29/21 8:42 PM
 */
object EventBusUtils {

    /**
     * 订阅
     * @param subscriber 订阅者
     */
    fun register(subscriber: Any) = EventBus.getDefault().register(subscriber)

    /**
     * 解除注册
     * @param subscriber 订阅者
     */
    fun unRegister(subscriber: Any) = EventBus.getDefault().unregister(subscriber)

    /**
     * 发送普通事件
     * @param event 事件
     */
    fun postEvent(event: Any) = EventBus.getDefault().post(event)

    /**
     * 发送粘性事件
     * @param stickyEvent 粘性事件
     */
    fun postStickyEvent(stickyEvent: Any) = EventBus.getDefault().postSticky(stickyEvent)

    /**
     * 手动获取粘性事件
     * @param stickyEventType 粘性事件
     * @param <T>             事件泛型
     * @return 返回给定事件类型的最近粘性事件
     */
    fun <T> getStickyEvent(stickyEventType: Class<T>): T = EventBus.getDefault().getStickyEvent(stickyEventType)

    /**
     * 手动删除粘性事件
     * @param stickyEventType 粘性事件
     * @param <T>             事件泛型
     * @return 返回给定事件类型的最近粘性事件
     */
    fun <T> removeStickyEvent(stickyEventType: Class<T>): T = EventBus.getDefault().removeStickyEvent(stickyEventType)
}

组件之间的通信—EventBus

Zihuatanejo

前言