作者简介：大家好，我是smart哥，前中兴通讯、美团架构师，现某互联网公司CTO

联系qq：184480602，加我进群，大家一起学习，一起进步，一起对抗互联网寒冬

之前我们一起学习了Spring事件监听机制，已经忘了的同学可以先去回顾一下。

当时我在文章里留了一个问题：

现在，终于到了填坑的时候了！为了把这个问题讲清楚，我打算模拟一个山寨版的Spring事件监听机制。

然而，重新回顾却发现：当时太年轻了，刚学完Spring源码，巴不得秀一波骚操作，所以写得很复杂，可读性较差（你看看网上很多文章，都犯了我以前的毛病）。既然这篇文章是为了让大家明白底层原理，那么“让大家懂”比什么都重要。

所以这次重写山寨版Spring事件监听机制，我去除了很多非核心类，把所有逻辑都压缩到ApplicationContext中，希望能带来更好的阅读体验。

事件监听机制？还是观察者模式？

很多人总是执着于外在的表象，并在“它究竟是什么”这个问题上争论不休，却很少去了解它能做什么。在对待设计模式这个问题上，很多人执着于“它究竟是哪种模式”，却不去理会“这种模式能解决什么问题”。就像Spring的事件监听机制，它其实是什么模式都不重要，重要的是了解它可以解决什么问题。

说起来也是GOF害的，当年编写了一本《Design Patterns: Elements of Reusable Object-Oriented Software》（中文译名《设计模式》），举例了常见的23种设计模式，结果内容实在抽象，很多人看完云里雾里，只记得了“23”这个数字，然后以为天底下只有23种设计模式，每每见到一种模式，就想着往上面套...发现那里有点不一致，就浑身难受，到处问人：哎呀，这个到底是啥模式呀...

去他的，一点都不重要！设计模式最重要的就是设计原则，而不是具体的模式，理解了设计原则才能写出好的设计模式。无招胜有招，才是一种境界。

设计思路

代码

简单的maven项目即可

<build><plugins><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-compiler-plugin</artifactId><configuration><source>8</source><target>8</target></configuration></plugin></plugins>
</build><dependencies><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><version>1.18.16</version></dependency>
</dependencies>

自定义事件

/*** 退单事件*/
public class OrderCanceledEvent extends Event {public OrderCanceledEvent(Object source) {super(source);}
}/*** 下单事件*/
public class OrderCompletedEvent extends Event {public OrderCompletedEvent(Long source) {super(source);}
}

业务代码

/*** 短信服务，监听下单事件，下单后发短信通知用户*/
public class SmsService implements Listener<OrderCompletedEvent> {@SneakyThrows@Overridepublic void onApplicationEvent(OrderCompletedEvent event) {System.out.println("下单成功！您的订单号是: " + event.getSource());TimeUnit.SECONDS.sleep(2);}@Overridepublic boolean supportsEventType(Event event) {return event instanceof OrderCompletedEvent;}}/*** 物流服务，监听下单事件，用户下单后发货*/
public class CarService implements Listener<OrderCompletedEvent> {@SneakyThrows@Overridepublic void onApplicationEvent(OrderCompletedEvent event) {System.out.println("订单" + event.getSource() + "已经发货！");TimeUnit.SECONDS.sleep(2);}@Overridepublic boolean supportsEventType(Event event) {return event instanceof OrderCompletedEvent;}
}/*** 退款服务，监听取消订单事件，为用户退款*/
public class RefundService implements Listener<OrderCanceledEvent> {@SneakyThrows@Overridepublic void onApplicationEvent(OrderCanceledEvent event) {System.out.println("退款成功！" + event.getSource() + "元已经退回原账户");TimeUnit.SECONDS.sleep(2);}@Overridepublic boolean supportsEventType(Event event) {return event instanceof OrderCanceledEvent;}
}

核心实现

ApplicationContext

public class ApplicationContext {private final Set<Listener<?>> listeners = new LinkedHashSet<>();/*** 注册bean（监听器）** @param listener*/public void registerListener(Listener<?> listener) {listeners.add(listener);}/*** 发布事件** @param event*/public void publish(Event event) {Set<Listener<?>> matchedListeners = getMatchedListeners(event);matchedListeners.forEach(listener -> this.invokeListener(listener, event));}// ------------- private methods -------------private Set<Listener<?>> getMatchedListeners(Event event) {if (listeners.isEmpty()) {return Collections.emptySet();}return listeners.stream().filter(listener -> listener.supportsEventType(event)).collect(Collectors.toSet());}@SuppressWarnings({"unchecked", "rawtypes"})private void invokeListener(Listener listener, Event event) {listener.onApplicationEvent(event);}}

event

/*** 事件*/
@Getter
public class Event {private Object source;public Event(Object source) {this.source = source;}
}

Listener

/*** 监听器** @param <E>*/
public interface Listener<E extends Event> {/*** 事件发生时触发** @param event*/void onApplicationEvent(E event);/*** 监听器是否匹配** @param event* @return*/boolean supportsEventType(Event event);}

测试

public class EventTest {private ApplicationContext applicationContext = new ApplicationContext();// 模拟Spring启动，初始化容器并注册bean@Beforepublic void refreshApplication() {applicationContext.registerListener(new SmsService());applicationContext.registerListener(new CarService());applicationContext.registerListener(new RefundService());}// 模拟下单@Testpublic void orderCompletedService() {// 扣减库存...// 生成订单... orderId=10086// 订单流水...// 下单成功，发布事件applicationContext.publish(new OrderCompletedEvent(10086L));}// 模拟取消订单@Testpublic void orderCanceledService() {// 回退库存...// 更改订单状态... orderId=10086// 订单流水...// 订单取消成功，发布事件applicationContext.publish(new OrderCanceledEvent(10086L));}
}

优化：支持异步事件

之前提到过，Spring的事件监听机制模式是同步的：

上面代码有3个角色，OrderService发布事件、SmsService监听事件（sleep 2s）、CarService监听事件（sleep 2s）

那么，怎么才能支持异步呢？引入线程池即可：

public class ApplicationContext {private final Set<Listener<?>> listeners = new LinkedHashSet<>();// 支持异步事件@Nullableprivate Executor taskExecutor;/*** 注册bean（监听器）** @param listener*/public void registerListener(Listener<?> listener) {listeners.add(listener);}/*** 发布事件** @param event*/public void publish(Event event) {Set<Listener<?>> matchedListeners = getMatchedListeners(event);for (Listener<?> listener : matchedListeners) {Executor executor = getTaskExecutor();if (executor != null) {// 如果外界设置了线程池，则变为异步事件executor.execute(() -> invokeListener(listener, event));} else {// 默认同步事件invokeListener(listener, event);}}}// ------------- private methods -------------private Set<Listener<?>> getMatchedListeners(Event event) {if (listeners.isEmpty()) {return Collections.emptySet();}return listeners.stream().filter(listener -> listener.supportsEventType(event)).collect(Collectors.toSet());}@SuppressWarnings({"unchecked", "rawtypes"})private void invokeListener(Listener listener, Event event) {listener.onApplicationEvent(event);}@Nullablepublic Executor getTaskExecutor() {return this.taskExecutor;}public void setTaskExecutor(Executor executor) {this.taskExecutor = executor;}}

至此，本篇完。初看不以为意，但你如果再扫一眼，就会发现整个工程只引入了Lombok和Junit，几乎全部依赖都来自于JDK本身。也就是说，Spring最大的用处只不过是提供了自动装配（DI），它的事件监听机制本身和DI没太大关系，JDK足矣。

学习必须往深处挖，挖的越深，基础越扎实！

阶段1、深入多线程

阶段2、深入多线程设计模式

阶段3、深入juc源码解析

阶段4、深入jdk其余源码解析

阶段5、深入jvm源码解析