上一篇文章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 block
private 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()方法的实现。
假设对文章内容有不论什么疑惑，欢迎留言。
转载请注明出处。