EventBus的api很简单:
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
findViewById(R.id.btn).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
EventBus.getDefault().post(new MyEvent(123));
}
});
}
@Override
protected void onResume() {
super.onResume();
EventBus.getDefault().register(this);
}
@Override
protected void onPause() {
super.onPause();
EventBus.getDefault().unregister(this);
}
@Subscribe(threadMode = ThreadMode.MAIN)
public void onMyEvent(MyEvent event) {
Log.d("testtest", "onMyEvent " + event.data);
}
}
class MyEvent {
public int data;
MyEvent(int data) {
this.data = data;
}
}
注册监听的原理
坦白讲内部的实现原理也挺简单的，我们从注册开始看:
public void register(Object subscriber) {
Class<?> subscriberClass = subscriber.getClass();
// 从subscriber的class从查找回调方法
List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
synchronized (this) {
for (SubscriberMethod subscriberMethod : subscriberMethods) {
// SubscriberMethod里面是方法的反射，所以需要绑定回调方法和观察者对象
subscribe(subscriber, subscriberMethod);
}
}
}
private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
Class<?> eventType = subscriberMethod.eventType;
Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
// 使用Event的class做key，查找这个Event的所有观察者
CopyOnWriteArrayList<Subscription> subscriptions = subscriptionsByEventType.get(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;
}
}
...
}
使用Finder从对象的Class中查找注册的回调方法的信息，使用Subscription将调用者与方法信息绑定起来，然后使用Event的Class作为key将它放到subscriptionsByEventType这个map中。由于同一种Event可能会有多个观察者，所以map的value是一个按优先级排序的List。
SubscriberMethod和Subscription的定义如下:
public class SubscriberMethod {
final Method method; // 回调方法
final ThreadMode threadMode; // 回调的线程策略
final Class<?> eventType; // 监听的事件类型
final int priority; // 优先级
final boolean sticky; // 是否监听粘性事件
...
}
final class Subscription {
final Object subscriber; //观察者的对象引用，可以用来反射调用subscriberMethod.method
final SubscriberMethod subscriberMethod;
...
}
从上面可以大概猜出来，事件的分发实际是反射调用的方法。
也就是说当我们使用post方法发送Event的时候就能用Event的Class查找到所有的Subscription，通过Subscription的subscriber找到注册的对象、subscriberMethod找到注册的方法，接着就能使用反射去进行分发。
整个注册的流程大体上是比较清晰的，但是findSubscriberMethods的查找注册信息流程中有些小的细节也比较值得学习。
1.缓存
第一点是扫描完一个class之后会将监听的信息放入METHOD_CACHE缓存中，例如我们的demo，onResume的时候register，onPause的时候unregister，就能减少第二次onResume的耗时。
List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
// METHOD_CACHE会保存查找过的subscriberClass的监听信息，防止重复查找耗时
List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass);
if (subscriberMethods != null) {
return subscriberMethods;
}
...
subscriberMethods = findUsingInfo(subscriberClass);
...
// 加入缓存，下次可以直接使用
METHOD_CACHE.put(subscriberClass, subscriberMethods);
return subscriberMethods;
...
}
2.APT生成索引
第二点就是由于反射遍历类方法去查找被@Subscribe修饰的方法比较耗时，所以可以使用apt编译时根据注解生成代码的方式直接生成索引:
private List<SubscriberMethod> findUsingInfo(Class<?> subscriberClass) {
FindState findState = prepareFindState();
findState.initForSubscriber(subscriberClass);
while (findState.clazz != null) {
// 优先从apt生成的索引查找，如果找不到就是用反射去遍历class，查找@Subscribe修饰的方法
findState.subscriberInfo = getSubscriberInfo(findState);
if (findState.subscriberInfo != null) {
...
} else {
// 使用反射查找
findUsingReflectionInSingleClass(findState);
}
findState.moveToSuperclass();
}
return getMethodsAndRelease(findState);
}
apt创建索引的使用方法见官方文档
3.对象池减少内存碎片
第三就是FindState是一个辅助查找的工具类，为了避免应用初始化的时候多个类都在注册到EventBus，导致这个FindState创建消耗多次，产生内存碎片，所以它使用类对象池技术:
// 获取
private FindState prepareFindState() {
synchronized (FIND_STATE_POOL) {
for (int i = 0; i < POOL_SIZE; i++) {
FindState state = FIND_STATE_POOL[i];
if (state != null) {
FIND_STATE_POOL[i] = null;
return state;
}
}
}
return new FindState();
}
// 回收
private List<SubscriberMethod> getMethodsAndRelease(FindState findState) {
List<SubscriberMethod> subscriberMethods = new ArrayList<>(findState.subscriberMethods);
findState.recycle();
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;
}
消息分发原理
上面我们看完了注册，实际上分发的流程大概也能猜出来了。不过这里面还是有蛮多小细节同样值得学习的。
1.Event Queue
EventBus的Event分发并不是直接循环遍历观察者进行分发，而是先将Event放到队列中，然后再去队列里面拿出来分发。
PostingThreadState使用了ThreadLocal，每条线程都有自己的Event队列，而且isPosting能够记录当前的线程是否正在分发Event。
也就是说如果在Event的回调中再去post一个Event，并不会立刻分发，而是会等之前的Event都分发完之后在去分发。
public void post(Object event) {
PostingThreadState postingState = currentPostingThreadState.get();
List<Object> eventQueue = postingState.eventQueue;
//将Event丢到队列中
eventQueue.add(event);
if (!postingState.isPosting) { // 是否正在分发,例如在监听的回调中post,isPosting就是true
postingState.isMainThread = isMainThread();
postingState.isPosting = true;
if (postingState.canceled) {
throw new EventBusException("Internal error. Abort state was not reset");
}
try {
// 从队列中拿出Event进行分发，直至队列为空
while (!eventQueue.isEmpty()) {
postSingleEvent(eventQueue.remove(0), postingState);
}
} finally {
postingState.isPosting = false;
postingState.isMainThread = false;
}
}
}
这里有个小坑:threadMode是POSTING，只能代表回调是在post的线程调用的，并不能代表post方法里面会立即调用
2.eventInheritance
当一个观察者监听的是父类，如果post了一个子类的Event，默认情况下观察者是可以接收到这个子类的Event。这是因为默认情况下EventBusBuilder.eventInheritance为true:
boolean eventInheritance = true;
如果不想要这个功能我们可以设置成false。它的原理在postSingleEvent里面可以看到:
private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
Class<?> eventClass = event.getClass();
boolean subscriptionFound = false;
if (eventInheritance) {
// 如果eventInheritance为true，查找eventClass的父类、实现的interface等去分发
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 {
// eventInheritance为false则只分发这个eventClass
subscriptionFound = postSingleEventForEventType(event, postingState, eventClass);
}
...
}
postSingleEventForEventType方法就是根据Class查找register的对应Subscription，调用postToSubscription进行实际的分发操作
private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class<?> eventClass) {
CopyOnWriteArrayList<Subscription> subscriptions;
synchronized (this) {
subscriptions = subscriptionsByEventType.get(eventClass);
}
if (subscriptions != null && !subscriptions.isEmpty()) {
for (Subscription subscription : subscriptions) {
...
postToSubscription(subscription, event, postingState.isMainThread);
...
}
return true;
}
return false;
}
3.threadMode原理
postToSubscription内部就会根据不同的threadMode在不同线程使用反射调用注册的方法:
private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {
switch (subscription.subscriberMethod.threadMode) {
case POSTING:
..
break;
case MAIN:
...
break;
case MAIN_ORDERED:
...
break;
case BACKGROUND:
...
break;
case ASYNC:
...
break;
default:
...
}
}
