本文EventBus源码基于3.1.1版本
前言
EventBus是Android开发最常使用到的通信框架，它的源码和设计相对简单，学习开源框架，就从EventBus开始吧。
它的全部代码结构如下：
以上是EventBus的所有代码
EventBus基于观察者模式，即订阅—— 发布为核心流程的事件分发机制，发布者将事件(event)发送到总线上，然后EventBus根据已注册的订阅者(subscribers)来匹配相应的事件，进而把事件传递给订阅者。流程示意图如下：
image
源码分析
EventBus.getDefault().register(Object o)
EventBus使用register()方法进行注册，并传入一个该观察者subscriber。
getDefault()方法使用双重检验锁创建一个EventBus单例：
public static EventBus getDefault() {
if (defaultInstance == null) {
synchronized (EventBus.class) {
if (defaultInstance == null) {
defaultInstance = new EventBus();
}
}
}
return defaultInstance;
}
EventBus.register()方法传入需要注册的观察者，通常是Activity/Fragment。
public void register(Object subscriber) {
Class<?> subscriberClass = subscriber.getClass();
List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
synchronized (this) {
for (SubscriberMethod subscriberMethod : subscriberMethods) {
//subscribe()方法将subscriber与订阅方法关联起来
subscribe(subscriber, subscriberMethod);
}
}
}
并通过SubscriberMethodFinder.findSubscriberMethods()方法获取订阅类的订阅方法SubscriberMethod列表：
List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
//METHOD_CACHE是一个Map<Class<?>, List<SubscriberMethod>>，保存该类的所有订阅方法
List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass);
if (subscriberMethods != null) {
return subscriberMethods;
}
if (ignoreGeneratedIndex) {
//通过反射去获取被该类中@Subscribe 所修饰的方法
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;
}
}
解析：
- 如果缓存中有对应class的订阅方法列表，则直接返回------此时是第一次创建，subscriberMethods应为空；
- 通过ignoreGeneratedIndex参数（默认为false）判断，此时进入else代码块，后面生成subscriberMethods成功的话会加入到缓存中，失败的话会throw异常。
- 先来看一下findUsingReflection()方法，其核心调用的是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];
//判断是否应该添加该方法
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");
}
}
}
checkAdd()方法如下：
boolean checkAdd(Method method, Class<?> eventType) {
// 2 level check: 1st level with event type only (fast), 2nd level with complete signature when required.
// Usually a subscriber doesn't have methods listening to the same event type.
Object existing = anyMethodByEventType.put(eventType, method);
if (existing == null) {
return true;
} else {
if (existing instanceof Method) {
if (!checkAddWithMethodSignature((Method) existing, eventType)) {
// Paranoia check
throw new IllegalStateException();
}
// Put any non-Method object to "consume" the existing Method
anyMethodByEventType.put(eventType, this);
}
return checkAddWithMethodSignature(method, eventType);
}
}
解析：
- 在anyMethodByEventType（Map）中检查判断eventType的类型，没有返回ture；
- 判断方法的完整签名，checkAddWithMethodSignature如下：
private boolean checkAddWithMethodSignature(Method method, Class<?> eventType) {
methodKeyBuilder.setLength(0);
methodKeyBuilder.append(method.getName());
methodKeyBuilder.append('>').append(eventType.getName());
String methodKey = methodKeyBuilder.toString();
//获取当前方法所在的类的类名
Class<?> methodClass = method.getDeclaringClass();
////给subscriberClassByMethodKey赋值，并返回上一个相同key的 类名
Class<?> methodClassOld = subscriberClassByMethodKey.put(methodKey, methodClass);
//未添加过该参数的方法；另外的类添加过但是是该类的同类/父类
if (methodClassOld == null || methodClassOld.isAssignableFrom(methodClass)) {
// Only add if not already found in a sub class
return true;
} else {
// Revert the put, old class is further down the class hierarchy
subscriberClassByMethodKey.put(methodKey, methodClassOld);
return false;
}
}
A.isAssignableFrom(B)方法判断A与B是否为同一个类/接口或者A是B的父类。
- findUsingInfo()方法
private List<SubscriberMethod> findUsingInfo(Class<?> subscriberClass) {
//创建一个新的FindState类----FindState池中取出可用的FindState，如果没有则直接new一个新的FindState对象
FindState findState = prepareFindState();
findState.initForSubscriber(subscriberClass);
while (findState.clazz != null) {
//此时应返回的是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);
}
getSubscriberInfo()方法如下：初始化时findState.subscriberInfo和subscriberInfoIndexes为空，所以这里直接返回null
private SubscriberInfo getSubscriberInfo(FindState findState) {
if (findState.subscriberInfo != null && findState.subscriberInfo.getSuperSubscriberInfo() != null) {
SubscriberInfo superclassInfo = findState.subscriberInfo.getSuperSubscriberInfo();
if (findState.clazz == superclassInfo.getSubscriberClass()) {
return superclassInfo;
}
}
if (subscriberInfoIndexes != null) {
for (SubscriberInfoIndex index : subscriberInfoIndexes) {
SubscriberInfo info = index.getSubscriberInfo(findState.clazz);
if (info != null) {
return info;
}
}
}
return null;
}
getMethodsAndRelease()方法：
private List<SubscriberMethod> getMethodsAndRelease(FindState findState) {
//从findState获取subscriberMethods，放进新的ArrayList
List<SubscriberMethod> subscriberMethods = new ArrayList<>(findState.subscriberMethods);
//回收findState
findState.recycle();
//findState存储在FindState池中，方便下一次使用，提高性能
synchronized (FIND_STATE_POOL) {
for (int i = 0; i < POOL_SIZE; i++) {
if (FIND_STATE_POOL[i] == null) {
FIND_STATE_POOL[i] = findState;
break;
}
}
}
return subscriberMethods;
}
至此，register方法中拿到了subscriberMethod的list，然后遍历List<SubscriberMethod>，通过subscribe方法将每个SubscriberMethod和订阅者关联。
subscribe方法如下：
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 {
//同一个Subscriber中不能有相同的订阅事件方法
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 {
//根据eventType，从stickyEvents列表中获取特定的事件
Object stickyEvent = stickyEvents.get(eventType);
checkPostStickyEventToSubscription(newSubscription, stickyEvent);
}
}
}
分析：
- 首先，使用每一个subscriber和subscriberMethod创建一个Subscription，类似一个键值对；
- 根据subscriberMethod.eventType作为Key，在subscriptionsByEventType的Map中查找一个CopyOnWriteArrayList<Subscription>的list ，如果没有则创建一个新的CopyOnWriteArrayList；然后将这个CopyOnWriteArrayList作为subscriberMethod.eventType的value放入subscriptionsByEventType中；
- 根据优先级添加newSubscription，优先级越高，在List中的位置越靠前；
- 向typesBySubscriber中添加subscriber和本subscriber的所有订阅事件。typesBySubscriber是一个保存所有subscriber的Map，key为subscriber，value为该subscriber的所有订阅事件，即所有的eventType列表；
- 最后，判断是否是sticky。如果是sticky事件的话，到最后会调用checkPostStickyEventToSubscription()方法分发事件。
网友评论