掌握Spring事件监听器的内部逻辑与实现

package com.example.demo.event;

import org.springframework.context.ApplicationEvent;

// 事件类

public class HierarchicalEventPropagationEvent extends ApplicationEvent {

private String message;

public HierarchicalEventPropagationEvent(Object source, String message) {

super(source);

this.message = message;

}

public String getMessage() {

return message;

}

}

package com.example.demo.listener;

import com.example.demo.event.HierarchicalEventPropagationEvent;

import org.springframework.context.ApplicationListener;

// 监听器类

public class HierarchicalEventPropagationListener implements ApplicationListener<HierarchicalEventPropagationEvent> {

private String listenerId;

public HierarchicalEventPropagationListener(String listenerId) {

this.listenerId = listenerId;

}

@Override

public void onApplicationEvent(HierarchicalEventPropagationEvent event) {

System.out.println(listenerId + " received event - " + event.getMessage());

}

}

package com.example.demo;

import com.example.demo.event.HierarchicalEventPropagationEvent;

import com.example.demo.listener.HierarchicalEventPropagationListener;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class DemoApplication {

public static void main(String[] args) {

// 创建父容器,注册监听器

AnnotationConfigApplicationContext parentCtx = new AnnotationConfigApplicationContext();

parentCtx.addApplicationListener(new HierarchicalEventPropagationListener("Parent Listener"));

parentCtx.refresh();

// 创建子容器,注册监听器

AnnotationConfigApplicationContext childCtx = new AnnotationConfigApplicationContext();

childCtx.setParent(parentCtx);

childCtx.addApplicationListener(new HierarchicalEventPropagationListener("Child Listener"));

childCtx.refresh();

// 发布事件

HierarchicalEventPropagationEvent event1 = new HierarchicalEventPropagationEvent(parentCtx, "Event from parent");

parentCtx.publishEvent(event1);

HierarchicalEventPropagationEvent event2 = new HierarchicalEventPropagationEvent(childCtx, "Event from child");

childCtx.publishEvent(event2);

}

}

package com.example.demo.listener;

import org.springframework.context.ApplicationListener;

import org.springframework.context.PayloadApplicationEvent;

/**

* 通用监听器，能监听到所有类型的PayloadApplicationEvent

*/

public class CustomObjectApplicationListener implements ApplicationListener<PayloadApplicationEvent> {



@Override

public void onApplicationEvent(PayloadApplicationEvent event) {

System.out.println("收到PayloadApplicationEvent，数据是：" + event.getPayload());

}

}

package com.example.demo.listener;

import org.springframework.context.ApplicationListener;

import org.springframework.context.PayloadApplicationEvent;

/**

* 特定数据类型的监听器。这个监听器专门监听String类型的PayloadApplicationEvent

*/

public class CustomStringApplicationListener implements ApplicationListener<PayloadApplicationEvent<String>> {



@Override

public void onApplicationEvent(PayloadApplicationEvent<String> event) {

System.out.println("收到了字符串数据：" + event.getPayload());

}

}

package com.example.demo;

import com.example.demo.listener.CustomObjectApplicationListener;

import com.example.demo.listener.CustomStringApplicationListener;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import java.util.Date;

public class DemoApplication {

public static void main(String[] args) {

AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();

// 注册监听器

ctx.addApplicationListener(new CustomObjectApplicationListener());

ctx.addApplicationListener(new CustomStringApplicationListener());

ctx.refresh();

// 发送事件

ctx.publishEvent("Hello, World!"); // 发送一个字符串

ctx.publishEvent(2023); // 发送一个整数

ctx.publishEvent(new Date()); // 发送一个日期对象

}

}

package com.example.demo.event;

import org.springframework.context.ApplicationEvent;

public class ArticlePublishedEvent extends ApplicationEvent {

private String title;

private String author;

private String publishedDate;

public ArticlePublishedEvent(Object source, String title, String author, String publishedDate) {

super(source);

this.title = title;

this.author = author;

this.publishedDate = publishedDate;

}

public String getTitle() {

return title;

}

public String getAuthor() {

return author;

}

public String getPublishedDate() {

return publishedDate;

}

}

import org.springframework.context.ApplicationListener;

public class ArticlePublishedListener implements ApplicationListener<ArticlePublishedEvent> {

@Override

public void onApplicationEvent(ArticlePublishedEvent event) {

System.out.println("A new article has been published!");

System.out.println("Title: " + event.getTitle());

System.out.println("Author: " + event.getAuthor());

System.out.println("Published Date: " + event.getPublishedDate());

// Notify subscribers about the new article

notifySubscribers(event);

// Update search engine index with new article details

updateSearchIndex(event);

// Update statistical data about articles

updateStatistics(event);

}

private void notifySubscribers(ArticlePublishedEvent event) {

// Logic to notify subscribers (dummy logic for demonstration)

System.out.println("Notifying subscribers about the new article titled: " + event.getTitle());

}

private void updateSearchIndex(ArticlePublishedEvent event) {

// Logic to update search engine index (dummy logic for demonstration)

System.out.println("Updating search index with the new article titled: " + event.getTitle());

}

private void updateStatistics(ArticlePublishedEvent event) {

// Logic to update statistical data (dummy logic for demonstration)

System.out.println("Updating statistics with the new article titled: " + event.getTitle());

}

}

package com.example.demo;

import com.example.demo.event.ArticlePublishedEvent;

import com.example.demo.listener.ArticlePublishedListener;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class DemoApplication {

public static void main(String[] args) {

// Initialize Spring ApplicationContext

AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();

// Register listener

ctx.addApplicationListener(new ArticlePublishedListener());

ctx.refresh();

// Simulate publishing an article

ctx.publishEvent(new ArticlePublishedEvent(ctx, "Spring Events", "John Doe", "2023-09-15"));

}

}

public void publishEvent(ApplicationEvent event) {

this.publishEvent(event, (ResolvableType)null);

}

public void publishEvent(Object event) {

this.publishEvent(event, (ResolvableType)null);

}

protected void publishEvent(Object event, @Nullable ResolvableType eventType) {

// 检查事件对象是否为空，确保发布的事件是有意义的

Assert.notNull(event, "Event must not be null");

// 判断传入的事件是否已经是ApplicationEvent类型，如果是，则无需再进行包装

Object applicationEvent;

if (event instanceof ApplicationEvent) {

applicationEvent = (ApplicationEvent)event;

} else {

// 如果传入的事件不是ApplicationEvent类型，则将其包装为PayloadApplicationEvent

applicationEvent = new PayloadApplicationEvent(this, event);

// 如果未指定事件类型，那么从包装后的事件中获取其真实类型

if (eventType == null) {

eventType = ((PayloadApplicationEvent)applicationEvent).getResolvableType();

}

}

// 判断当前是否存在earlyApplicationEvents列表

if (this.earlyApplicationEvents != null) {

// 如果存在，说明ApplicationContext还未完全初始化，将事件添加到此列表中，稍后再进行处理

this.earlyApplicationEvents.add(applicationEvent);

} else {

// 如果ApplicationContext已经初始化，那么直接通过事件多播器广播事件

this.getApplicationEventMulticaster().multicastEvent((ApplicationEvent)applicationEvent, eventType);

}

// 如果存在父ApplicationContext，则也将事件发布到父容器中

if (this.parent != null) {

if (this.parent instanceof AbstractApplicationContext) {

// 如果父容器是AbstractApplicationContext类型，则带上事件类型进行发布

((AbstractApplicationContext)this.parent).publishEvent(event, eventType);

} else {

// 否则，只传递事件对象进行发布

this.parent.publishEvent(event);

}

}

}

public class SimpleApplicationEventMulticaster extends AbstractApplicationEventMulticaster {

// 可选的任务执行器，用于异步调用事件监听器。

@Nullable

private Executor taskExecutor;

// 可选的错误处理器，用于处理在广播事件过程中出现的错误。

@Nullable

private ErrorHandler errorHandler;

// 用于记录日志的logger，它是延迟初始化的。

@Nullable

private volatile Log lazyLogger;

// 默认构造函数。

public SimpleApplicationEventMulticaster() {

}

// 带有BeanFactory参数的构造函数，通常用于更复杂的应用上下文配置中。

public SimpleApplicationEventMulticaster(BeanFactory beanFactory) {

this.setBeanFactory(beanFactory);

}

// 设置任务执行器。可以是任何Java Executor，比如Spring的SimpleAsyncTaskExecutor或Java的FixedThreadPool。

public void setTaskExecutor(@Nullable Executor taskExecutor) {

this.taskExecutor = taskExecutor;

}

// 获取当前设置的任务执行器。

@Nullable

protected Executor getTaskExecutor() {

return this.taskExecutor;

}

// 设置错误处理器。

public void setErrorHandler(@Nullable ErrorHandler errorHandler) {

this.errorHandler = errorHandler;

}

// 获取当前设置的错误处理器。

@Nullable

protected ErrorHandler getErrorHandler() {

return this.errorHandler;

}

// 这是广播事件的主要方法。它首先解析事件的类型，然后调用具有额外参数的重载方法。

public void multicastEvent(ApplicationEvent event) {

this.multicastEvent(event, this.resolveDefaultEventType(event));

}

// 这个方法是真正执行广播操作的方法。

public void multicastEvent(ApplicationEvent event, @Nullable ResolvableType eventType) {

// 确定事件类型。

ResolvableType type = (eventType != null) ? eventType : this.resolveDefaultEventType(event);

// 获取任务执行器。

Executor executor = this.getTaskExecutor();

// 获取匹配此事件类型的所有监听器。

Iterator<ApplicationListener<?>> listeners = this.getApplicationListeners(event, type).iterator();

// 遍历每个监听器并调用它。

while(listeners.hasNext()) {

ApplicationListener<?> listener = listeners.next();

// 如果有设置任务执行器，则异步调用监听器。

if (executor != null) {

executor.execute(() -> this.invokeListener(listener, event));

} else {

// 如果没有设置任务执行器，则同步调用监听器。

this.invokeListener(listener, event);

}

}

}

// 为给定的事件解析默认的事件类型。

private ResolvableType resolveDefaultEventType(ApplicationEvent event) {

return ResolvableType.forInstance(event);

}

// 调用指定的监听器来处理给定的事件，并根据需要处理错误。

protected void invokeListener(ApplicationListener<?> listener, ApplicationEvent event) {

// 获取当前的错误处理器。

ErrorHandler errorHandler = this.getErrorHandler();

if (errorHandler != null) {

try {

// 尝试调用监听器。

this.doInvokeListener(listener, event);

} catch (Throwable ex) {

// 如果出现错误，使用错误处理器处理。

errorHandler.handleError(ex);

}

} else {

// 如果没有设置错误处理器，则直接调用监听器。

this.doInvokeListener(listener, event);

}

}

// 直接调用监听器，捕获任何类型不匹配的异常。

private void doInvokeListener(ApplicationListener listener, ApplicationEvent event) {

try {

listener.onApplicationEvent(event);

} catch (ClassCastException ex) {

// 捕获类型转换异常，并根据需要进行处理。

// 这可以确保如果监听器不能处理特定类型的事件，不会导致整个广播操作失败。

String msg = ex.getMessage();

if (msg != null && !this.matchesClassCastMessage(msg, event.getClass()) && (!(event instanceof PayloadApplicationEvent) || !this.matchesClassCastMessage(msg, ((PayloadApplicationEvent)event).getPayload().getClass()))) {

throw ex;

}



// 在预期情况下捕获并记录异常，而不是抛出它。

Log loggerToUse = this.lazyLogger;

if (loggerToUse == null) {

loggerToUse = LogFactory.getLog(this.getClass());

this.lazyLogger = loggerToUse;

}

if (loggerToUse.isTraceEnabled()) {

loggerToUse.trace("Non-matching event type for listener: " + listener, ex);

}

}

}

// 根据给定的类型错误消息和事件类来检查ClassCastException是否是预期的。

private boolean matchesClassCastMessage(String classCastMessage, Class<?> eventClass) {

if (classCastMessage.startsWith(eventClass.getName())) {

return true;

} else if (classCastMessage.startsWith(eventClass.toString())) {

return true;

} else {

int moduleSeparatorIndex = classCastMessage.indexOf(47);

return moduleSeparatorIndex != -1 && classCastMessage.startsWith(eventClass.getName(), moduleSeparatorIndex + 1);

}

}

}

// 这个方法是真正执行广播操作的方法。

public void multicastEvent(ApplicationEvent event, @Nullable ResolvableType eventType) {

// 确定事件类型。

ResolvableType type = (eventType != null) ? eventType : this.resolveDefaultEventType(event);

......

// 获取匹配此事件类型的所有监听器。

Iterator<ApplicationListener<?>> listeners = this.getApplicationListeners(event, type).iterator();

......

}

public class Sample {

private List<String> names;

}

ResolvableType t = ResolvableType.forField(Sample.class.getDeclaredField("names"));

Class<?> genericType = t.getGeneric(0).resolve(); // 得到 String.class

ApplicationEvent event = new MyCustomEvent(this, "data");

applicationContext.publishEvent(event);

public class MyListener implements ApplicationListener<MyCustomEvent> {

@Override

public void onApplicationEvent(MyCustomEvent event) {

// handle the event

}

}