EventBus 是一款在 Android 开发中使用的发布/订阅事件总线框架，基于观察者模式，将事件的接收者和发送者分离，避免复杂且容易出错的依赖关系和生命周期问题，简化了组件之间的通信，使用简单、效率高、体积小！下边是官方的 EventBus 原理图：
EventBus 原理图
一、使用EventBus
EventBus支持订阅者方法在不同于发布事件所在线程的线程中被调用。你可以使用线程模式来指定调用订阅者方法的线程。这就需要了解EventBus支持的五种线程模式（ThreadMode）：POSTING、MAIN、MAIN_ORDERED、BACKGROUND、ASYNC。
1.线程模式
- POSTING
POSTING是默认线程模式，在哪个线程发送事件就在对应线程处理事件，避免了线程切换，效率高。因此，对于不要求是主线程并且耗时很短的简单任务推荐使用该模式。在线程模型为POSTING的事件处理函数中尽量避免执行耗时操作，因为它会阻塞事件的传递，甚至有可能会引起ANR。 - MAIN
订阅者方法将在主线程（UI线程）中被调用。因此，可以在该模式的订阅者方法中直接更新UI界面。事件处理的时间不能太长，长了会导致ANR。 - MAIN_ORDERED
订阅者在主线程中调用。该事件总是排队等待以后交付给订阅者，因此对post的调用将立即返回。这为事件处理提供了更严格且更一致的顺序，例如，在具有MAIN线程模式的事件处理程序中发布另一个事件，则第二个事件处理程序将在第一个事件处理程序之前完成，事件处理的时间不能太长，长了会导致ANR。 - BACKGROUND
订阅者将在后台线程中调用。如果发布线程不是主线程，则将在发布线程中直接调用事件处理程序方法。如果发布线程是主线程，则EventBus使用单个后台线程，该线程将按顺序传递其所有事件。在此事件处理函数中禁止进行UI更新操作。 - ASYNC
无论事件在哪个线程中发布，该事件处理函数都会在新建的子线程中执行；同样，此事件处理函数中禁止进行UI更新操作。
2.基本使用
EventBus的使用分4步
（1）定义事件
public static class MessageEvent {... }
（2）准备订阅者（指定模式）
@Subscribe(threadMode = ThreadMode.MAIN)
public void onMessageEvent(MessageEvent event) {...};
（3）注册/注销订阅者（注册和注销是成对出现的）
@Override
public void onStart() {
super.onStart();
EventBus.getDefault().register(this);
}
@Override
public void onStop() {
super.onStop();
EventBus.getDefault().unregister(this);
}
（4）发送事件
EventBus.getDefault().post(new MessageEvent());
3.使用示例
前面已经介绍了基本用法，下面看下使用示例：
首先配置gradle，如下所示：
implementation 'org.greenrobot:eventbus:3.1.1'
（1）定义消息事件类
public class MessageEvent {
private String message;
public MessageEvent(String message) {
this.message = message;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
}
（2）订阅者处理事件
@Subscribe(threadMode = ThreadMode.MAIN)
public void onShowEventMessage(MessageEvent messageEvent){
//将数据显示到页面上
tvMessage.setText(messageEvent.getMessage());
}
我们在MainActivity中创建一个订阅者处理事件onShowEventMessage方法，添加Subscribe注解，ThreadMode设置为MAIN，事件的处理会在UI线程中执行，用TextView来展示接收到的消息。
（3）注册和取消订阅事件
public class MainActivity extends AppCompatActivity {
private Button btnJump;
private Button btnReg;
private TextView tvMessage;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
btnJump = findViewById(R.id.btn_jump);
btnReg = findViewById(R.id.btn_reg);
tvMessage = findViewById(R.id.tv_message);
btnJump.setOnClickListener(v -> {
//跳转到SecondActivity
startActivity(new Intent(MainActivity.this,SecondActivity.class));
});
btnReg.setOnClickListener(v -> {
//注册事件
EventBus.getDefault().register(this);
});
}
@Override
protected void onDestroy() {
super.onDestroy();
//注销事件
EventBus.getDefault().unregister(this);
}
}
我们在MainAtivity中点击按钮注册事件，在onDestroy中注销事件。当我们注册事件后，跳转到SecondActivity中去发布事件。
（4）发布者发布事件
public class SecondActivity extends AppCompatActivity {
private Button btnSend;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_second);
btnSend = findViewById(R.id.btn_send);
btnSend.setOnClickListener(v -> {
//发送事件
EventBus.getDefault().post(new MessageEvent("我要学习EventBus"));
finish();
});
}
}
在SecondActivity中点击按钮发布事件后，返回到MainActivity中，可以看到页面上显示的就是我们发布的消息“我要学习EventBus”。在这里就不展示页面了。
EventBus的粘性事件
除了普通事件，EventBus还支持发送粘性事件，粘性事件就是在发送事件之后再订阅该事件也能收到该事件，这跟粘性广播类似。
（1）订阅者处理粘性事件
@Subscribe(threadMode = ThreadMode.POSTING, sticky = true)
public void onShowStickyEventMessage(MessageEvent messageEvent){
//显示粘性事件
tvMessage.setText(messageEvent.getMessage());
}
在MainActivity中新写一个方法用来处理粘性事件，可以看到和普通事件基本类似，在注解中多加了一个sticky = true属性。我们先不注册事件，直接跳转到MainActivity中，回来后在点击注册事件，看看效果。
（2）发送粘性事件
btnSend.setOnClickListener(v -> {
//发送事件
EventBus.getDefault().postSticky(new MessageEvent("我要学习EventBus的粘性事件"));
finish();
});
我们在SecondActivity中点击按钮发送粘性事件，我们可以看到普通事件是post()方法，而粘性事件是postSticky()方法，这点需要注意。再者，我们发送后，回到MainActivity中点击注册事件，我们就可以看到发送的事件了。
三、源码解析EventBus
下面我们看下EventBus的源码
1.注册订阅者
1.1EventBus构造方法
EventBus.getDefault().register(this);
我们在使用EventBus时，首先会调用EventBus.getDefault()来获取实例，其中getDefault()是一个单例方法，保证当前只有一个EventBus实例：
public static EventBus getDefault() {
if (defaultInstance == null) {
synchronized (EventBus.class) {
if (defaultInstance == null) {
defaultInstance = new EventBus();
}
}
}
return defaultInstance;
}
这个采用了双重检查模式的单例模式，下面看下EventBus的构造方法做了什么事情:
public EventBus() {
this(DEFAULT_BUILDER);
}
this调用了EventBus的另一个构造方法。而DEFAULT_BUILDER是默认的EventBusBuilder ，用来构造EventBus。
private static final EventBusBuilder DEFAULT_BUILDER = new EventBusBuilder();
又创建EventBusBuilder对象，构造一个EventBusBuilder来对EventBus进行配置。
EventBus(EventBusBuilder builder) {
logger = builder.getLogger();
subscriptionsByEventType = new HashMap<>();
typesBySubscriber = new HashMap<>();
stickyEvents = new ConcurrentHashMap<>();
//主线程初始化操作
mainThreadSupport = builder.getMainThreadSupport();
mainThreadPoster = mainThreadSupport != null ? mainThreadSupport.createPoster(this) : null;
//子线程初始化操作
backgroundPoster = new BackgroundPoster(this);
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的属性，如下方式也可以注册：
EventBus.builder()
.eventInheritance(false)
.logSubscriberExceptions(false)
.build()
.register(this);
下面我们看下register方法
public void register(Object subscriber) {
//获取类 通过debug可以看出获取出来的结果是com.monkey.eventbus.MainActivity
Class<?> subscriberClass = subscriber.getClass();
//找出传进来的订阅者的所有订阅方法
List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
//进行同步操作
synchronized (this) {
for (SubscriberMethod subscriberMethod : subscriberMethods) {
subscribe(subscriber, subscriberMethod);
}
}
}
可以看到register()方法主要分为查找和注册两部分。
1.2查找订阅者的订阅方法
我们先看下SubscriberMethod都包含了什么：
public class SubscriberMethod {
final Method method; //方法
final ThreadMode threadMode;//执行线程
final Class<?> eventType;//接收的事件类型
final int priority;//优先级
final boolean sticky;//是否粘性事件
/** Used for efficient comparison */
String methodString;
public SubscriberMethod(Method method, Class<?> eventType, ThreadMode threadMode, int priority, boolean sticky) {
this.method = method;
this.threadMode = threadMode;
this.eventType = eventType;
this.priority = priority;
this.sticky = sticky;
}
...
}
我们可以看到SubscriberMethod 类中主要保存了订阅方法的Method对象，线程模式、事件类型、优先级、是否是粘性事件
下面来看查找的过程，findSubscriberMethods()方法：
List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
//从缓存中查找是否有订阅方法,返回一个集合
List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass);
//如果缓存中存在订阅方法，则直接返回
if (subscriberMethods != null) {
return subscriberMethods;
}
//根据 ignoreGeneratedIndex属性值来选择采用何种方法查找订阅方法
//ignoreGeneratedIndex默认为false，是否忽略注解器生成的
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;
}
}
findSubscriberMethods()流程很清晰，即先从缓存中查找，如果找到则直接返回，否则去做下一步的查找过程，然后缓存查找到的集合。我们在项目中经常通过EventBus单例模式来获取默认的EventBus对象，也就是ignoreGeneratedIndex为false的情况，这种情况会调用findUsingInfo()方法:
private List<SubscriberMethod> findUsingInfo(Class<?> subscriberClass) {
//FindState其实就是一个里面保存了订阅者和订阅方法信息的一个实体类，包括订阅类中所有订阅的事件类型和所有的订阅方法等。
FindState findState = prepareFindState();
findState.initForSubscriber(subscriberClass);
//循环判断
while (findState.clazz != 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);
}
findUsingInfo()方法会在当前要注册的类以及其父类中查找订阅事件的方法，最后再通过getMethodsAndRelease方法对findState做回收处理并返回订阅方法的List集合。具体的查找过程在findUsingReflectionInSingleClass()方法，它主要通过反射查找订阅事件的方法：
private void findUsingReflectionInSingleClass(FindState findState) {
Method[] methods;
try {
// This is faster than getMethods, especially when subscribers are fat classes like Activities
methods = findState.clazz.getDeclaredMethods();
} catch (Throwable th) {
// Workaround for java.lang.NoClassDefFoundError, see https://github.com/greenrobot/EventBus/issues/149
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);
// 如果当前方法使用了Subscribe注解
if (subscribeAnnotation != null) {
// 得到该参数的类型
Class<?> eventType = parameterTypes[0];
// checkAdd()方法用来判断FindState的anyMethodByEventType map是否已经添加过以当前eventType为key的键值对，没添加过则返回true
if (findState.checkAdd(method, eventType)) {
// 得到Subscribe注解的threadMode属性值，即线程模式
ThreadMode threadMode = subscribeAnnotation.threadMode();
// 创建一个SubscriberMethod对象，并添加到subscriberMethods集合
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("@Subscribe method " + methodName +
"must have exactly 1 parameter but has " + parameterTypes.length);
}
} else if (strictMethodVerification && method.isAnnotationPresent(Subscribe.class)) {
String methodName = method.getDeclaringClass().getName() + "." + method.getName();
throw new EventBusException(methodName +
" is a illegal @Subscribe method: must be public, non-static, and non-abstract");
}
}
}
查找的过程，就是对当前类中的方法进行遍历，找到符合条件的方法(即添加了Subscribe注解)，获取相关属性值，添加到SubscriberMethod对象，将符合条件的对象添加到subscriberMethods集合中，即保存到findState中。
1.3订阅者的注册过程
在查找完订阅者的订阅方法后，就要对其进行注册。调用subscribe()方法进行注册
private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
// 得到当前订阅了事件的方法的参数类型
Class<?> eventType = subscriberMethod.eventType;
// Subscription类保存了要注册的类对象以及当前的subscriberMethod
Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
// subscriptionsByEventType是一个HashMap，保存了以eventType为key,Subscription对象集合为value的键值对
// 先查找subscriptionsByEventType是否存在以当前eventType为key的值
CopyOnWriteArrayList<Subscription> subscriptions = subscriptionsByEventType.get(eventType);
if (subscriptions == null) {
// 如果不存在，则创建一个subscriptions，并保存到subscriptionsByEventType
subscriptions = new CopyOnWriteArrayList<>();
subscriptionsByEventType.put(eventType, subscriptions);
} else {
if (subscriptions.contains(newSubscription)) {
throw new EventBusException("Subscriber " + subscriber.getClass() + " already registered to event "
+ eventType);
}
}
int size = subscriptions.size();
for (int i = 0; i <= size; i++) {
if (i == size || subscriberMethod.priority > subscriptions.get(i).subscriberMethod.priority) {
// 添加上边创建的newSubscription对象到subscriptions中
subscriptions.add(i, newSubscription);
break;
}
}
// typesBySubscriber也是一个HashMap，保存了以当前要注册类的对象为key，注册类中订阅事件的方法的参数类型的集合为value的键值对
// 查找是否存在对应的参数类型集合
List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber);
if (subscribedEvents == null) {
// 不存在则创建一个subscribedEvents，并保存到typesBySubscriber
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>).
// stickyEvents就是发送粘性事件时，保存了事件类型和对应事件
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);
}
}
}
subscribe()方法需要两个参数，第一个是订阅者，第二个是订阅者方法，然后将符合条件的订阅者信息保存到subscriptionsByEventType、typesBySubscriber两个HashMap中，当我们在发送事件的时候要用到subscriptionsByEventType，完成事件的处理，当取消 EventBus 注册的时候要用到typesBySubscriber、subscriptionsByEventType，完成相关资源的释放。
处理粘性事件就是在 EventBus 注册时，遍历stickyEvents，如果当前要注册的事件订阅方法是粘性的，并且该方法接收的事件类型和stickyEvents中某个事件类型相同或者是其父类，则取出stickyEvents中对应事件类型的具体事件，通过checkPostStickyEventToSubscription()方法做进一步处理。
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()方法完成粘性事件的处理，这就是粘性事件的整个处理流程。
注册订阅者总结：
(1).首先用register()方法注册一个订阅者
(2).获取该订阅者的所有订阅的方法
(3).根据该订阅者的所有订阅的事件类型，将订阅者存入到每个以 事件类型为key 以所有订阅者为values的map集合中
(4).然后将订阅事件添加到以订阅者为key 以订阅者所有订阅事件为values的map集合中
(5).如果是订阅了粘性事件的订阅者，从粘性事件缓存区获取之前发送过的粘性事件，响应这些粘性事件。
2.注销订阅者
下面看下注销订阅者
EventBus.getDefault().unregister(this);
注销订阅者是调用unregister()方法
public synchronized void unregister(Object subscriber) {
// 得到当前注册类对象 对应的订阅事件方法的参数类型的集合
List<Class<?>> subscribedTypes = typesBySubscriber.get(subscriber);
if (subscribedTypes != null) {
// 遍历参数类型集合，释放之前缓存的当前类中的Subscription
for (Class<?> eventType : subscribedTypes) {
unsubscribeByEventType(subscriber, eventType);
}
// 删除以subscriber为key的键值对
typesBySubscriber.remove(subscriber);
} else {
logger.log(Level.WARNING, "Subscriber to unregister was not registered before: " + subscriber.getClass());
}
}
private void unsubscribeByEventType(Object subscriber, Class<?> eventType) {
// 得到当前参数类型对应的Subscription集合
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对象对应的注册类对象和要取消注册的注册类对象相同，则删除当前subscription对象
subscription.active = false;
subscriptions.remove(i);
i--;
size--;
}
}
}
}
我们可以看到在unregister()方法中，释放了typesBySubscriber、subscriptionsByEventType中缓存的资源。
注销订阅者总结：
(1).首先通过unregister方法拿到要取消的订阅者
(2).得到该订阅者的所有订阅事件类型
(3).遍历事件类型，根据每个事件类型获取到所有的订阅者集合，并从集合中删除该订阅者
3.发送及处理事件
当我们要发送普通事件，就需要用到post()方法，
当我们要发送粘性事件，就需要用到postSticky()方法
//发送普通事件
EventBus.getDefault().post("我要学习EventBus")；
//发送粘性事件
EventBus.getDefault().postSticky(new MessageEvent("我要学习EventBus的粘性事件"));
3.1粘性事件 postSticky()方法
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);
}
postSticky()方法主要做了两件事，先将事件类型和对应事件保存到stickyEvents中，方便后续使用；然后执行post(event)继续发送事件，这个post()方法就是之前发送普通消息的post()方法。所以，如果在发送粘性事件前，已经有了对应类型事件的订阅者，不是非粘性的，依然可以接收到发送出的粘性事件。
3.2普通事件 post()方法
public void post(Object event) {
//currentPostingThreadState是一个PostingThreadState类型的ThreadLocal
// PostingThreadState类保存了事件队列和线程模式等信息
PostingThreadState postingState = currentPostingThreadState.get();
List<Object> eventQueue = postingState.eventQueue;
// 将要发送的事件添加到事件队列
eventQueue.add(event);
// isPosting默认为false
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;
}
}
}
post()方法先将发送的事件保存的事件队列，然后通过循环出队列，将事件交给postSingleEvent()方法处理：
private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
Class<?> eventClass = event.getClass();
boolean subscriptionFound = false;
// eventInheritance默认为true，表示是否向上查找事件的父类
if (eventInheritance) {
// 查找当前事件类型的Class，连同当前事件类型的Class保存到集合
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));
}
}
}
postSingleEvent()方法中，根据eventInheritance属性，决定是否向上遍历事件的父类型，然后用postSingleEventForEventType()方法进一步处理事件：
private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class<?> eventClass) {
CopyOnWriteArrayList<Subscription> subscriptions;
synchronized (this) {
// 获取事件类型对应的Subscription集合
subscriptions = subscriptionsByEventType.get(eventClass);
}
if (subscriptions != null && !subscriptions.isEmpty()) {
for (Subscription subscription : subscriptions) {
// 记录事件
postingState.event = event;
// 记录对应的subscription
postingState.subscription = subscription;
boolean aborted = false;
try {
// 最终的事件处理
postToSubscription(subscription, event, postingState.isMainThread);
aborted = postingState.canceled;
} finally {
//将postingState置为初始状态
postingState.event = null;
postingState.subscription = null;
postingState.canceled = false;
}
if (aborted) {
break;
}
}
return true;
}
return false;
}
遍历发送的事件类型对应的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 MAIN_ORDERED:
if (mainThreadPoster != null) {
// 无论在那个线程发送事件，都先将事件入队列，然后通过 Handler 切换到主线程，依次处理事件。
mainThreadPoster.enqueue(subscription, event);
} else {
// temporary: technically not correct as poster not decoupled from subscriber
invokeSubscriber(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);
}
}
可以看到，postToSubscription()方法就是根据订阅事件方法的线程模式、以及发送事件的线程来判断如何处理事件。
发送事件总结:
(1).首先获取当前线程的事件队列
(2).将要发送的事件添加到事件队列中
(3).根据发送事件类型获取所有的订阅者
(4).根据响应方法的执行模式，在相应线程通过反射执行订阅者的订阅方法
4.Subscribe注解
EventBus3.0 开始用Subscribe注解配置事件订阅方法，不再使用方法名了，如：
@Subscribe(threadMode = ThreadMode.MAIN)
public void onShowEventMessage(MessageEvent messageEvent) {
tvMessage.setText(messageEvent.getMessage());
}
看下Subscribe注解的实现:
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface Subscribe {
// 指定事件订阅方法的线程模式，即在那个线程执行事件订阅方法处理事件，默认为POSTING
ThreadMode threadMode() default ThreadMode.POSTING;
// 是否支持粘性事件，默认为false
boolean sticky() default false;
// 指定事件订阅方法的优先级，默认为0，如果多个事件订阅方法可以接收相同事件的，则优先级高的先接收到事件
int priority() default 0;
}
所以在使用Subscribe注解时可以根据需求指定threadMode、sticky、priority三个属性。关于threadMode的属性，文章开始已经介绍了。
关于EventBus的源码就学习到这里，如理解有误，还望指正！
