基于版本：Guava 22.0
Wiki：EventBus
0. EventBus简介
提供了发布-订阅模型，可以方便的在EventBus上注册订阅者，发布者可以简单的将事件传递给EventBus，EventBus会自动将事件传递给相关联的订阅者。
支持同步/异步模式。
只能用于线程间通信。
1. EventBus类图
EventBus是同步实现
AsyncEventBus是异步实现
2. 代码实例
EventBus eventBus = new EventBus(); eventBus.register(new Object() { @Subscribe public void listen(Object subReport) throws Exception { System.out.println("receive object event!"); } @Subscribe public void listen(Integer subReport) throws Exception { System.out.println("receive integer event!"); } }); eventBus.post(Integer.valueOf(1));
这段代码的输出如下：
receive integer event!
receive object event!
可以看到我们声明了一个EventBus，然后向其注册了两个订阅者（含有Subscribe注解的方法），然后调用post方法向EventBus发布了一条消息。
消息类型是Integer，由于订阅者的关注对象是Integer与Object，都与这条消息有关，所以两个订阅者都收到了通知。
但是这个发布-订阅模式是如何实现的呢？我们下面来逐步分析一下EventBus的源码。
3. EventBus.register()
EventBus.register /** * Registers all subscriber methods on {@code object} to receive events. * * @param object object whose subscriber methods should be registered. */ public void register(Object object) { subscribers.register(object); } SubscriberRegistry.register /** * Registers all subscriber methods on the given listener object. */ void register(Object listener) { Multimap<Class<?>, Subscriber> listenerMethods = findAllSubscribers(listener);//获取传入的listener中含有的所有的订阅者 for (Map.Entry<Class<?>, Collection<Subscriber>> entry : listenerMethods.asMap().entrySet()) { Class<?> eventType = entry.getKey();//订阅的事件类型 Collection<Subscriber> eventMethodsInListener = entry.getValue();//对应的订阅者本身 CopyOnWriteArraySet<Subscriber> eventSubscribers = subscribers.get(eventType); if (eventSubscribers == null) { CopyOnWriteArraySet<Subscriber> newSet = new CopyOnWriteArraySet<Subscriber>(); eventSubscribers = MoreObjects.firstNonNull(subscribers.putIfAbsent(eventType, newSet), newSet);//线程安全的修改subscribers对象 } eventSubscribers.addAll(eventMethodsInListener); } } /** * Returns all subscribers for the given listener grouped by the type of event they subscribe to. 分析传入的对象，遍历其中所有含有Subscribe注解而且只含有一个参数的方法，然后将其包装成订阅者并返回。 */ private Multimap<Class<?>, Subscriber> findAllSubscribers(Object listener) { Multimap<Class<?>, Subscriber> methodsInListener = HashMultimap.create(); Class<?> clazz = listener.getClass(); for (Method method : getAnnotatedMethods(clazz)) {//getAnnotatedMethods方法最终会调用到下面的SubscriberRegistry.getAnnotatedMethodsNotCached方法，这个方法会用反射处理传入的clazz及其所有的父类，提取出含有Subscribe注解并且有且只有一个参数的方法 Class<?>[] parameterTypes = method.getParameterTypes(); Class<?> eventType = parameterTypes[0];//获取这个方法的唯一参数的Class methodsInListener.put(eventType, Subscriber.create(bus, listener, method));//将EventBus，订阅者对象，订阅者方法包装一下并放入map，后续触发事件的时候会用到 } return methodsInListener; } SubscriberRegistry.getAnnotatedMethodsNotCached private static ImmutableList<Method> getAnnotatedMethodsNotCached(Class<?> clazz) { Set<? extends Class<?>> supertypes = TypeToken.of(clazz).getTypes().rawTypes();//连clazz的父类也会处理 Map<MethodIdentifier, Method> identifiers = Maps.newHashMap(); for (Class<?> supertype : supertypes) { for (Method method : supertype.getDeclaredMethods()) { if (method.isAnnotationPresent(Subscribe.class) && !method.isSynthetic()) {//含有Subscribe注解，而且不是合成的方法 // TODO(cgdecker): Should check for a generic parameter type and error out Class<?>[] parameterTypes = method.getParameterTypes(); checkArgument( parameterTypes.length == 1, "Method %s has @Subscribe annotation but has %s parameters." + "Subscriber methods must have exactly 1 parameter.", method, parameterTypes.length);//方法必须有且只有一个参数 MethodIdentifier ident = new MethodIdentifier(method); if (!identifiers.containsKey(ident)) { identifiers.put(ident, method); } } } } return ImmutableList.copyOf(identifiers.values()); }
从SubscriberRegistry.getAnnotatedMethods到SubscriberRegistry.getAnnotatedMethodsNotCached的跳转会涉及到Guava的LoadingCache，其他的逻辑都非常直观。
register方法的大概流程如下：
a. 解析传入的Object对象，用反射分析对应的class及其所有父类，找到所有用Subscribe注解修饰，而且只有一个参数的方法。由这个方法可以生成订阅者对象。
b. 解析这个方法的参数（订阅者订阅的事件类型）
c. 每个EventBus在初始化时都会与一个SubscriberRegistry关联，这个SubscriberRegistry内部维护了一个名为subscribers的ConcurrentMap，这个ConcurrentMap的 key是EventBus关心的事件类型，value是订阅了这些事件的订阅者的集合，subscribers在后续发布事件的流程中非常有用（可以通过发布的事件类型，找到这个事件所关联的所有订阅者，并通知这些相关的订阅者）。现在用a,b中的信息来更新subscribers，由于subscribers可能被并发操作，所以用到了ConcurrentMap.putIfAbsent方法以保证线程安全。
总之，调用register方法会更新subscribers，subscribers中含有事件与订阅者的关联关系。
4. EventBus.post()
EventBus.post public void post(Object event) { Iterator<Subscriber> eventSubscribers = subscribers.getSubscribers(event);//获取发布事件所关联的所有订阅者（包括event的所有父类/接口所关联的订阅者） if (eventSubscribers.hasNext()) { dispatcher.dispatch(event, eventSubscribers);//用分派器触发所有订阅者的订阅方法，分派器有同步/异步的不同实现 } else if (!(event instanceof DeadEvent)) { // the event had no subscribers and was not itself a DeadEvent post(new DeadEvent(this, event));//如果这个事件没有订阅者，则将这个事件包装为DeadEvent事件，然后重新触发post方法 } } SubscriberRegistry.getSubscribers /** * Gets an iterator representing an immutable snapshot of all subscribers to the given event at * the time this method is called. */ Iterator<Subscriber> getSubscribers(Object event) { ImmutableSet<Class<?>> eventTypes = flattenHierarchy(event.getClass());//flattenHierarchy方法会解析出event的class，及其所有父类/接口的class List<Iterator<Subscriber>> subscriberIterators = Lists.newArrayListWithCapacity(eventTypes.size()); for (Class<?> eventType : eventTypes) {//遍历event关联的所有class，找到这些class关联的所有订阅者，添加到subscriberIterators中 CopyOnWriteArraySet<Subscriber> eventSubscribers = subscribers.get(eventType); if (eventSubscribers != null) { // eager no-copy snapshot subscriberIterators.add(eventSubscribers.iterator()); } } return Iterators.concat(subscriberIterators.iterator()); } SubscriberRegistry.flattenHierarchy /** * Flattens a class's type hierarchy into a set of {@code Class} objects including all * superclasses (transitively) and all interfaces implemented by these superclasses. */ @VisibleForTesting static ImmutableSet<Class<?>> flattenHierarchy(Class<?> concreteClass) { try { return flattenHierarchyCache.getUnchecked(concreteClass);//这里会用Guava的TypeToken工具解析出concreteClass的class，以及所有父类/接口的class并返回 } catch (UncheckedExecutionException e) { throw Throwables.propagate(e.getCause()); } }
post方法的大概流程如下：
a. 用Guava的TypeToken工具解析Event的class，以及Event的所有父类/接口的class，所有订阅了这些class的订阅者后续都会收到通知
b. 调用EventBus关联的Dispatcher的dispatcher方法，将Event发布给所有关联的订阅者。
下一步我们会解析Dispatcher，以及Dispatcher是如何实现EventBus的同步/异步语义的。
5. EventBus的默认Dispatcher
EventBus /** * Creates a new EventBus named "default". */ public EventBus() { this("default"); } /** * Creates a new EventBus with the given {@code identifier}. * * @param identifier a brief name for this bus, for logging purposes. Should be a valid Java * identifier. */ public EventBus(String identifier) { this( identifier, MoreExecutors.directExecutor(),//由当前线程直接运行提交任务的“线程池” Dispatcher.perThreadDispatchQueue(), LoggingHandler.INSTANCE); } Dispatcher.perThreadDispatchQueue() static Dispatcher perThreadDispatchQueue() { return new PerThreadQueuedDispatcher(); } Dispatcher.PerThreadQueuedDispatcher /** * Implementation of a {@link #perThreadDispatchQueue()} dispatcher. */ private static final class PerThreadQueuedDispatcher extends Dispatcher { // This dispatcher matches the original dispatch behavior of EventBus. /** * Per-thread queue of events to dispatch. */ private final ThreadLocal<Queue<Event>> queue = new ThreadLocal<Queue<Event>>() { @Override protected Queue<Event> initialValue() { return Queues.newArrayDeque(); } };//为每个调用post方法的工作线程维护一个发布队列，工作线程独立操作这个队列完成时间发布流程，所以是线程安全的 /** * Per-thread dispatch state, used to avoid reentrant event dispatching. */ private final ThreadLocal<Boolean> dispatching = new ThreadLocal<Boolean>() { @Override protected Boolean initialValue() { return false; } }; @Override void dispatch(Object event, Iterator<Subscriber> subscribers) { checkNotNull(event); checkNotNull(subscribers); Queue<Event> queueForThread = queue.get(); queueForThread.offer(new Event(event, subscribers));//将发布事件+事件所关联的所有订阅者包装成一个Event对象，并提交至发布队列 if (!dispatching.get()) { dispatching.set(true); try { Event nextEvent; while ((nextEvent = queueForThread.poll()) != null) {//尝试从发布队列中poll元素 while (nextEvent.subscribers.hasNext()) {//遍历发布事件的所有订阅者，向订阅者派发事件，由于EventBus默认使用的线程池是MoreExecutors.directExecutor()，所以实际上发布者会串行而且同步的向事件的所有订阅者派发事件，直到全部派发结束，post方法才会返回，所以EventBus在默认情况下是同步的。 nextEvent.subscribers.next().dispatchEvent(nextEvent.event); } } } finally { dispatching.remove(); queue.remove(); } } } private static final class Event { private final Object event; private final Iterator<Subscriber> subscribers; private Event(Object event, Iterator<Subscriber> subscribers) { this.event = event; this.subscribers = subscribers; } } } Subscriber.dispatchEvent /** * Dispatches {@code event} to this subscriber using the proper executor. */ final void dispatchEvent(final Object event) {//向订阅者派发事件 executor.execute( new Runnable() { @Override public void run() { try { invokeSubscriberMethod(event);//用反射调用订阅的方法 } catch (InvocationTargetException e) { bus.handleSubscriberException(e.getCause(), context(event)); } } }); } Subscriber.invokeSubscriberMethod /** * Invokes the subscriber method. This method can be overridden to make the invocation * synchronized. */ @VisibleForTesting void invokeSubscriberMethod(Object event) throws InvocationTargetException { try { method.invoke(target, checkNotNull(event)); } catch (IllegalArgumentException e) { throw new Error("Method rejected target/argument: " + event, e); } catch (IllegalAccessException e) { throw new Error("Method became inaccessible: " + event, e); } catch (InvocationTargetException e) { if (e.getCause() instanceof Error) { throw (Error) e.getCause(); } throw e; } }
同步语义的实现关键在于
a. 使用的线程池为MoreExecutors.directExecutor()，这实际上不能算是一个真正的线程池，所有提交到这个池子里的任务，都是由提交任务的线程自身来执行的。
b. EventBus为每个调用post方法的线程维护了一个发布队列，工作线程会将事件提交到这个私有队列里，然后逐个通知事件所关联的订阅者，由于使用的线程池是MoreExecutors.directExecutor()，所以这个过程实际上是完全串行而且同步执行的，调用post方法的工作线程实际上会在将事件通知给所有订阅者后才会返回，从而实现了同步的EventBus语义。
6. AsyncEventBus的Dispatcher
AsyncEventBus public AsyncEventBus(Executor executor) { super("default", executor, Dispatcher.legacyAsync(), LoggingHandler.INSTANCE); Dispatcher.legacyAsync() static Dispatcher legacyAsync() { return new LegacyAsyncDispatcher(); } Dispatcher.LegacyAsyncDispatcher private static final class LegacyAsyncDispatcher extends Dispatcher { // This dispatcher matches the original dispatch behavior of AsyncEventBus. // // We can't really make any guarantees about the overall dispatch order for this dispatcher in // a multithreaded environment for a couple reasons: // // 1. Subscribers to events posted on different threads can be interleaved with each other // freely. (A event on one thread, B event on another could yield any of // [a1, a2, a3, b1, b2], [a1, b2, a2, a3, b2], [a1, b2, b3, a2, a3], etc.) // 2. It's possible for subscribers to actually be dispatched to in a different order than they // were added to the queue. It's easily possible for one thread to take the head of the // queue, immediately followed by another thread taking the next element in the queue. That // second thread can then dispatch to the subscriber it took before the first thread does. // // All this makes me really wonder if there's any value in queueing here at all. A dispatcher // that simply loops through the subscribers and dispatches the event to each would actually // probably provide a stronger order guarantee, though that order would obviously be different // in some cases. /** * Global event queue. */ private final ConcurrentLinkedQueue<EventWithSubscriber> queue = Queues.newConcurrentLinkedQueue();//公用的，支持并发访问的发布队列 @Override void dispatch(Object event, Iterator<Subscriber> subscribers) { checkNotNull(event); while (subscribers.hasNext()) {//将Event+订阅者包装成EventWithSubscriber，放入发布队列中 queue.add(new EventWithSubscriber(event, subscribers.next())); } EventWithSubscriber e; while ((e = queue.poll()) != null) { e.subscriber.dispatchEvent(e.event);//从发布队列中提取EventWithSubscriber，然后将事件发布给订阅者，这一过程是发送到AsyncEventBus初始化时提供的线程池里执行的，所以是异步的。也就是说post方法返回的时候，可能发布过程尚未完成，还有订阅者没有收到消息。 } } private static final class EventWithSubscriber { private final Object event; private final Subscriber subscriber; private EventWithSubscriber(Object event, Subscriber subscriber) { this.event = event; this.subscriber = subscriber; } } }
异步语义实现的关键在于：
a. 发布事件使用的线程池是创建AsyncEventBus时传入的线程池，一般来说都是正常的含有多个工作线程的线程池，提交到线程池里的任务可以被异步执行
b. LegacyAsyncDispatcher中维护了一个公用的ConcurrentLinkedQueue，这个AsyncEventBus收到的所有Event都会被put到这个队列中，put完Event的线程同时也会从这个队列中poll Event，然后submit这些Event到线程池中，如果这个线程池是普通的含有工作线程的线程池，那么submit完Event之后post方法即可立即返回，传递Event给订阅者的任务会由线程池里的工作线程完成。这样就实现了异步语义。
总的来说，EventBus的源码还是比较清晰易懂的，实现手法也非常优雅，值得我们学习。