EventBus源码解析（三）-注册

一、注册主要流程

EventBus的注册代码如下：

    public void register(Object subscriber) {
        Class subscriberClass = subscriber.getClass();
        List subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
        synchronized (this) {
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                subscribe(subscriber, subscriberMethod);
            }
        }
    }

register方法主要做了三件事：

获取订阅者类的class对象

根据class对象查找对应的订阅者类的所有订阅方法

执行订阅

二、SubscriberMethodFinder

查找订阅方法时，调用了SubscriberMethodFinder类的findSubscriberMethods方法，并将订阅者类的class对象作为实参传递进去。那么SubscriberMethodFinder是什么呢？

SubscriberMethodFinder类，顾名思义，它就是一个订阅者方法查找器。在它的内部有一个很重要的成员变量METHOD_CACHE，即订阅者方法缓存，它是线程安全的HashMap，键是订阅者类的class对象，具备唯一性；值是订阅方法（添加了@Subscribe注解的方法）集合。

private static final Map, List> METHOD_CACHE = new ConcurrentHashMap<>();

查找对应的订阅者类的订阅方法时，执行了如下逻辑：

List findSubscriberMethods(Class subscriberClass) {
        List 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;
        }
    }

这部分代码逻辑很清晰，按步骤分别作了以下操作：

根据订阅者class对象到METHOD_CACHE缓存中查找对应的订阅方法集合

如果订阅方法集合非空，直接返回；否则继续向下执行

如果不在编译时使用索引技术，则跳转findUsingReflection，使用反射查找

如果在编译时使用索引技术，则跳转findUsingInfo，使用索引查找

将查找到的集合存入METHOD_CACHE缓存

对于findUsingReflection和findUsingInfo，在这一章不去深究，我们的主线仍然是注册。

三、SubscriberMethod

那么订阅方法SubscriberMethod是什么呢？其实它对应的就是我们在代码中使用@Subscribe注解标记的public方法。

public class SubscriberMethod {
    final Method method;
    final ThreadMode threadMode;
    final Class eventType;
    final int priority;
    final boolean sticky;

    ...

}

回想一下，我们在使用EventBus时，订阅方法的常规写法，比如下面这种形式：

@Subscribe(threadMode = ThreadMode.MainThread,sticky=true)
public void subscribe(Event event) {
}

对应到SubscriberMethod 成员，是不是一路了然？method代表订阅方法，threadMode代表订阅方法的执行线程，eventType代表事件类型，priority代表事件优先级，sticky代表事件是否粘性。

四、订阅

回到第一小节，查找到订阅方法集合之后，需要遍历集合，对每个订阅者和订阅方法执行subscribe订阅操作。

subscribe的代码逻辑比较多，但其实也很清晰，我们将该方法完整地（不省略任何代码）拆分成3个小方法，依次分析。即：

//该代码是伪代码
private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
        subscribe1(subscriber,subscriberMethod);
        subscribe2(subscriber,subscriberMethod);
        subscribe3(subscriber,subscriberMethod);
}

4.1

private void subscribe1(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;
            }
        }
}

分析这部分代码之前，我们首先需要了解Subscription类和subscriptionsByEventType变量。

4.1.1 Subscription

Subscription的内部结构如下：

    final Object subscriber;
    final SubscriberMethod subscriberMethod;
    volatile boolean active;

该类和第二小节提到的METHOD_CACHE很相似，但又不同。METHOD_CACHE记录的是订阅者类中的所有订阅方法，是一对多的关系；而Subscription记录的是订阅者类的某个具体的订阅方法，是一对一的关系。该类中的active布尔值当注册解除时被置位成false。我们可以把该类理解成订阅信息。

4.1.2 subscriptionsByEventType

subscriptionsByEventType在该系列文章的第二篇中的结束语中有提及，但没有深究。subscriptionsByEventType其实是一个依据事件类型来存储订阅者及订阅方法信息的数据结构。subscriptionsByEventType在EventBus类中的定义是这样的：

Map, CopyOnWriteArrayList> subscriptionsByEventType;

subscriptionsByEventType也是一个Map结构，键是一个事件类型的class对象，值则是一个线程安全的订阅信息集合。也许会有读者问：为什么键是一个“事件类型”的class对象，而不是其他呢？我们可以从subscribe1的如下代码中推敲而出（更直观地，也可以通过命名得知）：

CopyOnWriteArrayList subscriptions = subscriptionsByEventType.get(eventType);

看到没有，get方法里的实参是一个事件类型的class对象，由此得出以上结论。

4.1.3 subscribe1流程分析

分析完Subscription和subscriptionsByEventType后，我们梳理一下subscribe1的代码逻辑：

将订阅者与某个具体的订阅方法包装成一个新的订阅信息对象newSubscription

根据事件类型，从subscriptionsByEventType中取出订阅信息集合subscriptions

如果订阅信息集合为null，说明是首次订阅该类事件，直接创建一个空的订阅信息集合，并存入subscriptionsByEventType

如果订阅信息集合不是null，则说明此前已经有订阅过该类事件的历史，对订阅信息集合进行contains判断，如果该集合中存在newSubscription，则说明订阅者重复订阅了同一类事件，抛出异常

将订阅信息newSubscription按照priority优先级存入订阅信息集合subscriptions中

也许会有读者有疑问，newSubscription明明每次都是被重新new出来的，对象地址势必都不同，这样在执行subscriptions.contains(newSubscription)不就一定是返回false吗？这样不就永远也不会抛出这个异常了？但在实际使用中，的确是有很多读者都遇到过这个异常信息。

EventBus之所以敢这样写，是因为它重写了Subscription的equals和hashCode方法，有兴趣的读者可以自行翻阅。

4.2

private void subscribe2(Object subscriber, SubscriberMethod subscriberMethod) {
        List> subscribedEvents = typesBySubscriber.get(subscriber);
        if (subscribedEvents == null) {
            subscribedEvents = new ArrayList<>();
            typesBySubscriber.put(subscriber, subscribedEvents);
        }
        subscribedEvents.add(eventType);
}

依照惯例，我们依然需要了解一下typesBySubscriber变量的作用。typesBySubscriber也是该系列第二章中结束语时提到的一个关键变量，它在EventBus中的定义如下：

private final Map>> typesBySubscriber;

typesBySubscriber也是一个Map结构，键是订阅者类的class对象，值是该订阅类已经订阅的事件类型的集合。

知道了这个变量的作用以后，subscribe2的逻辑理解起来就很简单了。

根据订阅者，从typesBySubscriber集合中取出已经订阅的事件类型集合subscribedEvents

如果subscribedEvents 为null，说明还没有订阅任何事件。创建一个空的事件类型集合，并存入typesBySubscriber中

将事件类型的class对象加入事件类型集合中

4.3

private void subscribe3(Object subscriber, SubscriberMethod subscriberMethod) {
if (subscriberMethod.sticky) {
            if (eventInheritance) {
                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);
            }
        }
}

subscribe3主要是针对sticky事件的前置处理。这里同样要先了解一下stickyEvents变量。它也是一个Map结构，键是事件类型的class对象，值是具体的粘性事件。

private final Map, Object> stickyEvents;

subscribe3执行逻辑梳理如下：

如果事件类型是可继承的（默认配置是可继承），则遍历事件本身和其超类，执行checkPostStickyEventToSubscription

如果是不可继承的，则直接执行checkPostStickyEventToSubscription

那么，checkPostStickyEventToSubscription做了什么操作呢？

    private void checkPostStickyEventToSubscription(Subscription newSubscription, Object stickyEvent) {
        if (stickyEvent != null) {
            postToSubscription(newSubscription, stickyEvent, isMainThread());
        }
    }


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);
        }
    }

可以看到，checkPostStickyEventToSubscription在内部调用了postToSubscription方法，该方法内部根据不同的threadMode，执行了不同的操作

如果线程模式是POSTING，则直接通过反射invoke调用执行订阅方法

如果线程模式是MAIN，且当前订阅方法就处于主线程，则执行同1操作，否则通过mainThreadPoster（HandlerPoster类型）切换到主线程来执行订阅方法

如果线程模式是MAIN_ORDERED，执行与2相反的操作

如果线程模式是BACKGROUND，且订阅方法定义在主线程，则通过backgroundPoster异步执行订阅方法，否则通过invoke直接执行订阅方法

如果线程模式是ASYNC，则通过asyncPoster异步执行订阅方法

从以上分析可知，当遇到粘性事件时，订阅者一旦向EventBus注册，EventBus就会马上直接或间接地处理粘性事件所在的订阅方法。具体的处理则是交由mainThreadPoster、backgroundPoster、asyncPoster等几个Poster实现，这些Poster我们将在后续章节去详细分析，这里暂且略过。

4.4 小结

综上，subscribe方法主要执行了如下几个操作：

根据事件类型，按照priority优先级将订阅信息newSubscription存入订阅信息集合subscriptions中

根据订阅者类的class对象，存储订阅者订阅的事件类型

执行粘性事件对应的订阅方法

五、结束语

本章分析了EventBus的订阅者注册流程，通过流程分析，我们可以知道，当同一个订阅类中，有同方法名且事件类型相同的订阅方法时，EventBus会抛出以下异常：

"Subscriber " + subscriber.getClass() + " already registered to event " + eventType

对于粘性事件，EventBus在完成订阅者的注册的最后，会直接或间接地执行其对应的订阅方法。这也就是为什么粘性事件会得以执行的原因。