What？EventBus的核心居然只是這兩個Map？
簡單介紹一下EventBus
其實EventBus你們都很熟悉了，就不過多去說它了。一般咱們叫它事件總線，其實它更像是廣播，觀察者模式，一方發送消息多方接收。在EventBus的建立訂閱過程當中，最重要的就是有兩個關鍵的Map，這兩個鍵值對裏面存儲了咱們定義的訂閱方法和相關的類，那究竟是具體是怎麼操做的呢，來源碼一探究竟。java
下面的代碼基於EventBus3.1.1git
建立和訂閱消息
註冊
EventBus的註冊很簡單，github
@Override
public void onStart() {
super.onStart();
EventBus.getDefault().register(this);
}
@Override
public void onStop() {
super.onStop();
EventBus.getDefault().unregister(this);
}
複製代碼
這裏必定要記住在onStop中註銷，避免在Activity關閉後還跟EventBus有聯繫，而後形成內存泄漏。數組
接下來進入到方法中看一看：緩存
單例模式
EventBus.getDefaultide
public static EventBus getDefault() {
if (defaultInstance == null) {
synchronized (EventBus.class) {
if (defaultInstance == null) {
defaultInstance = new EventBus();
}
}
}
return defaultInstance;
}
複製代碼
這個方法很簡單，就是雙重校驗單例，繼續看register方法：ui
register方法
EventBus.registerthis
public void register(Object subscriber) {
Class<?> subscriberClass = subscriber.getClass();//註冊的類
List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);//查找訂閱方法
synchronized (this) {
for (SubscriberMethod subscriberMethod : subscriberMethods) {//循環找到的全部方法
subscribe(subscriber, subscriberMethod);
}
}
}
複製代碼
在register中，傳入的參數名爲subscriber，意思就是訂閱者，類型爲Object。在這個方法裏有個List的列表，這個SubscriberMethod是什麼呢？spa
public class SubscriberMethod {
final Method method;//對應的方法
final ThreadMode threadMode;//線程模式
final Class<?> eventType;//消息類型
final int priority;//優先級
final boolean sticky;//是否支持粘性
/** Used for efficient comparison */
String methodString;//用於equal對比
}
複製代碼
其實這個類就保存了咱們訂閱者裏面定義的方法裏面的全部信息。線程
線程模式
其中threadMode的定義以下：
-
ThreadMode.POSTING：默認的線程模式，在那個線程發送事件就在對應線程處理事件，避免了線程切換，效率高。
-
ThreadMode.MAIN：如在主線程（UI線程）發送事件，則直接在主線程處理事件；若是在子線程發送事件，則先將事件入隊列，而後經過 Handler 切換到主線程，依次處理事件。
-
ThreadMode.MAIN_ORDERED：不管在那個線程發送事件，都先將事件入隊列，而後經過 Handler 切換到主線程，依次處理事件。
-
ThreadMode.BACKGROUND：若是在主線程發送事件，則先將事件入隊列，而後經過線程池依次處理事件；若是在子線程發送事件，則直接在發送事件的線程處理事件。
-
ThreadMode.ASYNC：不管在那個線程發送事件，都將事件入隊列，而後經過線程池處理。
因此在register方法中的這個列表其實就是當前咱們這個訂閱者類包含全部的接收方法。這裏經過subscriberMethodFinder.findSubscriberMethods(subscriberClass)方法獲取：
查找訂閱事件的方法（接收消息的方法）
SubscriberMethodFinder findSubscriberMethods
private static final Map<Class<?>, List<SubscriberMethod>> METHOD_CACHE = new ConcurrentHashMap<>();
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;
}
}
複製代碼
這裏咱們注意到有一個ignoreGeneratedIndex參數，這個屬性的值是在構造方法中獲取的
subscriberMethodFinder = new SubscriberMethodFinder(builder.subscriberInfoIndexes,
builder.strictMethodVerification, builder.ignoreGeneratedIndex);
複製代碼
/** Forces the use of reflection even if there's a generated index (default: false). */
public EventBusBuilder ignoreGeneratedIndex(boolean ignoreGeneratedIndex) {
this.ignoreGeneratedIndex = ignoreGeneratedIndex;
return this;
}
複製代碼
從官方的註釋能夠看出，這裏默認值是false，因此是調用findUsingInfo方法：
private List<SubscriberMethod> findUsingInfo(Class<?> subscriberClass) {
FindState findState = prepareFindState();
findState.initForSubscriber(subscriberClass);//初始化查找輔助類
while (findState.clazz != null) {//這裏就是咱們register的類
findState.subscriberInfo = getSubscriberInfo(findState);
if (findState.subscriberInfo != null) {//初始狀態爲空，因此執行else
SubscriberMethod[] array = findState.subscriberInfo.getSubscriberMethods();
for (SubscriberMethod subscriberMethod : array) {
if (findState.checkAdd(subscriberMethod.method, subscriberMethod.eventType)) {
findState.subscriberMethods.add(subscriberMethod);
}
}
} else {
findUsingReflectionInSingleClass(findState);
}
findState.moveToSuperclass();//查找父類
}
return getMethodsAndRelease(findState);//釋放資源
}
複製代碼
FindState是查找輔助類，裏面存儲了關於查找到的訂閱方法信息和相關類的信息：
static class FindState {
final List<SubscriberMethod> subscriberMethods = new ArrayList<>();//訂閱的方法
final Map<Class, Object> anyMethodByEventType = new HashMap<>();//經過消息類型獲取方法
final Map<String, Class> subscriberClassByMethodKey = new HashMap<>();//經過方法獲取訂閱的類
final StringBuilder methodKeyBuilder = new StringBuilder(128);
Class<?> subscriberClass;
Class<?> clazz;
boolean skipSuperClasses;
SubscriberInfo subscriberInfo;
}
複製代碼
在這裏會執行else裏面的findUsingReflectionInSingleClass方法，經過反射來查找訂閱方法
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) {//public，非abstract、static
Class<?>[] parameterTypes = method.getParameterTypes();//獲取參數類型
if (parameterTypes.length == 1) {//只能有一個參數
Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);//獲取Subscribe註解
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註解的方法，而後將方法的信息加到數組當中。在查找完畢以後，接下來回到register方法
public void register(Object subscriber) {
Class<?> subscriberClass = subscriber.getClass();
List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
synchronized (this) {
for (SubscriberMethod subscriberMethod : subscriberMethods) {
subscribe(subscriber, subscriberMethod);
}
}
}
複製代碼
循環訂閱
拿到咱們剛纔的全部訂閱方法的數組，而後在循環中執行subscribe方法，這個方法執行訂閱操做：
private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
Class<?> eventType = subscriberMethod.eventType;//獲取咱們自定義的消息類型
Subscription newSubscription = new Subscription(subscriber, subscriberMethod);//新建一個訂閱類，這個類包含了訂閱的類和方法兩個屬性
//subscriptionsByEventType是以eventType爲key，Subscription數組爲value的map
CopyOnWriteArrayList<Subscription> subscriptions = subscriptionsByEventType.get(eventType);
if (subscriptions == null) {//爲空的話建立數組，並加入到map中
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;
}
}
//typesBySubscriber是以對象爲key，訂閱的方法的數組爲value的map
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);
}
}
}
複製代碼
完
其實EventBus的register方法的內部具體作的事情很簡單，總的來講就是兩步：
- 經過反射查找咱們使用了Subscribe註解的訂閱方法
- 循環遍歷找到的方法，而後加到關鍵的兩個map中（subscriptionsByEventType和typesBySubscriber）
subscriptionsByEventType：以eventType爲key，Subscription數組爲value
typesBySubscriber：以對象爲key，訂閱的方法的數組爲value
相關文章
- 1. 這居然是一個RCE漏洞
- 2. vue.js的兩個核心是什麼
- 3. What？你和酷炫的PPT之間居然只差了一個QQ截圖！
- 4. 這套動捕方案居然只用一個攝像頭？
- 5. What？Tomcat-居然也算中間件？
- 6. What？Tomcat 居然也算中間件？
- 7. 程序員的平常居然是這樣，真的是又心疼又可笑······
- 8. 震驚，這個碼農居然是個混子！
- 9. 居然兩個NameNode都是備用，見了鬼了
- 10. spring兩個核心類
- 更多相關文章...
- • Hibernate的核心接口 - Hibernate教程
- • MyBatis的核心組件 - MyBatis教程
- • 再有人問你分佈式事務，把這篇扔給他
- • 漫談MySQL的鎖機制
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
