如何本身實現一個 EventBus

時間  2019-11-07
標籤 如何 本身 實現 一個 eventbus 简体版
原文   原文鏈接

什麼是 EventBus

EventBus 是一個基於觀察者模式的事件發佈／訂閱框架，開發者能夠經過極少的代碼去實現組件，模塊之間的通訊，而不須要以層層傳遞接口的形式去單獨構建通訊橋樑。從而下降因多重回調致使的模塊間強耦合，同時避免產生大量內部類。它擁有使用方便，性能高，接入成本低和支持多線程的優勢，實乃模塊解耦、代碼重構必備良藥。java

Android 中 提供了 Handler 來進行組件間的通訊，而 Handler 在使用上有不少不便，EventBus 的出現完美的解決了這些問題。git

用了那麼久 EventBus 因此我決定本身實現一個，正好最近項目開始使用 Kotlin 來寫，因此本文中的代碼和例子所有使用 Kotlin 來完成。github

Github 地址：github.com/Werb/EventB…安全

EventBus 的原理

前面說了 EventBus 是基於觀察者模式，核心是事件。經過事件的發佈和訂閱實現組件之間的通訊，EventBus 默認是一個單例存在，在 Java 中還須要使用 Synchronized 來保證線程安全。通俗來說，EventBus 經過註冊將全部訂閱事件的方法儲存在集合中，當有事件發佈的時候，根據某些規則，匹配出符合條件的方法，調用執行，從而實現組件間的通訊。多線程

發佈的事件至關於被觀察者，註冊的對象至關於觀察者，被觀察者和觀察者是一對多的關係。當被觀察者狀態發生變化，即發佈事件的時候，觀察者對象將會獲得通知並做出響應，即執行對應的方法。框架

EventBus 具體實現

EventBus 最終的目的，是在當有事件發生的時候，調用執行對應的方法，這裏咱們採用註解的方式來標記執行的方法，最終經過反射來調用。async

Subscriber

Subscriber 是一個註解類，咱們經過 @Subscriber關鍵字來標記方法。Subscriber 在聲明的時候，有兩個可選參數，tag: String 和 mode: ThreadMode，而且這兩個參數都有本身的默認值。ide

@Retention(AnnotationRetention.RUNTIME)
@Target(AnnotationTarget.FUNCTION,AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER)
annotation class Subscriber(val tag: String = DEFAULT_TAG, val mode: ThreadMode = ThreadMode.POST)複製代碼
  • @Retention(AnnotationRetention.RUNTIME) 聲明在運行時使用註解
  • AnnotationTarget.FUNCTION 聲明註解時做用在方法上
  • AnnotationTarget.PROPERTY_GETTER 聲明屬性存在 GET
  • AnnotationTarget.PROPERTY_SETTER 聲明屬性存在 SET

tag

tag 的目的是爲了當有相同事件發生的時候，細化區分不一樣的事件。函數

例如咱們定義了一個 SessionEvent 用於帳戶登陸和登出時的信息傳遞，這時候咱們就能夠定義 login 和 logout 兩個 tag 來進行區分。固然你也徹底能夠定義兩個 LoginEvent 和 LogoutEvent，這個字段的目的是爲了能夠更加方便靈活的操做代碼。oop

tag 的默認值爲 DEFAULT_TAG。

mode

mode 的目的是爲了聲明註解所標記的方法的執行環境。

mode 所表明的是 ThreadMode 類。這是一個枚舉類，可選值爲MAIN，POST， BACKGROUND，即響應 Event 事件時，方法執行所在的線程。

  • MAIN 主線程 UI 線程
  • POST 事件發出所在的線程
  • BACKGROUND 子線程

mode 的默認值爲 POST 。

IEvent

在這裏，我定義了一個空的接口 IEvent ，咱們經過 EventBus 發出的事件類須要實現這個接口，同時在經過註解定義事件執行方法的時候，須要將咱們接收的某個事件類做爲方法的參數，有且只有一個參數，它就是咱們的被觀察者。

一個完整的例子：

/** EventBus 發送的事件類 這個類的目的用於用戶登陸登出的相關操做 */
class SessionEvent: IEvent複製代碼
/** 登陸成功時發送 Event */
EventBus.post(SessionEvent(), "login")
/** 登出成功時發送 Event */
EventBus.post(SessionEvent(), "logout")複製代碼
/** 登陸成功 默認在 POST 線程執行 */
@Subscriber(tag = "login")
private fun login(event: SessionEvent) {
    // do something
}

/** 登陸成功 在 MAIN 線程執行，一般是一些 UI 上的操做 */
@Subscriber(tag = "logout", mode = ThreadMode.MAIN)
private fun logout(event: SessionEvent) {
    // do something
}複製代碼

前面說了，咱們須要將全部訂閱事件的方法存儲到一個集合中，當有事件發出的時候，咱們經過某些規則，匹配出符合條件的方法，調用執行。因此，首先咱們須要去定採用哪一種集合來存儲，存儲時的規則是什麼。

MutableMap

這裏咱們採用 MutableMap 來存儲事件執行的方法。MutableMap 在 Kotlin 中表示爲可變的，結構以下。

MutableMap<EventType, CopyOnWriteArrayList<Subscription>>

EventType 是惟一key（下面會介紹），經過key找到對應的執行方法。
CopyOnWriteArrayList<Subscription>> 是一個線程安全的 List ，前面咱們說過了被觀察者和觀察者是一對多的關係因此這裏使用 List，Subscription事件執行方法的包裝類（下面會介紹)。

EventType

EventType 類包含兩個字段，eventClass: Class<IEvent> 和 tag: String。

  • eventClass: Class<IEvent> 是咱們經過 EventBus 發出的事件類

  • tag: String 是咱們發出事件類時所指定的 tag

internal class EventType(private var eventClass: Class<IEvent>, private var tag: String) {

    override fun equals(other: Any?): Boolean {
        // 比較內存引用地址，相同則返回 true
        if (this === other) {
            return true
        }

        // 判斷是否爲空，是否屬於同一中類型
        if (other == null || (other.javaClass.name !== this.javaClass.name)) {
            return false
        }

        // 能執行到這裏，說明 obj 和 this 同類且非 null
        val eventType = other as EventType
        val tagJudge = tag == eventType.tag
        val eventJudge = eventClass.name == eventType.eventClass.name

        return tagJudge && eventJudge
    }

    override fun hashCode(): Int {
        var hash = 7
        hash = hash * 31 + eventClass.hashCode()
        hash = hash * 31 + tag.hashCode()
        return hash
    }
}複製代碼

經過這兩個字段咱們就能夠肯定一個惟一的key，準確的找到所對應的事件執行方法。

Subscription

Subscription 是事件執行方法的包裝類，它包含 subscriber: WeakReference<Any>，targetMethod: Method，threadMode: ThreadMode 這三個字段。

  • subscriber: WeakReference<Any> 這個就是咱們的觀察者，它能夠是一個 Activity 或 Fragment 或 Service，咱們註冊了這個觀察者到咱們的 EventBus 中，當被觀察者產生變化的時候，觀察者調用執行對應的方法，而且這裏使用弱引用來包裝這個對象。
  • targetMethod: Method 事件調用執行的具體方法。
  • threadMode: ThreadMode 事件方法執行時所在的環境。
internal class Subscription(val subscriber: WeakReference<Any>,
                            val targetMethod: Method,
                            val threadMode: ThreadMode) {

    override fun equals(other: Any?): Boolean {
        if (this === other) {
            return true
        }

        if (other == null || (other::class !== this::class)) {
            return false
        }

        val subscription = other as Subscription
        val judgeSubscriber = this.subscriber.get() === subscription.subscriber.get()
        val judgeMethod = this.targetMethod.name == subscription.targetMethod.name
        return judgeSubscriber && judgeMethod
    }

    override fun hashCode(): Int {
        var hash = 7
        hash = hash * 31 + subscriber.hashCode()
        hash = hash * 31 + targetMethod.hashCode()
        hash = hash * 31 + threadMode.hashCode()
        return hash
    }

}複製代碼

好了，如今咱們肯定了 EventBus 的內部存儲結構，接下來咱們就要說一下最關鍵的部分，EventBus 是如何註冊 register 和發送 post 事件的，先看一下 EventBus 的代碼。

/** object 表示單例 */
object EventBus {

    private val executorService: ExecutorService = Executors.newCachedThreadPool()
    private val subscriberMap = ConcurrentHashMap<EventType, CopyOnWriteArrayList<Subscription>>()
    private val methodHunter = SubscriberMethodHunter(subscriberMap)

    /** 註冊訂閱對象 */
    fun register(subscriber: Any) {
        executorService.execute {
            methodHunter.findSubscribeMethods(subscriber)
        }
    }

    /** 註銷訂閱對象 */
    fun unRegister(subscriber: Any) {
        executorService.execute {
            methodHunter.removeSubscribeMethods(subscriber)
        }
    }

    fun post(event: IEvent) {
        post(event, DEFAULT_TAG)
    }

    fun post(event: IEvent, tag: String) {
        val eventType = EventType(event.javaClass, tag)
        val list = methodHunter.getMatchEventType(eventType)
        list?.let {
            EventDispatcher.dispatcherEvent(event, it)
        }
    }

}複製代碼
  • executorService: ExecutorService 是一個線程池，咱們在註冊和註銷的時候，採用線程池，由於註冊和註銷是很頻繁數量大的一個操做，同時單個任務處理的時間比較短，使用線程池能夠很好的提升效率。
  • subscriberMap = ConcurrentHashMap<EventType, CopyOnWriteArrayList<Subscription>>() 這個就是咱們存儲被觀察者與觀察者的集合。
  • methodHunter = SubscriberMethodHunter(subscriberMap) 這個就是咱們註冊的核心類，下面會詳細介紹。

註冊 Register

/** 註冊訂閱對象 */
fun register(subscriber: Any) {
    executorService.execute {
        methodHunter.findSubscribeMethods(subscriber)
    }
}複製代碼

subscriber: Any 是咱們的觀察者對象，它能夠是一個 Activity 或 Fragment 或 Service。

舉個例子來講註冊的流程，當咱們註冊一個 Activity 到 EventBus 中時，咱們經過 methodHunter.findSubscribeMethods(subscriber) 方法，查找出當前 Activity 中被@Subscriber關鍵字來標記方法，判斷的規則以下：

  1. 被 @Subscriber 關鍵字標記
  2. 訂閱函數只支持一個參數
  3. 訂閱函數的參數是否實現了 IEvent 接口

當肯定是咱們要找的方法以後，根據方法的參數 IEvent 和 tag，生成一個 EventType 實例做爲當前方法的惟一key，根據觀察者對象 subscriber: Any 和找到的事件執行方法 method 以及事件執行環境 mode，生成一個 Subscription。

固然咱們如今還不能直接把它存儲到咱們的集合中，回顧一下咱們的集合結構，MutableMap<EventType, CopyOnWriteArrayList<Subscription>>，由於要先判斷集合中是否已存在同樣的 key，當存在則把當前 Subscription 添加到 CopyOnWriteArrayList<Subscription>> 中，這也是咱們重寫 EventType 的 equals() 和 hashCode() 的緣由，具體代碼以下。

/** 查找對象中有註解標記的執行方法 */
@Synchronized fun findSubscribeMethods(subscriber: Any) {
    var clazz: Class<*>? = subscriber.javaClass
    while (clazz != null && !isSystemClass(clazz.name)) {
        val allMethods = clazz.declaredMethods
        for (method in allMethods) {
            val annotation = method.getAnnotation(Subscriber::class.java)
            if (annotation != null) {
                // 獲取方法參數
                val paramsTypeClass = method.parameterTypes
                // 訂閱函數只支持一個參數
                if (paramsTypeClass != null && paramsTypeClass.size == 1) {
                    val paramsEvent = paramsTypeClass[0]
                    if (isImplementIEvent(paramsEvent)) {
                        method.isAccessible = true
                        @Suppress("UNCHECKED_CAST")
                        val eventType = EventType(paramsEvent as Class<IEvent>, annotation.tag)
                        val subscription = Subscription(WeakReference(subscriber), method, annotation.mode)
                        subscribe(eventType, subscription)
                    }
                }
            }
        }

        clazz = clazz.superclass
    }
}

/** 根據 EventType 來肯定一對多的訂閱關係 */
@Synchronized private fun subscribe(type: EventType, subscription: Subscription) {
    var subscriptionLists: CopyOnWriteArrayList<Subscription>? = getMatchEventType(type)
    if (subscriptionLists == null) {
        subscriptionLists = CopyOnWriteArrayList()
    }

    if (subscriptionLists.contains(subscription)) {
        return
    }

    subscriptionLists.add(subscription)
    // 將事件類型key和訂閱者信息存儲到map中
    subscriberMap.put(type, subscriptionLists)
}

/** 判斷是否有已存在的 EventType */
internal fun getMatchEventType(type: EventType): CopyOnWriteArrayList<Subscription>? {
    val keys = subscriberMap.keys
    return keys.firstOrNull { it == type }?.let { subscriberMap[it] }
}複製代碼

發送事件 POST

到這一步，咱們已經把觀察者對象註冊到了 EventBus 中，剩下的就是在須要的時候發送事件就能夠了，因此接下來，咱們來看一下如何發送事件和執行事件訂閱的方法。

fun post(event: IEvent) {
        post(event, DEFAULT_TAG)
    }

fun post(event: IEvent, tag: String) {
    val eventType = EventType(event.javaClass, tag)
    val list = methodHunter.getMatchEventType(eventType)
    list?.let {
        EventDispatcher.dispatcherEvent(event, it)
    }
}複製代碼

post 有兩個方法，一個是使用默認的tag，一個是本身指定tag，這個方法很簡單，咱們根據發送事件時指定的 IEvent 和 tag，肯定出 EventType，也就是咱們集合中惟一的 key，經過 key 獲得 value，value 就是 CopyOnWriteArrayList<Subscription>，也就是當前事件執行方法的集合，剩下的就是執行調用這些方法。

事件分發 EventDispatcher

前面說了，咱們在實現事件執行方法的時候，會指定事件執行時的環境，MAIN，POST， BACKGROUND，默認環境是 POST 線程，這樣能夠減小線程切換時帶來的開銷。

internal object EventDispatcher {

    /** POST 線程即事件發出的線程 */
    private val postHandler = PostEventHandler()
    /** MAIN 線程 UI 線程 */
    private val mainHandler = MainEventHandler()
    /** BACKGROUND 線程，ExecutorService 線程池 */
    private val asyncHandler = AsyncEventHandler()

    fun dispatcherEvent(event: IEvent, list: CopyOnWriteArrayList<Subscription>) {
        list.forEach {
            val eventHandler = getEventHandler(it.threadMode)
            eventHandler.handleEvent(it, event)
        }
    }

    private fun getEventHandler(mode: ThreadMode): EventHandler {
        return when (mode) {
            ThreadMode.POST -> postHandler
            ThreadMode.BACKGROUND -> asyncHandler
            ThreadMode.MAIN -> mainHandler
        }
    }

}複製代碼

正如上面的代碼，咱們依據 threadMode ，選擇符合的 EventHandler，調用其 handleEvent(subscription: Subscription, event: IEvent) 去執行方法。

事件執行 EventHandler

internal interface EventHandler {
    fun handleEvent(subscription: Subscription, event: IEvent)
}複製代碼

EventHandler 是一個接口，定義的事件執行時調用的方法 handleEvent()，咱們須要依次實現三種環境的具體實現。

  • PostEventHandler 
internal class PostEventHandler: EventHandler {

    override fun handleEvent(subscription: Subscription, event: IEvent) {
        try {
            subscription.targetMethod.invoke(subscription.subscriber.get(), event)
        } catch (e: IllegalAccessException) {
            e.printStackTrace()
        } catch (e: IllegalArgumentException) {
            e.printStackTrace()
        } catch (e: InvocationTargetException) {
            throw e.targetException
        }
    }
}複製代碼
  • MainEventHandler UI 線程
internal class MainEventHandler: EventHandler {

    private val handler = Handler(Looper.getMainLooper())

    override fun handleEvent(subscription: Subscription, event: IEvent) {
        handler.post({
            try {
                subscription.targetMethod.invoke(subscription.subscriber.get(), event)
            } catch (e: IllegalAccessException) {
                e.printStackTrace()
            } catch (e: IllegalArgumentException) {
                e.printStackTrace()
            } catch (e: InvocationTargetException) {
                throw e.targetException
            }
        })
    }

}複製代碼

  • AsyncEventHandler 後臺線程採用線程池實現

    internal class AsyncEventHandler: EventHandler {

  private val bgExecutor = Executors.newCachedThreadPool()

  override fun handleEvent(subscription: Subscription, event: IEvent) {
      bgExecutor.execute {
          try {
              subscription.targetMethod.invoke(subscription.subscriber.get(), event)
          } catch (e: IllegalAccessException) {
              e.printStackTrace()
          } catch (e: IllegalArgumentException) {
              e.printStackTrace()
          } catch (e: InvocationTargetException) {
              throw e.targetException
          }
      }
  }
}複製代碼

三種環境中，核心的執行方法都是同樣的，採用反射來調用具體事件的執行方法，僅僅是方法所在的執行環境不一樣而已。

到目前爲止，咱們的 EventBus 就完成了，經過註解的形式實現事件的執行方法，經過註冊觀察者對象，生成 key 和 value 創建關係存儲到集合中，在事件發出的時候，查找出對應的事件方法集合，而後在指定的執行環境中調用。

有哪些寫的不對的地方請提出，我會立刻改正

我是 wanbo。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程