快速Android開發系列通訊篇之EventBus

AngelDevil發表於2014-05-08
Android

先吐槽一下部落格園的MarkDown編輯器，推出的時候還很高興部落格園支援MarkDown了，試用了下發現支援不完善就沒用了，這次這篇是在其他編輯器下寫的，複製過來後發現。。太爛了。怎麼著作為一個技術部落格社群，對程式碼的支援應該完善一下吧，`行內程式碼塊`不支援就算了，程式碼段內還不能有空行，一有空行就識別不了了。而且試著用MarkDown發了篇草稿，右邊的側邊欄竟然被擠到螢幕下方了，還影響到了部落格佈局。。不說了。。簡單修改下標題、程式碼直接發表。

概述及基本概念

**EventBus**是一個Android端最佳化的publish/subscribe訊息匯流排，簡化了應用程式內各元件間、元件與後臺執行緒間的通訊。比如請求網路，等網路返回時透過Handler或Broadcast通知UI，兩個Fragment之間需要透過Listener通訊，這些需求都可以透過**EventBus**實現。

作為一個訊息匯流排，有三個主要的元素：

  • Event：事件
  • Subscriber：事件訂閱者，接收特定的事件
  • Publisher:事件釋出者，用於通知Subscriber有事件發生

Event

**Event**可以是任意型別的物件。

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。

簡單使用

基本的使用步驟就是如下4步，點選此連結檢視例子及介紹。

  1. 定義事件型別：
    `public class MyEvent {}`
  2. 定義事件處理方法：
    `public void onEventMainThread`
  3. 註冊訂閱者：
    `EventBus.getDefault().register(this)`
  4. 傳送事件：
    `EventBus.getDefault().post(new MyEvent())`

實現

**EventBus**使用方法很簡單，但用一個東西，如果不瞭解它的實現用起來心裡總是沒底，萬一出問題咋辦都不知道，所以還是研究一下它的實現，肯定要Read the fucking Code。其實主要是`EventBus`這一個類，在看看Code時需要了解幾個概念與成員，瞭解了這些後實現就很好理解了。

  • EventType：onEvent\*函式中的引數，表示事件的型別
  • Subscriber：訂閱源，即呼叫register註冊的物件，這個物件內包含onEvent\*函式
  • SubscribMethod：`Subscriber`內某一特定的onEvent\*方法，內部成員包含一個`Method`型別的method成員表示這個onEvent\*方法，一個`ThreadMode`成員threadMode表示事件的處理執行緒，一個`Class<?>`型別的eventType成員表示事件的型別`EventType`。
  • Subscription，表示一個訂閱物件，包含訂閱源`Subscriber`，訂閱源中的某一特定方法`SubscribMethod`，這個訂閱的優先順序`priopity`


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

// EventType -> List<Subscription>，事件到訂閱物件之間的對映
private final Map<Class<?>, CopyOnWriteArrayList<Subscription>> subscriptionsByEventType;

// Subscriber -> List<EventType>，訂閱源到它訂閱的的所有事件型別的對映
private final Map<Object, List<Class<?>>> typesBySubscriber;

// stickEvent事件，後面會看到
private final Map<Class<?>, Object> stickyEvents;

// EventType -> List<? extends EventType>，事件到它的父事件列表的對映。即快取一個類的所有父類
private static final Map<Class<?>, List<Class<?>>> eventTypesCache = new HashMap<Class<?>, List<Class<?>>>();

註冊事件：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);
}

可以看到，這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);
    }
}

 

第一個引數就是訂閱源，第二個引數就是用到指定方法名約定的，預設為*onEvent*開頭，說預設是其實是可以透過引數修改的，但前面說了，方法已被廢棄，最好不要用。第三個參數列示是否是*Sticky Event*，第4個引數是優先順序，這兩個後面再說。

在上面這個方法中，使用了一個叫`SubscriberMethodFinder`的類，透過其`findSubscriberMethods`方法找到了一個`SubscriberMethod`列表，前面知道了`SubscriberMethod`表示Subcriber內一個onEvent\*方法，可以看出來`SubscriberMethodFinder`類的作用是在Subscriber中找到所有以methodName（即預設的onEvent）開頭的方法，每個找到的方法被表示為一個`SubscriberMethod`物件。

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

  1. 所有事件處理方法**必需是`public void`型別**的，並且只有一個參數列示*EventType*。
  2. `findSubscriberMethods`不只查詢*Subscriber*內的事件處理方法，**同時還會查到它的繼承體系中的所有基類中的事件處理方法**。

找到*Subscriber*中的所有事件處理方法後，會對每個找到的方法（表示為`SubscriberMethod`物件）呼叫`subscribe`方法註冊。`subscribe`方法幹了三件事：

  1. 根據`SubscriberMethod`中的*EventType*型別將`Subscribtion`物件存放在`subscriptionsByEventType`中。建立*EventType*到*Subscription*的對映，每個事件可以有多個訂閱者。
  2. 根據`Subscriber`將`EventType`存放在`typesBySubscriber`中，建立*Subscriber*到*EventType*的對映，每個Subscriber可以訂閱多個事件。
  3. 如果是*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;
            }
    }
}

可以看到post內使用了`PostingThreadState`的物件，並且是`ThreadLocal`，來看`PostingThreadState`的定義：

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

主要是有個成員`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));
        }
    }
}

來看一下`postSingleEvent`這個函式，首先看第一點，呼叫了`findEventTypes`這個函式，程式碼不帖了，這個函式的應用就是，把這個類的類物件、實現的介面及父類的類物件存到一個List中返回.

接下來進入第二步，遍歷第一步中得到的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);
    }
}

這裡就用到`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);
        }
    }
}

程式碼比較簡單，其實就是，待傳送的事件被封裝成了`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");
            }
        }
    }
}

在`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);
}

Stick Event

透過`registerSticky`可以註冊Stick事件處理函式，前面我們知道了，無論是`register`還是`registerSticky`最後都會呼叫`Subscribe`函式，在`Subscribe`中有這麼一段程式碼：

 

也就是會根據事件型別從`stickyEvents`中查詢是否有對應的事件，如果有，直接傳送這個事件到這個訂閱者。而這個事件是什麼時候存起來的呢，同`register`與`registerSticky`一樣，和`post`一起的還有一個`postSticky`函式：

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());
    }
}

當透過`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

 一個很簡單的Demo，Activity中包含列表和詳情兩個Fragment，Activity啟動時載入一個列表，點選列表後更新詳情資料：EventBusDemo

相關文章