EventBus原理與原始碼解析

weixin_34138377發表於2018-10-25
原始碼

1、概述

EventBus是針對Android優化的釋出-訂閱事件匯流排，簡化了Android元件間的通訊。EventBus以其簡單易懂、優雅、開銷小等優點而備受歡迎。關於其如何使用網上有很多教程，也可以從其官網中瞭解到基本用法。其中整體事件流程的走向基本上可以用官網的一張圖來說明，如下：

1594504-86a8386e85c11555.png
EventBus-Publish-Subscribe.png

publisher通過post來傳遞事件到事件中心Bus，Bus再將事件分發到Subscriber。其本質是一個觀察者模型，最核心部分也就是Bus如何接收訊息和分發訊息。

2、基本概念：

在講解原始碼之前，先說一下EventBus需要關注的點 - EventBus支援的四種執行緒模式（ThreadMode）。如我們常常採用以下方式使用

  @Subscribe(threadMode = ThreadMode.POSTING)
    public void getEventBus(Integer num) {
        if (num != null) {
            Toast.makeText(this, "num" + num, Toast.LENGTH_SHORT).show();
        }
    }

其中@Subscribe(threadMode = ThreadMode.POSTING)也可以寫成@Subscribe。
1. POSTING（預設）：事件在哪個執行緒釋出，就在哪個執行緒消費，因此要特別注意不要在UI執行緒進行耗時的操作，否則會ANR。
2. MAIN：事件的消費會在UI執行緒。因此，不宜進行耗時操作，以免引起ANR。
3. BACKGROUND：如果事件在UI執行緒產生，那麼事件的消費會在單獨的子執行緒中進行。否則，在同一個執行緒中消費。
4. ASYNC：不管是否在UI執行緒產生事件，都會在單獨的子執行緒中消費事件。

除此之外EventBus還支援粘性事件，即傳送一個未註冊的粘性事件，註冊者會在完成註冊之後收到這個粘性事件。

3、原始碼解析

正如官網圖和上文所說，EventBus最核心的部分就是其訊息註冊和分發中心，如何將訊息註冊者和訊息接收這繫結起來達到準確的分發，這個當是難點。接下來我們通過起原始碼來逐一分析和解讀。從官網中下載EventBus的原始碼，可以知道其原始碼並不是很多，整體結構基本如下：

1594504-55fd49e62905d2ac.png
eventbus_sources.png

原始碼結構相對來說是非常清晰了，大佬就是大佬。
我們開始使用EventBus的時候都會採用如下方式註冊使用

EventBus.getDefault().register(this);

通過檢視getDefault方法

/** Convenience singleton for apps using a process-wide EventBus instance. */
    public static EventBus getDefault() {
        EventBus instance = defaultInstance;
        if (instance == null) {
            synchronized (EventBus.class) {
                instance = EventBus.defaultInstance;
                if (instance == null) {
                    instance = EventBus.defaultInstance = new EventBus();
                }
            }
        }
        return instance;
    }

發現是一個“雙重校驗鎖”的單例模式。
檢視EventBus

EventBus(EventBusBuilder builder) {
        logger = builder.getLogger();
        subscriptionsByEventType = new HashMap<>();
        typesBySubscriber = new HashMap<>();
        stickyEvents = new ConcurrentHashMap<>();
        mainThreadSupport = builder.getMainThreadSupport();
        mainThreadPoster = mainThreadSupport != null ? mainThreadSupport.createPoster(this) : null;
        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;
    }

構造者，裡面會初始化一些基礎變數。

3.1註冊

 public void register(Object subscriber) {
        Class<?> subscriberClass = subscriber.getClass();//1
        List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);//2
        synchronized (this) {
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                subscribe(subscriber, subscriberMethod);//3
            }
        }
    }
  1. 獲取註冊的者上下文，比如說Activity
  2. 通過註冊者的上下文查詢註冊的事件方法
  3. 將註冊者和註冊的事件繫結起來，即完成了註冊，可以檢視subscribe方法
private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
        Class<?> eventType = subscriberMethod.eventType;
        Subscription newSubscription = new Subscription(subscriber, subscriberMethod);//1
        CopyOnWriteArrayList<Subscription> subscriptions = subscriptionsByEventType.get(eventType);//2
        if (subscriptions == null) {
            subscriptions = new CopyOnWriteArrayList<>();
            subscriptionsByEventType.put(eventType, subscriptions);//3
        } 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) {//4
            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);
            }
        }
    }
  1. 將註冊者和事件消費方法封裝起來，這裡才是真正的繫結。
  2. 就像上述註冊者和事件消費方法是1：N的關係。一個Event與註冊者之間也是1：N的關係。因為一個Event可能會被不同的Activity註冊。也就是說Event、註冊者、事件消費方法的關係是：1：N：M（其中M、N均大於等於1）。
  3. 註冊者（比如MainActivity.this）與事件消費方法（SubscriberMethod）的關係，我們封裝到了Subscription(s)中了。而Event和Subscription(s)的關係，我們通過HashMap儲存，key為event.class，value即Subscription(s)。
  4. 黏性事件的處理。

3.2釋出與消費

public void post(Object event) {
        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);//1
                }
            } finally {
                postingState.isPosting = false;
                postingState.isMainThread = false;
            }
        }
    }
  1. 通過前面的狀態判斷，走到這一步真正消費事件。繼續往下走該方法，我們可以發現其最終是呼叫方法
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);
        }
    }

從程式碼可以知道，最終會通過判斷執行緒，來依次消費事件。
檢視方法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);
        }
    }

可以看出最終是以反射的方式。

3.3 反註冊

註冊消費完事件後，我們需要反向註冊，類似如我們廣播的使用。

private void unsubscribeByEventType(Object subscriber, Class<?> eventType) {
        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--;
                }
            }
        }
    }

可以看到是依次移除掉subscriptions列表。

4、總結

從整個程式碼流程來看，基本上沒什麼難點，用起來也非常方便。
但在使用過程中，像我這種菜鳥發現了兩個問題

  1. 其訊息給人感覺是一種亂跳的感覺，因為其採用註解的方式，這點感覺對業務邏輯梳理並不一定佔有優勢，就拿Android Studio來說，居然會提示該方法無處使用，如下圖：


    1594504-a0dd39c235f30bd9.png
    no_use.png
  2. 採用反射方法invokeSubscriber來消費事件，效率如何。

相關文章