前言
最近阅读了EventBus（3.0.0）的源码，这里也是记录下自己对EventBus的理解，功力善浅，如有错误地方还望各位大佬及时指正。
1、EventBus的简单使用
1、注册与反注册
@Override
protected void onStart() {
super.onStart();
EventBus.getDefault().register(this);
}
@Override
protected void onStop() {
super.onStop();
EventBus.getDefault().unregister(this);
}
关联Activity或者Fragment的生命周期，在onStart方法中注册，在onStop方法中反注册，防止内存泄漏
2、定义事件实体类
public class MessageEvent {
public String message;
public MessageEvent(String message) {
this.message = message;
}
}
一个简单的事件实体类，将发送消息的内容存储于这个类的实例中
3、定义接收消息的方法
@Subscribe(threadMode = ThreadMode.MAIN)
public void onMessageEvent(MessageEvent event) {
Log.d(TAG,"收到了一条EventBus消息" + event.message);
}
这里有一个Subscribe注解，括号里的threadMode = ThreadMode.MAIN指定了方法执行的线程，3.0以后方法名onMessageEvent支持修改。收到了MessageEvent 的消息便会在主线程执行此方法。同时threadMode目前有四种线程模式：
- ThreadMode.POSTING：方法在post方法执行的线程中执行
- ThreadMode.MAIN：方法在主线程中执行
- ThreadMode.BACKGROUND：方法在后台线程中执行
- ThreadMode.ASYNC：方法在非post方法执行的后台线程中执行
4、发送消息
EventBus.getDefault().post(new MessageEvent("我是一条EventBus消息"));
发送消息后我们接收的消息方法便会执行。
2、EventBus实现流程
1、 EventBus的getDefault()
我们可以发现无论是我们注册和反注册还是发送消息，我们都是先调用了EventBus的getDefault方法。这里我们先看一下这个方法
static volatile EventBus defaultInstance;
/** 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;
}
很明显这里是获得一个EventBus类的单例。我们再来看一下EventBus的构造方法
private static final EventBusBuilder DEFAULT_BUILDER = new EventBusBuilder();
/**
* Creates a new EventBus instance; each instance is a separate scope in which events are delivered. To use a
* central bus, consider {@link #getDefault()}.
*/
public EventBus() {
this(DEFAULT_BUILDER);
}
EventBus(EventBusBuilder builder) {
//存放订阅事件对应的Subscription（封装订阅者对象对应的订阅事件封装容器类SubscriberMethod的容器类）对象集合
subscriptionsByEventType = new HashMap<>();
//存放订阅者对象对应订阅事件的集合
typesBySubscriber = new HashMap<>();
//粘性事件订阅事件对应的订阅者对象集合
stickyEvents = new ConcurrentHashMap<>();
//主线程的handler对象，主要是用来执行在订阅在主线程执行的事件
mainThreadPoster = new HandlerPoster(this, Looper.getMainLooper(), 10);
//后台线程的Runnable，主要是通过线程池成员变量executorService来执行订阅在后台线程执行的事件
backgroundPoster = new BackgroundPoster(this);
//异步线程的Runnable，主要是通过线程池成员变量executorService来执行订阅在非当前线程执行的事件
asyncPoster = new AsyncPoster(this);
indexCount = builder.subscriberInfoIndexes != null ? builder.subscriberInfoIndexes.size() : 0;
//用来查找订阅类对应的订阅方法的对象
subscriberMethodFinder = new SubscriberMethodFinder(builder.subscriberInfoIndexes,
builder.strictMethodVerification, builder.ignoreGeneratedIndex);
//打印订阅异常日志
logSubscriberExceptions = builder.logSubscriberExceptions;
//打印没有订阅者接收订阅事件的事件
logNoSubscriberMessages = builder.logNoSubscriberMessages;
//是否发送订阅异常事件
sendSubscriberExceptionEvent = builder.sendSubscriberExceptionEvent;
//是否发送没有事件没有订阅者的事件
sendNoSubscriberEvent = builder.sendNoSubscriberEvent;
//是否抛出订阅异常
throwSubscriberException = builder.throwSubscriberException;
//是否包括其父类事件
eventInheritance = builder.eventInheritance;
//线程池对象
executorService = builder.executorService;
}
可以看出无参构造函数调用了有参构造函数，参数是一个EventBusBuilder 实例。有参构造里面也是对EventBus的成员变量进行赋值，部分也是直接赋值于EventBusBuilder 的成员变量，其实看到Builder我们就很容易猜到这里也是采用了构建者模式，除了通过getDefault方法获得EventBus实例，我们也可以通过EventBusBuilder来设置成员变量来构建EventBus实例。这里就不细说了。
2、EventBus的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();
//通过subscriberMethodFinder找到订阅对象中的所有订阅事件方法
List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
synchronized (this) {
//遍历订阅对象中所有的订阅事件，将其缓存到EventBus的subscriptionsByEventType集合中
for (SubscriberMethod subscriberMethod : subscriberMethods) {
subscribe(subscriber, subscriberMethod);
}
}
}
这里先是拿到了注册对象的class对象，然后调用了SubscriberMethodFinder类的findSubscriberMethods方法
private static final Map<Class<?>, List<SubscriberMethod>> METHOD_CACHE = new ConcurrentHashMap<>();
List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
//先从METHOD_CACHE集合中查找订阅者对应的订阅事件集合
List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass);
if (subscriberMethods != null) {
return subscriberMethods;
}
//是否忽略注解器生成的MyEventBusIndex类，默认为false
if (ignoreGeneratedIndex) {
//通过反射查找订阅者类中对应的订阅事件集合
subscriberMethods = findUsingReflection(subscriberClass);
} else {
//通过注解器生成的MyEventBusIndex类查找订阅者类中对应的订阅事件集合
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集合中
METHOD_CACHE.put(subscriberClass, subscriberMethods);
return subscriberMethods;
}
}
METHOD_CACHE 是一个ConcurrentHashMap，我们之前在Retorfit中看到过这个，这是一个线程安全的map集合。SubscriberMethodFinder类的ignoreGeneratedIndex是一个布尔类型的，EventBus在创建SubscriberMethodFinder实例时给这个变量赋值是直接采用了EventBusBuilder的ignoreGeneratedIndex的值，默认情况下是false。接着会继续findUsingInfo方法，
private List<SubscriberMethod> findUsingInfo(Class<?> subscriberClass) {
FindState findState = prepareFindState();
findState.initForSubscriber(subscriberClass);
while (findState.clazz != null) {
//通过MyEventBusIndex类获取订阅者类中对应的订阅事件集合
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);
}
这里FindState实例相当于一个临时的存储器，findUsingReflectionInSingleClass方法来检查注册类里面是否带有 @Subscribe注解的方法，并检测其合法性（是否是共public方法，是否非静态，是否只有一个参数等等），然后用@Subscribe注解的方法名，方法参数，执行线程，优先级这些信息构建出一个SubscriberMethod类实例，存储在FindState实例中，最后通过getMethodsAndRelease方法或者存储在FindState实例中的SubscriberMethod的list，然后释放FindState实例的引用，但是不置空FindState实例，以便下次直接使用。最终findSubscriberMethods方法就是返回了注册类中合法的@Subscribe注解方法集合，找到了便将其缓存起来并返回，如果找不到，便会抛出异常。最后看下register方法中遍历了注册类中@Subscribe注解方法构成的的SubscriberMethod的list，调用了subscribe方法。
// Must be called in synchronized block
private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
//拿到订阅事件类型的Class对象
Class<?> eventType = subscriberMethod.eventType;
//Subscription是一个封装订阅对象和SubscriberMethod对象的封装类
Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
//在EventBus的subscriptionsByEventType集合中缓存订阅事件类型的Class对象对应的Subscription集合，检查订阅类是否已经注册过了
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);
}
}
//根据优先级顺序在对应的Subscription集合中来插入本次创建的Subscription实例
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;
}
}
//在EventBus的typesBySubscriber（Map集合）中缓存订阅类中对应的订阅事件集合
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);
}
}
}
总结一下这个方法主要将订阅类中的订阅事件缓存到EventBus的subscriptionsByEventType和typesBySubscriber中，以便后续发送事件使用
3、EventBus的post方法
/** Posts the given event to the event bus. */
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方法主要是循环当前线程中保存的PostingThreadState实例中的事件队列，取出并通过postSingleEvent方法对事件进行进一步处理。
private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
Class<?> eventClass = event.getClass();
boolean subscriptionFound = false;
//是否对事件的父类也进行发送，EventBusBuilder中默认为true
if (eventInheritance) {
//寻找其继承关系，将其父类，以及父类的父类等也添加到eventTypesCache集合中，
// // 返回的eventTypes集合就包含了eventClass以及eventClass的父类,父类的父类，eventClass实现的接口以及接口实现的接口等
List<Class<?>> eventTypes = lookupAllEventTypes(eventClass);
int countTypes = eventTypes.size();
//遍历eventTypes中的事件，进行发送
for (int h = 0; h < countTypes; h++) {
Class<?> clazz = eventTypes.get(h);
subscriptionFound |= postSingleEventForEventType(event, postingState, clazz);
}
} else {
//直接对事件进行发送
subscriptionFound = postSingleEventForEventType(event, postingState, eventClass);
}
//如果没有事件订阅者则打印日志，并发送一个NoSubscriberEvent事件
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));
}
}
}
postSingleEvent方法主要是判断是否连事件的的父类事件也要一起发送，以及对发送事件没有订阅者的情况进行处理。这里调用了postSingleEventForEventType方法来进一步处理
private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class<?> eventClass) {
CopyOnWriteArrayList<Subscription> subscriptions;
synchronized (this) {
//从subscriptionsByEventType集合中获取Subscription对象集合
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 {
//还原当前线程PostingThreadState实例中的成员变量
postingState.event = null;
postingState.subscription = null;
postingState.canceled = false;
}
//如果取消发送则跳出循环返回false
if (aborted) {
break;
}
}
return true;
}
//没有订阅者返回false
return false;
}
postSingleEventForEventType方法主要是通过EventBus中的subscriptionsByEventType集合找出事件对应的Subscription对象，然后通过postToSubscription方法对订阅者和事件进行处理。
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) {
//当前线程是主线程则最终通过EventBus中的executorService线程池执行事件
backgroundPoster.enqueue(subscription, event);
} else {
//当前线程是后台线程则直接执行事件
invokeSubscriber(subscription, event);
}
break;
case ASYNC://订阅事件在别的线程异步执行
//直接通过EventBus中的executorService线程池执行事件
asyncPoster.enqueue(subscription, event);
break;
default:
throw new IllegalStateException("Unknown thread mode: " + subscription.subscriberMethod.threadMode);
}
}
postToSubscription方法主要是根据定义事件接收时的执行的线程，用不同的线程通过反射来执行订阅者对应的接收事件方法。
至此，post方法的流程也分析完了。接下来我们再来看EventBus的unregister方法。
4、EventBus的unregister方法
/** 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) {
//根据订阅事件来找到其对应的subscriptionsByEventType中对应的Subscription对象集合
//从对应的订阅者集合中移除此订阅者对象
unsubscribeByEventType(subscriber, eventType);
}
//从typesBySubscriber集合中移除此订阅对象以及其对应的订阅事件
typesBySubscriber.remove(subscriber);
} else {
logger.log(Level.WARNING, "Subscriber to unregister was not registered before: " + subscriber.getClass());
}
}
unregister方法主要是将订阅者对象从EventBus缓存的订阅者对象以及订阅者对象订阅的方法的相关集合中移除。
至此，EvenBus整个事件的订阅，发送，执行，取消订阅我们就分析完了。大致的流程总结：
- 订阅（register方法）时寻找订阅对象中对应的订阅事件，构建出对应的SubscriberMethod对象。将订阅对象对应的订阅事件集合缓存到EventBus中的typesBySubscriber集合中。将其订阅事件对应的Subscription对象集合缓存到subscriptionsByEventType集合中。
- 发送（post方法）和执行，通过遍历eventTypesCache集合，找出发送事件对应的父类事件所有相关事件的集合，遍历subscriptionsByEventType集合找到订阅事件对应的Subscription对象，根据定义订阅事件所执行的线程和post方法执行的线程来进行分发事件，通过Subscription对象运用反射手段来执行订阅对象相应的订阅事件方法。
- 取消订阅（unregister方法）主要是将订阅时缓存到typesBySubscriber和subscriptionsByEventType中订阅对象以及订阅对象的订阅事件集合进行移除。不再持有订阅对象，避免内存泄漏。
