- 原理* 源码
- 1. 创建事件管理器
- 2. 注册事件监听器
- 自定义监听器创建
- 3. 发布事件
- 测试代码
- publishEvent(ApplicationEvent event) 源码
- 同步或者异步调用 对应事件的监听器 集合。
- invokeListener 调用监听器
原理
Spring 事件机制 其实就是 观察者模式的应用。
内部存在一个事件管理器(可以理解为维护观察者的集合),在ioc阶段，将实现了ApplicationListener接口的bean作为事件的监听器收集起来，或者我们也可以在运行时创建监听器添加到事件管理器中, 当spring发布内置事件时或者 业务代码发布事件时, 通知到对应事件的监听器, 响应消息。以实现发布订阅的效果。
源码
1. 创建事件管理器
spring容器启动核心方法 refresh() 的initApplicationEventMulticaster()
该方法的主要逻辑就是 创建ApplicationEventMulticaster 实例, 注册到bean工厂中。
/**
* Initialize the ApplicationEventMulticaster.
* Uses SimpleApplicationEventMulticaster if none defined in the context.
* @see org.springframework.context.event.SimpleApplicationEventMulticaster
*/
protected void initApplicationEventMulticaster() {
// 获取bean工厂
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
// 如果存在该bean，就打了个日志
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 {
// 如果不存在该bean,new出applicationEventMulticaster实例
this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
// 注册到bean工厂中
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() + "]");
}
}
}
2. 注册事件监听器
在 注册事件管理器 的代码下面 有个registerListeners();
image
该方法的主要逻辑 是 从 BeanFactory中取出 所有 类型为 ApplicationListener的 BeanNames,添加到 事件管理器applicationEventMulticaster的内部 类 ListenerRetriever 实例的 applicationListenerBeans 的set集合中。
protected void registerListeners() {
// Register statically specified listeners first.
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!
// 从 BeanFactory中取出 所有 类型为 ApplicationListener的 BeanNames,
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);
}
}
}
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
image
this.defaultRetriever是 AbstractApplicationEventMulticaster 内部类ListenerRetriever 的实例, 在声明阶段就已经实例化了
image
该ListenerRetriever 的实例又有一个内部set集合，专门用来放 监听器的BeanName.
image
注册事件监听器,就是将 事件监听器的BeanName 添加到 AbstractApplicationEventMulticaster.defaultRetriever.applicationListenerBeans 的set集合中。
自定义监听器创建
一、常用的方式 , 注册ApplicationListener类型的Bean,让spring在该阶段 获取到 BeanName
- 注册监听监听器bean，只订阅 MyEvent 事件。
@Component
public class MyListener implements ApplicationListener {
@Override
public void onApplicationEvent(MyEvent event) {
// do sth;
}
}
-
创建事件类,继承 spring的ApplicationEvent 类。构造方法可以传入一些信息,在 响应事件的时候可以被获取到。
public class MyEvent extends ApplicationEvent { /** * Create a new ApplicationEvent. * * @param source the object on which the event initially occurred (never {@code null}) */ public MyEvent(Object source) { super(source); } }
二、还有一种方式 就是 直接调用AbstractApplicationContext实例的addApplicationListener 方法。
@Component
public class ListenerCreator implements InitializingBean {
// 这里需要用AbstractApplicationContext类型,ApplicationContext接口没有这个api
@Autowired
private AbstractApplicationContext applicationContext;
@Override
public void afterPropertiesSet() throws Exception {
// 直接添加到事件管理器中
applicationContext.addApplicationListener(new MyListener());
}
}
3. 发布事件
测试代码
@Test
void test1() {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
applicationContext.publishEvent(new MyEvent("我发布了一个自定义事件。"));
}
image
publishEvent(ApplicationEvent event) 源码
image
调用这里的getApplicationEventMulticaster() 就是获取到 事件管理器 applicationEventMulticaster 对象,调用它的multicastEvent方法
同步或者异步调用 对应事件的监听器 集合。
监听器 订阅的事件 是通过泛型来指定的。
@Override
public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
// getApplicationListeners(event, type)获取订阅对应事件的监听器的集合,遍历，调用invokeListener
for (final ApplicationListener listener : getApplicationListeners(event, type)) {
// 判断内部是有执行器,有的话就异步调用。
Executor executor = getTaskExecutor();
if (executor != null) {
executor.execute(() -> invokeListener(listener, event));
}
else {
// 否则同步调用。
invokeListener(listener, event);
}
}
}
这个执行器成员变量,只要可以拿到SimpleApplicationEventMulticaster实例,或者自己创建其实例，就可以设置进去任何Executor类型 实例，比如常见的线程池。
@Component
public class ListenerCreator implements InitializingBean {
@Autowired
private SimpleApplicationEventMulticaster applicationEventMulticaster;
@Override
public void afterPropertiesSet() throws Exception {
applicationEventMulticaster.setTaskExecutor(Executors.newSingleThreadExecutor());
// applicationContext.addApplicationListener(new MyListener());
}
}
invokeListener 调用监听器
protected void invokeListener(ApplicationListener listener, ApplicationEvent event) {
// 这个又是内部的成员变量,也可以和taskExecutor一样的的方式设置进去 ,用来处理异常的。
ErrorHandler errorHandler = getErrorHandler();
if (errorHandler != null) {
try {
doInvokeListener(listener, event);
}
catch (Throwable err) {
errorHandler.handleError(err);
}
}
else {
doInvokeListener(listener, event);
}
}
doInvokeListener方法就是直接调用 监听器对象 实现 的 onApplicationEvent(event)。over。