一、架构速读
传统上，Java的进程内事件分发都是通过发布者和订阅者之间的显式注册实现的。设计EventBus就是为了取代这种显示注册方式，使组件间有了更好的解耦。EventBus不是通用型的发布-订阅实现，不适用于进程间通信。
架构图如下：
。
二、简单使用
步骤如下：
1.构造一个事件总线
2.构造一个事件监听器
3.把事件监听器注册到事件总线上
4.事件总线发布事件，触发监听器方法
主测试类如下：
1 package guava.eventbus; 2 3 import com.google.common.eventbus.EventBus; 4 5 /** 6 * @Description 主测试类 7 * @author denny 8 * @date 2018/7/18 上午9:54 9 */ 10 public class MainTest { 11 12 13 public static void main(String[] args) { 14 // 1.构造一个事件总线 15 EventBus eventBus = new EventBus("test"); 16 17 // 2.构造一个事件监听器 18 EventListener listener = new EventListener(); 19 20 // 3.把事件监听器注册到事件总线上 21 eventBus.register(listener); 22 23 // 4.事件总线发布事件，触发监听器方法 24 eventBus.post(new TestEvent1(1)); 25 eventBus.post(new TestEvent2(2)); 26 // 事件3是事件2子类，虽然监听器只订阅了父类事件2，一样可以监听到子类 27 eventBus.post(new TestEvent3(3)); 28 // 未被订阅的事件,用DeadEvent可订阅 29 eventBus.post(new TestEvent4(4)); 30 } 31 }
事件监听器如下：
1 package guava.eventbus; 2 3 import com.alibaba.fastjson.JSON; 4 import com.google.common.eventbus.DeadEvent; 5 import com.google.common.eventbus.Subscribe; 6 7 /** 8 * @Description 事件监听器 9 * @author denny 10 * @date 2018/7/18 上午9:53 11 */ 12 public class EventListener { 13 14 private int message = 0; 15 16 /** 17 * @Description 订阅事件1 18 * @param event 事件1 19 * @return void 20 * @author denny 21 * @date 2018/7/18 上午9:46 22 */ 23 @Subscribe 24 public void onEvent1(TestEvent1 event) { 25 message = event.getMessage(); 26 System.out.println("EventListener onEvent1 监听器接收到消息:"+message); 27 } 28 29 /** 30 * @Description 订阅事件2 31 * @param event 事件2 32 * @return void 33 * @author denny 34 * @date 2018/7/18 上午9:59 35 */ 36 @Subscribe 37 public void onEvent2(TestEvent2 event) { 38 message = event.getMessage(); 39 System.out.println("EventListener onEvent2 监听器接收到消息:"+message); 40 } 41 42 /** 43 * @Description 死亡事件（该事件没有被订阅会触发） 44 * @param event 未订阅事件 45 * @return void 46 * @author denny 47 * @date 2018/7/18 上午9:59 48 */ 49 @Subscribe 50 public void onDeadEvent(DeadEvent event) { 51 System.out.println("EventListener DeadEvent 有消费没有被订阅！！！！event="+ event.toString()); 52 } 53 }
事件类：
1 package guava.eventbus; 2 3 /** 4 * @Description 事件1 5 * @author denny 6 * @date 2018/7/18 上午9:54 7 */ 8 public class TestEvent1 { 9 10 private final int message; 11 12 /** 13 * 构造方法 14 * @param message 15 */ 16 public TestEvent1(int message) { 17 this.message = message; 18 System.out.println("TestEvent1 事件message:"+message); 19 } 20 21 public int getMessage() { 22 return message; 23 } 24 } 25 26 27 /** 28 * @Description 事件2 29 * @author denny 30 * @date 2018/7/18 上午9:54 31 */ 32 public class TestEvent2 { 33 34 private final int message; 35 36 /** 37 * 构造方法 38 * @param message 39 */ 40 public TestEvent2(int message) { 41 this.message = message; 42 System.out.println("TestEvent2 事件message:"+message); 43 } 44 45 public int getMessage() { 46 return message; 47 } 48 } 49 50 /** 51 * @Description 事件3 52 * @author denny 53 * @date 2018/7/18 上午9:54 54 */ 55 public class TestEvent3 extends TestEvent2{ 56 57 private final int message; 58 59 /** 60 * 构造方法 61 * @param message 62 */ 63 public TestEvent3(int message) { 64 super(message); 65 this.message = message; 66 System.out.println("TestEvent2 事件message:"+message); 67 } 68 69 @Override 70 public int getMessage() { 71 return message; 72 } 73 } 74 75 /** 76 * @Description 事件4 77 * @author denny 78 * @date 2018/7/18 上午9:54 79 */ 80 public class TestEvent4 { 81 82 private final int message; 83 84 /** 85 * 构造方法 86 * @param message 87 */ 88 public TestEvent4(int message) { 89 this.message = message; 90 System.out.println("TestEvent4 事件message:"+message); 91 } 92 93 public int getMessage() { 94 return message; 95 } 96 }
运行结果如下：
TestEvent1 事件message:1 EventListener onEvent1 监听器接收到消息:1 ---》触发订阅的事件1 TestEvent2 事件message:2 EventListener onEvent2 监听器接收到消息:2---》触发订阅的事件2（一个监听器可以订阅多个事件） TestEvent2 事件message:3 TestEvent2 事件message:3 EventListener onEvent2 监听器接收到消息:3---》订阅事件2，可触发订阅子类事件3 TestEvent4 事件message:4 EventListener DeadEvent 有消费没有被订阅！！！！event="DeadEvent{source=EventBus{test}, event=guava.eventbus.TestEvent4@19e1023e}"---》事件4没有被订阅，触发DeadEvent死亡事件。
注意：
1.事件总线EventBus：
不提供单列，用户自己看着用~
2.监听器Listener：
1)监听器使用@Subscribe标记的方法(参数为自定义事件)，即可实现事件的监听。要监听多个事件，就写多个方法(每个方法都用@Subscribe标记)即可。
2)注意一定要把Listener注册到eventbus上。
三、源码剖析
源码版本为：guava-22.0.jar，先来回顾下第一节的样例代码：
1 public static void main(String[] args) { 2 // 1.构造一个事件总线 3 EventBus eventBus = new EventBus("test"); 4 5 // 2.构造一个事件监听器 6 EventListener listener = new EventListener(); 7 8 // 3.把事件监听器注册到事件总线上 9 eventBus.register(listener); 10 11 // 4.事件总线发布事件，触发监听器方法 12 eventBus.post(new TestEvent1(1)); 13 eventBus.post(new TestEvent2(2)); 14 // 事件3是事件2子类，虽然监听器只订阅了父类事件2，一样可以监听到子类 15 eventBus.post(new TestEvent3(3)); 16 // deadEvent未被订阅的事件，供用户自行处理 17 eventBus.post(new TestEvent4(4)); 18 }
如上图，虽然是google封装的事件总线，但是依然是观察者模式，那么核心就是发布、订阅。下面就从这两个方面来看一下源码，看看有没有值得借鉴的地方。
3.1 核心类速读
1.EventBus事件总线
核心方法
register：把监听器中申明的所有订阅事件方法注册到SubscriberRegistry（订阅者注册器）中。
post：发布事件给所有已注册过的订阅者，最终开启线程完成订阅方法。
具体如下图：
1 @Beta 2 public class EventBus { 6 private final String identifier;//事件总线标识：用于自定义标识这个事件总线 7 private final Executor executor;//默认的线程执行器，用于把事件转发给订阅者 10 private final SubscriberRegistry subscribers = new SubscriberRegistry(this);//订阅注册器 11 private final Dispatcher dispatcher;//事件转发器 12 15 //构造器：使用默认字符串 16 public EventBus() { 17 this("default"); 18 } 19 //构造器：使用自定义字符串 26 public EventBus(String identifier) { 27 this( 28 identifier, 29 MoreExecutors.directExecutor(), 30 Dispatcher.perThreadDispatchQueue(), 31 LoggingHandler.INSTANCE); 32 } 58 93 //注册监听者中申明的所有订阅方法（@Subscribe标记的），用以接收事件 97 public void register(Object object) { 98 subscribers.register(object); 99 } 100 // 解除订阅 107 public void unregister(Object object) { 108 subscribers.unregister(object); 109 } 110 111 //发布事件给所有已注册过的订阅者 121 public void post(Object event) {
// 找到事件的所有订阅者 122 Iterator<Subscriber> eventSubscribers = subscribers.getSubscribers(event); 123 if (eventSubscribers.hasNext()) {
// 事件转发器，把事件转发给订阅者 124 dispatcher.dispatch(event, eventSubscribers); 125 } else if (!(event instanceof DeadEvent)) { 126 // 如果该事件即没有订阅者，也没事DeadEvent,那么封装成DeadEvent并重新发布 127 post(new DeadEvent(this, event)); 128 }
...省略非重要方法167 }
2.Subscriber订阅者
核心方法：dispatchEvent使用executor线程执行器，单独开启线程执行订阅方法。
1 class Subscriber { 2 3 /** 4 * 构造 5 */ 6 static Subscriber create(EventBus bus, Object listener, Method method) { 7 return isDeclaredThreadSafe(method) 8 ? new Subscriber(bus, listener, method) 9 : new SynchronizedSubscriber(bus, listener, method); 10 } 11 12 /** 订阅者所属的事件总线*/ 13 @Weak private EventBus bus; 14 15 /** 监听器 listener*/ 16 @VisibleForTesting final Object target; 17 18 /** 订阅者方法 */ 19 private final Method method; 20 21 /** 线程执行器，用来分发事件给订阅者 */ 22 private final Executor executor;
23 /** 构造器：使用事件总线、监听器、订阅方法 */ 24 private Subscriber(EventBus bus, Object target, Method method) { 25 this.bus = bus; 26 this.target = checkNotNull(target); 27 this.method = method; 28 method.setAccessible(true); 29 30 this.executor = bus.executor(); 31 } 32 33 /** 34 * 使用executor线程执行器，执行订阅方法*/ 36 final void dispatchEvent(final Object event) { 37 executor.execute( 38 new Runnable() { 39 @Override 40 public void run() { 41 try { 42 invokeSubscriberMethod(event); 43 } catch (InvocationTargetException e) { 44 bus.handleSubscriberException(e.getCause(), context(event)); 45 } 46 } 47 }); 48 } 49 50 /** 51 * 调用订阅者方法*/ 54 @VisibleForTesting 55 void invokeSubscriberMethod(Object event) throws InvocationTargetException { 56 try { 57 method.invoke(target, checkNotNull(event)); 58 } catch (IllegalArgumentException e) { 59 throw new Error("Method rejected target/argument: " + event, e); 60 } catch (IllegalAccessException e) { 61 throw new Error("Method became inaccessible: " + event, e); 62 } catch (InvocationTargetException e) { 63 if (e.getCause() instanceof Error) { 64 throw (Error) e.getCause(); 65 } 66 throw e; 67 } 68 }
...
120 }
本节我们了解了2个核心类EventBus（注册监听器、发布事件）、Subscriber订阅者（执行订阅方法），下面我们从源码流程上来串连一遍。
3.2.注册监听器
我们从注册监听器开始看，eventBus.register(listener); 如下图所示：
1 public void register(Object object) { 2 subscribers.register(object); 3 } 4 5 /** 6 * 把listener中申明的所有订阅方法都注册 7 */ 8 void register(Object listener) {
// 获取该监听器类型对应的所有订阅方法，key是事件类型,value是订阅者集合 9 Multimap<Class<?>, Subscriber> listenerMethods = findAllSubscribers(listener); 10 // 遍历map Map<K, Collection<V>> 11 for (Map.Entry<Class<?>, Collection<Subscriber>> entry : listenerMethods.asMap().entrySet()) { 12 //key:事件类型
Class<?> eventType = entry.getKey();
//value:订阅者集合 13 Collection<Subscriber> eventMethodsInListener = entry.getValue(); 14 //从subscribers并发map 中获取事件对应的事件订阅者set，subscribers：private final ConcurrentMap<Class<?>, CopyOnWriteArraySet<Subscriber>> subscribers = Maps.newConcurrentMap(); 15 CopyOnWriteArraySet<Subscriber> eventSubscribers = subscribers.get(eventType); 16 //不存在，就构造 17 if (eventSubscribers == null) { 18 CopyOnWriteArraySet<Subscriber> newSet = new CopyOnWriteArraySet<Subscriber>(); 19 eventSubscribers = 20 MoreObjects.firstNonNull(subscribers.putIfAbsent(eventType, newSet), newSet); 21 } 22 //存在，把订阅者集合添加进subscribers 23 eventSubscribers.addAll(eventMethodsInListener); 24 } 25 }
1.调用SubscriberRegistry的register(listener)来执行注册监听器。
2.register步骤如下：
EventBus-包含-》SubscriberRegistry-包含-》ConcurrentMap<Class<?>, CopyOnWriteArraySet<Subscriber>> subscribers 用以维护事件和订阅者的映射
1). findAllSubscribers从缓存中获取该监听器类型对应的所有订阅方法，key是event class,value是Subscriber集合
2).遍历map，把订阅者集合添加进SubscriberRegistry-》subscribers。
其中findAllSubscribers详细代码如下：
12 /** 13 * 返回所有该监听器订阅者，以事件分组 14 */ 15 private Multimap<Class<?>, Subscriber> findAllSubscribers(Object listener) { 16 Multimap<Class<?>, Subscriber> methodsInListener = HashMultimap.create(); 17 Class<?> clazz = listener.getClass();
//从缓存中获取该监听器类型对应的所有订阅方法，遍历塞进Multimap 18 for (Method method : getAnnotatedMethods(clazz)) { 19 Class<?>[] parameterTypes = method.getParameterTypes(); 20 Class<?> eventType = parameterTypes[0]; 21 methodsInListener.put(eventType, Subscriber.create(bus, listener, method)); 22 } 23 return methodsInListener; 24 }
如上图，
1.方法getAnnotatedMethods：从缓存中取 listener中订阅方法的不可变列表，
2.遍历塞进Multimap：一个key,多个value，每次put进去，往Collection<V>中add(value)。
getAnnotatedMethods源码如下：
1 private static ImmutableList<Method> getAnnotatedMethods(Class<?> clazz) { 2 return subscriberMethodsCache.getUnchecked(clazz); 3 } 4 5 private static final LoadingCache<Class<?>, ImmutableList<Method>> subscriberMethodsCache = 6 CacheBuilder.newBuilder() 7 .weakKeys() 8 .build( 9 new CacheLoader<Class<?>, ImmutableList<Method>>() { 10 @Override 11 public ImmutableList<Method> load(Class<?> concreteClass) throws Exception { 12 return getAnnotatedMethodsNotCached(concreteClass); 13 } 14 });
如上图，我们发现这里用到了google cache来做缓存，关于google cache飞机票。
这个cache的源码注释翻译如下：一个线程安全的缓存，包含从每个类到该类中的所有方法和所有超类的映射，这些超类都用{@code @Subscribe}注释。缓存是跨该类的所有实例共享的;如果创建了多个EventBus实例，并且在所有这些实例上注册了同一个类的对象，这将大大提高性能。
值得借鉴点：EventBus-包含->SubscriberRegistry-->static final subscriberMethodsCache,即所有EventBus类的实例共享一个静态cache,性能高且线程安全。
下面来看看具体怎么获取的订阅事件方法（监听器@Subscribe注解的订阅事件方法），核心方法getAnnotatedMethodsNotCached如下：
1 private static ImmutableList<Method> getAnnotatedMethodsNotCached(Class<?> clazz) {
//获取超类class集合 2 Set<? extends Class<?>> supertypes = TypeToken.of(clazz).getTypes().rawTypes(); 3 Map<MethodIdentifier, Method> identifiers = Maps.newHashMap();
//遍历超类 4 for (Class<?> supertype : supertypes) {
5 //遍历超类中的所有定义的方法
for (Method method : supertype.getDeclaredMethods()) {
//如果方法上有@Subscribe注解 6 if (method.isAnnotationPresent(Subscribe.class) && !method.isSynthetic()) { 7 // 方法的参数类型数组 8 Class<?>[] parameterTypes = method.getParameterTypes(); 9 // 校验：事件订阅方法必须只能有一个参数，即事件类
checkArgument( 10 parameterTypes.length == 1, 11 "Method %s has @Subscribe annotation but has %s parameters." 12 + "Subscriber methods must have exactly 1 parameter.", 13 method, 14 parameterTypes.length); 15 // 封装方法定义对象 16 MethodIdentifier ident = new MethodIdentifier(method);
// 去重并添加进map 17 if (!identifiers.containsKey(ident)) { 18 identifiers.put(ident, method); 19 } 20 } 21 } 22 }
// map转ImmutableList 23 return ImmutableList.copyOf(identifiers.values()); 24 }
3.3 发布事件
eventBus.post(new TestEvent1(1));
调用事件转发器Dispatcher，分发事件给订阅者,
1 public void post(Object event) {
//从注册器中获取当前事件对应的订阅者集合：eventBus-包含-》SubscriberRegistry-包含-》ConcurrentMap<Class<?>, CopyOnWriteArraySet<Subscriber>> subscribers 2 Iterator<Subscriber> eventSubscribers = subscribers.getSubscribers(event); 3 if (eventSubscribers.hasNext()) { 4 dispatcher.dispatch(event, eventSubscribers); 5 } else if (!(event instanceof DeadEvent)) { 6 //如果该事件即没有订阅者，也没事DeadEvent,那么封装成DeadEvent并重新发布
7 post(new DeadEvent(this, event));
8 }
9 }
Dispatcher是个抽象类，有多个内部类复写不同dispatch方法。EventBus默认构造时使用PerThreadQueuedDispatcher，即每个线程一个待转发事件队列。如下图所示：
1 private static final class PerThreadQueuedDispatcher extends Dispatcher { 2 3 // This dispatcher matches the original dispatch behavior of EventBus. 4 5 /** 6 * 每个线程待转发事件队列 7 */ 8 private final ThreadLocal<Queue<Event>> queue = 9 new ThreadLocal<Queue<Event>>() { 10 @Override 11 protected Queue<Event> initialValue() { 12 return Queues.newArrayDeque(); 13 } 14 }; 15 16 /** 17 * 每个线程的转发状态，用于避免重入事件转发，初始化状态为fasle,即不在转发。 18 */ 19 private final ThreadLocal<Boolean> dispatching = 20 new ThreadLocal<Boolean>() { 21 @Override 22 protected Boolean initialValue() { 23 return false; 24 } 25 }; 26 27 @Override 28 void dispatch(Object event, Iterator<Subscriber> subscribers) { 29 checkNotNull(event); 30 checkNotNull(subscribers); 31 Queue<Event> queueForThread = queue.get();
// 事件添加进队列 32 queueForThread.offer(new Event(event, subscribers)); 33 // 当前不在转发中，开始转发 34 if (!dispatching.get()) { 35 dispatching.set(true); 36 try { 37 Event nextEvent;
// 迭代从线程队列中取事件 38 while ((nextEvent = queueForThread.poll()) != null) {
// 迭代事件的Iterator<Subscriber> subscribers,调用订阅者转发事件 39 while (nextEvent.subscribers.hasNext()) { 40 nextEvent.subscribers.next().dispatchEvent(nextEvent.event); 41 } 42 } 43 } finally { 44 dispatching.remove(); 45 queue.remove(); 46 } 47 } 48 } 49 50 private static final class Event { 51 private final Object event; 52 private final Iterator<Subscriber> subscribers; 53 54 private Event(Object event, Iterator<Subscriber> subscribers) { 55 this.event = event; 56 this.subscribers = subscribers; 57 } 58 } 59 }
可见核心方法在dispatchEvent，调用订阅者转发事件
1 final void dispatchEvent(final Object event) { 2 executor.execute( 3 new Runnable() { 4 @Override 5 public void run() { 6 try { 7 invokeSubscriberMethod(event); 8 } catch (InvocationTargetException e) { 9 bus.handleSubscriberException(e.getCause(), context(event)); 10 } 11 } 12 }); 13 } 14 15 /** 16 * 执行订阅者方法18 */ 19 @VisibleForTesting 20 void invokeSubscriberMethod(Object event) throws InvocationTargetException { 21 try { 22 method.invoke(target, checkNotNull(event)); 23 } catch (IllegalArgumentException e) { 24 throw new Error("Method rejected target/argument: " + event, e); 25 } catch (IllegalAccessException e) { 26 throw new Error("Method became inaccessible: " + event, e); 27 } catch (InvocationTargetException e) { 28 if (e.getCause() instanceof Error) { 29 throw (Error) e.getCause(); 30 } 31 throw e; 32 } 33 }
四、总结
本文我们先快速了解Google EventBus总体架构,然后从一个简单的应用入手知道如何使用，再深入剖析源码彻底了解原理，并分析了有哪些值得借鉴的地方，最后我们来看一下传统观察者模式和EventBus的区别：
|
监听者管理 |
监听特定事件 |
把监听者注册到生产者 |
按事件超类监听 | 检测没有监听者的事件 | 分发事件 | |
|
传统观察者模式 |
用列表管理监听者，还要考虑线程同步；或者使用工具类 | 定义相应的事件监听者类 |
调用事件生产者的register方法，开发者必须知道所有事件生产者的类型，才能正确地注册监听者 |
很困难，需要开发者自己去实现匹配逻辑 | 在每个事件分发方法中添加逻辑代码 | 开发者自己写代码，包括事件类型匹配、异常处理、异步分发 |
| EventBus | 内部已经实现了监听者管理 |
以自定义Event为唯一参数创建方法， 并用Subscribe注解标记。 |
EventBus.register(Object) | EventBus自动把事件分发给事件超类的监听者 | EventBus会把所有发布后没有监听者处理的事件包装为DeadEvent |
EventBus.post(Object) 异步分发可以直接用EventBus的子类AsyncEventBus |
==参考==
官方介绍https://github.com/google/guava/wiki/EventBusExplained