老司机狂飙之路--EventBus原理简要分析

一步一步分析：首先它是实现SubscriberInfoIndex接口 ，在addIndex方法中的参数，看看具体实现：

使用Map保存 SubscriberInfo，即所有订阅者的接受方法，然后 接口内定义的方法getSubscriberInfo，通过subscriberClass（key订阅者）去获得SubscriberInfo (value，也就是订阅方法集合)；通俗的讲呢 就是以订阅者为单位，将订阅者类所有的订阅函数及相关参数，封装到SimpleSubscriberInfo中去了，方便EventBus在注册过程中使用；声明下SimpleSubscriberInfo是在编译时候生成的，这样运行的时候可直接用，省去了运行中反射操作的资源和时间消耗，高效运行!

走到这，突然多出个问题，他的生成过程呢？其实根据build.gradle的配置可以看出点端倪；

首先明确的是MyEventBusIndex是通过第三方的那个android-apt或者Gradle本身提供的annotationProcessor，与EventBus提供的 EventBusAnnotationProcessor合体，协同生产出的玩意， EventBus控制着 EventBusAnnotationProcessor-详情看源码( package org.greenrobot.eventbus.annotationprocessor;)：

实战篇

步入正题;先来个整体的玩意

订阅者和事件的发布所在线程不固定，取决于ThreadMode，但是每个线程都有相关联的Queue。

首先从注册开始看

/** Posts the given event to the event bus. */
 
public void post(Object event) {
 
    //1.获取当前线程postingstate
    PostingThreadState postingState = currentPostingThreadState.get();
    //2.获取线程的事件队列
    List<Object> eventQueue = postingState.eventQueue;
    //3.等待分发
    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);
            }
        } finally {
            postingState.isPosting = false;
            postingState.isMainThread = false;
 
        }
    }
}

那啥是PostingThreadState，他包含了当前事件队列，以及订阅者订阅事件等信息，拿到这些就可以去实现分发啦；可我明明看见上面使用的postSingleEvent呀，这有什么联系？我们进去瞅瞅

private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
 
    Class<?> eventClass = event.getClass();
    boolean subscriptionFound = false;
 
    if (eventInheritance) {
 
        List<Class<?>> eventTypes = lookupAllEventTypes(eventClass);
 
        int countTypes = eventTypes.size();
 
        for (int h = 0; h < countTypes; h++) {
            Class<?> clazz = eventTypes.get(h);
            subscriptionFound |= postSingleEventForEventType(event, postingState, clazz);
        }
 
    } else {
 
        subscriptionFound = postSingleEventForEventType(event, postingState, eventClass);
    }
 
    if (!subscriptionFound) {
 
        if (logNoSubscriberMessages) {
 
            logger.log(Level.FINE, "No subscribers registered for event " + eventClass);
        }
 
        if (sendNoSubscriberEvent && eventClass != NoSubscriberEvent.class &&
                eventClass != SubscriberExceptionEvent.class) {
            post(new NoSubscriberEvent(this, event));
        }
    }
}

/** Unregisters the given subscriber from all event classes. */
 
public synchronized void unregister(Object subscriber) {
 
    List<Class<?>> subscribedTypes = typesBySubscriber.get(subscriber);
 
    if (subscribedTypes != null) {
        for (Class<?> eventType : subscribedTypes) {
 
            unsubscribeByEventType(subscriber, eventType);
        }
 
        typesBySubscriber.remove(subscriber);
    } else {
 
        logger.log(Level.WARNING, "Subscriber to unregister was not registered before: " + subscriber.getClass());
    }
}
 
/** Only updates subscriptionsByEventType, not typesBySubscriber! Caller must update typesBySubscriber. */
 
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--;
            }
        }
    }
}