概述
經過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<ApplicationEvent> 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<OrderEvent> {
@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中剩下的幾個方法。
