EventBus的源码解析（一）

EventBus已经出来很久了，相信大家并不陌生，很多android程序员应该在项目中都使用过它了，当然了我也使用过，以前使用的时候就是觉得它使用起来挺简单的，但是它的具体实现原理却没有研究过，作为一名有追求的程序员，仅仅会使用是无法满足我的，今天我们就从源码来看看他是如何实现的。

EventBus的作用就是方便应用的各个部分之间的通信，且能降低彼此之间的耦合。

使用EventBus第一步就是要获取它的实例，看一下它提供的方法：

EventBus.getDefault()

public static EventBus getDefault() {
if(defaultInstance == null) {
Class var0 = EventBus.class;
synchronized(EventBus.class) {
if(defaultInstance == null) {
defaultInstance = new EventBus();
}
}
}

return defaultInstance;
}

可以看到他使用的是双重判断的单列模式，并且考虑了并发问题。

使用EventBus主要分为两步：

1. 注册 Register（Object subscriber）

public void register(Object subscriber) {
this.register(subscriber, false, 0);
}

private synchronized void register(Object subscriber, boolean sticky, int priority) {
List subscriberMethods = this.subscriberMethodFinder.findSubscriberMethods(subscriber.getClass());
Iterator i$ = subscriberMethods.iterator();

while(i$.hasNext()) {
SubscriberMethod subscriberMethod = (SubscriberMethod)i$.next();
this.subscribe(subscriber, subscriberMethod, sticky, priority);
}

}

首先看方法的几个参数，目前看得懂的就是Object subscriber，因为这是我们register(param)传进去。

让我们来看看

List subscriberMethods = this.subscriberMethodFinder.findSubscriberMethods(subscriber.getClass());

参数subscriber.getClass()返回的是subscriber这个对象所属的类对象（java.lang.Class），这个对象是在类加载过程中生成的，它主要是作为方法区中这个类的各个数据的访问入口（小说一句，该对象存在于HotSpot虚拟机中的方法区里面）。

List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
String key = subscriberClass.getName();
Map clazz = methodCache;
List subscriberMethods;
synchronized(methodCache) {
subscriberMethods = (List)methodCache.get(key);
}

if(subscriberMethods != null) {
return subscriberMethods;
} else {
ArrayList var23 = new ArrayList();
Class var24 = subscriberClass;
HashSet eventTypesFound = new HashSet();

for(StringBuilder methodKeyBuilder = new StringBuilder(); var24 != null; var24 = var24.getSuperclass()) {
String name = var24.getName();
if(name.startsWith("java.") || name.startsWith("javax.") || name.startsWith("android.")) {
break;
}

Method[] methods = var24.getDeclaredMethods();
Method[] arr$ = methods;
int len$ = methods.length;

for(int i$ = 0; i$ < len$; ++i$) {
Method method = arr$[i$];
String methodName = method.getName();
if(methodName.startsWith("onEvent")) {
int modifiers = method.getModifiers();
if((modifiers & 1) != 0 && (modifiers & 5192) == 0) {
Class[] parameterTypes = method.getParameterTypes();
if(parameterTypes.length == 1) {
String modifierString = methodName.substring("onEvent".length());
ThreadMode threadMode;
if(modifierString.length() == 0) {
threadMode = ThreadMode.PostThread;
} else if(modifierString.equals("MainThread")) {
threadMode = ThreadMode.MainThread;
} else if(modifierString.equals("BackgroundThread")) {
threadMode = ThreadMode.BackgroundThread;
} else {
if(!modifierString.equals("Async")) {
if(!this.skipMethodVerificationForClasses.containsKey(var24)) {
throw new EventBusException("Illegal onEvent method, check for typos: " + method);
}
continue;
}

threadMode = ThreadMode.Async;
}

Class eventType = parameterTypes[0];
methodKeyBuilder.setLength(0);
methodKeyBuilder.append(methodName);
methodKeyBuilder.append('>').append(eventType.getName());
String methodKey = methodKeyBuilder.toString();
if(eventTypesFound.add(methodKey)) {
var23.add(new SubscriberMethod(method, threadMode, eventType));
}
}
} else if(!this.skipMethodVerificationForClasses.containsKey(var24)) {
Log.d(EventBus.TAG, "Skipping method (not public, static or abstract): " + var24 + "." + methodName);
}
}
}
}

if(var23.isEmpty()) {
throw new EventBusException("Subscriber " + subscriberClass + " has no public methods called " + "onEvent");
} else {
Map var25 = methodCache;
synchronized(methodCache) {
methodCache.put(key, var23);
return var23;
}
}
}
}

2-10行：通过我们传入对象的类名作为键在一个map集合中查找对应的值，如果查找到了就直接返回。

22-23行：通过我们之前获得的java.lang.Class类对象利用反射去获取该类里面所有的方法。

26-66行：遍历该类中所有的方法,如果是以“onEvent”开头，并且该方法的修饰符是public且非static和abstract方法，并且该方法只有一个参数，就可以进入到封装的代码中。通过截取该方法名onEvent后面的字符串与“MainThread”,“BackgroundThread”,“Async”进行对比来确定threadMode，它是一个枚举，eventType是该方法的参数Class对象，将该方法的method,threadMode,eventType作为参数封装到一个SubscriberMethod对象当中，并将该对象添加到一个ArrayList集合当中并返回，在返回之前会吧这个以传入的类名作为键，这个ArrayList集合作为值缓存到methodCache这个map集合中，下次就可以直接从缓存中拿到ArrayList对象了。

List subscriberMethods = this.subscriberMethodFinder.findSubscriberMethods(subscriber.getClass());
Iterator i$ = subscriberMethods.iterator();

while(i$.hasNext()) {
SubscriberMethod subscriberMethod = (SubscriberMethod)i$.next();
this.subscribe(subscriber, subscriberMethod, sticky, priority);
}

接下来就是继续遍历我们刚才获取到的ArrayList对象，将得到的subscriberMethod 对象作为参数传入subscribe(subscriber, subscriberMethod, sticky, priority)这个方法，我们再去看看这个方法里面做了什么：

private void subscribe(Object subscriber, SubscriberMethod subscriberMethod, boolean sticky, int priority) {
Class eventType = subscriberMethod.eventType;
CopyOnWriteArrayList subscriptions = (CopyOnWriteArrayList)this.subscriptionsByEventType.get(eventType);
Subscription newSubscription = new Subscription(subscriber, subscriberMethod, priority);
if(subscriptions == null) {
subscriptions = new CopyOnWriteArrayList();
this.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 subscribedEvents = 0; subscribedEvents <= size; ++subscribedEvents) {
if(subscribedEvents == size || newSubscription.priority > ((Subscription)subscriptions.get(subscribedEvents)).priority) {
subscriptions.add(subscribedEvents, newSubscription);
break;
}
}

Object var14 = (List)this.typesBySubscriber.get(subscriber);
if(var14 == null) {
var14 = new ArrayList();
this.typesBySubscriber.put(subscriber, var14);
}

((List)var14).add(eventType);
if(sticky) {
Map var11 = this.stickyEvents;
Object stickyEvent;
synchronized(this.stickyEvents) {
stickyEvent = this.stickyEvents.get(eventType);
}

if(stickyEvent != null) {
this.postToSubscription(newSubscription, stickyEvent, Looper.getMainLooper() == Looper.myLooper());
}
}

}

还好这个方法没有那么长，让我们来分析一下：

首先创建了一个Subscription对象，将之前封装对象里面的eventType（方法参数的Class 对象）作为键，创建一个List集合作为值添加到了一个concurrentHashmap对象subscriptionsByEventType中，后序就是通过这个对象来查找我们想要调用的方法并通过反射调用（这里只是先提一下）。

之前有几个参数我们没看懂，比如priority，当传入相同参数类型有多个方法的时候，将刚生产的Subscription按优先级的大小来确定位置添加到List集合当中。

Object var14 = (List)this.typesBySubscriber.get(subscriber);
if(var14 == null) {
var14 = new ArrayList();
this.typesBySubscriber.put(subscriber, var14);
}

((List)var14).add(eventType);
if(sticky) {
Map var11 = this.stickyEvents;
Object stickyEvent;
synchronized(this.stickyEvents) {
stickyEvent = this.stickyEvents.get(eventType);
}

if(stickyEvent != null) {
this.postToSubscription(newSubscription, stickyEvent, Looper.getMainLooper() == Looper.myLooper());
}
}

将方法参数的Class对象添加到var14 就是一个List集合中，并将这个List集合作为值和传入的subscriber作为键添加到一个map集合中typesBySubscriber。

2. 发布 Post(Object event)

public void post(Object event) {
EventBus.PostingThreadState postingState = (EventBus.PostingThreadState)this.currentPostingThreadState.get();
List 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()) {
this.postSingleEvent(eventQueue.remove(0), postingState);
}
} finally {
postingState.isPosting = false;
postingState.isMainThread = false;
}
}

}

让我们来分析一下发布方法里面做了些什么：

1.将post（Object event）参数event对象添加到一个list集合。

2.第6行判断当前是否是UI线程,并且把isPosting属性设置为true。

3.然后会走到一个循环当中 当list集合不为空，会调用postSingleEvent方法，好吧 我们去看下这个方法。

4.最后会吧 isPosting和isMainThread都设置为false。

private void postSingleEvent(Object event, EventBus.PostingThreadState postingState) throws Error {
Class eventClass = event.getClass();
boolean subscriptionFound = false;
if(this.eventInheritance) {
List eventTypes = this.lookupAllEventTypes(eventClass);
int countTypes = eventTypes.size();

for(int h = 0; h < countTypes; ++h) {
Class clazz = (Class)eventTypes.get(h);
subscriptionFound |= this.postSingleEventForEventType(event, postingState, clazz);
}
} else {
subscriptionFound = this.postSingleEventForEventType(event, postingState, eventClass);
}

if(!subscriptionFound) {
if(this.logNoSubscriberMessages) {
Log.d(TAG, "No subscribers registered for event " + eventClass);
}

if(this.sendNoSubscriberEvent && eventClass != NoSubscriberEvent.class && eventClass != SubscriberExceptionEvent.class) {
this.post(new NoSubscriberEvent(this, event));
}
}

}

首先看到这个方法lookupAllEventTypes(eventClass)

private List<Class<?>> lookupAllEventTypes(Class<?> eventClass) {
Map var2 = eventTypesCache;
synchronized(eventTypesCache) {
Object eventTypes = (List)eventTypesCache.get(eventClass);
if(eventTypes == null) {
eventTypes = new ArrayList();

for(Class clazz = eventClass; clazz != null; clazz = clazz.getSuperclass()) {
((List)eventTypes).add(clazz);
addInterfaces((List)eventTypes, clazz.getInterfaces());
}

eventTypesCache.put(eventClass, eventTypes);
}

return (List)eventTypes;
}
}

这个方法会得到一个List集合，里面装的是我们pos传入参数event对象的Class，以及他的父类和接口的Class对象。

接着会遍历这个List集合，获得其中的每一个Class对象，然后调用了postSingleEventForEventType(event, postingState, eventClass)方法，再进入这个方法

private boolean postSingleEventForEventType(Object event, EventBus.PostingThreadState postingState, Class<?> eventClass) {
CopyOnWriteArrayList subscriptions;
synchronized(this) {
subscriptions = (CopyOnWriteArrayList)this.subscriptionsByEventType.get(eventClass);
}

if(subscriptions != null && !subscriptions.isEmpty()) {
Iterator i$ = subscriptions.iterator();

while(i$.hasNext()) {
Subscription subscription = (Subscription)i$.next();
postingState.event = event;
postingState.subscription = subscription;
boolean aborted = false;

try {
this.postToSubscription(subscription, event, postingState.isMainThread);
aborted = postingState.canceled;
} finally {
postingState.event = null;
postingState.subscription = null;
postingState.canceled = false;
}

if(aborted) {
break;
}
}

return true;
} else {
return false;
}
}

subscriptionsByEventType 有没有很熟悉啊？？？ 对了就是之前那个存放方法参数的Class对象为键，Subscriptions为值得那个concurrentHashmap对象，这个通过这个对象将post(Object event)参数的Class对象作为键的值取出来，这如果这个event的Class对象跟之前那个方法参数的Class对象是同一个对象，那么取出来的不就是之前存的Subscriptions对象吗？而Subscriptions集合里面装着newSubscription对象，newSubscription对象里面封装了所有需要的信息，在看postToSubscription(subscription, event, postingState.isMainThread)方法

private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {
switch(EventBus.SyntheticClass_1.$SwitchMap$de$greenrobot$event$ThreadMode[subscription.subscriberMethod.threadMode.ordinal()]) {
case 1:
this.invokeSubscriber(subscription, event);
break;
case 2:
if(isMainThread) {
this.invokeSubscriber(subscription, event);
} else {
this.mainThreadPoster.enqueue(subscription, event);
}
break;
case 3:
if(isMainThread) {
this.backgroundPoster.enqueue(subscription, event);
} else {
this.invokeSubscriber(subscription, event);
}
break;
case 4:
this.asyncPoster.enqueue(subscription, event);
break;
default:
throw new IllegalStateException("Unknown thread mode: " + subscription.subscriberMethod.threadMode);
}

}

当threadMode枚举为1是说明找到的是onEvent()方法，并利用反射调用；当threadMode为2的时候说明找到的是onEventMainThread()方法，然后判断是否是主线程，如果是主线程就反射调用，如果不是，就将放入队列中。当threadMode为3的时候说明找到的是onEventBackgroundThread（）方法，同样判断发送事件如果是在主线程，就将其放入队列，如果是子线程就直接利用发射调用，当threadMode为4的时候说明是调用onEventAsync（）方法，它会将其放入队列并在合适的时候反射调用。

好了，到这里EventBus的源码大致分析清楚了，但还有一小部分没有分析，比如boolean sticky这个参数是干什么用的？registerSticky()这个构造函数有什么不同？下次再跟大家一起分析了。