EventBus3.0源码分析
Posted lzy_tinyjoy
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了EventBus3.0源码分析相关的知识，希望对你有一定的参考价值。
简述：
在项目中，我们大多数开发者可能都使用过EventBus,即使没有使用过但我可以确定android开发者也听说过这个牛X的库，从诞生到目前EventBus已经更新到3.X版本，可见生命力极强呀。那么这篇博文就从EventBus3.0源码的角度分析一下其内部处理流程。
使用流程：
注册：
EventBus.getDefault().register(obj)@Subscribe
public void receive(Object event)
EventBus.getDefault().post(event)EventBus.getDefault().unregister(obj)源码分析：
注册：
EventBus.getDefault().register(obj) 这段代码做了两件事情：① EventBus.getDefault() 创建EventBus对象；② register(obj) 方法为obj该类对象注册EventBus。 那这两个方法究竟在EventBus中究竟做了哪些工作呢？我们打开EventBus的源码看一下:
1、EventBus.getDefault() 源码如下：public static EventBus getDefault()
if (defaultInstance == null)
synchronized (EventBus.class)
if (defaultInstance == null)
defaultInstance = new EventBus();
return defaultInstance;
public EventBus()
this(DEFAULT_BUILDER);
EventBus(EventBusBuilder builder)
subscriptionsByEventType = new HashMap<>();
typesBySubscriber = new HashMap<>();
stickyEvents = new ConcurrentHashMap<>();
mainThreadPoster = new HandlerPoster(this, Looper.getMainLooper(), 10);
backgroundPoster = new BackgroundPoster(this);
asyncPoster = new AsyncPoster(this);
indexCount = builder.subscriberInfoIndexes != null ? builder.subscriberInfoIndexes.size() : 0;
//默认情况下参数为（null，false，false）
subscriberMethodFinder = new SubscriberMethodFinder(builder.subscriberInfoIndexes,
builder.strictMethodVerification, builder.ignoreGeneratedIndex);
logSubscriberExceptions = builder.logSubscriberExceptions;
logNoSubscriberMessages = builder.logNoSubscriberMessages;
sendSubscriberExceptionEvent = builder.sendSubscriberExceptionEvent;
sendNoSubscriberEvent = builder.sendNoSubscriberEvent;
throwSubscriberException = builder.throwSubscriberException;
eventInheritance = builder.eventInheritance;
executorService = builder.executorService;
register()和unregister()的时候都是操作这个Map。
③ Map<Class<?>, Object> stickyEvents：维护的是粘性事件的集合，粘性事件也就是当event发送出去之后再注册粘性事件的话，该粘性事件也能接收到之前发送出去的event消息。
其次，初始化3个消息发送器如下：
mainThreadPoster ：该类继承自Handler，而且在EventBus中mainThreadPoster属于主线程Handler，这是因为mainThreadPoster就是为处理“消息接收方法在主线程而消息发送在子线程 ”这个问题而设计的，所以子线程向主线程发送消息必须使用主线程的Handler。mainThreadPoster继承Handler也是为了效率考虑的。
backgroundPoster：该类继承自Runnable，重写了run()方法。在run（）方法中将子线程中的消息通过EventBus发送到主线程。所以这个消息发送器作用就是处理“消息接收方法在子线程接而消息的发布在主线程”这样的问题。
asyncPoster：该类继承自Runnable，也重写了run()方法，不过就像名字一样“异步”，也就是说不管订阅者是不是在主线程，消息接收方法都会另外开启一个线程处理消息。
然后，一个重要的初始化对象为subscriberMethodFinder，这个对象利用反射的方法查找每一个接收消息者的方法（也即是添加了“@Subscribe ”注解的方法）。
最后就是一些对EventBusBuilder的一些配置信息。其中eventInheritance和executorService在接下来分析源码时会经常碰到：① eventInheritance表示我们自定义的待发布消息事件是否允许继承,，默认情况下eventInheritance==true。它的作用就是处理业务时后来新增加业务后不必再修改代码，只需要继承就OK啦（这也符合程序的“开闭原则”）如下：public class MessageEvent
public final String message;
public MessageEvent(String message)
this.message = message;
public class SubMessageEvent extends MessageEvent
public SubMessageEvent(String message)
super(message);
2、注册register(Object subscriber ) EventBus的初始化工作已经完毕，我们继续看一下EventBus是怎么进行注册的，在注册过程中又搞了哪些事情？
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注解的所有方法
*
* @param subscriberClass @Subscribe注解所属类的运行时类对象
* @return 注册EventBus类中@Subscribe注解的所有方法的List集合
*/
List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass)
//先从缓存中查找是否存在消息接收的方法
List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass);
if (subscriberMethods != null)
return subscriberMethods;
if (ignoreGeneratedIndex)
//使用反射方法拿到订阅者中的订阅方法
subscriberMethods = findUsingReflection(subscriberClass);
else
//使用apt处理器拿到订阅者中的订阅方法
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;
Caused by: org.greenrobot.eventbus.EventBusException: Subscriber class XXX and its super classes
have no public methods with the @Subscribe annotationprivate void subscribe(Object subscriber, SubscriberMethod subscriberMethod)
Class<?> eventType = subscriberMethod.eventType;
Log.e(TAG, eventType.getSimpleName());
//将订阅类Object对象subscriber封装为EventBus的订阅类Subscription
Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
CopyOnWriteArrayList<Subscription> subscriptions = subscriptionsByEventType.get(eventType);
if (subscriptions == null)
subscriptions = new CopyOnWriteArrayList<>();
subscriptionsByEventType.put(eventType, subscriptions);
else
if (subscriptions.contains(newSubscription))
throw new EventBusException("Subscriber " + subscriber.getClass() + " already registered to event "
+ eventType);
/**
* 方法描述：对CopyOnWriteArrayList中的Subscription根据优先级的高低重新进行排序
*/
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;
/**
* 方法描述：将开发者注册EventBus的类的运行时类添加到subscribedEvents中，并且把该运行时类添加到
* typesBySubscriber中
*/
List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber);
Log.e(TAG, "typesBySubscriber的");
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
Object stickyEvent = stickyEvents.get(eventType);
checkPostStickyEventToSubscription(newSubscription, stickyEvent);
发布消息：
我们已经分析完了EventBus的注册过程，接下来我们再来分析一下EventBus的事件发送过程。
EventBus.getDefault().post(event);public void post(Object event)
PostingThreadState postingState = currentPostingThreadState.get();
List<Object> eventQueue = postingState.eventQueue;
eventQueue.add(event);//将该事件添加到事件队列当中
//事件没有分发则开始分发
if (!postingState.isPosting)
//判断消息接收者是否在主线程
postingState.isMainThread = Looper.getMainLooper() == Looper.myLooper();
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;
从上面的代码中可以得知，待发送的消息首先存储到一个消息list集合当中，然后再不断的循环发送消息。发送消息时利用的方法是postSingleEvent（Object event, PostingThreadState postingState ），OK，我们继续跟进：
private void postSingleEvent(Object event, PostingThreadState postingState) throws Error
Class<?> eventClass = event.getClass();
boolean subscriptionFound = false;
//默认情况下Event事件允许继承，即默认情况下eventInheritance==true
if (eventInheritance)
//查找event事件及event子类事件
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)
...
private boolean postSingleEventForEventType(Object event, PostingThreadState postingState,
Class<?> eventClass)
CopyOnWriteArrayList<Subscription> subscriptions;
synchronized (this)
//从Map中取出所有订阅了eventClass事件的所有订阅者
subscriptions = subscriptionsByEventType.get(eventClass);
//如果该事件的订阅者存在则向每一个订阅者发布消息事件
if (subscriptions != null && !subscriptions.isEmpty())
for (Subscription subscription : subscriptions)
postingState.event = event;
postingState.subscription = subscription;
boolean aborted = false;
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 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);
final class HandlerPoster extends Handler
private final PendingPostQueue queue;
private final int maxMillisInsideHandleMessage;
private final EventBus eventBus;
private boolean handlerActive;
//默认情况下EventBus创建HandlerPoster的Looper为MainLooper，最大maxMillisInsideHandleMessage==10ms
HandlerPoster(EventBus eventBus, Looper looper, int maxMillisInsideHandleMessage)
super(looper);
this.eventBus = eventBus;
this.maxMillisInsideHandleMessage = maxMillisInsideHandleMessage;
queue = new PendingPostQueue();
/**
* 方法描述：将订阅者与消息实体之间的映射存到队列PendingPostQueue当中
*
* @param subscription 订阅者
* @param event 消息事件
*/
void enqueue(Subscription subscription, Object event)
PendingPost pendingPost = PendingPost.obtainPendingPost(subscription, event);
synchronized (this)
queue.enqueue(pendingPost);
if (!handlerActive)
handlerActive = true;
if (!sendMessage(obtainMessage()))
throw new EventBusException("Could not send handler message");
@Override
public void handleMessage(Message msg)
boolean rescheduled = false;
try
long started = SystemClock.uptimeMillis();
while (true)
//同步取出消息队列
PendingPost pendingPost = queue.poll();
if (pendingPost == null)
synchronized (this)
// Check again, this time in synchronized
pendingPost = queue.poll();
if (pendingPost == null)
handlerActive = false;
return;
eventBus.invokeSubscriber(pendingPost);
long timeInMethod = SystemClock.uptimeMillis() - started;
//消息发送超时
if (timeInMethod >= maxMillisInsideHandleMessage)
if (!sendMessage(obtainMessage()))
throw new EventBusException("Could not send handler message");
rescheduled = true;
return;
finally
handlerActive = rescheduled;
final class BackgroundPoster implements Runnable
....
private volatile boolean executorRunning;
BackgroundPoster(EventBus eventBus)
this.eventBus = eventBus;
queue = new PendingPostQueue();
public void enqueue(Subscription subscription, Object event)
PendingPost pendingPost = PendingPost.obtainPendingPost(subscription, event);
synchronized (this)
...
eventBus.getExecutorService().execute(this);
@Override
public void run()
try
while (true)
...
eventBus.invokeSubscriber(pendingPost);
finally
executorRunning = false;
void invokeSubscriber(Subscription subscription, Object event)
try
subscription.subscriberMethod.method.invoke(subscription.subscriber, event);
catch (InvocationTargetException e)
handleSubscriberException(subscription, event, e.getCause());
catch (IllegalAccessException e)
throw new IllegalStateException("Unexpected exception", e);
以上是关于EventBus3.0源码分析的主要内容，如果未能解决你的问题，请参考以下文章