EventBus源码分析

最新推荐文章于 2022-09-21 16:08:21 发布

CodeInfo_

最新推荐文章于 2022-09-21 16:08:21 发布

阅读量334

点赞数

分类专栏： Android源码之路文章标签： android

本文链接：https://blog.csdn.net/a8082649/article/details/107748908

版权

Android源码之路专栏收录该内容

6 篇文章 0 订阅

订阅专栏

## 总结

1. 需要先通过register接口进行注册为订阅者，订阅方法才能生效，不再接收消息的时候主动调用
unregister取消注册，也避免内存泄漏(特别是一些有生命周期的activity等)；

2. 只有通过注释@Subscribe声明为订阅者方法(消息处理)才能接收EventBus接口发送的消息，并且要求必须是public，非sstatic，非abstract,而且入参数量只能是1个;

3. @Subscribe注释提供了3个属性字段：

3.1 threadMode: 指明订阅方法允许在哪个线程上，默认为；

3.2 sticky: 指明是否是粘性事件，默认false；

3.3 priority：指明订阅方法的优先级，越大优先级越高，默认为0；

4. threadMode目前支持：

4.1 POSTING ：运行在与事件发送方相同的线程上，堵塞执行；

4.2 MAIN ：运行在主线程，如果当前发送方式主线程，则立马堵塞并执行，否则进入排队等待主线程Handler执行；

4.3 MAIN_ORDERED ：运行在主线程，与main的区别在于，MAIN_ORDERED都是排队执行，如果发送方当前是主线程的话，不会堵塞当前线程，而main则是如果当前是主线程会堵塞主线程直到订阅方法执行完毕；

4.4 BACKGROUND ：运行在后台线程，如果当前post发送方是主线程，进入后台线程排队，如果当前post发送方是后台线程，则直接堵塞该线程并执行；

4.5 ASYNC ：运行在异步线程，无论如何都另起线程来执行订阅方法，与post发送方所在线程不同，与BACKGROUND都是非主线程，但是async一定会另起线程执行。

5. 发送的粘性事件默认会被缓存，并且相同类型的事件只会缓存当前最新的一个；

6. 粘性事件与普通事件的差别：

6.1 普通事件：发送普通事件的时候，只有已经注册成功的同事件类型的订阅者方才能够接收到该普通事件。事件发送后不会被缓存，在发送之后注册的同类型的订阅者方法无法接收到该事件；

6.2 粘性事件：发送粘性事件的时候，已经注册同事件类型的订阅者方法(sticky=true)能够接收到该通事件。并且框架对每一种事件类型都默认会缓存最新的一个粘性事件，也就是说在发送结束后再进行注册的同事件类型的粘性订阅者方法(sticky=true)会立马再次接受到该最新的粘性事件；

7. 框架不会主动删除粘性事件，需要手动调用removeStickyEvent移除粘性事件，否则最后一个粘性事件会一直被缓存着,每次重新注册同事件类型的粘性订阅者方法时，都会再次执行该事件；

8. 发送消息事件Class A后，接收该事件类型A的订阅方法、接收A的父类的订阅方法、接收A实现的接口的订阅方法等，都会触发执行；

10. 子类会从父类继承订阅者方法;

11. 子类与父类不能同时进行regisrer注册，否则会抛出异常,其实就是一个类中register不能连续调用2次;

## 源码分析

EventBus源码最关键的就是几个用来缓存的集合，搞懂其左右基本就明白了大体上的实现思路了：
(源码阅读建议fork或者下载源码到android studio中查看，代码路径 https://github.com/yangjinze/EventBus 记得切换到代码注释版本分支)

```
public class EventBus {

/**
* 缓存事件类型对应的继承体系和实现的接口列表，避免每次都重复解析获取
*
* key : 发送的事件对应的class，比如 post("123")， key则为String.class
* value : 事件class、事件实现的接口、事件的父类、父类实现的接口、父类的父类......这一连串有继承关系和接口实现关系的类集合
*
* 发送一个事件时，事件类型为其父类或者接口的订阅者方法也能被触发，比如：
*
* 假设A.class , B extends A , B implements C接口
* @Subscribe()
* public void subsA(A a) {}
* @Subscribe()
* public void subsC(C c) {}
* @Subscribe()
* public void subsB(B b) {}
*
* 则Post(B)的时候，上述3个订阅者方法都会被执行
*/
private static final Map<Class<?>, List<Class<?>>> eventTypesCache = new HashMap<>();

/**
* 存放订阅方法的接收的消息入参class --> 对应的订阅Subscription对象列表
*
*
* 作用：进行post(消息)的时候,根据消息.class 就可以取出ubscription对象列表，然后逐一执行里面的订阅者方法
*/
private final Map<Class<?>, CopyOnWriteArrayList<Subscription>> subscriptionsByEventType;
/**
* 存放订阅者 -> 所拥有的订阅方法的入参class列表
*
* 订阅者: 调用register传入的对象，比如 FirstActivity.this
* 订阅方法的入参class列表:
* 假设 FirstActivity 存在2个订阅者方法
* @Subscribe
* public void test(String msg)
* @Subscribe
* public void test(int type)
* 则对应列表[String.class, Integer.class]
*
* 作用：下次根据unregister传入的对象，比如 FirstActivity.this就可以获取到列表 [String.class, Integer.class]
* 然后就可以从 subscriptionsByEventType 得到String.class 和 Integer.class对应的订阅方法对象列表
* 遍历订阅对象一致，则移除FirstActivity.this包含的所有订阅方法
*/
private final Map<Object, List<Class<?>>> typesBySubscriber;
/**
* 粘性事件缓存,比如postSticky("123")
* 则缓存String.class --> "123" ，可见对于每一个类型的事件只会缓存最新的粘性事件
*/
private final Map<Class<?>, Object> stickyEvents;

}
```

### 注册相关 register与unregister

#### register

传入需要注册的对象，eventBus会去解析该对象中存在的订阅者方法，并与该对象建立联系关系：

```
//subscriber :订阅者，比如FirstActivity.this
public void register(Object subscriber) {
//获取到订阅者的类型，比如FirstActivity.class
Class<?> subscriberClass = subscriber.getClass();
//获取订阅者中符合条件的@Subscribe标注的订阅者方法列表
List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);

//这边遍历解析到的结果，根据优先级缓存在subscriptionsByEventType列表中，
//并且会判断是否是粘性订阅方法，是且存在符合的粘性事件时，则触发处理
synchronized (this) {
for (SubscriberMethod subscriberMethod : subscriberMethods) {
subscribe(subscriber, subscriberMethod);
}
}
}
```

##### findSubscriberMethods

获取订阅者中符合条件的@Subscribe标注的订阅者方法列表：

```
List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
//判断这个类相关订阅方法是否解析过了，解析过则从缓存中读取，
// 比如这样就避免了每次进入FirstActivity时执行register都需要重新再解析一遍
List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass);
if (subscriberMethods != null) {
return subscriberMethods;
}
//没缓存，重新解析，ignoreGeneratedIndex默认是false
//属性表示是否忽略注解器生成的MyEventBusIndex
if (ignoreGeneratedIndex) {
subscriberMethods = findUsingReflection(subscriberClass);
} else {
//解析得到订阅者方法列表
subscriberMethods = findUsingInfo(subscriberClass);
}

if (subscriberMethods.isEmpty()) {
//调用register注册的订阅者，如果不存在符合条件的订阅者方法，则抛出异常
throw new EventBusException("Subscriber " + subscriberClass
+ " and its super classes have no public methods with the @Subscribe annotation");
} else {
//缓存解析到的订阅者类对应的订阅者方法列表，比如 FirstActivity - List<subscriberMethod>
METHOD_CACHE.put(subscriberClass, subscriberMethods);
return subscriberMethods;
}
}
```

##### findUsingInfo

实际解析并得到订阅方法列表的执行步骤

```
//subscriberClass:订阅者对应的类，比如FirstActivity.class
private List<SubscriberMethod> findUsingInfo(Class<?> subscriberClass) {
FindState findState = prepareFindState();
findState.initForSubscriber(subscriberClass);
//初始 findState.clazz = subscriberClass
while (findState.clazz != null) {
//获取订阅者的相关信息
findState.subscriberInfo = getSubscriberInfo(findState);
//一开始为null
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 {
//解析该subscriberClass,比如FirstActivity，将其中的订阅者方法存放在列表
findUsingReflectionInSingleClass(findState);
}
//递归搜索父类中的订阅者方法，默认会进行父类搜索
//所以在父类中的订阅者方法也会一并被继承过来并且生效
findState.moveToSuperclass();
}
//返回解析到的订阅者方法列表，并释放资源
return getMethodsAndRelease(findState);
}
```

##### findUsingReflectionInSingleClass

private void findUsingReflectionInSingleClass(FindState findState) {
Method[] methods;
try {
//获取订阅者类所有的方法
methods = findState.clazz.getDeclaredMethods();
} catch (Throwable th) {
// Workaround for java.lang.NoClassDefFoundError, see https://github.com/greenrobot/EventBus/issues/149
try {
methods = findState.clazz.getMethods();
} catch (LinkageError error) { // super class of NoClassDefFoundError to be a bit more broad...
String msg = "Could not inspect methods of " + findState.clazz.getName();
if (ignoreGeneratedIndex) {
msg += ". Please consider using EventBus annotation processor to avoid reflection.";
} else {
msg += ". Please make this class visible to EventBus annotation processor to avoid reflection.";
}
throw new EventBusException(msg, error);
}
findState.skipSuperClasses = true;
}
//遍历获取到的方法
for (Method method : methods) {
int modifiers = method.getModifiers();
//method必须是public，并且不能是static、abstract、桥接方法，订阅者方法的第一点限制
if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {
//获取method入参列表对应的class数组，按顺序
Class<?>[] parameterTypes = method.getParameterTypes();
//这边限制了参数个数只能是1个,订阅者方法的第二点限制
if (parameterTypes.length == 1) {
//获取该方法上的@Subscribe注解,订阅者方法的第三点限制，必须要用@Subscribe注解声明
Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);
if (subscribeAnnotation != null) {
//得到入参对应的class类，比如String.class
Class<?> eventType = parameterTypes[0];
if (findState.checkAdd(method, eventType)) {
//获取注解中threadMode的值,用于指定订阅者方法运行在哪个线程
ThreadMode threadMode = subscribeAnnotation.threadMode();
//将订阅者方法存放在该list中; SubscriberMethod构造对应订阅者方法method，入参class，注解中的3个参数
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");
}
}
}

#### subscribe

这边遍历解析到的结果，根据优先级缓存在subscriptionsByEventType列表中，并且会判断是否是粘性订阅方法，是且存在符合的粘性事件时，则触发处理

```
private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
Class<?> eventType = subscriberMethod.eventType; //method，入参对应的class，比如String.class
//订阅对象，存放订阅者对象与订阅方法对象 , FirstActivity.this 与 SubscriberMethod
Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
/***
* CopyOnWriteArrayList是线程安全的List
*
* 获取入参类型对应的订阅列表,这样可以在进行post的时候，直接根据发送的消息参数.class
* 获取到需要执行的订阅者方法了吧，逐一进行调用
* ***/
CopyOnWriteArrayList<Subscription> subscriptions = subscriptionsByEventType.get(eventType);
if (subscriptions == null) {
subscriptions = new CopyOnWriteArrayList<>();
subscriptionsByEventType.put(eventType, subscriptions);
} else {
//如果这个订阅者方法已经添加过，重复添加则抛出异常；
//1.调用了2次register导致这种情况；
//2.父类调用了register，子类又调用了register，这样在子类中也会导致这种情况；
if (subscriptions.contains(newSubscription)) {
throw new EventBusException("Subscriber " + subscriber.getClass() + " already registered to event "
+ eventType);
}
}

//根据@Subscribe中参数priority指定的优先级存放找个订阅对象
int size = subscriptions.size();
for (int i = 0; i <= size; i++) {
//priority越大，优先级越高，放在越前面，更早被调用
if (i == size || subscriberMethod.priority > subscriptions.get(i).subscriberMethod.priority) {
subscriptions.add(i, newSubscription);
break;
}
}

//缓存这个订阅者对象，比如FirstActivity.this，所拥有的订阅方法入参class列表
//作用可以参考typesBySubscriber属性注释
List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber);
if (subscribedEvents == null) {
//TODO ArrayList存在不妥的地方，应该用Set集合来避免添加了相同的Class
//不过一般一个订阅者也不会存在相同入参类型的订阅者方法
subscribedEvents = new ArrayList<>();
typesBySubscriber.put(subscriber, subscribedEvents);
}
subscribedEvents.add(eventType);

//处理粘性事件，有符合事件类型的，则执行
//注意的是这边粘性事件执行完，并不会从缓存中清除粘性事件，也就是下次再次注册或者有相关事件类型的定义方法注册时，都会再次执行这个粘性事件。
//粘性事件的删除需要主动删除，因为毕竟框架不清楚到底这个粘性事件有多少地方需要执行
if (subscriberMethod.sticky) {
if (eventInheritance) {//默认是true
// 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();
//eventType是candidateEventType的父类，或者2者同一类型时，返回true
if (eventType.isAssignableFrom(candidateEventType)) {
Object stickyEvent = entry.getValue();
checkPostStickyEventToSubscription(newSubscription, stickyEvent);
}
}
} else {
Object stickyEvent = stickyEvents.get(eventType);
checkPostStickyEventToSubscription(newSubscription, stickyEvent);
}
}
}
```

#### unregister

从typesBySubscriber获取该对象包含了几种入参类型不一样的订阅方法，比如有String.class和Man.class这2种。

然后从subscriptionsByEventType分别获取String.class和Man.class对应的所有订阅者方法列表，判断与之联系的订阅对象是否是subscriber，是则删除。
```

/**
* 取消注册，并且清除对应的订阅方法列表
* 避免一直缓存了该对象，导致内存泄漏
*
* @param subscriber
*/
public synchronized void unregister(Object subscriber) {
//获取该对象，比如FirstActivity.this所拥有的订阅方法消息入参class列表
List<Class<?>> subscribedTypes = typesBySubscriber.get(subscriber);
if (subscribedTypes != null) {
//遍历入参class列表
for (Class<?> eventType : subscribedTypes) {
//传入订阅者对象，与入参class
unsubscribeByEventType(subscriber, eventType);
}
//移除缓存的这个对象与列表
typesBySubscriber.remove(subscriber);
} else {
logger.log(Level.WARNING, "Subscriber to unregister was not registered before: " + subscriber.getClass());
}
}
```

##### unsubscribeByEventType

判断eventType对应的事件列表中的订阅者方法，如果与之联系的订阅者对象为subscriber，则移除该方法；

```
//subscriber调用unregister传入的对象，比如FirstActivity.this

private void unsubscribeByEventType(Object subscriber, Class<?> eventType) {
//获取入参class所对应的订阅方法对象列表
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);
//如果这个订阅者方法是该subscriber所有的，则进行移除
if (subscription.subscriber == subscriber) {
subscription.active = false;
subscriptions.remove(i);
i--;
size--;
}
}
}
}
```

### 消息发送：post或postSticky

#### post

发送给定的事件到消息事件总线。

```
public void post(Object event) {
PostingThreadState postingState = currentPostingThreadState.get();
List<Object> eventQueue = postingState.eventQueue;
//将要发送的消息添加进事件队列
eventQueue.add(event);

if (!postingState.isPosting) {
//当前是否在主线程
postingState.isMainThread = isMainThread();
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;
}
}
}
```

##### postSingleEvent

```
/**
* 发送一个事件
*
* @param event 要发送的事件,EventBus.getDefault().post(event);
* @param postingState
* @throws Error
*/
private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
//event要发送的事件对象，获取事件class类型，比如String.class
Class<?> eventClass = event.getClass();
boolean subscriptionFound = false;
//默认是true
if (eventInheritance) {
//递归获取事件class类型的相关父类，实现的接口，父类实现的接口
//也就是说相应入参为父类、实现的接口的订阅方法，都能被调用到
//调用顺序为事件class > 接口 > 父类 > 父类接口 > 父类的父类 > 父类的父类接口.....
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) {
logger.log(Level.FINE, "No subscribers registered for event " + eventClass);
}
if (sendNoSubscriberEvent && eventClass != NoSubscriberEvent.class &&
eventClass != SubscriberExceptionEvent.class) {
post(new NoSubscriberEvent(this, event));
}
}
}
```

##### postSingleEventForEventType

```
/**
* 发送事件
*
* @param event 事件对象 ,比如post("123")，则为"123"
* @param postingState
* @param eventClass 事件类型， "123"对应String.class ，看调用的地方，也可能为其父类或者实现的接口
* @return
*/
private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class<?> eventClass) {
CopyOnWriteArrayList<Subscription> subscriptions;
synchronized (this) {
//获取该事件类型对应的订阅方法对象列表
subscriptions = subscriptionsByEventType.get(eventClass);
}
if (subscriptions != null && !subscriptions.isEmpty()) {
//Subscription存放每个订阅者方法与订阅者对象
for (Subscription subscription : subscriptions) {
postingState.event = event;
postingState.subscription = subscription;
boolean aborted;
try {
//将事件传递给订阅方法@Subscribe
postToSubscription(subscription, event, postingState.isMainThread);
aborted = postingState.canceled;
} finally {
postingState.event = null;
postingState.subscription = null;
postingState.canceled = false;
}
if (aborted) {
break;
}
}
return true;
}
return false;
}
```

##### postToSubscription

根据指定的线程类型，开始调度执行

```
private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {
//根据@Subscribe里面threadMode所指定的线程做处理
switch (subscription.subscriberMethod.threadMode) {
case POSTING://默认的运行方式，运行在与发送方(post调用所在的线程)相同的线程，堵塞并直接执行
//堵塞并执行的意思是，post之后立马执行订阅者方法后，再接着执行post后面的代码
invokeSubscriber(subscription, event);
break;
case MAIN://运行在主线程
if (isMainThread) {//如果当前post发送方就是在主线程，堵塞并直接执行
invokeSubscriber(subscription, event);
} else {//如果当前post发送方不在主线程，最终由handler切换到主线程执行
mainThreadPoster.enqueue(subscription, event);
}
break;
case MAIN_ORDERED://运行在主线程
//与main的区别在于，MAIN_ORDERED都是排队执行，如果发送方当前是主线程的话，不会堵塞当前线程，
//而main则是如果当前是主线程会堵塞主线程直到订阅方法执行完毕
if (mainThreadPoster != null) {
mainThreadPoster.enqueue(subscription, event);
} else {
// temporary: technically not correct as poster not decoupled from subscriber
invokeSubscriber(subscription, event);
}
break;
case BACKGROUND://运行在后台线程(非主线程)
if (isMainThread) {//如果当前post发送方是主线程，进入后台线程排队
backgroundPoster.enqueue(subscription, event);
} else {//如果当前post发送方是后台线程，则直接堵塞该线程并执行
invokeSubscriber(subscription, event);
}
break;
case ASYNC://运行在异步线程，无论如何都另起线程来执行订阅方法，与post发送方所在线程不同
asyncPoster.enqueue(subscription, event);
break;
default:
throw new IllegalStateException("Unknown thread mode: " + subscription.subscriberMethod.threadMode);
}
}
```

#### postSticky

发送3个同事件类型class的粘性事件结束后，再进行粘性方法的注册，这时候只会接收到最后一个最新的粘性事件，而不是3个都能再次接收。

已经注册的同事件类型的方法无论是不是粘性方法都可以接收并执行。

```
private final Map<Class<?>, Object> stickyEvents = new ConcurrentHashMap<>();

public void postSticky(Object event) {
//缓存粘性事件,每种事件类型只会缓存最新的一个
synchronized (stickyEvents) {
stickyEvents.put(event.getClass(), event);
}
//执行正常的事件发送，无论是不是粘性方法，已经注册的同事件类型的方法都可以接收并执行
post(event);
}
```

微信公众号

CodeInfo_

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
EventBus源码分析

## 总结1. 需要先通过register接口进行注册为订阅者，订阅方法才能生效，不再接收消息的时候主动调用unregister取消注册，也避免内存泄漏(特别是一些有生命周期的activity等)；2. 只有通过注释@Subscribe声明为订阅者方法(消息处理)才能接收EventBus接口发送的消息，并且要求必须是public，非sstatic，非abstract,而且入参数量只能是1个;3. @Subscribe注释提供了3个属性字段： 3.1 threadMode: 指明...
复制链接

扫一扫

专栏目录