EventBus源码分析（四）： 发送Event和响应注册的回调方法

前言

今天是EventBus的最后一篇了，之前我们已经理解了EventBus的编译过程，以及如何注册和解绑Event，发送Event其实是在注册成功的基础上遍历的你需要的类和方法，相对于之前的几篇，今天的内容会相对轻松很多。

正文

发送Event有两种，一种是普通的Event，一种是StickyEvent。我们先看普通的Event，打开post方法：

/**
*  发送Event
* */
public void post(Object event) {
// 通过工厂类，获取一个执行状态类
// 每一个线程对应一个
PostingThreadState postingState = currentPostingThreadState.get();
// 把Event加入到队列中
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");
}
// 开始循环发送Event
try {
while (!eventQueue.isEmpty()) {
// 别忘了ArrayList的remove会返回remove的对象
// 执行队列中第一个Event
postSingleEvent(eventQueue.remove(0), postingState);
}
} finally {
// 执行结束之后，要重置状态类的属性
postingState.isPosting = false;
postingState.isMainThread = false;
}
}
}

先从ThreadLocal中得到当前执行线程中对应的执行状态对象，ThreadLocal可以为不同线程创建不同的对象，并且这个对象是可以复用的，防止了创建短生命周期的对象，减轻了内存的压力。

之后把回调的Event类型放入到这个对象中，设置了一些属性，例如是否是主线程，是否在执行中等等。最关键的部分就是这个while循环，所以我们接下来要看的是postSingleEvent(eventQueue.remove(0), postingState)这个方法：

/**
* 执行单个Event
* */
private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
// 得到Event的Class
Class<?> eventClass = event.getClass();
boolean subscriptionFound = false;
// 如果Event是支持继承的
if (eventInheritance) {
// 找到使用Event的父类
List<Class<?>> eventTypes = lookupAllEventTypes(eventClass);
int countTypes = eventTypes.size();
for (int h = 0; h < countTypes; h++) {
Class<?> clazz = eventTypes.get(h);
// 开始发送Event给当前的Class
// 每一次都要跟下一次的结果进行 或操作，也就是只要有一个Class的Event没找到，都会返回false
subscriptionFound |= postSingleEventForEventType(event, postingState, clazz);
}
} else {
// 开始发送Event给当前的Class
subscriptionFound = postSingleEventForEventType(event, postingState, eventClass);
}
//如果并没有找到这个Event绑定的信息
if (!subscriptionFound) {
// 是否打印log
if (logNoSubscriberMessages) {
Log.d(TAG, "No subscribers registered for event " + eventClass);
}
// 是否发送Event
if (sendNoSubscriberEvent && eventClass != NoSubscriberEvent.class &&
eventClass != SubscriberExceptionEvent.class) {
post(new NoSubscriberEvent(this, event));
}
}
}

这个方法中，先判断是否支持Event继承，如果是支持的，要把这个当前Event的父类也要回调，例如MyEvent继承了SuperEvent，发送的MyEvent的同时也要发送SuperEvent，如果不支持的话只要回调当前这个类型就可以了。

看来这里还没有回调绑定的方法，所以要查看postSingleEventForEventType(event, postingState, clazz)中的代码：

/**
*  根据Event的类型发送给对一个的Class
* */
private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class<?> eventClass) {
CopyOnWriteArrayList<Subscription> subscriptions;
synchronized (this) {
// 得到和Event对应的类和方法
subscriptions = subscriptionsByEventType.get(eventClass);
}
// 判空
if (subscriptions != null && !subscriptions.isEmpty()) {
// 对列表循环
for (Subscription subscription : subscriptions) {
// 设置要执行的信息
postingState.event = event;
postingState.subscription = subscription;
boolean aborted = false;
try {
// 执行Class中被注解的方法
postToSubscription(subscription, event, postingState.isMainThread);
// 如果post被取消了，停止循环
aborted = postingState.canceled;
} finally {
// 重置执行的信息
postingState.event = null;
postingState.subscription = null;
postingState.canceled = false;
}
if (aborted) {
break;
}
}
return true;
}
return false;
}

大家也应该看出来了，这个方法主要是对PostingThreadState在回调绑定方法的前后状态进行设置，核心方法是在postToSubscription(subscription, event, postingState.isMainThread)中：

/**
* 根据不同的ThreadMode，回调被绑定的方法
* */
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 {
// 通过Handler机制，在主线程中调用被注解的方法
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);
}
}

这里我们终于看到了之前在Subscribe中设置的ThreadMode的作用，因为篇幅的问题，这里我简单的概括一下：

1、POSTING：表示的是直接在当前线程回调，和你发送Event时的线程是一样的，所以使用的时候要特别注意：别在子线程中更新UI。

2、MAIN：主线程中回调，如果当前不是主线程，就通过Handler机制在主线程调用，详细可以看HandlerPoster。

3、BACKGROUND：后台线程，也可以叫做非主线程。如果发送Event是在主线程，则会创建一个新的Runnable，在线程池中运行，如果发送Event在子线程，则会使用当前的线程。详细可以看BackgroundPoster。

4、ASYNC：异步线程，不管是在什么线程中发送Event，回调绑定的方法，都会新建Runnable，运行在线程池中。详细可以看AsyncPoster。

不管进行了什么样的判断，最终都会调用invokeSubscriber(subscription, event)方法：

/**
* 通过反射的方法，调用被注解的方法
* */
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);
}
}

最后是通过反射，调用了绑定的Class的被注解的方法，到此圆满结束。

postStickyEvent的事就不讲了吗？当然不会，因为你懂了普通Event，就自然明白了StickyEvent：

/**
* 发送StickyEvent
* */
public void postSticky(Object event) {
// 这个把Event进行了缓存
synchronized (stickyEvents) {
stickyEvents.put(event.getClass(), event);
}
// Should be posted after it is putted, in case the subscriber wants to remove immediately
//  和post的执行是完全一样的
post(event);
}

因为是StickyEvent的缓存是Map类型，所以先添加或者是覆盖相同Event的缓存，这样下次谁绑定StickyEvent就会得到最近的结果。之后调用了我们刚刚分析过的post(Event)。

总结

到此为止，我们的EventBus的源码解析就结束了，为什么好像看上去很简单的观察者模式，怎么感觉变得复杂了呢？跟我们之前的demo比，有什么优势呢？

我们最后来进行一个总结：

1、通过注解，可以更加灵活直观的设置Event回调的优先级，线程，是否是StickyEvent，否则我们需要在注册或者其他地方，增加属性和参数，并且和方法分离开来，维护起来会比较麻烦。

2、增加了不同线程的回调，让开发者更明确自己在回调将要做什么，例如使用了MAIN，那我能猜测，他肯定是要更新UI。

3、StickyEvent的使用丰富了使用场景，解决了某些情况下，页面是一篇空白的尴尬。

应该说注解的使用，是整个EventBus的亮点，是他让EventBus变得灵活，让我们更加简便的配置每一个需要绑定的方法。

好了，有关EventBus的内容就到此结束了，还有什么问题，欢迎大家留言一起讨论。

添加了注释的EventBus源码地址