EventBus 源码解析

本文目的

---

分析EventBus是如何工作的（基于3.0版本）。

放两张EventBus内部的数据的存储图：

eventbus_eventmethods.png

这里是用一个HashMap保存每一个事件类型对应的所有监听方法。

typesBySubscriber.png

这里是用一个HashMap保存每一个注册了的类中，所有的监听事件的类型。

先看看EventBus.java中，它有哪些属性值得关注：

public class EventBus {

    static volatile EventBus defaultInstance;
    // 保存每个事件类型接收通知的方法
    private final Map, CopyOnWriteArrayList> subscriptionsByEventType;
    // 保存每个类中，所有的事件类型
    private final Map>> typesBySubscriber;
    private final Map, Object> stickyEvents;

    private final HandlerPoster mainThreadPoster;
    private final BackgroundPoster backgroundPoster;
    private final AsyncPoster asyncPoster;
    private final SubscriberMethodFinder subscriberMethodFinder;
    private final ExecutorService executorService;

    private final ThreadLocal currentPostingThreadState = new ThreadLocal() {
        @Override
        protected PostingThreadState initialValue() {
            return new PostingThreadState();
        }
    };
}

Subscription就是一个类+它内部一个事件监听方法的封装：

final class Subscription {
    final Object subscriber;
    final SubscriberMethod subscriberMethod;
}

SubscribeMethod代表一个事件监听方法

public class SubscriberMethod {
    final Method method;
    final ThreadMode threadMode;
    final Class eventType;
    final int priority;
    final boolean sticky;
    /** Used for efficient comparison */
    String methodString;
}

注册过程

---

我们一般都是在Activity的onStart方法中，执行EventBus.getDefault().register(this):

    public void register(Object subscriber) {
        Class subscriberClass = subscriber.getClass();
        // 这里通过2种方式去获取一个类里面所有加了@Subscribe注解的事件监听方法：
        // 1、是通过annotationProcessor，在编译时获取注解，然后生成Java代码，在运行时叫用此生成的Java代码，完成所有类中监听方法的收集工作。
        // 2、使用反射
        List subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
        synchronized (this) {
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                subscribe(subscriber, subscriberMethod);
            }
        }
    }

这里根据注册的类，找到这个类里所有的EventBus事件方法List，然后对每一个方法中的事件进行订阅：

    private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
        Class eventType = subscriberMethod.eventType;
        Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
        // 此事件已经拥有的监听者方法
        CopyOnWriteArrayList 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> 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).
                Set, Object>> entries = stickyEvents.entrySet();
                for (Map.Entry, 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, Looper.getMainLooper() == Looper.myLooper());
        }
    }

看名字，应该就是将事件发布给订阅者了，好了，消息的详细发布过程后面再看，先来看看我们发送普通事件的过程是怎样的。

事件发布

---

一般情况，我们发布事件是调用EventBus.getDefault().post()：

    public void post(Object event) {
        // 又看到了ThreadLocal的身影了，此处currentPostingThreadState.get就是在每个线程内部都保存一份自己的PostingThreadState
        PostingThreadState postingState = currentPostingThreadState.get();
        List