上一篇文章http://blog.csdn.net/crazy__chen/article/details/47425779

和大家一起模仿EventBus的实现机制。和大家一起写出了一个简易的EventBus。

通过这个项目，大家应该对EventBus的实现机理由大致的了解。

建议大家在看这篇文章之前。先读上一篇文章，有助于了解。

本篇文章希望通过对Github上EventBus的源代码。向大家讲些事实上现细节。

网上有非常多讲EventBus架构的文章。我看了以后都认为不大清晰，希望这篇文章能够帮到你。

EventBus源代码地址https://github.com/greenrobot/EventBus

对于整个框架的理解，我们先来看一下文件图

我们希望了解整个框架的每一个文件存在的意义，在这里我将具体介绍大部分主要类的用处和设计的思路。

我们都知道整个框架的入口是EventBus这个类，网上非常多文章都是以这个类为入口

我却先给大家将一些实体类的构建。

我们知道，EventBus解耦的方式事实上是使用了反射。我在调用register()方法的时候，EventBus就扫描调用这种方法的类，将须要反射调用的方法信息记录下来，这些方法就是onEvent(),onEventMainThread(),onEventBackgroundThread()和onEventAsync()。

这些方法被记录以后，假设有人调用post()方法，就会在记录里面查找，然后使用发射去触发这些方法

反射触发方法的方式是调用Method类的invoke()方法,其签名例如以下：

public Object invoke(Object obj, Object... args)

显然要我们须要1，Method对象，订阅者对象obj。还有參数对象args

也就是说记录里面，相应一个订阅方法。起码要有上面三个參数。

OK，依据面向对象的思想，我们最好将这些參数封装成一个详细的类。接下来我们看一张图

这张图说明了EventBus里面实体类的构造结构，外层的类包裹着里面的类。

也就是外面的方框有一个里面方框所代表的类。作为它的属性

我们能够看到PendingPost包括Subscription,Subscription包括SubscriberMethod,SubscriberMethod包括ThreadMode

我如今向大家说明一下。

首先，最里面的是SubscriberMethod类，它的意义就是EventBus扫描到的订阅方法主体

final class SubscriberMethod {/*** 方法本体*/final Method method;/*** 订阅类型*/final ThreadMode threadMode;/*** 參数类型*/final Class<?> eventType;

这个类包括了EventBus扫描到的方法Method,订阅类型ThreadMode。事实上是一个枚举类。它代表订阅方法的类型(是在主线程，子线程，还是在公布线程执行等等)

public enum ThreadMode {  PostThread,    MainThread, BackgroundThread,Async
}

还有订阅方法的參数Class<?> eventType

试想一下，要假设要反射调用这种方法。那么我们如今仅仅满足了第一个条件，就是我们获得了方法对象本身

然后是Subscription。它的意义就是一个订阅。订阅包括订阅者和订阅方法

final class Subscription {/*** 订阅者*/final Object subscriber;/*** 订阅的方法*/final SubscriberMethod subscriberMethod;/*** 优先级*/final int priority;......
}

能够见到，有订阅者。订阅方法对象SubscriberMethod，一个优先级。优先级是用于队列排序的，后面会讲到，优先级越高。当post的时候。者订阅就越先被触发。

这时反射的第二个条件，反射要传入的第一个參数就具备了。

再次封装成PendingPost，这个类的意义是在队列中排队的一个详细运行请求，也就是post以后，就会产生这样一个对象

final class PendingPost {Object event;Subscription subscription;PendingPost next;.......
}

当中Object event，就是我们post(Object obj)方法调用的时候。參数的obj。这就是我们反射须要的最后一个參数。

这样，我们通过构建这几个层次分明的实体类，我们就具备了触发反射的能力。

通过上面的分析我们也知道。我们在register()的时候。目的是获得Subscription对象

我们在post(Object obj)的时候，目的是将传入的obj和对应的Subscription对象一起封装成PendingPost对象

将其放入队列里面排队，队列会不断取出元素。触发反射！

了解上面思路以后，我们開始从EventBus入手。看看最基本的register和post方法，详细是再怎么做到的。

再次之前。我们要看EventBus里面的几个重要属性，这几个属性非常复杂。大家先有个印象

public class EventBus {/** Log tag, apps may override it. */public static String TAG = "Event";static volatile EventBus defaultInstance;private static final EventBusBuilder DEFAULT_BUILDER = new EventBusBuilder();/*** key为參数类型,value为參数类型及其父类型,接口类型列表*/private static final Map<Class<?

>, List<Class<?

>>> eventTypesCache = new HashMap<Class<?

>, List<Class<?>>>(); /** * key为參数类型，value为该參数类型的全部订阅(订阅包含，订阅者，订阅方法，优先级) */ private final Map<Class<?

>, CopyOnWriteArrayList<Subscription>> subscriptionsByEventType; /** * key为订阅者，value为參数列表 */ private final Map<Object, List<Class<?

>>> typesBySubscriber; /** * 能够看做缓存,key參数类型，value是參数 */ private final Map<Class<?>, Object> stickyEvents; ....... }

这么多属性有什么意义？有的是为了功能必须，有的是为了提高性能，比如缓存。

再看源代码过程中我会看到他们的作用。

可是如今我们必须关注的一个属性是subscriptionsByEventType。这个属性我们在上一篇文章也说过它的重要作用。

subscriptionsByEventType的key是參数类型，比如我们又一个onEvent(Info i)方法，我们知道EventBus是通过參数类型找到订阅方法的，比如post(new Info("msg"));

EventBus负责找到所以订阅了Info类型的订阅方法。比如上面说的onEvent(Info i)

那么这就要求我们将Info.class记录下来。作为key，通过这个key，我们就能够找到全部这些方法了。

所以。subscriptionsByEventType的value是一个ArrayList，里面存储了Subscription。

OK，如今让我们来看register()方法

private synchronized void register(Object subscriber, boolean sticky, int priority) {List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriber.getClass());for (SubscriberMethod subscriberMethod : subscriberMethods) {//遍历改订阅者的全部订阅方法subscribe(subscriber, subscriberMethod, sticky, priority);}}

在这种方法里面，调用了subscriberMethodFinder这个类的findSubscriberMethods()方法。依据上面的分析我们也知道。这种方法用于找出订阅者subscriber中的全部订阅方法，而且将它们封装成SubscriberMethod对象返回。

然后调用了subscribe()方法。将SubscriberMethod对象。和订阅者一起，封装成了subscription对象，我们详细看这两个方法。

首先是findSubscriberMethods()

List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {String key = subscriberClass.getName();//订阅者名称List<SubscriberMethod> subscriberMethods;//订阅的方法集synchronized (methodCache) {subscriberMethods = methodCache.get(key);}if (subscriberMethods != null) {return subscriberMethods;}subscriberMethods = new ArrayList<SubscriberMethod>();Class<?

> clazz = subscriberClass; /** * 记录订阅的全部方法，防止父类反复订阅在子类中已经订阅的方法 */ HashSet<String> eventTypesFound = new HashSet<String>(); StringBuilder methodKeyBuilder = new StringBuilder(); while (clazz != null) { String name = clazz.getName(); if (name.startsWith("java.") || name.startsWith("javax.") || name.startsWith("android.")) { // Skip system classes, this just degrades performance break; } // Starting with EventBus 2.2 we enforced methods to be public (might change with annotations again) Method[] methods = clazz.getDeclaredMethods();//找到订阅者的全部方法 for (Method method : methods) { String methodName = method.getName(); if (methodName.startsWith(ON_EVENT_METHOD_NAME)) { int modifiers = method.getModifiers(); if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {//仅仅找public方法。并且没有static,final等修饰 Class<?>[] parameterTypes = method.getParameterTypes();//方法參数 if (parameterTypes.length == 1) { String modifierString = methodName.substring(ON_EVENT_METHOD_NAME.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")) { threadMode = ThreadMode.Async; } else { if (skipMethodVerificationForClasses.containsKey(clazz)) {//过滤 continue; } else { throw new EventBusException("Illegal onEvent method, check for typos: " + method); } } Class<?> eventType = parameterTypes[0];//參数 methodKeyBuilder.setLength(0); methodKeyBuilder.append(methodName); methodKeyBuilder.append('>').append(eventType.getName()); String methodKey = methodKeyBuilder.toString(); if (eventTypesFound.add(methodKey)) {//假设之前没有加入 // Only add if not already found in a sub class subscriberMethods.add(new SubscriberMethod(method, threadMode, eventType)); } } } else if (!skipMethodVerificationForClasses.containsKey(clazz)) { Log.d(EventBus.TAG, "Skipping method (not public, static or abstract): " + clazz + "." + methodName); } } } <pre name="code" class="java"> clazz = clazz.getSuperclass();//查找父类

} if (subscriberMethods.isEmpty()) { throw new EventBusException("Subscriber " + subscriberClass + " has no public methods called " + ON_EVENT_METHOD_NAME); } else { synchronized (methodCache) { methodCache.put(key, subscriberMethods); } return subscriberMethods; } }
上面的代码有点复杂，事实上就是扫描订阅者，找到订阅方法。

注意有这样一个

 /*** 记录订阅的全部方法，防止父类反复订阅在子类中已经订阅的方法*/HashSet<String> eventTypesFound = new HashSet<String>();

这个eventTypesFound是记录了整个扫描过程中扫描到的方法签名。为什么要记录呢？

看到这一句

clazz = clazz.getSuperclass();//查找父类

也就是说扫描一个订阅者的时候，假设这个订阅者本身没有订阅方法，可是它的父类有订阅方法，也会被扫描出来

这样的优化就是为了实现继承的作用。

所以扫描父类的时候，要避免反复记录子类中已经扫描到的订阅方法。

另外另一点。就是skipMethodVerificationForClasses，它能够用于过滤不须要扫描的方法，也就是这些订阅不会被记录

这个属性时在创建时传入的对象，我们看SubscriberMethodFinder的构造函数

SubscriberMethodFinder(List<Class<?>> skipMethodVerificationForClassesList) {skipMethodVerificationForClasses = new ConcurrentHashMap<Class<?

>, Class<?

>>(); if (skipMethodVerificationForClassesList != null) { for (Class<?> clazz : skipMethodVerificationForClassesList) { skipMethodVerificationForClasses.put(clazz, clazz); } } }

传入一个名单。名单内的订阅者将会被忽略。

最后，在封装过程中，依据方法签名，构造SubscriberMethod，而且将SubscriberMethod加入到队列里面，最后返回这个队列。

这样findSubscriberMethods()就结束了。

我们接着register()方法里面的

for (SubscriberMethod subscriberMethod : subscriberMethods) {//遍历改订阅者的全部订阅方法subscribe(subscriber, subscriberMethod, sticky, priority);}

这里将方法封装成subscription

// Must be called in synchronized blockprivate void subscribe(Object subscriber, SubscriberMethod subscriberMethod, boolean sticky, int priority) {Class<?

> eventType = subscriberMethod.eventType; CopyOnWriteArrayList<Subscription> subscriptions = subscriptionsByEventType.get(eventType); Subscription newSubscription = new Subscription(subscriber, subscriberMethod, priority);//封装成<span style="font-family: Arial, Helvetica, sans-serif;">newSubscription</span> if (subscriptions == null) { subscriptions = new CopyOnWriteArrayList<Subscription>(); subscriptionsByEventType.put(eventType, subscriptions);//假设该參数类型没有队列。新建一个 } else { if (subscriptions.contains(newSubscription)) { throw new EventBusException("Subscriber " + subscriber.getClass() + " already registered to event " + eventType); } } // Starting with EventBus 2.2 we enforced methods to be public (might change with annotations again) // subscriberMethod.method.setAccessible(true); int size = subscriptions.size(); for (int i = 0; i <= size; i++) {//依据优先级找到在队列的位置 if (i == size || newSubscription.priority > subscriptions.get(i).priority) { subscriptions.add(i, newSubscription); break; } } List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber);//这里是为了删除订阅的须要 if (subscribedEvents == null) { subscribedEvents = new ArrayList<Class<?>>(); typesBySubscriber.put(subscriber, subscribedEvents); } subscribedEvents.add(eventType); if (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); } } }

上面，依据首先封装出一个subscription。然后推断subscriptionsByEventType里面是否由參数类型相应的队列，没有就创建一个

将subscription增加队列。

然后就涉及到一个typesBySibcriber属性，看我凝视

/*** key为订阅者，value为參数类型列表*/private final Map<Object, List<Class<?>>> typesBySubscriber;

也就是说这个属性能够告诉我们，某个订阅者。订阅了哪些參数类型

通过这个记录。我们能够为某个订阅者解除订阅，看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) { unubscribeByEventType(subscriber, eventType);//为该类型解除订阅 } typesBySubscriber.remove(subscriber); } else { Log.w(TAG, "Subscriber to unregister was not registered before: " + subscriber.getClass()); } }

/** Only updates subscriptionsByEventType, not typesBySubscriber! Caller must update typesBySubscriber. */private void unubscribeByEventType(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中找到參数类型列表中的subscription队列，再在队列中找到订阅者subscriber，将它们从队列清除

这样就实现了解除订阅。

OK。subscribe()方法的最后，另一个关于sticky的推断，这个我们后面再讲，也就是subscribe()方法先说到这，register()方法也说到这。

下一篇文章。我会继续讲post()方法的实现。

假设对文章内容有不论什么疑惑，欢迎留言。

转载请注明出处。