今天开始拆分EventBus源码，废话少说，五步骤，如何使用，源码解析，学到了什么，有什么不足之处
第一部分：如何使用
//第二步：注册 接收类
EventBus.getDefault().register(this);
//第三步，发送事件 发送事件 事件参数
EventBus.getDefault().post(new Object());
//第四步，注销注册
EventBus.getDefault().unregister(this);
//第一步，添加接收通知事件的方法 接收方法 接收方法参数
@Subscribe(threadMode = ThreadMode.POSTING)
public void dealEventBus(Object o){
}1.添加接收方法，名字随意，参数需要啥参数就写啥参数就行，必须要添加注解，可以指定该方法执行的线程，默认为在发送通知的线程
2.注册，必须要有第一步才可以注册，否则会报错，提示没有找到接收通知的方法
3.发送事件，同一进程任意线程，任意地方发送都可以，事件参数类型必须要和接收方法参数类型一致
4.反注册，页面关闭或者不需要的时候必须要反注册，否则会发生内存泄漏。
第二部分：源码解析
1.我们先看添加接收事件方法的注解
@Retention(RetentionPolicy.RUNTIME)//注解的生命长度，一直到jvm加载时
@Target({ElementType.METHOD}) //注解的使用范围，方法上
public @interface Subscribe {
//接收通知事件执行线程模式
ThreadMode threadMode() default ThreadMode.POSTING;
/**
* If true, delivers the most recent sticky event (posted with
* {@link EventBus#postSticky(Object)}) to this subscriber (if event available).
*/
//表示这是一个粘性事件，也就是说可以先发通知，再去注册接收，也同样可以收到已经发送过的通知
boolean sticky() default false;
/** Subscriber priority to influence the order of event delivery.
* Within the same delivery thread ({@link ThreadMode}), higher priority subscribers will receive events before
* others with a lower priority. The default priority is 0. Note: the priority does *NOT* affect the order of
* delivery among subscribers with different {@link ThreadMode}s! */
//接收通知事件方法的优先级，影响事件的执行传递顺序，默认为0
int priority() default 0;
}三个点：一是定义了粘性事件，何为粘性事件？就是我们可以先发送通知，然后再注册接收者，接收者同样可以接收到已经发送过的最新通知。二是接收方法的优先级，默认为0级，级别越高，则会越优先接收到通知。三是接收方法的所在线程可以指定，默认为发送事件所在的线程，而发送事件默认所在线程为创建eventbus所在线程。所以，事件接收方法完整写法为:
//第一步，添加接收通知事件的方法
@Subscribe(threadMode = ThreadMode.POSTING,priority = 1,sticky = false)
public void dealEventBus(Object o){
}threadMode我们可以看看都有什么：
public enum ThreadMode {
POSTING,
MAIN,
MAIN_ORDERED,
BACKGROUND,
ASYNC
}五种，分别为：
posting:发送事件所在线成(默认)，如果是主线程，则不可以做太耗时操作
main:主线程，不可以做耗时操作，可以理解为同时将事件交给所有订阅者
main_ordered:主线程，不可以做耗时操作，按照顺序依次交给所有订阅者
background:子线程，会有线程池来处理
async:异步线程，不是主线程也不是发布线程，是第三个线程，例如网络请求
2.注解方法源码：
public static EventBus getDefault() {
EventBus instance = defaultInstance;
if (instance == null) {
synchronized (EventBus.class) {
instance = EventBus.defaultInstance;
if (instance == null) {
instance = EventBus.defaultInstance = new EventBus();
}
}
}
return instance;
}单例模式，话说这个单例模式好特别啊，双重校验，为啥还要有个局部变量？
创建方法:new EventBus();
public EventBus() {
this(DEFAULT_BUILDER);
}
EventBus(EventBusBuilder builder) {
//设置初始化参数
}什么鬼？这不是单例模式啊，我们完全可以自己new一个对象出来，好吧，不过我们也看到了建造者模式。EventBusBuilder，建造者模式也可以创建EventBus实例。也就是说我们有三种方法来拿到EventBus实例
EventBus.getDefault().register(this);
EventBus.builder().build().register();
new EventBus().register();为啥要留这么多方式呢？方便，还可以根据需要修改默认配置，预留出来可扩展性。
这里还需要看看，eventBus类中的几个属性
//默认创建EventBus实例所用builder
private static final EventBusBuilder DEFAULT_BUILDER = new EventBusBuilder();
//缓存事件参数类型以及所有父类、接口的类型，比如说我们发送了一个参数为String类型的事件，那么如果订阅者方法参数为String类型或者为String的父亲CharSequence类型，都可以收到事件
private static final Map<Class<?>, List<Class<?>>> eventTypesCache = new HashMap<>();
//以事件参数类型为key ，接收类信息为value，保存起来
private final Map<Class<?>, CopyOnWriteArrayList<Subscription>> subscriptionsByEventType;
//接收类为key 接收方法为value
private final Map<Object, List<Class<?>>> typesBySubscriber;
//粘性事件集合
private final Map<Class<?>, Object> stickyEvents;
//跟创建实例线程绑定
private final ThreadLocal<PostingThreadState> currentPostingThreadState = new ThreadLocal<PostingThreadState>() {
@Override
protected PostingThreadState initialValue() {
return new PostingThreadState();
}
};
// 主线程事件发送者
private final Poster mainThreadPoster;
//后台线程事件发送者
private final BackgroundPoster backgroundPoster;
//第三者线程事件发送者
private final AsyncPoster asyncPoster;
//订阅者方法查找类
private final SubscriberMethodFinder subscriberMethodFinder;
//后台事件执行线程池
private final ExecutorService executorService=Executors.newCachedThreadPool()；开始注册
/**
* Registers the given subscriber to receive events. Subscribers must call {@link #unregister(Object)} once they
* are no longer interested in receiving events.
* <p/>
* Subscribers have event handling methods that must be annotated by {@link Subscribe}.
* The {@link Subscribe} annotation also allows configuration like {@link
* ThreadMode} and priority.
*/
public void register(Object subscriber) {
//获取接收类
Class<?> subscriberClass = subscriber.getClass();
//查找接收类中接收方法
List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
synchronized (this) {
for (SubscriberMethod subscriberMethod : subscriberMethods) {
//保存接收方法
subscribe(subscriber, subscriberMethod);
}
}
}先看注解，接收类在不关心的时候一定要反注册，也就是页面关闭的时候反注册。接收方法必须要添加Subscribe注解，可以添加threadmode等参数。然后分为三部，获取接收类，查找类中
所有接收方法，将所有接收方法添加到订阅集合中。第二步很关键：
List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
//在缓存中查找是否解析过这个类，如果有，则直接返回
List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass);
if (subscriberMethods != null) {
return subscriberMethods;
}
if (ignoreGeneratedIndex) {//true，进入这个方法
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;
}
}现在缓存中查找是否有，如果有则不再解析，没有则去解析，并且缓存起来。如果解析完发现没有任何接收方法，就会抛异常。findUsingReflection 方法进去看看：
private List<SubscriberMethod> findUsingReflection(Class<?> subscriberClass) {
FindState findState = prepareFindState();
findState.initForSubscriber(subscriberClass);
while (findState.clazz != null) {
//通过反射找到接收类所有方法
findUsingReflectionInSingleClass(findState);
findState.moveToSuperclass();
}
return getMethodsAndRelease(findState);
}我们关注通过反射找到类中方法：
private void findUsingReflectionInSingleClass(FindState findState) {
Method[] methods;
try {
// 默认通过这个找，效率高
methods = findState.clazz.getDeclaredMethods();
} catch (Throwable th) {
try {
//上面方法失败，则换这个找
methods = findState.clazz.getMethods();
} catch (LinkageError error) {
//还不行就抛异常了
throw new EventBusException(msg, error);
}
findState.skipSuperClasses = true;
}
for (Method method : methods) {
int modifiers = method.getModifiers();
if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) { //参数为1个
Class<?>[] parameterTypes = method.getParameterTypes();
if (parameterTypes.length == 1) {
//有Subscribe注解的
Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);
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 {
//异常
}
}
}首先会通过getDeclaredMethods拿到接收类中所有声明的方法，效率最高，如果出现问题则通过getMethods获取接收类中所有方法，在所有方法中查找那些只一个参数且添加了Subscribe注解的方法(方法不能私有、不能是静态方法)，将他们保存起来。那些不符合规则的方法，则会抛出异常。然后就是将这些接收方法，保存起来，并且会按照优先级保存，subscribe方法代码：
// Must be called in synchronized block
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 {
//重复注册，抛异常
}
//将所有都是这个接收参数类型的接收类，按照接收方法设置的优先级排序
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;
}
}
//接收类为key，接收方法为value保存起来
List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber);
if (subscribedEvents == null) {
subscribedEvents = new ArrayList<>();
typesBySubscriber.put(subscriber, subscribedEvents);
}
subscribedEvents.add(eventType);
if (subscriberMethod.sticky) {//如果是粘性事件，则将最新的通知立马发送一遍
if (eventInheritance) {
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);
}
}
}几个步骤，首先根据接收方法参数类型，将所在接收类保存起来，然后将所有接收方法参数的接收类按照接收方法的优先级进行排序。其次，把接收类和类中所有接收方法保存起来。最后，检查是否这个类中方法是粘性方法，如果是则会立马发送粘性事件。
我们把注册流程总结一下:
第一：解析接收类中所有添加注解的接收方法，没有找到抛异常
第二：以接收方法的参数类型为key，这个接收类为信息为value保存起来。然后根据每个接收类中接收方法的优先级进行排序。因为我们发送事件，肯定是只知道参数，那你如何找到哪个类中有处理事件的方法呢？肯定是也要保存一份。
第三：以接收类为key，接收方法为value保存起来。找到处理该事件的类后，肯定要找到具体方法吧。
第四：如果这个类中接收事件方法为粘性事件，则将最后一个发送的事件立马执行一下。
3.EventBus.getDefault().post(new Object()); 发送事件
public void post(Object event) {
//eventbus类中属性介绍currentPostingThreadState，用于记录当前线程，也就是eventbus创建线程，线程隔离作用
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;
}
}
}获取eventbus创建线程的队列，然后将事件放进队列中，取出队列中所有事件，发送出去。这里有个isPosting变量，也就是说如果以前的队列正在被发送处理，我们又发送了一个事件，这时这个被发送的事件不是会立马就发送出去，而是需要等到下次有事件发送才会一起被处理。postSingleEvent 方法如下：
private void postSingleEvent(Object event, PostingThreadState postingState) throws Error { //获取事件参数类
Class<?> eventClass = event.getClass();
//标记是否找到有这个事件参数方法的接收类
boolean subscriptionFound = false;
if (eventInheritance) {//默认为true
//找到事件参数以及事件参数所有父类、接口的类型集合
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) {
//。。。
post(new NoSubscriberEvent(this, event));
}
}先去通过事件参数类型，通过lookupAllEventTypes 方法找到事件参数类以及事件参数所有父类、父接口的类型，都会作为接收参数来发送事件。当然我们可以将 eventInheritance 设置为false，则会严格按照参数类型发送事件。lookupAllEventTypes 方法看看：
private static List<Class<?>> lookupAllEventTypes(Class<?> eventClass) {
synchronized (eventTypesCache) {
//如果解析过，则直接返回
List<Class<?>> eventTypes = eventTypesCache.get(eventClass);
if (eventTypes == null) {//没有解析过
eventTypes = new ArrayList<>();
Class<?> clazz = eventClass;
while (clazz != null) {
//将自己以及自己的父类、父参数的class全部解析出来放进去
eventTypes.add(clazz);
addInterfaces(eventTypes, clazz.getInterfaces());
clazz = clazz.getSuperclass();
}
eventTypesCache.put(eventClass, eventTypes);
}
return eventTypes;
}
}还是如果解析过这个事件参数类，则直接将解析结果返回，如果没有解析过，则将事件参数、事件参数的父类、父接口全部解析出来，缓存进去。举个例子，比如说我们发送的事件参数为String类型的，那么实际上他会把String类型、String父类型Serializable、Comparable、CharSequence、Object全部都存起来，如果有一个接收方法参数为这五个类型中的任意一个，则都将会接收到事件回调。当然了，这个问题我们可以通过EventBusBuilder.eventInheritance(false)来修改，严格按照我们设置的参数类型来查找对应的接收方法，这样可以大大提高效率。
继续该发送事件了:postSingleEventForEventType
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) {
postingState.event = event;
postingState.subscription = subscription;
boolean aborted;
try {
//调用类中指定方法
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;
}先去根据发送事件参数，找到对应的接收类信息，然后调用接收类中指定方法:
private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {
switch (subscription.subscriberMethod.threadMode) {
case POSTING:
invokeSubscriber(subscription, event);
break;
case MAIN:
if (isMainThread) {
invokeSubscriber(subscription, event);
} else {
mainThreadPoster.enqueue(subscription, event);
}
break;
case MAIN_ORDERED:
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) {
backgroundPoster.enqueue(subscription, event);
} else {
invokeSubscriber(subscription, event);
}
break;
case ASYNC:
asyncPoster.enqueue(subscription, event);
break;
default:
throw new IllegalStateException("Unknown thread mode: " + subscription.subscriberMethod.threadMode);
}
}可以看到，根据不同的线程类型，我们会用相应的执行者去掉用执行方法，我们就看main吧：如果发送事件是在主线程，则直接执行，如果不是则放到主线程队列中，先看直接执行方法：
void invokeSubscriber(Subscription subscription, Object event) {
try {
subscription.subscriberMethod.method.invoke(subscription.subscriber, event);
} catch (InvocationTargetException e) {
//处理异常
}
}直接调用接收类中方法执行。回头看看放到队列中如何执行的:
public class HandlerPoster extends Handler implements Poster {
//插入队列中
public void enqueue(Subscription subscription, Object event) {
PendingPost pendingPost = PendingPost.obtainPendingPost(subscription, event);
synchronized (this) {
queue.enqueue(pendingPost);
}
}
//调用
@Override
public void handleMessage(Message msg) {
boolean rescheduled = false;
try {
eventBus.invokeSubscriber(pendingPost);
}
} finally {
//
}
}
}我们可以看到就是一个hanlder，插入队列，然后执行handlemessage方法，调用eventBus.invokeSubscriber方法处理，然后还是调用上面的直接处理方法处理，调用接收类中订阅者方法。
4.反注册
public synchronized void unregister(Object subscriber) {
//接收类中所有接收方法
List<Class<?>> subscribedTypes = typesBySubscriber.get(subscriber);
if (subscribedTypes != null) {
for (Class<?> eventType : subscribedTypes) {
//将接收参数缓存的接收类删除掉
unsubscribeByEventType(subscriber, eventType);
}
//将接收类从缓存中删除掉
typesBySubscriber.remove(subscriber);
} else {
//没有注册过调用这个方法会报错
}
}其实就是两个步骤：先找到接收类中所有接收方法，将接收参数缓存的接收类删除掉，将缓存的接收类保存的接收方法删除掉。有点绕啊。。。。这么说吧，我们发送事件，怎么才能不被接收到了呢？发送事件后----找含有事件参数的事件类(需要删除掉)-----找事件类中事件方法(需要删除掉)----执行事件方法，这不就解释清楚了。
第三部分：学到了什么
1.单例模式，非严谨的单例模式
2.建造者模式
3.这种复杂的逻辑思维
第四部分：不足之处
1.接注册没有找到不应该报错，给安卓提供一个默认的activity、fragment生命周期监测器，自动接注册。
2.可以通过优化事件参数类型解析方式，来提高速度和准确性
至此，eventbus源码分析完毕，还是很简单的。
扫一扫
497
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
