EventBus3.0源码详解

原理

先上代码：

 public static EventBus getDefault() {
        if (defaultInstance == null) {
            synchronized (EventBus.class) {
                if (defaultInstance == null) {
                    defaultInstance = new EventBus();
                }
            }
        }
        return defaultInstance;
    }

从代码可以看出，EventBus能够在不同组件、Activity之间通信都是通过一个static的单例对象。是观察者模式的一种应用，注册—>list.add post—>通知所有注册的观察者。具体来看代码。

注册

先来看register方法:

 public void register(Object subscriber) {
        Class subscriberClass = subscriber.getClass(); //获取观察者的Class
        List subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass); //获取Class中带有Subscribe注释的方法
        synchronized (this) {
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                subscribe(subscriber, subscriberMethod);//核心代码，下面会详细分析
            }
        }
    }

在register方法中调用的subscribe方法:

private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
        Class eventType = subscriberMethod.eventType; //注册的方法所在的class
        Subscription newSubscription = new Subscription(subscriber, subscriberMethod);//此对象是用来检测是否已经调用过注册
        CopyOnWriteArrayList subscriptions = subscriptionsByEventType.get(eventType);//全局的Map中获取所有此class注册的方法
        if (subscriptions == null) {//观察者第一次调用注册（观察者class中有多个subscribe方法会调用多次）
            subscriptions = new CopyOnWriteArrayList<>();
            subscriptionsByEventType.put(eventType, subscriptions);//将注册对象的class和class中的注册方法放入全局Map中
        } else {
            if (subscriptions.contains(newSubscription)) {//此类型的Event已经在class上注册过了，抛出异常
                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) {//检查优先级 优先级高的在前  默认优先级为0 可通过在观察中用    priority = X 来配置
                subscriptions.add(i, newSubscription);
                break;
            }
        }

        List> subscribedEvents = typesBySubscriber.get(subscriber);
        if (subscribedEvents == null) {//第一次调用-->新建key--value配对
            subscribedEvents = new ArrayList<>();
            typesBySubscriber.put(subscriber, subscribedEvents);
        }
        subscribedEvents.add(eventType);

        if (subscriberMethod.sticky) { //是否是sticky事件（如果是粘性事件，事件总线会传递最近的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 final Map, CopyOnWriteArrayList> subscriptionsByEventType;//存观察者的class和对应的SubcriptionList

private final Map>> typesBySubscriber;//存观察者和观察者需要观察的数据类型List

以上为EventBus的注册过程，代码中涉及的其他类后面会详细分析，这里只是分析流程。

Post事件

EventBus为Post事件提供了两个方法post()和postSticky(),其中postSticky()内部也是通过post()实现的只不过是多了事件的保存，代码如下:

 /**
     * Posts the given event to the event bus and holds on to the event (because it is sticky). The most recent sticky
     * event of an event's type is kept in memory for future access by subscribers using {@link Subscribe#sticky()}.
     */
    public void postSticky(Object event) {
        synchronized (stickyEvents) {
            stickyEvents.put(event.getClass(), event);
        }
        // Should be posted after it is putted, in case the subscriber wants to remove immediately
        post(event);
    }

这里注释已经解释的很明显了"将给定的事件发布到事件总线并保持事件(因为它是粘性的)。事件类型的最新粘性事件保存在内存中，供使用{@link Subscribe#sticky()}的订阅者将来访问。"
再来看post：

/** Posts the given event to the event bus. */
    public void post(Object event) {
        PostingThreadState postingState = currentPostingThreadState.get();//获取post线程的状态，这里currentPostingThreadState被ThreadLocal修饰只能在一个线程中访问
        List