一、为什么需要事件机制

痛点：业务代码高度耦合。新增副作用需要改动主要业务类，副作用失败会影响主流程，单元测试必须 mock 所有副作用依赖。

先看一个没有事件的代码：

@Service
public class OrderService {
@Autowired private SmsService smsService;@Autowired private PointService pointService;@Autowired private LogService logService;@Autowired private InventoryService inventoryService;@Transactional
public void createOrder {
// 主要：创建订单
saveOrder;// 副作用：发短信、加积分、记日志、扣库存
smsService.sendOrderSuccessSms);pointService.addPoints,dto.getAmount);logService.recordOrderLog;inventoryService.deduct,dto.getQty);}
}

问题一目了然：

耦合问题
├── OrderService 直接依赖多个副作用服务
├── 新增一个副作用要改 OrderService
├── 某个副作用失败可能影响主流程
├── 无法控制副作用执行顺序
└── 单元测试需要 mock 所有依赖

用事件机制重构后：

@Service
public class OrderService {
@Autowired private ApplicationEventPublisher publisher;@Transactional
public void createOrder {
// 主要：创建订单
saveOrder;// 发布事件，不管副作用
publisher.publishEvent);}
}
@Component
public class SmsListener {
@EventListener
public void onOrderCreated {
// 发短信
}
}
@Component
public class PointListener {
@EventListener
public void onOrderCreated {
// 加积分
}
}

主要价值：发布者和监听者解耦，通过事件作为通信媒介。

二、Spring 事件的主要三件套

定义事件

// Spring + 任意对象都能当事件。不需要继承 ApplicationEvent
public record OrderCreatedEvent(
Long orderId,Long userId,String phone,BigDecimal amount) {}

发布事件

@Service
public class OrderService {
// 方式一：直接注入 Publisher
@Autowired private ApplicationEventPublisher publisher;// 方式二：ApplicationContext 本身就是 Publisher
// @Autowired private ApplicationContext applicationContext;public void createOrder {
saveOrder;// 发布事件
publisher.publishEvent(new OrderCreatedEvent(
dto.getOrderId。dto.getUserId,dto.getPhone,dto.getAmount));}
}

监听事件

// 方式一：@EventListener 注解
@Component
public class OrderEventListener {
@EventListener
public void handleOrderCreated {
log.info);// 处理逻辑，话说回来，}
}
// 方式二：实现 ApplicationListener 接口
@Component
public class OrderCreatedListener implements ApplicationListener {
@Override
public void onApplicationEvent {
// 处理逻辑…}
}

三、源码拆解：publishEvent 到底干了什么

整体链路

publisher.publishEvent
│ ▼ AbstractApplicationContext.publishEvent
│ ├── 获取事件类型
│ ├── 调用 ApplicationEventMulticaster
│ └─► SimpleApplicationEventMulticaster.multicastEvent
│ │ ├── 获取所有匹配的 ApplicationListener
│ │ └─► 遍历 Listener → invokeListener
│ │ ├─► listener.onApplicationEvent
│ │ └─► 或 MethodApplicationListenerAdapter.invoke
│ └── 父容器传播
└─► this.parent.publish

publishEvent 源码片段

@Override
public void publishEvent {
publishEvent;}
protected void publishEvent {
// . 包装事件：如果不是 ApplicationEvent，用 PayloadApplicationEvent 包装
ApplicationEvent applicationEvent;if {
applicationEvent = ae;} else {
// ← 任意对象都能当成 Event 的根本原因
applicationEvent = new PayloadApplicationEvent<>;其实，**/
java
**/
java
**/
java
**/
java
**/
java
**/
java
**/
java
**/
java
**/


一、为什么需要 Event 机制——业务痛点直击！​​​​​​​​​​​ ​​ ​ ​ ​ ​ ​ ​ ​


从*痛点*来看。主要业务与各种副作用强耦合，导致新增需求改动大量代码；事务回滚时副作用仍会执行，单元测试必须 mock 所有外部服务。

① 没有 Event 的写法示例：
@Service
public class OrderService {
@Autowired private SmsService smsService;@Autowired private PointService pointService;说起来，@Autowired private LogService logService;@Autowired private InventoryService inventoryService;@Transactional
public void createOrder {
// 主要业务 – 创建订单
saveOrder;// 副作用 – 发短信、加积分、记日志、扣库存
smsService.sendOrderSuccessSms);pointService.addPoints,dto.getAmount);logService.recordOrderLog;inventoryService.deduct,dto.getQty);}
}



*问题清单*这方面，

耦合问题
├─ Order Service 直接依赖多个副作用 Service
├─ 新增副作用 必须改动 Order Service
├─ 任意副作用异常都会导致主事务回滚或错误传播
├─ 无法控制副作用执行顺序
└─ 单元测试需 Mock 所有依赖。维护成本高



② 引入 Event 后的重构示例：
@Service
public class OrderService {
@Autowired private ApplicationEventsPublisher publisher;@Transactional
public void createOrder {
saveOrder;// 主要业务不变
publisher.publish);// 发布领域 Event
}
}
@Component
public class SmsListener {
@ EventListener
public void onCreate{ sms.send);}
}
@Component
public class PointListener {
@ EventListener
public void onCreate{ point.add,e.amount);
}
}

}

再看*主要价值*。发布者与监听者彻底解耦，业务侧只关心“发生了什么”，而不关心“谁来处理”。


二、Spring Event 的主要三件套 


.


组件名称 & 职责 
说明 & 注意事项 
备注 


`ApplicationE vent` 
携带业务数据。但 POJO / record，无需继承 `Applic ationE vent`。
Spring 4+ 开始支持任意对象 

`Applicatio nE v entPublisher` 
发布入口；按理说，`Applicatio nC ontext` 本身即实现此接口。可直接 `@Autowire` 使用。
无论是同步还是异步，都由此入口触发 

`@E ventLis tener / Applicatio nLis ten er` 
消费端；支持注解或实现接口两种风格。可多对同一 Event 注册多 Listener。
SpEL 条件过滤 + `@Async` 异步灵活组合 



① 定义 Event :
& nbsp;老实说，// 任意 POJO / record 均可当作 Event，不必继承 Applicati onE v ent
pub lic rec ord Or derCr eatedEv ent(
long orderI d,long userI d。Stri ng phone,BigDeci mal amou nt){ }


 {
＠Override
pu bl ic vo i d onAppli cationEv ent{…，…}
}
＜／ code ＞＜／ pre ＞

/ table>
***


*关键发现*这方面。


对比项 <> th>
@ E ventL istener <> th>
Applicatio nLis tener<> / th>/ tr>/ ad>


灵活度 <> td>✓✓✓✓✓&checkmar k;&checkmar k，其实，&checkmar k;
✗✗✗✗

SpEL 条件支持 <> td>✓
✗

异步集成 <> td>&c heckmark;<

推荐度 <> t d>☆☆☆☆☆☆☆// 推荐
& star;-~ /t d>











PayloadAppli­cation­Even

t 为任意 POJO 提供统一包装，使得 record/Map 都能直接作为 Event。


multicast­Evento f 才是真正遍历并调用 Listener 的地方。



if…怎么说呢，实现子容 器向上广播。这也是子容 器 Listener 能收到父 容 器 发出的 Event 的根本原因。


<\/ul>



‹ pre ›‹ code cl ass = “ language - java ” ›@Override

pub lic voi d multica stErEve nt{

multica stErEv ent);

}

@Override

for){

Execu tor exec u tor = getTa skExe ctor;

if{ execu tor.ex ect -> invok eLis ten er);}else{ invok eLis tener;}

‹／ co de› ‹／pr e› 

至于*关键发现*，







默认同步 – 未配置 TaskExecutor 时直接同步调用 Listener；会冒泡回 Publisher。



异步 – 配置 TaskExecutor 后交给线程池执行。异常不影响 Publisher，但执行顺序不可控。




‹ pre ›‹ code cl ass = “ language - java ” ›protected Co llection getA pplicationListeners{
Object cacheKey = new CacheKey,eventTy pe );ListenerRetriever retriever = this.retri everCache.ge);if{ return retriever.ge);}
List allListeners = new Arra yList<>;for{
App lic ationListe ner lis tene r = getBe an;if){
allListeners.add;//<— 类型匹配成功才加入集合 
            }
        }
        …// 缓存结果后返回 
        return allListeners;
}
*主要判断* — `supportsEvento f` 使用 Spring 的 `ResolvableType` 检查泛型声明，实现“只有相同或子类 Events 才会被投递”。这也是不同 Events 不会互相干扰的根本原因。


@ EventListerner 方法如何变成 Listener？






- 启动时 org.springframework.context.event.EventListe nerMethodProcessor 扫描所有 Bean。
- 启动时>


- 找到标注 @ EventListerner 的方法后为每个方法生成 ApplicationListe nerMethodAdapter。
- 找到标注>


- 把该 ApplicationEven tMulticaster，随后在 multicastEvento f 中被遍历调用。
- 把该>

＜ pre ＞＜ co de cla ss ="lan guage-ja va"＞
@Override
public void afterSingletonsInstantiated {

for){
Object bean = appCtx.getBean;for.getMethods){
if){
Applica­tionListen­er adapt =
new MethodApplic­a­tionListen­erAdapter;appCtx.addApp­licationList­ener;}
}
}
}
＜/ co de ›

＜/ pr e>


四、同步 VS 异步——Execution Model 大揭秘！