EventBus源码阅读（20）-EventBus注册

我们注册的时候是从调用register开始的，我们也从这里读起来！

register函数源码：

    /**
     * Registers the given subscriber to receive events. Subscribers must call {@link #unregister(Object)} once they
     * are no longer interested in receiving events.
     * <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();//获取注册的上下文环境对应的类（activity/fragment）
        List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);//获取该类对应的订阅方法列表
        synchronized (this) {
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                subscribe(subscriber, subscriberMethod);//循环遍历注册（订阅者，订阅方法）
            }
        }
    }

参数就是我们调用的常用的context

我们的Activity的类就是 subscriberClass

subscriberMethodFinder在上一节初始化的时候初始的。

下边就是对每一个订阅方法进行注册了。

subscribe方法：

    // Must be called in synchronized block
    private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
        Class<?> eventType = subscriberMethod.eventType;
        Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
        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;
            }
        }
<span style="white-space:pre">	</span>//从上边可以看出，一个事件可以被多次订阅，可以在不同的Activity中订阅

</pre><pre name="code" class="java"><span style="white-space:pre">	</span>//将订阅事件注册到依据订阅者进行存储的泪表中

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

从代码中看，我们主要注册在三个地方

1、subscriptionsByEventType
注册的是（eventType，(subscriber, subscriberMethod)）

即：事件-> 注册（注册者（context），注册的方法（menthod））

把事件与对应的所有注册关联起来
2、typesBySubscriber

注册的是（subscriber, eventTypes）

即：注册者 ->  事件列表

就是把一个注册者与其注册的所有事件对应起来

3、stickyEvents

注册的是：事件类型 -> 事件

如果我们使用的是默认配置，则此处可以不看。

看看

checkPostStickyEventToSubscription

源码：

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

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

上边这个函数就是依据 处理模式以及当前线程是否为主线程（UI线程），进行不同的处理。

发送事件

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

而对于sticky事件，如果初次注册，则不会出发之后的发送事件情况，当如果再次注册stcky事件（就是同一个sticky事件已经触发了，但当时没有人处理，此时注册处理该事件的activity，就会出发发送事件了）此时则会触发发送事件的情况。

此时我们已经看过的函数如下（红色点标记）