[Android]事件总线之EventBus的使用背景
在我们的android项目开发过程中，经常会有各个组件如activity,fragment和service之间，各个线程之间的通信需求；项目中用的最多的是Android框架的广播机制，android的广播机制是基于系统的Binder机制实现IPC或者进程内部的通信，而Binder这种IPC机制相比于Linux原有的机制来说具有，性能更好、安全性更高和易用性更好的特点，所以android系统中很多系统事件都是基于广播的方式来发送，如开机广播、电量低的提醒广播等。然而在一个android的进程内部，各个组件、子线程之间通信如果使用广播的话，那就有种杀鸡用牛刀的赶脚。。。
[Android]进程内部通信之EventBus
EventBus是greenrobot开发的发布/订阅事件总线组件，也是基于观察者模式，不同点在于，EventBus框架解耦了事件的发送和订阅模块，事件对象的分发交由EventBus来处理，下面的框架图可以清晰的看到这一点。
[Android]EventBus 3.0基本使用方法
一、定义事件类
作为事件的发布者，需要定义所发布的事件的类：
public class MessageEvent {
private String msg;
public MessageEvent(String msg) {
this.msg = msg;
}
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
}
二、注册/取消注册响应事件
作为事件的订阅者，需要把响应事件的对象注册到EventBus当中:
EventBus.getDefault().register(obj)
当不需要处理某个类型的事件的时候，取消对这个事件的监听:
EventBus.getDefault().unregister(obj)
三、声明和注释订阅方法，选择指定线程模式
作为事件的订阅者，需要定义事件的响应方法，方法名称可以随意取，方法的形参类型，必须和监听的事件对象类型一致：
@Subscribe(threadMode = ThreadMode.MAIN)
public void onMessageEvent(MessageEvent event) {
Toast.makeText(this, event.getMsg (),
Toast.LENGTH_SHORT).show();
}
3.1 四种线程模式
事件订阅者可以通过注解的方式选择处理事件的方法所在的线程：
PostThread：如果事件处理函数指定了线程模型为PostThread，那么事件的发布和接收处理会在同一个线程当中。
BackgroundThread：如果事件处理函数指定了线程模型为BackgroundThread，那么如果事件是在UI线程中发布出来的，那么该事件处理函数就会在新的子线程中运行，如果事件发布本来就是非UI线程中发布出来 的，那么该事件处理函数直接在发布事件的线程中执行。
MainThread:如果事件处理函数指定了线程模型为MainThread，那么不论事件对象是在哪个线程中发布出来的，该事件处理函数都会在UI线程中执行。
Async：如果事件处理函数指定了线程模型为Async，那么无论事件在哪个线程发布，该事件处理函数都会在新建的子线程中执行。
3.2 黏性事件
通过注解的方式设置sticky为true，那么事件处理函数则可以处理上一次的事件对象：
@Subscribe(sticky = true, threadMode = ThreadMode.MAIN)
四、EventBus 3.0源码详解
4.1 注册流程
/**
* 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对象
Class<?> subscriberClass = subscriber.getClass();
//通过类的class对象得到此对象的订阅方法列表
List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
synchronized (this) {
for (SubscriberMethod subscriberMethod :subscriberMethods) {
//线程同步，遍历订阅方法列表，注册每一个订阅方法
subscribe(subscriber, subscriberMethod);
}
}
}
代码subscriberMethodFinder.findSubscriberMethods(subscriberClass)获取订阅方法列表具体如下：
List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
//在缓存中查找此class对象对应的订阅方法列表
List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass);
if (subscriberMethods != null) {
return subscriberMethods;
}
//是否忽略注解器生成的MyEventBusIndex类
if (ignoreGeneratedIndex) {
//通过反射机制得到订阅者类class对象对应的订阅事件方法列表
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 {
//缓存此class对象的订阅方法列表
METHOD_CACHE.put(subscriberClass, subscriberMethods);
return subscriberMethods;
}
}
通过反射机制获取订阅方法列表：
private List<SubscriberMethod> findUsingReflection(Class<?> subscriberClass) {
FindState findState = prepareFindState();
findState.initForSubscriber(subscriberClass);
while (findState.clazz != null) {
//遍历当前class对象和其父类中的订阅方法
findUsingReflectionInSingleClass(findState);
findState.moveToSuperclass();
}
return getMethodsAndRelease(findState);
}
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);
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("@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");
}
}
}
至此，我们得到了所有的订阅函数列表，下一步，会对每一个订阅函数进行注册：
// Must be called in synchronized block
private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
Class<?> eventType = subscriberMethod.eventType;
Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
//通过监听的事件对象得到其对应的监听者对象列表
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);
}
}
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;
}
}
//通过订阅者对象得到其对应的监听事件类型列表
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);
}
}
事件的注册流程实际是从监听者对象和消息事件两个维度，将对方分别添加到自己对应的列表当中，具体可以通过以下流程图总结：
4.2发布流程
/** Posts the given event to the event bus. */
public void post(Object event) {
//通过ThreadLocal机制得到当前线程的postingState对象
PostingThreadState postingState = currentPostingThreadState.get();
List<Object> eventQueue = postingState.eventQueue;
//在此线程的eventQueue中添加此事件对象
eventQueue.add(event);
if (!postingState.isPosting) {
//判断当前线程是否UI线程
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;
}
}
}
ThreadLocal机制可以存储各个线程的局部数据；
postSingleEvent函数处理此线程消息队列中的消息事件：
private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
Class<?> eventClass = event.getClass();
boolean subscriptionFound = false;
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));
}
}
}
事件消息对象具体的分发函数：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 {
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);
}
}
至此，我们完成了事件消息对象的分发流程，以下流程图来总结post的过程：
4.3 取消注册流程
/** 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中删除此订阅者对象
typesBySubscriber.remove(subscriber);
} else {
Log.w(TAG, "Subscriber to unregister was not registered before: " + subscriber.getClass());
}
}
unsubscribeByEventType函数：
/** Only updates subscriptionsByEventType, not typesBySubscriber! Caller must update typesBySubscriber. */
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--;
}
}
}
}
取消注册的流程总结如下：
1.通过观察者类对象通过MAP表得到其对应的事件类class对象列表.
2.遍历list列表，通过事件类class对象得到其在MAP表中对应的观察者类对象列表。
3.遍历此观察者对象列表，判断如果列表中存在需要取消的注册观察者对象，则从对象列表中删除此观察者对象。
4.从第1步中得到的MAP对象中删除以取消注册的观察者对象为key的映射项目。
5.完成unregister过程。
五、相似功能框架的比较
和EventBus具有相似功能的组件有Square推出的Otto,Android系统的LocalBroadCast,共同点是这三个框架都是进程内通信，方便进程内各个组件和子线程间的通信。
Ottootto采用了注解的方式完成注册，Otto更多使用场景应该就是在主线程中，因为其不像EventBus可以选择不同的线程模式。
LocalBroadCast是Android在Android Support Library中提供的，用于进程内部通信框架，其主要目的是保证广播在进程内部传递，确保通讯的安全行，其内部通过handler的方式实现。