【Android】事件總線（解耦組件） EventBus 詳解

時間 2019-11-06

標籤 Android 事件總線組件 eventbus 詳解欄目 Android 简体版

原文原文鏈接

　　當Android項目愈來愈龐大的時候，應用的各個部件之間的通訊變得愈來愈複雜，例如：當某一條件發生時，應用中有幾個部件對這個消息感興趣，那麼咱們一般採用的就是觀察者模式，使用觀察者模式有一個弊病就是部件之間的耦合度過高，在這裏將會詳細介紹Android中的解耦組件EventBus的使用。html

EventBus簡介

　　Publisher-Subscriber這種設計模式在GoF中早就詳細的解釋。也是一種最經常使用不過的設計模式。而EventBus則是對於Publisher和Subscriber的一種實現，若是你還在使用JDK中的Observer，則不妨看看TW大大的一片博客《你應該更新的java知識之observer》，使用EventBus替代Observer彷佛成了一種必須。

　　EventBus是一個Android端優化的publish/subscribe消息總線，簡化了應用程序內各組件間、組件與後臺線程間的通訊。好比請求網絡，等網絡返回時經過Handler或Broadcast通知UI，兩個Fragment之間須要經過Listener通訊，這些需求均可以經過**EventBus**實現。

EventBus主要的元素

　　事件：

Event：事件,能夠是任意類型的對象
Subscriber：事件訂閱者，接收特定的事件
Publisher:事件發佈者，用於通知Subscriber有事件發生

　　Subscriber

在EventBus中，使用約定來指定事件訂閱者以簡化使用。
即全部事件訂閱都都是以onEvent開頭的函數，具體來講，函數的名字是onEvent，onEventMainThread，onEventBackgroundThread，onEventAsync這四個
這個和ThreadMode有關（見下文）

Publisher

能夠在任意線程任意位置發送事件，直接調用EventBus的post(Object)方法
能夠本身實例化EventBus對象，但通常使用默認的單例就行了：EventBus.getDefault()
根據post函數參數的類型，會自動調用訂閱相應類型事件的函數

　　ThreadMode

Subscriber函數的名字只能是那4個，由於每一個事件訂閱函數都是和一個ThreadMode相關聯的，ThreadMode指定了會調用的函數。

　　有如下四個ThreadMode：

PostThread：事件的處理在和事件的發送在相同的進程，因此事件處理時間不該太長，否則影響事件的發送線程，而這個線程多是UI線程。對應的函數名是onEvent。
MainThread: 事件的處理會在UI線程中執行。事件處理時間不能太長，這個不用說的，長了會ANR的，對應的函數名是onEventMainThread。
BackgroundThread：事件的處理會在一個後臺線程中執行，對應的函數名是onEventBackgroundThread，雖然名字是BackgroundThread，事件處理是在後臺線程，但事件處理時間仍是不該該太長，由於若是發送事件的線程是後臺線程，會直接執行事件，若是當前線程是UI線程，事件會被加到一個隊列中，由一個線程依次處理這些事件，若是某個事件處理時間太長，會阻塞後面的事件的派發或處理。
Async：事件處理會在單獨的線程中執行，主要用於在後臺線程中執行耗時操做，每一個事件會開啓一個線程（有線程池），但最好限制線程的數目。

　　根據事件訂閱都函數名稱的不一樣，會使用不一樣的ThreadMode，好比果在後臺線程加載了數據想在UI線程顯示，訂閱者只需把函數命名爲onEventMainThread。

使用EventBus的步驟

　　EventBus使用起來和Otto差很少，分訂閱、註冊、發佈、取消註冊等步驟：

//定義事件類型：
publicclassMyEvent{}
//定義事件處理方法：
publicvoid onEventMainThread
//註冊訂閱者：
EventBus.getDefault().register(this)
//發送事件：
EventBus.getDefault().post(newMyEvent())
//實現

View Code

EventBus源碼分析

EventType：onEvent函數中的參數，表示事件的類型
Subscriber：訂閱源，即調用register註冊的對象，這個對象內包含onEvent函數
SubscribMethod：Subscriber內某一特定的onEvent方法，內部成員包含一個Method類型的method成員表示這個onEvent方法，一個ThreadMode成員threadMode表示事件的處理線程，一個Class<?>類型的eventType成員表示事件的類型EventType。
Subscription，表示一個訂閱對象，包含訂閱源Subscriber，訂閱源中的某一特定方法SubscribMethod，這個訂閱的優先級priopity

瞭解了以上幾個概念後就能夠看 `EventBus `中的幾個重要成員了

// EventType -> List<Subscription>，事件到訂閱對象之間的映射
privatefinalMap<Class<?>,CopyOnWriteArrayList<Subscription>> subscriptionsByEventType;
// Subscriber -> List<EventType>，訂閱源到它訂閱的的全部事件類型的映射
privatefinalMap<Object,List<Class<?>>> typesBySubscriber;
// stickEvent事件，後面會看到
privatefinalMap<Class<?>,Object> stickyEvents;
// EventType -> List<? extends EventType>，事件到它的父事件列表的映射。即緩存一個類的全部父類
privatestaticfinalMap<Class<?>,List<Class<?>>> eventTypesCache =newHashMap<Class<?>,List<Class<?>>>();

View Code

註冊事件：Register

　　經過`EventBus.getDefault().register`方法能夠向`EventBus`註冊來訂閱事件，`register`有不少種重載形式，但大都被標記爲`Deprecated`了，因此仍是不用爲好

　　前面說了事件處理方法都是以*onEvent*開頭，實際上是能夠經過register方法修改的，但相應的方法被廢棄了，仍是不要用了，就用默認的*onEvent*，除下廢棄的register方法，還有如下4個**public**的`register`方法

public void register(Object subscriber) {
    register(subscriber, defaultMethodName, false, 0);
}

public void register(Object subscriber, int priority) {
    register(subscriber, defaultMethodName, false, priority);
}

public void registerSticky(Object subscriber) {
    register(subscriber, defaultMethodName, true, 0);
}

public void registerSticky(Object subscriber, int priority) {
    register(subscriber, defaultMethodName, true, priority);
}

View Code

　　能夠看到，這4個方法都調用了同一個方法：

private synchronized void register(Object subscriber, String methodName, boolean sticky, int priority) {
    List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriber.getClass(),
methodName);
    for (SubscriberMethod subscriberMethod : subscriberMethods) {
        subscribe(subscriber, subscriberMethod, sticky, priority);
    }
}

View Code

　　第一個參數就是訂閱源，第二個參數就是用到指定方法名約定的，默認爲*onEvent*開頭，說默認是實際上是能夠經過參數修改的，但前面說了，方法已被廢棄，最好不要用。第三個參數表示是不是*Sticky Event*，第4個參數是優先級，這兩個後面再說。java

　　在上面這個方法中，使用了一個叫`SubscriberMethodFinder`的類，經過其`findSubscriberMethods`方法找到了一個`SubscriberMethod`列表，前面知道了`SubscriberMethod`表示Subcriber內一個onEvent\*方法，能夠看出來`SubscriberMethodFinder`類的做用是在Subscriber中找到全部以methodName（即默認的onEvent）開頭的方法，每一個找到的方法被表示爲一個`SubscriberMethod`對象。android

　　`SubscriberMethodFinder`就再也不分析了，但有兩點須要知道：

全部事件處理方法**必需是`public void`類型**的，而且只有一個參數表示*EventType*。
`findSubscriberMethods`不僅查找*Subscriber*內的事件處理方法，**同時還會查到它的繼承體系中的全部基類中的事件處理方法**。

　　找到*Subscriber*中的全部事件處理方法後，會對每一個找到的方法（表示爲`SubscriberMethod`對象）調用`subscribe`方法註冊。

　　`subscribe`方法幹了三件事：

根據`SubscriberMethod`中的*EventType*類型將`Subscribtion`對象存放在`subscriptionsByEventType`中。創建*EventType*到*Subscription*的映射，每一個事件能夠有多個訂閱者。
根據`Subscriber`將`EventType`存放在`typesBySubscriber`中，創建*Subscriber*到*EventType*的映射，每一個Subscriber能夠訂閱多個事件。
若是是*Sticky*類型的訂閱者，直接向它發送上個保存的事件（若是有的話）。

　　經過*Subscriber*到*EventType*的映射，咱們就能夠很方便地使一個Subscriber取消接收事件，經過*EventType*到*Sucscribtion*的映射，能夠方便地將相應的事件發送到它的每個訂閱者。

Post事件

　　直接調用`EventBus.getDefault().post(Event)就能夠發送事件，根據Event的類型就能夠發送到相應事件的訂閱者。

public void post(Object event) {
    PostingThreadState postingState = currentPostingThreadState.get();
    List<Object> eventQueue = postingState.eventQueue;
    eventQueue.add(event);
    if (postingState.isPosting) {
        return;
    } else {
        postingState.isMainThread = Looper.getMainLooper() == Looper.myLooper();
        postingState.isPosting = true;
        if (postingState.canceled) {
            throw new EventBusException("Internal error. Abort state was not reset");
        }
        try {
            while (!eventQueue.isEmpty()) {
                postSingleEvent(eventQueue.remove(0), postingState);
            }
        } finally {
            postingState.isPosting = false;
            postingState.isMainThread = false;
            }
    }
}

View Code

　　能夠看到post內使用了`PostingThreadState`的對象，而且是`ThreadLocal`，來看`PostingThreadState`的定義：git

final static class PostingThreadState {
    List<Object> eventQueue = new ArrayList<Object>();
    boolean isPosting;
    boolean isMainThread;
    Subscription subscription;
    Object event;
    boolean canceled;
}

View Code

　　主要是有個成員`eventQueue`，因爲是ThreadLocal，因此結果就是，每一個線程有一個`PostingThreadState`對象，這個對象內部有一個事件的隊列，而且有一個成員`isPosting`表示如今是否正在派發事件，當發送事件開始時，會依次取出隊列中的事件發送出去，若是正在派發事件，那麼post直接把事件加入隊列後返回，還有個成員`isMainThread`，這個成員在實際派發事件時會用到，在`postSingleEvent`中會用到。

private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
    Class<? extends Object> eventClass = event.getClass();
    List<Class<?>> eventTypes = findEventTypes(eventClass); // 1
    boolean subscriptionFound = false;
    int countTypes = eventTypes.size();
    for (int h = 0; h < countTypes; h++) { // 2
        Class<?> clazz = eventTypes.get(h);
        CopyOnWriteArrayList<Subscription> subscriptions;
        synchronized (this) {
            subscriptions = subscriptionsByEventType.get(clazz);
        }
        if (subscriptions != null && !subscriptions.isEmpty()) { // 3
            for (Subscription subscription : subscriptions) {
                postingState.event = event;
                postingState.subscription = subscription;
                boolean aborted = false;
                try {
                    postToSubscription(subscription, event, postingState.isMainThread); // 4
                    aborted = postingState.canceled;
                } finally {
                    postingState.event = null;
                    postingState.subscription = null;
                    postingState.canceled = false;
                }
                if (aborted) {
                    break;
                }
            }
            subscriptionFound = true;
        }
    }
    if (!subscriptionFound) {
        Log.d(TAG, "No subscribers registered for event " + eventClass);
        if (eventClass != NoSubscriberEvent.class && eventClass != SubscriberExceptionEvent.class) {
            post(new NoSubscriberEvent(this, event));
        }
    }
}

View Code

　　來看一下`postSingleEvent`這個函數，首先看第一點，調用了`findEventTypes`這個函數，代碼不帖了，這個函數的應用就是，把這個類的類對象、實現的接口及父類的類對象存到一個List中返回.github

　　接下來進入第二步，遍歷第一步中獲得的List，對List中的每一個類對象（即事件類型）執行第三步操做，即找到這個事件類型的全部訂閱者向其發送事件。設計模式

　　能夠看到，當咱們Post一個事件時，這個事件的父事件（事件類的父類的事件）也會被Post，因此若是有個事件訂閱者接收Object類型的事件，那麼它就能夠接收到全部的事件。緩存

　　還能夠看到，實際是經過第四步中的`postToSubscription`來發送事件的，在發送前把事件及訂閱者存入了`postingState`中。再來看`postToSubscription`網絡

private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {
    switch (subscription.subscriberMethod.threadMode) {
    case PostThread:
        invokeSubscriber(subscription, event);
        break;
    case MainThread:
        if (isMainThread) {
            invokeSubscriber(subscription, event);
        } else {
            mainThreadPoster.enqueue(subscription, event);
        }
        break;
    case BackgroundThread:
        if (isMainThread) {
            backgroundPoster.enqueue(subscription, event);
        } else {
            invokeSubscriber(subscription, event);
        }
        break;
    case Async:
        asyncPoster.enqueue(subscription, event);
        break;
    default:
        throw new IllegalStateException("Unknown thread mode: " + subscription.subscriberMethod.threadMode);
    }
}

View Code

　　這裏就用到`ThreadMode`了：異步

若是是PostThread，直接執行
若是是MainThread，判斷當前線程，若是原本就是UI線程就直接執行，不然加入`mainThreadPoster`隊列
若是是後臺線程，若是當前是UI線程，加入`backgroundPoster`隊列，不然直接執行
若是是Async，加入`asyncPoster`隊列

BackgroundPoster

private final PendingPostQueue queue;

public void enqueue(Subscription subscription, Object event) {
    PendingPost pendingPost = PendingPost.obtainPendingPost(subscription, event);
    synchronized (this) {
        queue.enqueue(pendingPost);
        if (!executorRunning) {
            executorRunning = true;
            EventBus.executorService.execute(this);
        }
    }
}

View Code

　　代碼比較簡單，其實就是，待發送的事件被封裝成了`PendingPost`對象，`PendingPostQueue`是一個`PendingPost`對象的隊列，當`enqueue`時就把這個事件放到隊列中，

　　`BackgroundPoster`其實就是一個Runnable對象，當`enqueue`時，若是這個Runnable對象當前沒被執行，就將`BackgroundPoster`加入EventBus中的一個線程池中，當`BackgroundPoster`被執行時，會依次取出隊列中的事件進行派發。

　　當長時間無事件時`BackgroundPoster`所屬的線程被會銷燬，下次再Post事件時再建立新的線程。

HandlerPoster

　　`mainThreadPoster`是一個`HandlerPoster`對象，`HandlerPoster`繼承自`Handler`，構造函數中接收一個`Looper`對象，當向`HandlerPoster` enqueue事件時，會像`BackgroundPoster`同樣把這個事件加入隊列中，只是若是當前沒在派發消息就向自身發送Message

void enqueue(Subscription subscription, Object event) {
    PendingPost pendingPost = PendingPost.obtainPendingPost(subscription, event);
    synchronized (this) {
        queue.enqueue(pendingPost);
        if (!handlerActive) {
            handlerActive = true;
            if (!sendMessage(obtainMessage())) {
                throw new EventBusException("Could not send handler message");
            }
        }
    }
}

View Code

　　在`handleMessage`中會依次取出隊列中的消息交由`EventBus`直接調用事件處理函數，而`handleMessage`執行所在的線程就是構造函數中傳進來的`Looper`所屬的線程，在`EventBus`中構造`mainThreadPoster`時傳進來的是MainLooper，因此會在UI線程中執行。

AsyncPoster

　　`AsyncPoster`就簡單了，把每一個事件都加入線程池中處理

public void enqueue(Subscription subscription, Object event) {
    PendingPost pendingPost = PendingPost.obtainPendingPost(subscription, event);
    queue.enqueue(pendingPost);
    EventBus.executorService.execute(this);
}

View Code

Stick Event

　　經過`registerSticky`能夠註冊Stick事件處理函數，前面咱們知道了，不管是`register`仍是`registerSticky`最後都會調用`Subscribe`函數，在`Subscribe`中有這麼一段代碼：async

if (sticky) {
    Object stickyEvent;
    synchronized (stickyEvents) {
        stickyEvent = stickyEvents.get(eventType);
    }
    if (stickyEvent != null) {
        // If the subscriber is trying to abort the event, it will fail (event is not tracked in posting state)
        // --> Strange corner case, which we don't take care of here.
        postToSubscription(newSubscription, stickyEvent, Looper.getMainLooper() == Looper.myLooper());
    }
}

View Code

　　也就是會根據事件類型從`stickyEvents`中查找是否有對應的事件，若是有，直接發送這個事件到這個訂閱者。

　　而這個事件是何時存起來的呢，同`register`與`registerSticky`同樣，和`post`一塊兒的還有一個`postSticky`函數

　　當經過`postSticky`發送一個事件時，這個類型的事件的最後一次事件會被緩存起來，當有訂閱者經過`registerSticky`註冊時，會把以前緩存起來的這個事件直接發送給它。

事件優先級Priority

　　`register`的函數重載中有一個能夠指定訂閱者的優先級，咱們知道`EventBus`中有一個事件類型到List<Subscription>的映射，在這個映射中，全部的Subscription是按priority排序的，這樣當post事件時，優先級高的會先獲得機會處理事件。

　　優先級的一個應用就是，高優先級的事件處理函數能夠終止事件的傳遞，經過`cancelEventDelivery`方法，但有一點須要注意，`這個事件的ThreadMode必須是PostThread`，而且只能終止它在處理的事件。

缺點

　　沒法進程間通訊，若是一個應用內有多個進程的話就沒辦法了

注意事項及要點

同一個onEvent函數不能被註冊兩次，因此不能在一個類中註冊同時還在父類中註冊
當Post一個事件時，這個事件類的父類的事件也會被Post。
Post的事件無Subscriber處理時會Post `NoSubscriberEvent`事件，當調用Subscriber失敗時會Post `SubscriberExceptionEvent`事件。

其餘

　　`EventBus`中還有個Util包，主要做用是能夠經過`AsyncExecutor`執行一個Runnable，經過內部的RunnableEx(能夠搜索異常的Runnable)當Runnable拋出異常時經過`EventBus`發消息顯示錯誤對話框。

　　項目主頁： https://github.com/greenrobot/EventBus

EventBus和Otto的3點不一樣

事件訂閱函數不是基於註解(Annotation)的，而是基於命名約定的，在Android 4.0以前的版本中，註解解析起來比較慢，事件響應函數默認以「onEvent」開始，能夠在EventBus中修改這個值，可是不推薦這麼幹
事件響應有更多的線程選擇，EventBus能夠向不一樣的線程中發佈事件，在ThreadMode 枚舉中定義了4個線程，只須要在事件響應函數名稱「onEvent」後面添加對應的線程類型名稱，則還事件響應函數就會在對應的線程中執行，好比事件函數「onEventAsync」就會在另一個異步線程中執行。
EventBus支持 Sticky Event

有時候某個事件可能會用到屢次，真對這種狀況，您能夠把該事件發佈爲Sticky Event，
而後，當須要查詢該信息的時候，能夠經過Bus的getStickyEvent(ClasseventType) 函數來查詢最新發布的Event對象。
同一類型的事件只保存最新的Event對象。
1. //註冊和發佈事件的函數分別爲
```
registerSticky(…)和 postSticky(Object event)
```