本文深入剖析了EventBus的源码，包括EventBus的基本概念、工作原理、使用方法和源码解析。详细讲解了注册、事件分发和取消注册的流程，并探讨了EventBus的性能优化，如线程模型和添加索引的功能。通过对源码的分析，揭示了EventBus如何实现实时事件通信，以及如何在项目中高效地应用EventBus。
前言：在现在的android项目开发小伙伴们越来越多的在使用EventBus了作为事件的同步了，EventBus是针对Android优化的发布-订阅事件总线，简化了Android组件间的通信，以其简单易懂、优雅、开销小等优点而备受欢迎。所以在之前已经整理了EventBus与Otto使用和区别之后，我最近再次梳理了EventBus的源码原理。
友情提示：该篇文章主要是介绍梳理EventBus的源码原理，所以如果只是想要了解EventBus的使用方法，请查看网上其他的相关资料。
EventBus简介
EventBus属于观察者模式：观察者模式是设计模式中的一种。它是为了定义对象间的一种一对多的依赖关系，即当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
1.EventBus的三要素：
- Event：事件，可以是任意类型的对象。
- Subscriber：事件订阅者，在EventBus3.0之前，消息处理的方法只能限定于onEvent、onEventMainThread、onEventBackgroundThread和onEventAsync，他们分别代表四种线程模型。在EventBus3.0之后，事件处理的方法可以随便取名，但是需要添加一个注解@Subscribe，并且要指定线程模型（默认为POSTING），四种线程模型下面会讲到。
- Publisher：事件发布者，可以在任意线程任意位置发送事件，直接调用EventBus的post(Object)方法。可以自己实例化EventBus对象，但一般使用EventBus.getDefault()就好了，根据post函数参数的类型，会自动调用订阅相应类型事件的函数。
2. EventBus的四种ThreadMode（线程模型）：
- POSTING（默认）：如果使用事件处理函数指定了线程模型为POSTING，那么该事件在哪个线程发布出来的，事件处理函数就会在这个线程中运行，也就是说发布事件和接收事件在同一个线程。在线程模型为POSTING的事件处理函数中尽量避免执行耗时操作，因为它会阻塞事件的传递，甚至有可能会引起ANR。
-
MAIN:事件的处理会在UI线程中执行。事件处理时间不能太长，长了会ANR的。
-
BACKGROUND：如果事件是在UI线程中发布出来的，那么该事件处理函数就会在新的线程中运行，如果事件本来就是子线程中发布出来的，那么该事件处理函数直接在发布事件的线程中执行。在此事件处理函数中禁止进行UI更新操作。
-
ASYNC：无论事件在哪个线程发布，该事件处理函数都会在新建的子线程中执行，同样，此事件处理函数中禁止进行UI更新操作。
EventBus使用
- 自定义一个事件类：
public class MessageEvent { } - 在需要订阅事件的地方注册事件：
EventBus.getDefault().register(this); - 发送事件：
EventBus.getDefault().post(messageEvent); - 处理事件：需要添加一个注解@Subscribe，并且要指定线程模型，如果没有添加，那就是默认为POSTING。
@Subscribe(threadMode = ThreadMode.MAIN) public void Hhhh(MessageEvent messageEvent) { ... } - 取消事件订阅：
EventBus.getDefault().unregister(this);
EventBus源码解析
1、注册源码解析
在创建EventBus实例的时候，一种方式是按照我们上面的形式，通过EventBus的静态方法getDefault来获取一个实例。getDefault本身会调用其内部的构造方法，通过传入一个默认的EventBusBuilder来创建EventBus。此外，我们还可以直接通过EventBus的builder()方法获取一个EventBusBuilder的实例，然后通过该构建者模式来个性化地定制自己的EventBus。
EventBus.getDefault()获取对象，下面看该方法的源码：
// 静态的单例实例
static volatile EventBus defaultInstance;
// 默认的构建者
private static final EventBusBuilder DEFAULT_BUILDER = new EventBusBuilder();
public EventBus() {
this(DEFAULT_BUILDER);
}
// 调用getDefault的时候，最终会调用该方法，使用DEFAULT_BUILDER创建一个实例
EventBus(EventBusBuilder builder) {
// ...
}
// 也可以使用下面的方法获取一个构建者，然后使用它来个性化定制EventBus
public static EventBusBuilder builder() {
return new EventBusBuilder();
}
/** Convenience singleton for apps using a process-wide EventBus instance. */
public static EventBus getDefault() {
if (defaultInstance == null) {
synchronized (EventBus.class) {
if (defaultInstance == null) {
defaultInstance = new EventBus();
}
}
}
return defaultInstance;
}
分析：使用单例模式， 使用了双重判断的方式，防止并发的问题，还能极大的提高效率。
register(this)注册源码解析，看下面源码：
public void register(Object subscriber) {
//首先获取订阅者的类对象
Class<?> subscriberClass = subscriber.getClass();
//用 subscriberMethodFinder 提供的方法，找到在 subscriber 这个类里面订阅的内容。
List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
synchronized (this) {
for (SubscriberMethod subscriberMethod : subscriberMethods) {
subscribe(subscriber, subscriberMethod);
}
}
}
这里的SubscriberMethod封装了订阅方法（使用@Subscribe注解的方法）类型的信息，它的定义如下所示。从下面可以的代码中我们可以看出，实际上该类就是通过几个字段来存储@Subscribe注解中指定的类型信息，以及一个方法的类型变量。
public class SubscriberMethod {
final Method method;
final ThreadMode threadMode;
final Class<?> eventType;
final int priority;
final boolean sticky;
// ...
}
接下来看findSubscriberMethods(subscriberClass)里面的源码：
List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
//首先从缓存中读取
List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass);
if (subscriberMethods != null) {
return subscriberMethods;
}
//是否忽略注解器生成的MyEventBusIndex类
if (ignoreGeneratedIndex) {
//利用反射来获取订阅类中的订阅方法信息
subscriberMethods = findUsingReflection(subscriberClass);
} else {
//从注解器生成的MyEventBusIndex类中获得订阅类的订阅方法信息
subscriberMethods = findUsingInfo(subscriberClass);
}
//在获得subscriberMethods以后，如果订阅者中不存在@Subscribe注解并且为public的订阅方法，则会抛出异常。
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;
}
}
//METHOD_CACHE，是一个map集合，键是class类型
Map<Class<?>, List<SubscriberMethod>> METHOD_CACHE = new ConcurrentHashMap<>();
上面源码分析：首先从缓存中查找，如果找到了就立马返回。如果缓存中没有的话，则根据 ignoreGeneratedIndex 选择如何查找订阅方法，ignoreGeneratedIndex属性表示是否忽略注解器生成的MyEventBusIndex。最后，找到订阅方法后，放入缓存，以免下次继续查找。ignoreGeneratedIndex 默认就是false，可以通过EventBusBuilder来设置它的值。我们在项目中经常通过EventBus单例模式来获取默认的EventBus对象，也就是ignoreGeneratedIndex为false的情况，这种情况调用了findUsingInfo方法。
接下来看findUsingInfo(subscriberClass)源码：
private List<SubscriberMethod> findUsingInfo(Class<?> subscriberClass) {
FindState findState = prepareFindState();
findState.initForSubscriber(subscriberClass);
while (findState.clazz != null) {
//获取订阅者信息，没有配置MyEventBusIndex返回null
findState.subscriberInfo = getSubscriberInfo(findState);
if (findState.subscriberInfo != null) {
SubscriberMethod[] array = findState.subscriberInfo.getSubscriberMethods();
for (SubscriberMethod subscriberMethod : array) {
if (findState.checkAdd(subscriberMethod.method, subscriberMethod.eventType)) {
findState.subscriberMethods.add(subscriberMethod);
}
}
} else {
//通过反射来查找订阅方法
findUsingReflectionInSingleClass(findState);
}
findState.moveToSuperclass();
}
return getMethodsAndRelease(findState);
}
SubscriberMethodFinder#prepareFindState()代码：
private static final FindState[] FIND_STATE_POOL = new FindState[POOL_SIZE];
private FindState prepareFindState() {
synchronized(FIND_STATE_POOL) {
for (int i = 0; i < POOL_SIZE; i++) {
FindState state = FIND_STATE_POOL[i];
if (state != null) {
FIND_STATE_POOL[i] = null;
return state;
}
}
}
return new FindState();
}
这个方法是创建一个新的FindState类，通过两种方法获取，一种是从FIND_STATE_POOL即FindState池中取出可用的FindState，如果没有的话，则通过第二种方式：直接new一个新的FindState对象。
FindState#initForSubscriber()代码：
static class FindState {
// 省略代码
void initForSubscriber(Class<?> subscriberClass) {
this.subscriberClass = clazz = subscriberClass;
skipSuperClasses = false;
subscriberInfo = null;
}
// 省略代码
}
FindState类是SubscriberMethodFinder的内部类，这个方法主要做一个初始化的工作。
SubscriberMethodFinder#getMethodsAndRelease代码：
private List<SubscriberMethod> getMethodsAndRelease(FindState findState) {
List<SubscriberMethod> subscriberMethods = new ArrayList<>(findState.subscriberMethods);
findState.recycle();
synchronized(FIND_STATE_POOL) {
for (int i = 0; i < POOL_SIZE; i++) {
if (FIND_STATE_POOL[i] == null) {
FIND_STATE_POOL[i] = findState;
break;
}
}
}
return subscriberMethods;
}
这里将subscriberMethods列表直接返回，同时会把findState做相应处理，存储在FindState池中，方便下一次使用，提高性能。
SubscriberMethodFinder#getSubscriberInfo()代码：
private SubscriberInfo getSubscriberInfo(FindState findState) {
if (findState.subscriberInfo != null && findState.subscriberInfo.getSuperSubscriberInfo() != null) {
SubscriberInfo superclassInfo = findState.subscriberInfo.getSuperSubscriberInfo();
if (findState.clazz == superclassInfo.getSubscriberClass()) {
return superclassInfo;
}
}
if (subscriberInfoIndexes != null) {
for (SubscriberInfoIndex index: subscriberInfoIndexes) {
SubscriberInfo info = index.getSubscriberInfo(findState.clazz);
if (info != null) {
return info;
}
}
}
return null;
}
这里由于初始化的时候，findState.subscriberInfo和subscriberInfoIndexes为空，所以这里直接返回null，后续我们可以再回到这里看看subscriberInfo有什么作用。
findUsingInfo方法源码分析：通过getSubscriberInfo方法来获取订阅者信息，在我们开始查找订阅方法的时候并没有忽略注解器为我们生成的索引MyEventBusIndex，如果我们通过EventBusBuilder配置了MyEventBusIndex，便会获取到subscriberInfo，调用subscriberInfo的getSubscriberMethods方法便可以得到订阅方法相关的信息，这个时候就不在需要通过注解进行获取订阅方法。如果没有配置MyEventBusIndex，便会执行findUsingReflectionInSingleClass方法，将订阅方法保存到findState中。最后再通过getMethodsAndRelease方法对findState做回收处理并反回订阅方法的List集合。
下面是使用反射findUsingReflectionInSingleClass从订阅者中得到订阅方法的代码：
private void findUsingReflectionInSingleClass(FindState findState) {
Method[] methods;
try {
// 获取该类中声明的所有方法
methods = findState.clazz.getDeclaredMethods();
} catch (Throwable th) {
methods = findState.clazz.getMethods();
findState.skipSuperClasses = true;
}
// 对方法进行遍历判断
for (Method method : methods) {
int modifiers = method.getModifiers();
// 这里会对方法的修饰符进行校验
if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {
// 这里对方法的输入参数进行校验
Class<?>[] parameterTypes = method.getParameterTypes();
if (parameterTypes.length == 1) {
// 获取方法的注解，用来从注解中获取注解的声明信息
Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);
if (subscribeAnnotation != null) {
// 获取该方法的第一个参数
Class<?> eventType = parameterTypes[0];
if (findState.checkAdd(method, eventType)) {
ThreadMode threadMode = subscribeAnnotation.threadMode();
// 最终将封装之后的方法塞入到列表中
findState.subscriberMethods.add(new SubscriberMethod(method, eventType, threadMode,
subscribeAnnotation.priority(), subscribeAnnotation.sticky()));
}
}
} else if (strictMethodVerification && method.isAnnotationPresent(Subscribe.class)) {
String methodName = method.getDeclaringClass().getName() + "." + method.getName();
throw new EventBusException(...);
}
} else if (strictMethodVerification && method.isAnnotationPresent(Subscribe.class)) {
String methodName = method.getDeclaringClass().getName() + "." + method.getName();
throw new EventBusException(...);
}
}
}
源码分析：该方法通过反射的方式获取订阅者类中的所有声明方法，然后在这些方法里面寻找以@Subscribe作为注解的方法进行处理，先经过一轮检查，看看findState.subscriberMethods是否存在，如果没有的话，将方法名，threadMode，优先级，是否为sticky方法封装为SubscriberMethod对象，添加到subscriberMethods列表中。
上面的所有的方法流程的调用结果其实就是从订阅类中获取所有的订阅方法信息，findSubscriberMethods找出一个SubscriberMethod的集合，也就是传进来的订阅者所有的订阅的方法，接下来遍历订阅者的订阅方法来完成订阅者的订阅操作。
下面接着看订阅者的订阅过程的代码：
private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
Class<?> eventType = subscriberMethod.eventType;
// 将所有的观察者和订阅方法封装成一个Subscription对象
Subscription newSubscription = new Subscription(subscriber, subscriberMethod); // 1
// 尝试从缓存中根据事件类型来获取所有的Subscription对象
CopyOnWriteArrayList<Subscription> subscriptions = subscriptionsByEventType.get(eventType); // 2
if (subscriptions == null) {
// 指定的事件类型没有对应的观察对象的时候
subscriptions = new CopyOnWriteArrayList<>();
subscriptionsByEventType.put(eventType, subscriptions);
} else {
if (subscriptions.contains(newSubscription)) {
throw new EventBusException(...);
}
}
// 这里会根据新加入的方法的优先级决定插入到队列中的位置
int size = subscriptions.size(); // 2
for (int i = 0; i <= size; i++) {
if (i == size || subscriberMethod.priority > subscriptions.get(i).subscriberMethod.priority) {
subscriptions.add(i, newSubscription);
break;
}
}
// 这里又会从“订阅者-事件类型”列表中尝试获取该订阅者对应的所有事件类型
List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber); // 3
if (subscribedEvents == null) {
subscribedEvents = new ArrayList<>();
typesBySubscriber.put(subscriber, subscribedEvents);
}
subscribedEvents.add(eventType);
// 如果是黏性事件还要进行如下的处理
if (subscriberMethod.sticky) { // 4
if (eventInheritance) {
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);
}
}
}
该订阅方法的代码主要就做了两件事，第一件事是将我们的订阅方法和订阅者封装到subscriptionsByEventType和typesBySubscriber中，subscriptionsByEventType是我们投递订阅事件的时候，就是根据我们的EventType找到我们的订阅事件，从而去分发事件，处理事件的；typesBySubscriber在调用unregister(this)的时候，根据订阅者找到EventType，又根据EventType找到订阅事件，从而对订阅者进行解绑。第二件事，如果是粘性事件的话，就立马投递、执行。
这里涉及到了几个集合，它们是用来做缓存的，还有就是来维护观察者、事件类型和订阅方法之间的关系的。
首先，会在代码1处将观察者和订阅方法封装成一个Subscription对象。
然后，在2处用到了CopyOnWriteArrayList这个集合，它是一种适用于多读写少场景的数据结构，是一种线程安全的数组型的数据结构，主要用来存储一个事件类型所对应的全部的Subscription对象。EventBus在这里通过一个Map<Class<?>, CopyOnWriteArrayList<Subscription>>类型的哈希表来维护这个映射关系。
再然后，我们的程序执行到2处，在这里会对Subscription对象的列表进行遍历，并根据订阅方法的优先级，为当前的Subscription对象寻找一个合适的位置。3的地方主要的逻辑是获取指定的观察者对应的全部的观察事件类型，这里也是通过一个哈希表来维护这种映射关系的。
最后，在代码4处，程序会根据当前的订阅方法是否是黏性的，来决定是否将当前缓存中的信息发送给新订阅的方法。这里会通过checkPostStickyEventToSubscription方法来发送信息，该方法内部最终调用的还是postToSubscription方法，请看下面的代码：
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, isMainThread());
}
}
在后面的发布流程中可以看到postToSubscription方法代码就是用来最后发布处理事件的，这个地方相当于是说如果是粘性事件在订阅的时候就会触发发布事件。
什么是sticky event？
sticky event，中文名为粘性事件。普通事件是先注册，然后发送事件才能收到；而粘性事件，在发送事件之后再订阅该事件也能收到。此外，粘性事件会保存在内存中，每次进入都会去内存中查找获取最新的粘性事件，除非你手动解除注册。
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);
}
可以看到首先执行的是往stickyEvents集合中添加数据，此时发送粘性事件先将事件存储到stickyEvents中，这种情况是订阅事件还没有声明订阅。所以在订阅粘性事件的时候就可以接收到之前的粘性事件了。
以上就是注册的全部流程， copy一张流程图总结一下：
2.EventBus事件分发解析
从post方法入手，首先从PostingThreadState对象中取出事件队列，然后再将当前的事件插入到事件队列当中。最后将队列中的事件依次交由postSingleEvent方法进行处理，并移除该事件。
/** Posts the given event to the event bus. */
public void post(Object event) {
//获取当前线程的postingState
PostingThreadState postingState = currentPostingThreadState.get();
//取得当前线程的事件队列
List<Object> eventQueue = postingState.eventQueue;
//将该事件添加到当前的事件队列中等待分发
eventQueue.add(event);
if (!postingState.isPosting) {
//判断是否是在主线程post
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;
}
}
}
什么是PostingThreadState？
PostingThreadState中包含了当前线程的事件队列，就是当前线程所有分发的事件都保存在eventQueue事件队列中以及订阅者订阅事件等信息，有了这些信息我们就可以从事件队列中取出事件分发给对应的订阅者。
看下面类代码信息：
final static class PostingThreadState {
final List<Object> eventQueue = new ArrayList<Object>();//当前线程的事件队列
boolean isPosting;//是否有事件正在分发
boolean isMainThread;//post的线程是否是主线程
Subscription subscription;//订阅者
Object event;//订阅事件
boolean canceled;//是否取消
}
PostingThreadState怎么获得？
private final ThreadLocal<PostingThreadState> currentPostingThreadState = new ThreadLocal<PostingThreadState>() {
@Override
protected PostingThreadState initialValue() {
return new PostingThreadState();
}
};
ThreadLocal 是一个线程内部的数据存储类，通过它可以在指定的线程中存储数据，而这段数据是不会与其他线程共享的。可以看出currentPostingThreadState的实现是一个包含了PostingThreadState的ThreadLocal对象,这样可以保证取到的都是自己线程对应的数据。我们有了PostingThreadState获取到了当前线程的事件队列，接下来就是事件分发。
接下来看看postSingleEvent(eventQueue.remove(0), postingState)方法里做了什么：
事件分发
private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
//得到事件类型
Class<?> eventClass = event.getClass();
boolean subscriptionFound = false;
//是否触发订阅了该事件(eventClass)的父类,以及接口的类的响应方法.
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) {
Log.d(TAG, "No subscribers registered for event " + eventClass);
}
if (sendNoSubscriberEvent && eventClass != NoSubscriberEvent.class &&
eventClass != SubscriberExceptionEvent.class) {
post(new NoSubscriberEvent(this, event));
}
}
}
eventInheritance表示是否向上查找事件的父类,它的默认值为true，可以通过在EventBusBuilder中来进行配置。当eventInheritance为true时，则通过lookupAllEventTypes找到所有的父类事件并存在List中，然后通过postSingleEventForEventType方法对事件逐一处理。
接下来看看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;
}
同步取出该事件对应的Subscription集合并遍历该集合将事件event和对应Subscription传递给postingState并调用postToSubscription方法对事件进行处理。
接下来看看postToSubscription方法：
private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {
switch (subscription.subscriberMethod.threadMode) {
case POSTING://默认的 ThreadMode，表示在执行 Post 操作的线程直接调用订阅者的事件响应方法，
//不论该线程是否为主线程（UI 线程）。
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);
}
}
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);
}
}
在上面的方法中，会根据当前的线程状态和订阅方法指定的threadMode信息来决定合适触发方法。这里的invokeSubscriber会在当前线程中立即调用反射来触发指定的观察者的订阅方法。否则会根据具体的情况将事件加入到不同的队列中进行处理。这里的mainThreadPoster最终继承自Handler，当调用它的enqueue方法的时候，它会发送一个事件并在它自身的handleMessage方法中从队列中取值并进行处理，从而达到在主线程中分发事件的目的。这里的backgroundPoster实现了Runnable接口，它会在调用enqueue方法的时候，拿到EventBus的ExecutorService实例，并使用它来执行自己。在它的run方法中会从队列中不断取值来进行执行。
总结一下整个事件分发的过程：
-
首先获取当前线程的PostingThreadState对象从而获取到当前线程的事件队列；
-
通过事件类型获取到所有订阅者集合；
-
通过反射执行订阅者中的订阅方法；
至此post 就算分析完了，copy上一张流程图：
3.EventBus取消注册解析
从unregister(this)方法入手：
/** 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 {
Log.w(TAG, "Subscriber to unregister was not registered before: " + subscriber.getClass());
}
}
上述代码很简单，也就是通过subscriber为key获取该订阅类下的所有订阅方法集合，然后遍历该集合，执行unsubscribeByEventType方法，之后删除typesBySubscriber中的subscriber相关信息。
那么unsubscribeByEventType方法内做了什么操作呢？接着看unsubscribeByEventType(subscriber, eventType)：
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--;
}
}
}
}
上述代码整体维护的就是subscriptionsByEventType集合的正确性，操作的维度是以要删除的订阅类中的订阅方法中的参数为中心的。
解绑流程就是维护了typesBySubscriber和subscriptionsByEventType两个集合的数据。
总结一下取消注册的过程：
-
首先获取订阅者的所有订阅事件；
-
遍历订阅事件；
-
根据订阅事件获取所有的订阅了该事件的订阅者集合；
-
将该订阅者移除；
-
将步骤1中的集合中的订阅者移除；
解绑流程分析完了，copy上一张流程图：
4.总结EventBus的工作原理
-
订阅逻辑：
-
1、首先用register（）方法注册一个订阅者；
-
2、获取该订阅者的所有订阅的方法；
-
3、根据该订阅者的所有订阅的事件类型，将订阅者存入到每个以 事件类型为key 以所有订阅者为values的map集合中；
-
4、然后将订阅事件添加到以订阅者为key 以订阅者所有订阅事件为values的map集合中；
-
5、如果是订阅了粘滞事件的订阅者，从粘滞事件缓存区获取之前发送过的粘滞事件，响应这些粘滞事件；
-
-
事件发送逻辑：
-
1、首先获取当前线程的事件队列；
-
2、将要发送的事件添加到事件队列中；
-
3、根据发送事件类型获取所有的订阅者；
-
4、根据响应方法的执行模式，在相应线程通过反射执行订阅者的订阅方法；
-
-
取消逻辑：
-
1、首先通过unregister方法拿到要取消的订阅者；
-
2、得到该订阅者的所有订阅事件类型；
-
3、遍历事件类型，根据每个事件类型获取到所有的订阅者集合，并从集合中删除该订阅者；
-
4、将订阅者从步骤2的集合中移除；
-
-
利与弊：
-
EventBus好处比较明显，它能够解耦和，将业务和视图分离，代码实现比较容易。而且3.0后，我们可以通过apt预编译找到订阅者，避免了运行期间的反射处理解析，大大提高了效率。当然EventBus也会带来一些隐患和弊端，如果滥用的话会导致逻辑的分散并造成维护起来的困难。另外大量采用EventBus代码的可读性也会变差。
-
附加索引的添加
关于EventBus的添加，该功能是在EventBus3.0之后添加的新功能，据说能大幅提升性能？为什么能提升性能呢？
添加索引的方法是：
EventBus eventBus = EventBus.builder().addIndex(new MyEventBusIndex()).build();
此处的MyEventBusIndex是我们定义的自定义名称，我们先看下addIndex的方法：
/** Adds an index generated by EventBus' annotation preprocessor. */
public EventBusBuilder addIndex(SubscriberInfoIndex index) {
if (subscriberInfoIndexes == null) {
subscriberInfoIndexes = new ArrayList<>();
}
subscriberInfoIndexes.add(index);
return this;
}
将index对象添加到了subscriberInfoIndexes集合中，那么SubscriberInfoIndex是什么呢?
/**
* Interface for generated indexes.
*/
public interface SubscriberInfoIndex {
SubscriberInfo getSubscriberInfo(Class<?> subscriberClass);
}
可以看到是个接口，那么实现类在哪里呢？就是我们定义的MyEventBusIndex类：
/** This class is generated by EventBus, do not edit. */
public class MyEventBusIndex implements SubscriberInfoIndex {
private static final Map<Class<?>, SubscriberInfo> SUBSCRIBER_INDEX;
static {
SUBSCRIBER_INDEX = new HashMap<Class<?>, SubscriberInfo>();
//每个订阅类
putIndex(new SimpleSubscriberInfo(TestActivity.class, true, new SubscriberMethodInfo[] {
//每个订阅方法的相关信息
new SubscriberMethodInfo("onEventObject", EventObject.class, ThreadMode.MAIN, 0, true),
new SubscriberMethodInfo("onEventObject", SecondEvent.class, ThreadMode.MAIN, 0, true),
new SubscriberMethodInfo("onEventObject", TestInterfaceEvent.class, ThreadMode.MAIN, 0, true),
new SubscriberMethodInfo("onEventObject", ThirdEvent.class, ThreadMode.MAIN, 0, true),
}));
}
private static void putIndex(SubscriberInfo info) {
SUBSCRIBER_INDEX.put(info.getSubscriberClass(), info);
}
//实现接口的方法
@Override
public SubscriberInfo getSubscriberInfo(Class<?> subscriberClass) {
//返回订阅类的相关信息（全部订阅方法的相关信息）
SubscriberInfo info = SUBSCRIBER_INDEX.get(subscriberClass);
if (info != null) {
return info;
} else {
return null;
}
}
}
这个类是编译自动生成，不是手动添加的。那么在编译的时候，获取了订阅类的相关信息，在注册的时候是怎么用的呢？在上文注册源码分析的时候提到了这句代码：
List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
List<SubscriberMethod> 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;
}
}
ignoreGeneratedIndexb标记代表是否添加索引，默认是false，也就是没有添加索引，那么findUsingInfo方法是干什么的呢？
private List<SubscriberMethod> findUsingInfo(Class<?> subscriberClass) {
FindState findState = prepareFindState();
findState.initForSubscriber(subscriberClass);
while (findState.clazz != null) {
//获取存储的相关索引信息
findState.subscriberInfo = getSubscriberInfo(findState);
if (findState.subscriberInfo != null) { //索引信息不为null
SubscriberMethod[] array = findState.subscriberInfo.getSubscriberMethods();
for (SubscriberMethod subscriberMethod : array) {
if (findState.checkAdd(subscriberMethod.method, subscriberMethod.eventType)) {
findState.subscriberMethods.add(subscriberMethod);
}
}
} else { //索引存储为null,该方法内部就是通过反射获取订阅类的相关订阅信息
findUsingReflectionInSingleClass(findState);
}
findState.moveToSuperclass();
}
return getMethodsAndRelease(findState);
}
private SubscriberInfo getSubscriberInfo(FindState findState) {
if (findState.subscriberInfo != null && findState.subscriberInfo.getSuperSubscriberInfo() != null) {
SubscriberInfo superclassInfo = findState.subscriberInfo.getSuperSubscriberInfo();
if (findState.clazz == superclassInfo.getSubscriberClass()) {
return superclassInfo;
}
}
if (subscriberInfoIndexes != null) {
//遍历取出索引集合中的相关信息
for (SubscriberInfoIndex index : subscriberInfoIndexes) {
SubscriberInfo info = index.getSubscriberInfo(findState.clazz);
if (info != null) {
return info;
}
}
}
return null;
}
我们可以知道，其实消耗时间的重头部分就是在注册的时候，因为注册的时候（没添加索引），需要通过Java的反射获取注册类的订阅方法相关信息，这部分是非常耗时间的，它发生在运行过程。但是添加完了索引之后，会在编译的时候生成一个类，该类包含了注册类的相关信息，发生在编译过程。
通过上述代码分析，原理可以总结两点：
1：源码架构：实际上维护的就是两个Map集合，分别是：以订阅方法的参数class为key, 然后存储相关订阅信息，value也就是整个应用以该Class类为参数的订阅类信息；另一个是以订阅类为key， 此时value为该订阅类的所有方法。
2：提高性能：第一点是关闭父类以及接口查找分发事件；第二点 添加索引，索引添加的原理就是提前在编译的时候加载好注册类的相关信息。
最后说下关于EvenBus提高性能的相关设置，可以在Application中设置如下：
EventBus.builder().addIndex(new MyEventBusIndex()).eventInheritance(false).installDefaultEventBus();
好了，到此为止，文本结束，希望你是耐着性子看到了现在 see you
扫一扫
1018
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
