先吐槽一下博客園的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步，點擊此鏈接查看例子及介紹。

定義事件類型：

`public class MyEvent {}`

定義事件處理方法：

`public void onEventMainThread`

注冊訂閱者：

`EventBus.getDefault().register(this)`

發送事件：

`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，事件到訂閱對象之間的映射privatefinalMap, CopyOnWriteArrayList>subscriptionsByEventType;//Subscriber -> List，訂閱源到它訂閱的的所有事件類型的映射privatefinalMap>>typesBySubscriber;//stickEvent事件，后面會看到privatefinalMap, Object>stickyEvents;//EventType -> List，事件到它的父事件列表的映射。即緩存一個類的所有父類privatestaticfinalMap, List>> eventTypesCache =newHashMap, List>>();

注冊事件：Register

通過`EventBus.getDefault().register`方法可以向`EventBus`注冊來訂閱事件，`register`有很多種重載形式，但大都被標記為`Deprecated`了，所以還是不用為好，前面說了事件處理方法都是以*onEvent*開頭，其實是可以通過register方法修改的，但相應的方法被廢棄了，還是不要用了，就用默認的*onEvent*，除下廢棄的register方法，還有以下4個**public**的`register`方法

publicvoidregister(Object subscriber) {

register(subscriber, defaultMethodName,false, 0);

}publicvoidregister(Object subscriber,intpriority) {

register(subscriber, defaultMethodName,false, priority);

}publicvoidregisterSticky(Object subscriber) {

register(subscriber, defaultMethodName,true, 0);

}publicvoidregisterSticky(Object subscriber,intpriority) {

register(subscriber, defaultMethodName,true, priority);

}

可以看到，這4個方法都調用了同一個方法：

privatesynchronizedvoidregister(Object subscriber, String methodName,booleansticky,intpriority) {

List 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`就不再分析了，但有兩點需要知道：

所有事件處理方法**必需是`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的類型就可以發送到相應事件的訂閱者。

publicvoidpost(Object event) {

PostingThreadState postingState=currentPostingThreadState.get();

List eventQueue =postingState.eventQueue;

eventQueue.add(event);if(postingState.isPosting) {return;

}else{

postingState.isMainThread= Looper.getMainLooper() ==Looper.myLooper();

postingState.isPosting=true;if(postingState.canceled) {thrownewEventBusException("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`的定義：

finalstaticclassPostingThreadState {

List eventQueue =newArrayList();booleanisPosting;booleanisMainThread;

Subscription subscription;

Object event;booleancanceled;

}

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

privatevoidpostSingleEvent(Object event, PostingThreadState postingState)throwsError {

Class eventClass =event.getClass();

List> eventTypes = findEventTypes(eventClass);//1booleansubscriptionFound =false;intcountTypes =eventTypes.size();for(inth = 0; h < countTypes; h++) {//2Class clazz =eventTypes.get(h);

CopyOnWriteArrayListsubscriptions;synchronized(this) {

subscriptions=subscriptionsByEventType.get(clazz);

}if(subscriptions !=null&& !subscriptions.isEmpty()) {//3for(Subscription subscription : subscriptions) {

postingState.event=event;

postingState.subscription=subscription;booleanaborted =false;try{

postToSubscription(subscription, event, postingState.isMainThread);//4aborted =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(newNoSubscriberEvent(this, event));

}

}

}

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

接下來進入第二步，遍歷第一步中得到的List，對List中的每個類對象（即事件類型）執行第三步操作，即找到這個事件類型的所有訂閱者向其發送事件。可以看到，**當我們Post一個事件時，這個事件的父事件（事件類的父類的事件）也會被Post，所以如果有個事件訂閱者接收Object類型的事件，那么它就可以接收到所有的事件**。

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

privatevoidpostToSubscription(Subscription subscription, Object event,booleanisMainThread) {switch(subscription.subscriberMethod.threadMode) {casePostThread:

invokeSubscriber(subscription, event);break;caseMainThread:if(isMainThread) {

invokeSubscriber(subscription, event);

}else{

mainThreadPoster.enqueue(subscription, event);

}break;caseBackgroundThread:if(isMainThread) {

backgroundPoster.enqueue(subscription, event);

}else{

invokeSubscriber(subscription, event);

}break;caseAsync:

asyncPoster.enqueue(subscription, event);break;default:thrownewIllegalStateException("Unknown thread mode: " +subscription.subscriberMethod.threadMode);

}

}

這里就用到`ThreadMode`了：

如果是PostThread，直接執行

如果是MainThread，判斷當前線程，如果本來就是UI線程就直接執行，否則加入`mainThreadPoster`隊列

如果是后臺線程，如果當前是UI線程，加入`backgroundPoster`隊列，否則直接執行

如果是Async，加入`asyncPoster`隊列

BackgroundPoster

privatefinalPendingPostQueue queue;publicvoidenqueue(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

voidenqueue(Subscription subscription, Object event) {

PendingPost pendingPost=PendingPost.obtainPendingPost(subscription, event);synchronized(this) {

queue.enqueue(pendingPost);if(!handlerActive) {

handlerActive=true;if(!sendMessage(obtainMessage())) {thrownewEventBusException("Could not send handler message");

}

}

}

}

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

AsyncPoster

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

publicvoidenqueue(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是按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