概述
经过IoC的解析，我们需要将注意力再拉回到refresh方法中。我们还有这几个方法还没解析完:
这里继续，先来讲Spring事件监听机制。
Spring事件监听
在业务开发过程中为了解耦，我们可能或多或少接触过MQ消息队列这东西或者对设计模式中的观察者模式了解的话，实现事件监听需要的组成部分有这几个:
- 事件(Event)
- 事件生产者(Publisher)
- 事件消费者(Consumer)
- 管理中介(Broker)
是不是很熟悉？Spring中是用事件、事件监听器、事件发布者和事件广播器来实现
- 事件(ApplicationEvent)
- 事件监听器(ApplicationListener)
- 事件发布者(ApplicationEventPublisher)
- 事件广播器(ApplicationEventMulticaster)
它们的关系如下图:
那这里解析一下refresh中的这几个方法:
initApplicationEventMulticaster()：初始化应用的事件广播器(见源码解析1)
registerListeners()：注册监听器(见源码解析2)
finishRefresh()：完成上下文的刷新工作(见源码解析3)
【源码解析1】 初始化应用的事件广播器:initApplicationEventMulticaster方法
protected void initApplicationEventMulticaster() {
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
// 如有有自己注册class Name 是 applicationEventMulticaster，使用自定义广播器
//APPLICATION_EVENT_MULTICASTER_BEAN_NAME = "applicationEventMulticaster"
if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
this.applicationEventMulticaster =
beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
if (logger.isTraceEnabled()) {
logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
}
}
else {
// 没有自定义，使用默认的事件广播器
this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
if (logger.isTraceEnabled()) {
logger.trace("No '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "' bean, using " +
"[" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");
}
}
}
事件广播器beanName ：applicationEventMulticaster。
如果有自定义的广播器已经在beanFactory中注册，则使用该广播器;
若没有自定义的广播器的情况下，创建一个默认的事件广播器SimpleApplicationEventMulticaster，查看一下其类图:
【源码解析2】 注册监听器 : registerListeners方法
protected void registerListeners() {
// Register statically specified listeners first.
// 这里是硬编码注册的监听器(（可以通过自定义ApplicationContextInitializer添加）)
for (ApplicationListener listener : getApplicationListeners()) {
getApplicationEventMulticaster().addApplicationListener(listener);
}
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let post-processors apply to them!
// 不要在这里初始化 factoryBean : 我们需要保留所有常规 bean 未初始化，以便让后处理程序应用于它们!
// 通过配置文件或注解注入BeanFactory的监听器处理
String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
for (String listenerBeanName : listenerBeanNames) {
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
}
// Publish early application events now that we finally have a multicaster...
// 使用事件广播器，发布早期应用程序事件到相应的监听器
Set earlyEventsToProcess = this.earlyApplicationEvents;
this.earlyApplicationEvents = null;
if (earlyEventsToProcess != null) {
for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
getApplicationEventMulticaster().multicastEvent(earlyEvent);
}
}
}
到这个阶段，事件广播器和监听器都在Spring容器里初始化和注册了，之后就可以实现监听者模式了，对事件的发布进行监听然后处理。继续看finishRefresh里的内容。
finishRefresh
finishRefresh方法源码如下:
protected void finishRefresh() {
// Clear context-level resource caches (such as ASM metadata from scanning).
//清除resourceCaches资源缓存中的数据
clearResourceCaches();
// Initialize lifecycle processor for this context.
//注释1. 为此上下文初始化生命周期处理器
initLifecycleProcessor();
// Propagate refresh to lifecycle processor first.
//注释2. 首先将刷新完毕事件传播到生命周期处理器（触发isAutoStartup方法返回true的SmartLifecycle的start方法）
getLifecycleProcessor().onRefresh();
// Publish the final event.
//注释3. 推送上下文刷新完毕事件到相应的监听器
publishEvent(new ContextRefreshedEvent(this));
// Participate in LiveBeansView MBean, if active.
LiveBeansView.registerApplicationContext(this);
}
这里主要讲注释3,另外的解析放到后文里详解。
注释3.推送上下文刷新完毕事件到相应的监听器 publishEvent(见源码解析4)
【源码解析4】 推送上下文刷新完毕事件到相应的监听器:publishEvent方法
@Override
public void publishEvent(Object event) {
publishEvent(event, null);
}
protected void publishEvent(Object event, @Nullable ResolvableType eventType) {
Assert.notNull(event, "Event must not be null");
// Decorate event as an ApplicationEvent if necessary
//如果必需的话把event装饰成ApplicationEvent
ApplicationEvent applicationEvent;
if (event instanceof ApplicationEvent) {
applicationEvent = (ApplicationEvent) event;
}
else {
applicationEvent = new PayloadApplicationEvent<>(this, event);
if (eventType == null) {
eventType = ((PayloadApplicationEvent) applicationEvent).getResolvableType();
}
}
// Multicast right now if possible - or lazily once the multicaster is initialized
if (this.earlyApplicationEvents != null) {
this.earlyApplicationEvents.add(applicationEvent);
}
else {
//注释1. 使用事件广播器广播事件到相应的监听器
getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
}
// Publish event via parent context as well...
// 通过parent发布事件
if (this.parent != null) {
if (this.parent instanceof AbstractApplicationContext) {
((AbstractApplicationContext) this.parent).publishEvent(event, eventType);
}
else {
this.parent.publishEvent(event);
}
}
}
注释1. 使用事件广播器广播事件到相应的监听器
getApplicationEventMulticaster()获取事件广播器
multicastEvent()广播事件到相应的监听器(见源码解析5)
【源码解析5】 SimpleApplicationEventMulticaster类的multicastEvent方法
@Override
public void multicastEvent(ApplicationEvent event) {
multicastEvent(event, resolveDefaultEventType(event));
}
@Override
public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
//获取任务执行器executor
Executor executor = getTaskExecutor();
// 遍历注册的消息监听器(getApplicationListeners)
for (ApplicationListener listener : getApplicationListeners(event, type)) {
if (executor != null) {
//executor不为null，则使用executor调用监听器
executor.execute(() -> invokeListener(listener, event));
}
else {
// 直接调用监听器
invokeListener(listener, event);
}
}
}
在前面我们已经提到过SimpleApplicationEventMulticaster,是Spring默认的事件广播器。
调用监听器invokeListener方法(见源码解析6)
【源码解析6】 调用监听器:invokeListener方法,真正做事的为doInvokeListener方法
protected void invokeListener(ApplicationListener listener, ApplicationEvent event) {
ErrorHandler errorHandler = getErrorHandler();
if (errorHandler != null) {
try {
doInvokeListener(listener, event);
}
catch (Throwable err) {
errorHandler.handleError(err);
}
}
else {
doInvokeListener(listener, event);
}
}
//执行调用监听器
private void doInvokeListener(ApplicationListener listener, ApplicationEvent event) {
try {
//触发监听器的onApplicationEvent方法，参数为给定的事件
listener.onApplicationEvent(event);
}
catch (ClassCastException ex) {
String msg = ex.getMessage();
if (msg == null || matchesClassCastMessage(msg, event.getClass())) {
// Possibly a lambda-defined listener which we could not resolve the generic event type for
// -> let's suppress the exception and just log a debug message.
Log logger = LogFactory.getLog(getClass());
if (logger.isTraceEnabled()) {
logger.trace("Non-matching event type for listener: " + listener, ex);
}
}
else {
throw ex;
}
}
}
好了，在这里我们可以发现，监听器里边的onApplicationEvent方法被触发了，所以，从这一个流程下来，我们可以看到一个事件的发布，可以筛选出对应的监听器并触发其onApplicationEvent，执行相应的操作。
自定义一个事件和监听器
1.创建一个下单事件OrderEvent
public class OrderEvent extends ApplicationEvent{
public OrderEvent(ApplicationContext source) {
super(source);
System.out.println("构建下单事件");
}
}
- 创建一个监听器监听下单事件
@Component
public class OrderListener implements ApplicationListener {
@Override
public void onApplicationEvent(OrderEvent orderEvent) {
System.out.println("订单监听器监听到下单事件,订单号为:20210201100001");
//后续业务逻辑....
}
}
- 在前文的demo基础上，修改main函数
public class App {
public static void main(String[] args) throws ClassNotFoundException {
ClassPathXmlApplicationContext context =
new ClassPathXmlApplicationContext("applicationContext.xml");
OrderEvent orderEvent = new OrderEvent(context);
context.publishEvent(orderEvent);
}
}
这样容器初始化后，会执行发布下单事件，并将事件推送到OrderListener 监听器中，并触发onApplicationEvent,执行效果如下:
※Spring的事件监听机制是同步处理的，具体留给大家自己探索一下，可以打印每个事件监听器处理时的线程名，是否跟主线程是同一个。是否可以进行异步改造？
如果一个事件有多个监听器，如何给这些监听器排序呢？
用前文解析代码的时候提到的 ，bean实现Ordered接口和PriorityOrdered接口
这样重写其getOrder方法，设置这些监听器的触发顺序。
总结
好了，事件监听机制就介绍到这里，掌握观察者模式以及ApplicationEventMulticaster、ApplicationListener、ApplicationEvent、ApplicationEventPublisher这几个组件的关系，以及事件触发执行流程。下一节介绍finishRefresh中剩下的几个方法。