EventBus原始碼分析
EventBus 是一個事件匯流排框架，解決了元件之間通訊的問題。使用了觀察者模式。使程式碼更加簡潔
簡單使用
1.引入依賴
compile 'org.greenrobot:eventbus:3.1.1'
2.定義事件
public class MessageEvent {
private Object msg;
public MessageEvent(Object msg) {
this.msg = msg;
}
public Object getMsg() {
return msg;
}
public void setMsg(Object msg) {
this.msg = msg;
}
@Override
public String toString() {
return "MessageEvent{" +
"msg=" + msg +
'}';
}
}
複製程式碼3.註冊與反註冊
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
EventBus.getDefault().register(this);
mTextView = findViewById(R.id.tv);
}
@Override
protected void onDestroy() {
super.onDestroy();
EventBus.getDefault().unregister(this);
}
複製程式碼4.在某個地方傳送事件
EventBus.getDefault().post(new MessageEvent("嘿嘿嘿"));
複製程式碼5.在註冊頁面接收事件
@Subscribe(threadMode = ThreadMode.MAIN, priority = 100, sticky = false)
public void onMessageEventPost(MessageEvent messageEvent) {
Log.e(TAG, "onMessageEventPost: " + messageEvent.getMsg().toString());
mTextView.setText(messageEvent.getMsg().toString());
}
@Subscribe(threadMode = ThreadMode.MAIN, priority = 150, sticky = false)
public void onMessageEvent(MessageEvent messageEvent) {
Log.e(TAG, "onMessageEvent: " + messageEvent.getMsg().toString());
mTextView.setText(messageEvent.getMsg().toString());
}
複製程式碼註冊分析
EventBus.getDefault().register(this);這行程式碼都做了什麼呢，大眼一看感覺好像是用的單例模式構造物件。
建立EventBus物件
/** Convenience singleton for apps using a process-wide EventBus instance. */
/*使用雙重鎖校驗建立EventBus物件*/
public static EventBus getDefault() {
if (defaultInstance == null) {
synchronized (EventBus.class) {
if (defaultInstance == null) {
defaultInstance = new EventBus();
}
}
}
return defaultInstance;
}
複製程式碼註冊
/**
* Registers the given subscriber to receive events. Subscribers must call {@link #unregister(Object)} once they
* are no longer interested in receiving events.
* 引數型別是Object，可以接收各種型別。
* <p/>
* Subscribers have event handling methods that must be annotated by {@link Subscribe}.
* The {@link Subscribe} annotation also allows configuration like {@link
* ThreadMode} and priority.
*/
public void register(Object subscriber) {
// 使用反射獲取到類的位元組碼檔案
Class<?> subscriberClass = subscriber.getClass();
// 通過反射獲取該類中所有 包含 @Subscribe 註解的方法，得到的是一個集合
List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
// 上鎖
synchronized (this) {
// 迴圈遍歷所有的方法，進行訂閱
for (SubscriberMethod subscriberMethod : subscriberMethods) {
// 訂閱 subscriber 在這裡表示就是MainActivity
// subscriberMethod 在這裡表示方法有兩個 onMessageEventPost onMessageEvent
subscribe(subscriber, subscriberMethod);
}
}
}
複製程式碼來到了SubscriberMethodFinder類中，從類名直接來看，是訂閱者方法搜尋者，通過類的位元組碼檔案找到所有訂閱者的方法，這個類是在Eventbus的構造方法中建立的。
private static final Map<Class<?>, List<SubscriberMethod>> METHOD_CACHE = new ConcurrentHashMap<>();
List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
// 這裡使用Map做了一個快取，先從Map中找，如果沒有在通過反射去遍歷尋找。能提高效率
List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass);
// 如果Map中存在，就直接取出來
if (subscriberMethods != null) {
return subscriberMethods;
}
//ignoreGenerateIndex這個值表示是否忽略註解器生成的MyEventBusIndex
// 這個值預設是false,表示可以通過EventBusHandler來設定他的值
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.put(subscriberClass, subscriberMethods);
return subscriberMethods;
}
}
複製程式碼private List<SubscriberMethod> findUsingInfo(Class<?> subscriberClass) {
// 這裡有用到享元模式
FindState findState = prepareFindState();
findState.initForSubscriber(subscriberClass);
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 {
findUsingReflectionInSingleClass(findState);
}
findState.moveToSuperclass();
}
return getMethodsAndRelease(findState);
}
複製程式碼通過反射獲取訂閱類中的訂閱方法資訊
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();
// 方法只能是 public ，如果設定成private 和 static abstract 的話將會報錯
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 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 註解的方法之後，就要開始進行訂閱subscribe 操作，主要做的工作就是解析所有 subscriberMethod 的eventType,然後解析成Map<Class<?>, CopyOnWriteArrayList> subscriptionsByEventType;的格式，key 為引數型別的class，value是儲存了Subscription的一個列表，Subscription包含兩個屬性，一個是subscriber(訂閱者類)，一個是subscriberMethod,就是註解方法
private final Map<Class<?>, CopyOnWriteArrayList<Subscription>> subscriptionsByEventType;
// Must be called in synchronized block
private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
// 獲取方法引數的class ，在我們的這裡demo中表示 MessageEvent.class
Class<?> eventType = subscriberMethod.eventType;
// 構建一個 Subscription
Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
// subscriptionsByEventType 是一個Map，key是方法引數的Class:MessageEvent.class.value 是這裡相當於做了一個快取操作
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;
}
}
// 通過 subscriber 獲取 List<Class<?>> typesBySubscriber 也是一個Map，key儲存的是訂閱者，value是所有訂閱者裡面方法引數的Class
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);
}
}
}
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());
}
}
複製程式碼Map<Class<?>, CopyOnWriteArrayList<Subscription>> subscriptionsByEventType 這個Map的資料結構，subscriber -> MainActivity, subscriberMehtod -> onMessageEventPost
**粘性事件（sticky event）：**普通事件是先註冊，然後傳送事件才能收到；而粘性事件，在傳送事件之後再訂閱該事件也能收到。此外，粘性事件會儲存在記憶體中，每次進入都會去記憶體中查詢獲取最新的粘性事件，除非你手動解除註冊。
post()傳送分析
EventBus.getDefault().post(new MessageEvent("嘿嘿嘿"));
// ThreadLocal 是一個建立執行緒區域性變數的類，，通常情況下我們建立的變數是可以被任何一個執行緒訪問的，但是ThreadLocal建立的變數只能被當前執行緒訪問，其他
// 執行緒無法訪問和修改。
private final ThreadLocal<PostingThreadState> currentPostingThreadState = new ThreadLocal<PostingThreadState>() {
@Override
protected PostingThreadState initialValue() {
return new PostingThreadState();
}
};
/** Posts the given event to the event bus. */
public void post(Object event) {
// event 就是我們傳送的時間 MessageEvent
// 獲取到當前執行緒的變數資料
PostingThreadState postingState = currentPostingThreadState.get();
List<Object> eventQueue = postingState.eventQueue;
// 把事件新增到事件佇列中
eventQueue.add(event);
// 判斷是否處在事件釋出狀態，如果沒有，就傳送事件，並且一直保持釋出狀態。
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;
}
}
}
複製程式碼傳送事件
private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
// 事件的Class，就是 MessageEvent.class
Class<?> eventClass = event.getClass();
// 是否找到訂閱者
boolean subscriptionFound = false;
// 是否支援事件繼承，預設為true
if (eventInheritance) {
// 獲取到所有的事件的父類和介面
List<Class<?>> eventTypes = lookupAllEventTypes(eventClass);
int countTypes = eventTypes.size();
for (int h = 0; h < countTypes; h++) {
Class<?> clazz = eventTypes.get(h);
// 依次向 eventClass 的父類或介面的訂閱方法傳送事件
// 只要有一個事件傳送成功，返回 true ，那麼 subscriptionFound 就為 true
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) {
// 得到 subscription 列表，這個物件裡包含兩個部分，見上圖
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 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);
}
}
複製程式碼BACKGROUND 與 ASYNC 的區別： 前者中的任務是序列呼叫，後者是非同步呼叫。
總結：
事件的傳送和接收，主要是通過subscriptionsByEventType這個列表，Map<Class<?>, CopyOnWriteArrayList<Subscription>> subscriptionsByEventType。我們將訂閱即接收事件的方法儲存在這個列表，釋出事件的時候在遍歷列表，查詢出相對應的方法並通過反射執行。