EventBus 3.1.1 源碼解析
* 本篇文章已受權微信公衆號 guolin_blog（郭霖）獨家發佈
1、本文須要解決的問題
我研究EventBus源碼的目的是解決如下幾個我在使用過程當中所思考的問題：html
- 這個框架涉及到一種設計模式叫作觀察者模式，什麼是觀察者模式？
- 事件如何進行定義，有沒有相關限制？
- 觀察者綁定觀察事件的時候，綁定方法的命名有限制嗎？
- 事件發送和接收的原理？
2、初步使用
爲了研究源碼的方便，我寫了一個簡單的demo。java
定義事件
TestEvent.java：git
public class TestEvent {
private String msg;
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
}
複製代碼
主Activity
MainActivity.java：github
public class MainActivity extends AppCompatActivity {
private Button button;
private TextView textView;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
button = findViewById(R.id.button);
textView = findViewById(R.id.text);
EventBus.getDefault().register(this);
button.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
TestEvent event = new TestEvent();
event.setMsg("已接收到事件!");
EventBus.getDefault().post(event);
}
});
}
@Subscribe(threadMode = ThreadMode.MAIN)
public void onTestEvent(TestEvent event) {
textView.setText(event.getMsg());
}
@Override
protected void onDestroy() {
EventBus.getDefault().unregister(this);
super.onDestroy();
}
}
複製代碼
運行效果
3、源碼分析
關於觀察者模式
- 簡介：觀察者模式是設計模式中的一種。它是爲了定義對象間的一種一對多的依賴關係，即當一個對象的狀態發生改變時，全部依賴於它的對象都獲得通知並被自動更新。
- 如何使用：這裏傳送門有相關的demo，這裏再也不詳述。
- 重點：在這個模式中主要包含兩個重要的角色：發佈者和訂閱者（又稱觀察者）。對應EventBus來講，發佈者即發送消息的一方（即調用EventBus.getDefault().post(event)的一方），訂閱者即接收消息的一方（即調用EventBus.getDefault().register()的一方）。 咱們已經解決了第一個問題~
關於事件
這裏指的事件實際上是一個泛泛的統稱，指的是一個概念上的東西（當時我還覺得必定要以啥Event命名...），經過查閱官方文檔，我知道事件的命名格式並無任何要求，你能夠定義一個對象做爲事件，也能夠發送基本數據類型如int，String等做爲一個事件。後續的源碼分析我也會再次證實一下。設計模式
具體分析
從函數入口開始分析： 1.EventBus#getDefault()：緩存
public static EventBus getDefault() {
if (defaultInstance == null) {
synchronized (EventBus.class) {
if (defaultInstance == null) {
defaultInstance = new EventBus();
}
}
}
return defaultInstance;
}
複製代碼
這裏就是採用雙重校驗並加鎖的單例模式生成EventBus實例。微信
public void register(Object subscriber) {
Class<?> subscriberClass = subscriber.getClass();
List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
synchronized (this) {
for (SubscriberMethod subscriberMethod : subscriberMethods) {
subscribe(subscriber, subscriberMethod);
}
}
}
複製代碼
因爲咱們傳入的爲this，即MainActivity的實例，因此第一行代碼獲取了訂閱者的class對象，而後會找出全部訂閱的方法。咱們看一下第二行的邏輯。 SubscriberMethodFinder#findSubscriberMethods()：框架
List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass);
if (subscriberMethods != null) {
return subscriberMethods;
}
if (ignoreGeneratedIndex) {
subscriberMethods = findUsingReflection(subscriberClass);
} else {
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.put(subscriberClass, subscriberMethods);
return subscriberMethods;
}
}
複製代碼
分析：異步
- 若是緩存中有對應class的訂閱方法列表，則直接返回，這裏咱們是第一次建立，因此此時subscriberMethods爲空；
- 接下來會有一個參數判斷，經過查看前面的建立過程，ignoreGeneratedIndex默認爲false，進入else代碼塊，後面生成subscriberMethods成功的話會加入到緩存中，失敗的話會throw異常。
2.SubscriberMethodFinder#findUsingInfo()：async
private List<SubscriberMethod> findUsingInfo(Class<?> subscriberClass) {
// 2.1
FindState findState = prepareFindState();
findState.initForSubscriber(subscriberClass);
// 2.2
while (findState.clazz != null) {
findState.subscriberInfo = getSubscriberInfo(findState);
if (findState.subscriberInfo != null) {
SubscriberMethod[] array = findState.subscriberInfo.getSubscriberMethods();
for (SubscriberMethod subscriberMethod: array) {
if (findState.checkAdd(subscriberMethod.method, subscriberMethod.eventType)) {
findState.subscriberMethods.add(subscriberMethod);
}
}
} else {
// 2.3
findUsingReflectionInSingleClass(findState);
}
findState.moveToSuperclass();
}
// 2.4
return getMethodsAndRelease(findState);
}
複製代碼
2.1 SubscriberMethodFinder#prepareFindState()：
private static final FindState[] FIND_STATE_POOL = new FindState[POOL_SIZE];
private FindState prepareFindState() {
synchronized(FIND_STATE_POOL) {
for (int i = 0; i < POOL_SIZE; i++) {
FindState state = FIND_STATE_POOL[i];
if (state != null) {
FIND_STATE_POOL[i] = null;
return state;
}
}
}
return new FindState();
}
複製代碼
這個方法是建立一個新的FindState類，經過兩種方法獲取，一種是從FIND_STATE_POOL即FindState池中取出可用的FindState，若是沒有的話，則經過第二種方式：直接new一個新的FindState對象。 FindState#initForSubscriber()：
static class FindState {
// 省略代碼
void initForSubscriber(Class<?> subscriberClass) {
this.subscriberClass = clazz = subscriberClass;
skipSuperClasses = false;
subscriberInfo = null;
}
// 省略代碼
}
複製代碼
FindState類是SubscriberMethodFinder的內部類，這個方法主要作一個初始化的工做。
2.2 SubscriberMethodFinder#getSubscriberInfo()：
private SubscriberInfo getSubscriberInfo(FindState findState) {
if (findState.subscriberInfo != null && findState.subscriberInfo.getSuperSubscriberInfo() != null) {
SubscriberInfo superclassInfo = findState.subscriberInfo.getSuperSubscriberInfo();
if (findState.clazz == superclassInfo.getSubscriberClass()) {
return superclassInfo;
}
}
if (subscriberInfoIndexes != null) {
for (SubscriberInfoIndex index: subscriberInfoIndexes) {
SubscriberInfo info = index.getSubscriberInfo(findState.clazz);
if (info != null) {
return info;
}
}
}
return null;
}
複製代碼
這裏因爲初始化的時候，findState.subscriberInfo和subscriberInfoIndexes爲空，因此這裏直接返回null，後續咱們能夠再回到這裏看看subscriberInfo有什麼做用。
2.3 SubscriberMethodFinder#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;
}
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();
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");
}
}
}
複製代碼
這個方法的邏輯是： 經過反射的方式獲取訂閱者類中的全部聲明方法，而後在這些方法裏面尋找以@Subscribe做爲註解的方法進行處理（！！！部分的代碼），先通過一輪檢查，看看findState.subscriberMethods是否存在，若是沒有的話，將方法名，threadMode，優先級，是否爲sticky方法封裝爲SubscriberMethod對象，添加到subscriberMethods列表中。
什麼是sticky event？
sticky event，中文名爲粘性事件。普通事件是先註冊，而後發送事件才能收到；而粘性事件，在發送事件以後再訂閱該事件也能收到。此外，粘性事件會保存在內存中，每次進入都會去內存中查找獲取最新的粘性事件，除非你手動解除註冊。
在這裏咱們解決了第二個和第三個問題，方法的命名並無任何要求，只是加上@Subscribe註解便可！同時事件的命名也沒有任何要求！
以後這個while循環會繼續檢查父類，固然遇到系統相關的類時會自動跳過，以提高性能。
2.4 SubscriberMethodFinder#getMethodsAndRelease
private List<SubscriberMethod> getMethodsAndRelease(FindState findState) {
List<SubscriberMethod> subscriberMethods = new ArrayList<>(findState.subscriberMethods);
findState.recycle();
synchronized(FIND_STATE_POOL) {
for (int i = 0; i < POOL_SIZE; i++) {
if (FIND_STATE_POOL[i] == null) {
FIND_STATE_POOL[i] = findState;
break;
}
}
}
return subscriberMethods;
}
複製代碼
這裏將subscriberMethods列表直接返回，同時會把findState作相應處理，存儲在FindState池中，方便下一次使用，提升性能。
- EventBus#subscribe()： 返回subscriberMethods以後，register方法的最後會調用subscribe方法：
public void register(Object subscriber) {
Class<?> subscriberClass = subscriber.getClass();
List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
synchronized (this) {
for (SubscriberMethod subscriberMethod : subscriberMethods) {
subscribe(subscriber, subscriberMethod);
}
}
}
private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
Class<?> eventType = subscriberMethod.eventType;
Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
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);
}
}
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;
}
}
List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber);
if (subscribedEvents == null) {
subscribedEvents = new ArrayList<>();
typesBySubscriber.put(subscriber, subscribedEvents);
}
subscribedEvents.add(eventType);
if (subscriberMethod.sticky) {
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);
}
}
}
複製代碼
分析：
- 首先，根據subscriberMethod.eventType（在Demo裏面指的是TestEvent），在subscriptionsByEventType去查找一個CopyOnWriteArrayList ，若是沒有則建立一個新的CopyOnWriteArrayList；
- 而後將這個CopyOnWriteArrayList放入subscriptionsByEventType中，這裏的subscriptionsByEventType是一個Map，key爲eventType，value爲CopyOnWriteArrayList，這個Map很是重要，後續還會用到它；
- 接下來，就是添加newSubscription，它屬於Subscription類，裏面包含着subscriber和subscriberMethod等信息，同時這裏有一個優先級的判斷，說明它是按照優先級添加的。優先級越高，會插到在當前List靠前面的位置；
- typesBySubscriber這個類也是一個Map，key爲subscriber，value爲subscribedEvents，即全部的eventType列表，這個類我找了一下，發如今EventBus#isRegister()方法中有用到，應該是用來判斷這個Subscriber是否已被註冊過。而後將當前的eventType添加到subscribedEvents中；
- 最後，判斷是不是sticky。若是是sticky事件的話，到最後會調用checkPostStickyEventToSubscription()方法。
這裏其實就是將全部含@Subscribe註解的訂閱方法最終保存在subscriptionsByEventType中。
- EventBus#checkPostStickyEventToSubscription()：
private void checkPostStickyEventToSubscription(Subscription newSubscription, Object stickyEvent) {
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, isMainThread());
}
}
複製代碼
接下來，咱們重點看post()和postToSubscription()方法。post事件至關於把事件發送出去，咱們看看訂閱者是如何接收到事件的。
- EventBus#post()：
/** Posts the given event to the event bus. */
public void post(Object event) {
// 5.1
PostingThreadState postingState = currentPostingThreadState.get();
List <Object> eventQueue = postingState.eventQueue;
eventQueue.add(event);
// 5.2
if (!postingState.isPosting) {
postingState.isMainThread = isMainThread();
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;
}
}
}
複製代碼
5.1 代碼段分析
- currentPostingThreadState是一個ThreadLocal類型的，裏面存儲了PostingThreadState，而PostingThreadState中包含了一個eventQueue和其餘一些標誌位；
- 而後把傳入的event，保存到了當前線程中的一個變量PostingThreadState的eventQueue中。
private final ThreadLocal <PostingThreadState> currentPostingThreadState = new ThreadLocal <PostingThreadState> () {
@Override
protected PostingThreadState initialValue() {
return new PostingThreadState();
}
};
/** For ThreadLocal, much faster to set (and get multiple values). */
final static class PostingThreadState {
final List <Object> eventQueue = new ArrayList<>();
boolean isPosting;
boolean isMainThread;
Subscription subscription;
Object event;
boolean canceled;
}
複製代碼
5.2 代碼段分析
- 這裏涉及到兩個標誌位，第一個是isMainThread，判斷是否爲UI線程；第二個是isPosting，做用是防止方法屢次調用。
- 最後調用到postSingleEvent()方法
- EventBus#postSingleEvent()：
private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
Class<?> eventClass = event.getClass();
boolean subscriptionFound = false;
if (eventInheritance) {
List<Class<?>> eventTypes = lookupAllEventTypes(eventClass);
int countTypes = eventTypes.size();
for (int h = 0; h < countTypes; h++) {
Class<?> clazz = eventTypes.get(h);
subscriptionFound |= postSingleEventForEventType(event, postingState, clazz);
}
} else {
subscriptionFound = postSingleEventForEventType(event, postingState, eventClass);
}
if (!subscriptionFound) {
if (logNoSubscriberMessages) {
logger.log(Level.FINE, "No subscribers registered for event " + eventClass);
}
if (sendNoSubscriberEvent && eventClass != NoSubscriberEvent.class &&
eventClass != SubscriberExceptionEvent.class) {
post(new NoSubscriberEvent(this, event));
}
}
}
private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class <?> eventClass) {
CopyOnWriteArrayList <Subscription> subscriptions;
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;
}
複製代碼
- 這裏會首先取出Event的class類型，而後有一個標誌位eventInheritance判斷，默認爲true，做用在相關代碼註釋有說，若是設爲true的話，它會拿到Event父類的class類型，設爲false，能夠在必定程度上提升性能；
- 接下來是lookupAllEventTypes()方法，就是取出Event及其父類和接口的class列表，固然重複取的話會影響性能，因此它也有作一個eventTypesCache的緩存，這樣不用都重複調用getClass()方法。
- 而後是postSingleEventForEventType()方法，這裏就很清晰了，就是直接根據Event類型從subscriptionsByEventType中取出對應的subscriptions，與以前的代碼對應，最後調用postToSubscription()方法。
- EventBus#postToSubscription()：
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 MAIN_ORDERED:
if (mainThreadPoster != null) {
mainThreadPoster.enqueue(subscription, event);
} else {
// temporary: technically not correct as poster not decoupled from subscriber
invokeSubscriber(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);
}
}
複製代碼
這裏會根據threadMode來判斷應該在哪一個線程中去執行方法：
- POSTING：執行invokeSubscriber()方法，就是直接反射調用；
- MAIN：首先去判斷當前是否在UI線程，若是是的話則直接反射調用，不然調用mainThreadPoster#enqueue()，即把當前的方法加入到隊列之中，而後經過handler去發送一個消息，在handler的handleMessage中去執行方法。具體邏輯在HandlerPoster.java中；
- MAIN_ORDERED：與上面邏輯相似，順序執行咱們的方法；
- BACKGROUND：判斷當前是否在UI線程，若是不是的話直接反射調用，是的話經過backgroundPoster.enqueue()將方法加入到後臺的一個隊列，最後經過線程池去執行；
- ASYNC：與BACKGROUND的邏輯相似，將任務加入到後臺的一個隊列，最終由Eventbus中的一個線程池去調用，這裏的線程池與BACKGROUND邏輯中的線程池用的是同一個。
補充：BACKGROUND和ASYNC有什麼區別呢？ BACKGROUND中的任務是一個接着一個的去調用，而ASYNC則會即時異步運行，具體的能夠對比AsyncPoster.java和BackgroundPoster.java二者代碼實現的區別。
到這裏，咱們就解決了第四個問題，事件的發送和接收，主要是經過subscriptionsByEventType這個很是重要的列表，咱們將訂閱即接收事件的方法存儲在這個列表，發佈事件的時候在列表中查詢出相對應的方法並執行~
這篇文章會同步到個人我的日誌，若有問題，請你們踊躍提出，謝謝你們！
相關文章
- 1. EventBus源碼解析
- 2. EventBus 源碼解析
- 3. EventBus—源碼解析
- 4. [EventBus源碼解析] 初探EventBus
- 5. 【Android】EventBus 源碼解析
- 6. EventBus源碼解析（一）
- 7. EventBus 3.0源碼解析
- 8. Guava源碼解析之EventBus
- 9. guava eventbus源碼解析
- 10. andorid jar/庫源碼解析之EventBus
- 更多相關文章...
- • XML DOM 解析器 - XML DOM 教程
- • TCP報文格式解析 - TCP/IP教程
- • Scala 中文亂碼解決
- • 互聯網組織的未來：剖析GitHub員工的任性之源
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. 安裝cuda+cuDNN
- 2. GitHub的使用說明
- 3. phpDocumentor使用教程【安裝PHPDocumentor】
- 4. yarn run build報錯Component is not found in path 「npm/taro-ui/dist/weapp/components/rate/index「
- 5. 精講Haproxy搭建Web集羣
- 6. 安全測試基礎之MySQL
- 7. C/C++編程筆記：C語言中的複雜聲明分析，用實例帶你完全讀懂
- 8. Python3教程(1)----搭建Python環境
- 9. 李宏毅機器學習課程筆記2：Classification、Logistic Regression、Brief Introduction of Deep Learning
- 10. 阿里雲ECS配置速記
歡迎關注本站公眾號,獲取更多信息
