EventBus3.0源码分析(二)post

距离上篇整整两个月了，忙不是借口，反省。

上一篇文章介绍了register的过程，这篇接着来，一起看看EventBus发送事件的过程。EventBus可以通过post发送普通事件，还可以通过postSticky发送粘性事件。粘性事件与普通事件的区别在于：当粘性事件发布后，若有订阅者订阅该事件，该订阅者依然能收到最近一个该事件， 这点在上篇最后有提到。有了这个最基本的认识，我们来看看这两个方法的具体实现。

先瞅瞅发送普通事件post方法的源码

public void post(Object event) {
    // 获取当前线程的PostingThreadState
    PostingThreadState postingState = currentPostingThreadState.get();
    // 事件队列
    List<Object> eventQueue = postingState.eventQueue;
    // 添加到事件队列中
    eventQueue.add(event);
    // 如果没有发送事件，则将事件队列中的事件一一发送出去
    if (!postingState.isPosting) {
        postingState.isMainThread = Looper.getMainLooper() == Looper.myLooper();
        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;
        }
    }
}

简单说一下post的流程：先获取当前调用post方法的PostingThreadState，并将该事件添加到事件队列中，如果当前没有发送事件， 则通过postSingleEvent方法将队列中的事件一一发送出去。

继续分析postSingleEvent方法

private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
    // 获取该事件的class
    Class<?> eventClass = event.getClass();
    boolean subscriptionFound = false;
  // 是否支持事件继承(默认是支持的)
    if (eventInheritance) {
        // 查找所有跟eventClass相关的类(包括eventClass实现的接口以及父类)
        // 若是第一次发送eventClass，通过api获取其父类及其实现接口的集合，并放入map中缓存，
       //  第二次直接从map中取
        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) {
        // 默认情况下， 如果没有订阅者订阅该事件, 则打印如下信息，并且发送NoSubscriberEvent事件
        if (logNoSubscriberMessages) {
            Log.d(TAG, "No subscribers registered for event " + eventClass);
        }
 
        if (sendNoSubscriberEvent && eventClass != NoSubscriberEvent.class &&
                eventClass != SubscriberExceptionEvent.class) {
            post(new NoSubscriberEvent(this, event));
        }
    }
}

继续简单的说下上述postSingleEvent过程： 先判断是否支持事件继承，（默认情况下支持）如果支持，则寻找此事件对应类所有的父类，以及实现的接口，并发送。如果不支持，则仅发送此事件。 换句话说，如果支持事件继承， 订阅者订阅该事件的父类，或者其实现的接口，都能接受到该事件。写了个小demo大家看看：child 继承parent，并且实现了interfaceA，interfaceB。

public class Child extends Parent implements interfaceA, interfaceB {
}

// 发送child事件,则订阅了其父类或者其实现接口的订阅者，都能接受child事件
@Subscribe(threadMode = ThreadMode.MAIN)
 public void onInterfaceAEvent(interfaceA a) {
    Log.i(TAG, "onInterfaceAEvent: " + a.toString());
 }
@Subscribe(threadMode = ThreadMode.MAIN)
public void onInterfaceBEvent(interfaceB b) {
    Log.i(TAG, "onInterfaceBEvent: " + b.toString());
}
@Subscribe(threadMode = ThreadMode.MAIN)
public void onParrentEvent(Parent p) {
    Log.i(TAG, "onParrentEvent: " + p.toString());
}

@Subscribe(threadMode = ThreadMode.MAIN)
public void onChildEvent(Child c) {
    Log.i(TAG, "onChildEvent: " + c.toString());
}

postSingleEvent中真正发送事件的方法是postSingleEventForEventType，我们继续查看该方法干了什么勾当：

private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class<?> eventClass) {
    CopyOnWriteArrayList<Subscription> subscriptions;
    synchronized (this) {
        subscriptions = subscriptionsByEventType.get(eventClass);
    }
    if (subscriptions != null && !subscriptions.isEmpty()) {
        for (Subscription subscription : subscriptions) {
            postingState.event = event;
            postingState.subscription = subscription;
            boolean aborted = false;
            try {
                postToSubscription(subscription, event, postingState.isMainThread);
                aborted = postingState.canceled;
            } finally {
                postingState.event = null;
                postingState.subscription = null;
                postingState.canceled = false;
            }
            if (aborted) {
                break;
            }
        }
        return true;
    }
    return false;
}

上述方法主要取得订阅了eventClass的订阅者集合，并且通过postToSubscription在指定的线程回调订阅方法:

private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {
  // 订阅者的订阅方法需要在哪个线程调用
    switch (subscription.subscriberMethod.threadMode) {
        // 在调用post的线程,则直接调用订阅方法
        case POSTING:
            invokeSubscriber(subscription, event);
            break;
        case MAIN:
            // 需要在主线程回调，并且调用post的线程也是主线程，则直接调用订阅方法
            if (isMainThread) {
                invokeSubscriber(subscription, event);
            } else {
                 // 需要在主线程回调，调用post的线程不是主线程，则通过mainThreadPoster切换到主线程
                mainThreadPoster.enqueue(subscription, event);
            }
            break;
        case BACKGROUND:
             // 需要在非主线程回调，调用post的线程也是主线程，则通过backgroundPoster切换到子线程
            if (isMainThread) {
                backgroundPoster.enqueue(subscription, event);
            } else {
                 // 需要在非主线程回调，并且调用post的线程也是非主线程，则直接调用订阅方法
                invokeSubscriber(subscription, event);
            }
            break;
        case ASYNC:
            // 不论调用post的线程是否为主线程，都使用一个空闲线程来处理
            asyncPoster.enqueue(subscription, event);
            break;
        default:
            throw new IllegalStateException("Unknown thread mode: " + subscription.subscriberMethod.threadMode);
    }
}

至此，整个post过程也就结束了。

至于postSticky只是比post多了一个步奏，在发布事件之前，先将该事件放入粘性事件集合stickyEvents（事件类型作为key，具体事件作为value）中，当有订阅者订阅该事件并且注明接受粘性事件看，则能接收到最近的一个该事件。

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

最后借用网络上的一幅图来总结整个post流程:

post流程