官網地址：https://github.com/greenrobot/EventBus
EventBus產生需求背景：
在做項目的時候往往需要應用程序內各組件間、組件與後臺線程間的通信。比如耗時操作，等耗時操作完成後通過Handler或Broadcast將結果通知給UI，N個Activity之間需要通過Listener通信，之前的實現方式我們在Android消息傳遞之組件間傳遞消息（二）中已經介紹過了，其實這些都可以通過EventBus輕鬆實現，EventBus通過發佈/訂閱(publish/subscribe)方式來管理事件總線。其實EventBus的實現方式更加接近上篇文章的方式二，不同的是EventBus通過註解和反射機制 將訂閱者連同訂閱函數保存起來，然後在發送訂閱的時候 遍歷訂閱函數數組進行調用，其實從這方面就可以EventBus執行效率多少會受到一點影響。
EventBus介紹:
EventBus出自greenrobot，和之前大名鼎鼎的GreenDao出自同一家。之前一直使用的是2.4版本，今天我們將學習分析最新的Event 3.0，EventBus 3.0 最新的特性就是加入了註解，通過註解的方式 告知訂閱函數運行在哪個線程中。
github地址：https://github.com/greenrobot/EventBus
官方文檔：http://greenrobot.org/eventbus/documentation
EventBus主要角色:
- Event 傳遞的事件對象
- Subscriber 事件的訂閱者
- Publisher 事件的發佈者
- ThreadMode 定義函數在何種線程中執行
官網給出的各種角色的協作圖
EventBus配置:
EventBus框架也是採用建造者模式設計的，可以通過EventBusBuilder來設置一些配置信息，例如設置debug模式下要拋出異常
EventBus eventBus=EventBus.builder().throwSubscriberException(BuildConfig.DEBUG).build();2.使用方法
2.1註冊訂閱者
首先我們需要將我們希望訂閱事件的類,通過EventBus類註冊,註冊代碼如下:
//3.0版本的註冊
EventBus.getDefault().register(this);
//2.x版本的註冊
EventBus.getDefault().register(this);
EventBus.getDefault().register(this, 100);
EventBus.getDefault().registerSticky(this, 100);
EventBus.getDefault().registerSticky(this);可以看到2.x版本中有四種註冊方法,區分了普通註冊和粘性事件註冊,並且在註冊時可以選擇接收事件的優先級,這裏我們就不對2.x版本做過多的研究了,如果想研究可以參照此篇文章.由於3.0版本將粘性事件以及訂閱事件的優先級換了一種更好的實現方式,所以3.0版本中的註冊就變得簡單,只有一個register()方法即可.
2.2編寫響應事件訂閱方法
註冊之後,我們需要編寫響應事件的方法,代碼如下:
//3.0版本
@Subscribe(threadMode = ThreadMode.BACKGROUND, sticky = true, priority = 100)
public void test(String str) {
}
//2.x版本
public void onEvent(String str) {
}
public void onEventMainThread(String str) {
}
public void onEventBackgroundThread(String str) {
}在2.x版本中只有通過onEvent開頭的方法會被註冊,而且響應事件方法觸發的線程通過onEventMainThread或onEventBackgroundThread這些方法名區分,而在3.0版本中.通過@Subscribe註解,來確定運行的線程threadMode,是否接受粘性事件sticky以及事件優先級priority,而且方法名不在需要onEvent開頭,所以又簡潔靈活了不少.
2.3發送事件
我們可以通過EventBus的post()方法來發送事件,發送之後就會執行註冊過這個事件的對應類的方法.或者通過postSticky()來發送一個粘性事件.在代碼是2.x版本和3.0版本是一樣的.
EventBus.getDefault().post("str");
EventBus.getDefault().postSticky("str");2.4解除註冊
當我們不在需要接收事件的時候需要解除註冊unregister,2.x和3.0的解除註冊也是相同的.代碼如下:
EventBus.getDefault().unregister(this);3.類關係圖
類關係圖我直接引用了CodeKK的EventBus源代碼分析,
雖然更新了3.0,但是整體上的設計還是可以用上面的類圖來分析,從類圖上我們可以看到大部分類都是依賴於EventBus的,上部分主要是訂閱者相關信息，中間是 EventBus 類，
下面是發佈者發佈事件後的調用。下面我們來進行源碼分析.
4.源碼分析
這一節我們通過EventBus的使用流程來分析它的調用流程,通過我們熟悉的使用方法來深入到EventBus的實現內部並理解它的實現原理.
4.1創建EventBus
一般情況下我們都是通過EventBus.getDefault()獲取到EventBus對象,從而在進行register()或者post()等等,所以我們看看getDefault()方法的實現:
public static EventBus getDefault() {
if (defaultInstance == null) {
synchronized (EventBus.class) {
if (defaultInstance == null) {
defaultInstance = new EventBus();
}
}
}
return defaultInstance;
}這裏就是設計模式裏我們常用的單例模式了,目的是爲了保證getDefault()得到的都是同一個實例。如果不存在實例,就調用了EventBus的構造方法:
private static final EventBusBuilder DEFAULT_BUILDER = new EventBusBuilder();
public EventBus() {
this(DEFAULT_BUILDER);
}
EventBus(EventBusBuilder builder) {
//key:訂閱的事件,value:訂閱這個事件的所有訂閱者集合
//private final Map<Class<?>, CopyOnWriteArrayList<Subscription>> subscriptionsByEventType;
subscriptionsByEventType = new HashMap<>();
//key:訂閱者對象,value:這個訂閱者訂閱的事件集合
//private final Map<Object, List<Class<?>>> typesBySubscriber;
typesBySubscriber = new HashMap<>();
//粘性事件 key:粘性事件的class對象, value:事件對象
//private final Map<Class<?>, Object> stickyEvents;
stickyEvents = new ConcurrentHashMap<>();
//事件主線程處理
mainThreadPoster = new HandlerPoster(this, Looper.getMainLooper(), 10);
//事件 Background 處理
backgroundPoster = new BackgroundPoster(this);
//事件異步線程處理
asyncPoster = new AsyncPoster(this);
indexCount = builder.subscriberInfoIndexes != null ? builder.subscriberInfoIndexes.size() : 0;
//訂閱者響應函數信息存儲和查找類
subscriberMethodFinder = new SubscriberMethodFinder(builder.subscriberInfoIndexes,
builder.strictMethodVerification, builder.ignoreGeneratedIndex);
logSubscriberExceptions = builder.logSubscriberExceptions;
logNoSubscriberMessages = builder.logNoSubscriberMessages;
sendSubscriberExceptionEvent = builder.sendSubscriberExceptionEvent;
sendNoSubscriberEvent = builder.sendNoSubscriberEvent;
throwSubscriberException = builder.throwSubscriberException;
//是否支持事件繼承
eventInheritance = builder.eventInheritance;
executorService = builder.executorService;
}可以看出是通過初始化了一個EventBusBuilder()對象來分別初始化EventBus的一些配置,當我們在寫一個需要自定義配置的框架的時候,這種實現方法非常普遍,將配置解耦出去,使我們的代碼結構更清晰.註釋裏我標註了大部分比較重要的對象,這裏沒必要記住,看下面的文章時如果對某個對象不瞭解,可以再回來看看.
4.2註冊過程源碼分析
4.2.1 register()方法的實現
3.0的註冊只提供一個register()方法了,所以我們先來看看register()方法做了什麼:
public void register(Object subscriber) {
//首先獲得訂閱者的class對象
Class<?> subscriberClass = subscriber.getClass();
//通過subscriberMethodFinder來找到訂閱者訂閱了哪些事件.返回一個SubscriberMethod對象的List,SubscriberMethod
//裏包含了這個方法的Method對象,以及將來響應訂閱是在哪個線程的ThreadMode,以及訂閱的事件類型eventType,以及訂閱的優
//先級priority,以及是否接收粘性sticky事件的boolean值.
List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
synchronized (this) {
for (SubscriberMethod subscriberMethod : subscriberMethods) {
//訂閱
subscribe(subscriber, subscriberMethod);
}
}
}可以看到register()方法很簡潔,代碼裏的註釋也很清楚了,我們可以看出通過subscriberMethodFinder.findSubscriberMethods(subscriberClass)方法就能返回一個SubscriberMethod的對象,而SubscriberMethod裏包含了所有我們需要的接下來執行subscribe()的信息.所以我們先去看看findSubscriberMethods()是怎麼實現的,然後我們再去關注subscribe()。
4.2.2 SubscriberMethodFinder的實現
一句話來描述SubscriberMethodFinder類就是用來查找和緩存訂閱者響應函數的信息的類。所以我們首先要知道怎麼能獲得訂閱者響應函數的相關信息。在3.0版本中,EventBus提供了一個EventBusAnnotationProcessor註解處理器來在編譯期通過讀取@Subscribe()註解並解析,處理其中所包含的信息,然後生成java類來保存所有訂閱者關於訂閱的信息,這樣就比在運行時使用反射來獲得這些訂閱者的信息速度要快.我們可以參考EventBus項目裏的EventBusPerformance這個例子,編譯後我們可以在build文件夾裏找到這個類,MyEventBusIndex
類,當然類名是可以自定義的.我們大致看一下生成的MyEventBusIndex類是什麼樣的:
/**
* This class is generated by EventBus, do not edit.
*/
public class MyEventBusIndex implements SubscriberInfoIndex {
private static final Map<Class<?>, SubscriberInfo> SUBSCRIBER_INDEX;
static {
SUBSCRIBER_INDEX = new HashMap<Class<?>, SubscriberInfo>();
putIndex(new SimpleSubscriberInfo(org.greenrobot.eventbusperf.testsubject.PerfTestEventBus.SubscriberClassEventBusAsync.class,
true, new SubscriberMethodInfo[]{
new SubscriberMethodInfo("onEventAsync", TestEvent.class, ThreadMode.ASYNC),
}));
putIndex(new SimpleSubscriberInfo(TestRunnerActivity.class, true, new SubscriberMethodInfo[]{
new SubscriberMethodInfo("onEventMainThread", TestFinishedEvent.class, ThreadMode.MAIN),
}));
}
private static void putIndex(SubscriberInfo info) {
SUBSCRIBER_INDEX.put(info.getSubscriberClass(), info);
}
@Override
public SubscriberInfo getSubscriberInfo(Class<?> subscriberClass) {
SubscriberInfo info = SUBSCRIBER_INDEX.get(subscriberClass);
if (info != null) {
return info;
} else {
return null;
}
}
}可以看出是使用一個靜態HashMap即:SUBSCRIBER_INDEX來保存訂閱類的信息,其中包括了訂閱類的class對象,是否需要檢查父類,以及訂閱方法的信息SubscriberMethodInfo的數組,SubscriberMethodInfo中又保存了,訂閱方法的方法名,訂閱的事件類型,觸發線程,是否接收sticky事件以及優先級priority.這其中就保存了register()的所有需要的信息,如果再配置EventBus的時候通過EventBusBuilder配置:eventBus
= EventBus.builder().addIndex(new MyEventBusIndex()).build();來將編譯生成的MyEventBusIndex配置進去,這樣就能在SubscriberMethodFinder類中直接查找出訂閱類的信息,就不需要再利用註解判斷了,當然這種方法是作爲EventBus的可選配置,SubscriberMethodFinder同樣提供了通過註解來獲得訂閱類信息的方法,下面我們就來看findSubscriberMethods()到底是如何實現的:
List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
//先從METHOD_CACHE取看是否有緩存,key:保存訂閱類的類名,value:保存類中訂閱的方法數據,
List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass);
if (subscriberMethods != null) {
return subscriberMethods;
}
//是否忽略註解器生成的MyEventBusIndex類
if (ignoreGeneratedIndex) {
//利用反射來讀取訂閱類中的訂閱方法信息
subscriberMethods = findUsingReflection(subscriberClass);
} else {
//從註解器生成的MyEventBusIndex類中獲得訂閱類的訂閱方法信息
subscriberMethods = findUsingInfo(subscriberClass);
}
if (subscriberMethods.isEmpty()) {
throw new EventBusException("Subscriber " + subscriberClass
+ " and its super classes have no public methods with the @Subscribe annotation");
} else {
//保存進METHOD_CACHE緩存
METHOD_CACHE.put(subscriberClass, subscriberMethods);
return subscriberMethods;
}
}註釋很詳細我們就不在多說,由於篇幅原因我們就不在分析findUsingInfo()方法,其無非就是通過查找我們上面所說的MyEventBusIndex類中的信息,來轉換成List<SubscriberMethod>從而獲得訂閱類的相關訂閱函數的各種信息.有興趣的可以自己研究看看,下面我們就來看findUsingReflection()方法是如何實現的:
private List<SubscriberMethod> findUsingReflection(Class<?> subscriberClass) {
//FindState 用來做訂閱方法的校驗和保存
FindState findState = prepareFindState();
findState.initForSubscriber(subscriberClass);
while (findState.clazz != null) {
//通過反射來獲得訂閱方法信息
findUsingReflectionInSingleClass(findState);
//查找父類的訂閱方法
findState.moveToSuperclass();
}
//獲取findState中的SubscriberMethod(也就是訂閱方法List)並返回
return getMethodsAndRelease(findState);
}這裏通過FindState類來做訂閱方法的校驗和保存,並通過FIND_STATE_POOL靜態數組來保存FindState對象,可以使FindState複用,避免重複創建過多的對象.最終是通過findUsingReflectionInSingleClass()來具體獲得相關訂閱方法的信息的:
private void findUsingReflectionInSingleClass(FindState findState) {
Method[] methods;
//通過反射得到方法數組
try {
// This is faster than getMethods, especially when subscribers are fat classes like Activities
methods = findState.clazz.getDeclaredMethods();
} catch (Throwable th) {
// Workaround for java.lang.NoClassDefFoundError, see https://github.com/greenrobot/EventBus/issues/149
methods = findState.clazz.getMethods();
findState.skipSuperClasses = true;
}
//遍歷Method
for (Method method : methods) {
int modifiers = method.getModifiers();
if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {
Class<?>[] parameterTypes = method.getParameterTypes();
//保證必須只有一個事件參數
if (parameterTypes.length == 1) {
//得到註解
Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);
if (subscribeAnnotation != null) {
Class<?> eventType = parameterTypes[0];
//校驗是否添加該方法
if (findState.checkAdd(method, eventType)) {
ThreadMode threadMode = subscribeAnnotation.threadMode();
//實例化SubscriberMethod對象並添加
findState.subscriberMethods.add(new SubscriberMethod(method, eventType, threadMode,
subscribeAnnotation.priority(), subscribeAnnotation.sticky()));
}
}
} else if (strictMethodVerification && method.isAnnotationPresent(Subscribe.class)) {
String methodName = method.getDeclaringClass().getName() + "." + method.getName();
throw new EventBusException("@Subscribe method " + methodName +
"must have exactly 1 parameter but has " + parameterTypes.length);
}
} else if (strictMethodVerification && method.isAnnotationPresent(Subscribe.class)) {
String methodName = method.getDeclaringClass().getName() + "." + method.getName();
throw new EventBusException(methodName +
" is a illegal @Subscribe method: must be public, non-static, and non-abstract");
}
}
}這裏走完,我們訂閱類的所有SubscriberMethod都已經被保存了,最後再通過getMethodsAndRelease()返回List<SubscriberMethod>至此,所有關於如何獲得訂閱類的訂閱方法信息即:SubscriberMethod對象就已經完全分析完了,下面我們來看subscribe()是如何實現的.
4.2.3 subscribe()方法的實現
好的,這裏我們回到4.2.1的subscribe(subscriber, subscriberMethod);中去,通過這個方法,我們就完成了註冊,下面看一下subscribe()的實現:
//必須在同步代碼塊裏調用
private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
//獲取訂閱的事件類型
Class<?> eventType = subscriberMethod.eventType;
//創建Subscription對象
Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
//從subscriptionsByEventType裏檢查是否已經添加過該Subscription,如果添加過就拋出異常
CopyOnWriteArrayList<Subscription> subscriptions = subscriptionsByEventType.get(eventType);
if (subscriptions == null) {
subscriptions = new CopyOnWriteArrayList<>();
subscriptionsByEventType.put(eventType, subscriptions);
} else {
if (subscriptions.contains(newSubscription)) {
throw new EventBusException("Subscriber " + subscriber.getClass() + " already registered to event "
+ eventType);
}
}
//根據優先級priority來添加Subscription對象
int size = subscriptions.size();
for (int i = 0; i <= size; i++) {
if (i == size || subscriberMethod.priority > subscriptions.get(i).subscriberMethod.priority) {
subscriptions.add(i, newSubscription);
break;
}
}
//將訂閱者對象以及訂閱的事件保存到typesBySubscriber裏.
List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber);
if (subscribedEvents == null) {
subscribedEvents = new ArrayList<>();
typesBySubscriber.put(subscriber, subscribedEvents);
}
subscribedEvents.add(eventType);
//如果接收sticky事件,立即分發sticky事件
if (subscriberMethod.sticky) {
//eventInheritance 表示是否分發訂閱了響應事件類父類事件的方法
if (eventInheritance) {
// Existing sticky events of all subclasses of eventType have to be considered.
// Note: Iterating over all events may be inefficient with lots of sticky events,
// thus data structure should be changed to allow a more efficient lookup
// (e.g. an additional map storing sub classes of super classes: Class -> List<Class>).
Set<Map.Entry<Class<?>, Object>> entries = stickyEvents.entrySet();
for (Map.Entry<Class<?>, Object> entry : entries) {
Class<?> candidateEventType = entry.getKey();
if (eventType.isAssignableFrom(candidateEventType)) {
Object stickyEvent = entry.getValue();
checkPostStickyEventToSubscription(newSubscription, stickyEvent);
}
}
} else {
Object stickyEvent = stickyEvents.get(eventType);
checkPostStickyEventToSubscription(newSubscription, stickyEvent);
}
}
}以上就是所有註冊過程,現在再來看這張圖就會特別清晰EventBus的register()過程了:
4.3事件分發過程源碼分析
通過第二節我們知道可以通過EventBus.getDefault().post("str");來發送一個事件,所以我們就從這行代碼開始分析,首先看看post()方法是如何實現的:
public void post(Object event) {
//得到當前線程的Posting狀態.
PostingThreadState postingState = currentPostingThreadState.get();
//獲取當前線程的事件隊列
List<Object> eventQueue = postingState.eventQueue;
eventQueue.add(event);
if (!postingState.isPosting) {
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;
}
}
}首先是通過currentPostingThreadState.get()方法來得到當前線程PostingThreadState的對象,爲什麼是說當前線程我們來看看currentPostingThreadState的實現:
private final ThreadLocal<PostingThreadState> currentPostingThreadState = new ThreadLocal<PostingThreadState>() {
@Override
protected PostingThreadState initialValue() {
return new PostingThreadState();
}
};currentPostingThreadState的實現是一個包含了PostingThreadState的ThreadLocal對象,關於ThreadLocal
張濤的這篇文章解釋的很好:ThreadLocal 是一個線程內部的數據存儲類，通過它可以在指定的線程中存儲數據，
而這段數據是不會與其他線程共享的。其內部原理是通過生成一個它包裹的泛型對象的數組，在不同的線程會有不同的數組索引值，通過這樣就可以做到每個線程通過
get() 方法獲取的時候，取到的只能是自己線程所對應的數據。 所以這裏取到的就是每個線程的PostingThreadState狀態.接下來我們來看postSingleEvent()
方法:
private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
Class<?> eventClass = event.getClass();
boolean subscriptionFound = false;
//是否觸發訂閱了該事件(eventClass)的父類,以及接口的類的響應方法.
if (eventInheritance) {
//查找eventClass類所有的父類以及接口
List<Class<?>> eventTypes = lookupAllEventTypes(eventClass);
int countTypes = eventTypes.size();
//循環postSingleEventForEventType
for (int h = 0; h < countTypes; h++) {
Class<?> clazz = eventTypes.get(h);
//只要右邊有一個爲true,subscriptionFound就爲true
subscriptionFound |= postSingleEventForEventType(event, postingState, clazz);
}
} else {
//post單個
subscriptionFound = postSingleEventForEventType(event, postingState, eventClass);
}
//如果沒發現
if (!subscriptionFound) {
if (logNoSubscriberMessages) {
Log.d(TAG, "No subscribers registered for event " + eventClass);
}
if (sendNoSubscriberEvent && eventClass != NoSubscriberEvent.class &&
eventClass != SubscriberExceptionEvent.class) {
//發送一個NoSubscriberEvent事件,如果我們需要處理這種狀態,接收這個事件就可以了
post(new NoSubscriberEvent(this, event));
}
}
}跟着上面的代碼的註釋,我們可以很清楚的發現是在postSingleEventForEventType()方法裏去進行事件的分發,代碼如下:
private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class<?> eventClass) {
CopyOnWriteArrayList<Subscription> subscriptions;
//獲取訂閱了這個事件的Subscription列表.
synchronized (this) {
subscriptions = subscriptionsByEventType.get(eventClass);
}
if (subscriptions != null && !subscriptions.isEmpty()) {
for (Subscription subscription : subscriptions) {
postingState.event = event;
postingState.subscription = subscription;
//是否被中斷
boolean aborted = false;
try {
//分發給訂閱者
postToSubscription(subscription, event, postingState.isMainThread);
aborted = postingState.canceled;
} finally {
postingState.event = null;
postingState.subscription = null;
postingState.canceled = false;
}
if (aborted) {
break;
}
}
return true;
}
return false;
}
private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {
switch (subscription.subscriberMethod.threadMode) {
case POSTING:
invokeSubscriber(subscription, event);
break;
case MAIN:
if (isMainThread) {
invokeSubscriber(subscription, event);
} else {
mainThreadPoster.enqueue(subscription, event);
}
break;
case BACKGROUND:
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);
}
}總結上面的代碼就是,首先從subscriptionsByEventType裏獲得所有訂閱了這個事件的Subscription列表,然後在通過postToSubscription()方法來分發
事件,在postToSubscription()通過不同的threadMode在不同的線程裏invoke()訂閱者的方法,ThreadMode共有四類:
PostThread：默認的 ThreadMode，表示在執行 Post 操作的線程直接調用訂閱者的事件響應方法，不論該線程是否爲主線程（UI 線程）。當該線程爲主線程時，響應方法中不能有耗時操作，否則有卡主線程的風險。適用場景：對於是否在主線程執行無要求，但若 Post 線程爲主線程，不能耗時的操作；MainThread：在主線程中執行響應方法。如果發佈線程就是主線程，則直接調用訂閱者的事件響應方法，否則通過主線程的 Handler 發送消息在主線程中處理——調用訂閱者的事件響應函數。顯然，MainThread類的方法也不能有耗時操作，以避免卡主線程。適用場景：必須在主線程執行的操作；BackgroundThread：在後臺線程中執行響應方法。如果發佈線程不是主線程，則直接調用訂閱者的事件響應函數，否則啓動唯一的後臺線程去處理。由於後臺線程是唯一的，當事件超過一個的時候，它們會被放在隊列中依次執行，因此該類響應方法雖然沒有PostThread類和MainThread類方法對性能敏感，但最好不要有重度耗時的操作或太頻繁的輕度耗時操作，以造成其他操作等待。適用場景：操作輕微耗時且不會過於頻繁，即一般的耗時操作都可以放在這裏；Async：不論發佈線程是否爲主線程，都使用一個空閒線程來處理。和BackgroundThread不同的是，Async類的所有線程是相互獨立的，因此不會出現卡線程的問題。適用場景：長耗時操作，例如網絡訪問。
引用自
這裏我們只來看看invokeSubscriber(subscription, event);是如何實現的,關於不同線程的Poster的使用可以參考這篇文章
以及上面codekk的文章.invokeSubscriber(subscription, event);代碼如下:
void invokeSubscriber(Subscription subscription, Object event) {
try {
subscription.subscriberMethod.method.invoke(subscription.subscriber, event);
} catch (InvocationTargetException e) {
handleSubscriberException(subscription, event, e.getCause());
} catch (IllegalAccessException e) {
throw new IllegalStateException("Unexpected exception", e);
}
}實際上就是通過反射調用了訂閱者的訂閱函數並把event對象作爲參數傳入.至此post()流程就結束了,整體流程圖如下:
4.4解除註冊源碼分析
看完了上面的分析,解除註冊就相對容易了,解除註冊只要調用unregister()方法即可,實現如下:
public synchronized void unregister(Object subscriber) {
//通過typesBySubscriber來取出這個subscriber訂閱者訂閱的事件類型,
List<Class<?>> subscribedTypes = typesBySubscriber.get(subscriber);
if (subscribedTypes != null) {
//分別解除每個訂閱了的事件類型
for (Class<?> eventType : subscribedTypes) {
unsubscribeByEventType(subscriber, eventType);
}
//從typesBySubscriber移除subscriber
typesBySubscriber.remove(subscriber);
} else {
Log.w(TAG, "Subscriber to unregister was not registered before: " + subscriber.getClass());
}
}然後接着看unsubscribeByEventType()方法的實現:
private void unsubscribeByEventType(Object subscriber, Class<?> eventType) {
//subscriptionsByEventType裏拿出這個事件類型的訂閱者列表.
List<Subscription> subscriptions = subscriptionsByEventType.get(eventType);
if (subscriptions != null) {
int size = subscriptions.size();
//取消訂閱
for (int i = 0; i < size; i++) {
Subscription subscription = subscriptions.get(i);
if (subscription.subscriber == subscriber) {
subscription.active = false;
subscriptions.remove(i);
i--;
size--;
}
}
}
}最終分別從typesBySubscriber和subscriptions裏分別移除訂閱者以及相關信息即可.
5.設計模式
觀察者模式
觀察者模式觀察者模式是對象的行爲模式，又叫發佈-訂閱(Publish/Subscribe)模式、模型-視圖(Model/View)模式、源-監聽器(Source/Listener)模式或從屬者(Dependents)模式。觀察者模式定義了一種一對多的依賴關係，讓多個觀察者對象同時監聽某一個主題對象。這個主題對象在狀態上發生變化時，會通知所有觀察者對象，使它們能夠自動更新自己。EventBus並不是標準的觀察者模式的實現,但是它的整體就是一個發佈/訂閱框架,也擁有觀察者模式的優點,比如:發佈者和訂閱者的解耦.
6.個人評價
EventBus不論從使用方式和實現方式上都是非常值得我們學習的開源項目,我參與的一些項目裏都是廣泛的使用EventBus做消息的通知,可以說是目前消息通知裏最好用
的項目.但是業內對EventBus的主要爭論點是在於EventBus使用反射會出現性能問題,關於反射的性能問題可以參考這篇文章,
實際上在EventBus裏我們可以看到不僅可以使用註解處理器預處理獲取訂閱信息,EventBus也會將訂閱者的方法緩存到METHOD_CACHE裏避免重複查找,所以只有在最後invoke()方法的時候會比直接調用多出一些性能損耗,但是這些對於我們移動端來說是完全可以忽略的.所以盲目的說因爲性能問題而覺得EventBus不值得使用顯然是不
負責任的.在2.x版本里EventBus寫出的代碼可讀性不是太好因爲所有訂閱方法都是onEvent開頭,這樣就使代碼的可讀性降低不少,但是3.0之後我們就不用擔心這些了,因爲
方法名已經不再需要onEvent開頭了。所以總體上來說EventBus還是值得我們在項目中使用的。
http://www.jianshu.com/p/f057c460c77e