簡單介紹一下EventBus
其實EventBus大家都很熟悉了，就不過多去說它了。通常我們叫它事件總線，其實它更像是廣播，觀察者模式，一方發送消息多方接收。在EventBus的創建訂閱過程中，最重要的就是有兩個關鍵的Map，這兩個鍵值對里面存儲了我們定義的訂閱方法和相關的類，那到底是具體是怎么操作的呢，來源碼一探究竟。
下面的代碼基于EventBus3.1.1
創建和訂閱消息
注冊
EventBus的注冊很簡單，
@Override
public void onStart() {
super.onStart();
EventBus.getDefault().register(this);
}
@Override
public void onStop() {
super.onStop();
EventBus.getDefault().unregister(this);
}
這里一定要記住在onStop中注銷，避免在Activity關閉后還跟EventBus有聯系，然后造成內存泄漏。
接下來進入到方法中看一看：
單例模式
EventBus.getDefault
public static EventBus getDefault() {
if (defaultInstance == null) {
synchronized (EventBus.class) {
if (defaultInstance == null) {
defaultInstance = new EventBus();
}
}
}
return defaultInstance;
}
這個方法很簡單，就是雙重校驗單例，繼續看register方法：
register方法
EventBus.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);
}
}
}
在register中，傳入的參數名為subscriber，意思就是訂閱者，類型為Object。在這個方法里有個List<SubscriberMethod>的列表，這個SubscriberMethod是什么呢？
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）
