Spring-Boot和Spring的监听器模式

63 阅读 0 评论 42 点赞

我是靠谱客的博主舒心发卡，这篇文章主要介绍Spring-Boot和Spring的监听器模式，现在分享给大家，希望可以做个参考。

最近阅读SpringBoot的源码，发现一个奇怪的现象：项目中有两处地方具有发布事件功能，一个是SpringApplicationRunListener接口；另一个是ApplicationEventPublisher接口的publishEvent方法，ApplicationContext接口实现了该接口。标准监听器模式应该只会有一个地方可以发布事件，这里为什么会有两个呢？

先说结论。

经过仔细分析，发现SpringApplicationRunListener接口是属于SpringBoot包下的，该接口用于发布SpringBoot相关流程的事件；而ApplicationEventPublisher接口属于org.springframework.context包，用于ApplicationContext在refresh的流程中调用，refresh是应用上下文启动的核心方法。

也就是说，SpringApplicationRunListener接口用于监听SpringBoot的启动流程，而ApplicationEventPublisher用于监听Spring应用上下文的启动流程。

那么为什么要使用新的客户端监听SpringBoot的流程呢？

原因是SpringBoot项目是Spring项目的扩展，所以不能够让Spring的代码和SpringBoot的代码产生耦合，为了监听SpringBoot本身的启动流程，于是引入了SpringApplicationRunListener接口。另一个原因是SpringBoot启动过程中，需要用到监听器的地方还没有对ApplicationContext完成refresh，所以也没法使用ApplicationContext的publishEvent功能。

上面就是两个地方会调用到同一个SimpleApplicationEventMulticaster的原因（当然两个地方调用的SimpleApplicationEventMulticaster实例是不同的，以便于分隔监听器）。

1.SpringApplicationRunListener

public interface SpringApplicationRunListener {
void starting();
void environmentPrepared(ConfigurableEnvironment environment);
void contextPrepared(ConfigurableApplicationContext context);
void contextLoaded(ConfigurableApplicationContext context);
void finished(ConfigurableApplicationContext context, Throwable exception);
}

该接口唯一的实现类EventPublishingRunListener，调用的SimpleApplicationEventMulticaster进行事件广播，在SpringApplication启动的上面五个流程中，发布不同的事件。

2.AbstractApplicationContext

该类是应用上下文的抽象类，里面的publishEvent方法和监听器有关，这里就不贴代码了，调用的是AbstractApplicationContext的属性applicationEventMulticaster，该属性通过initApplicationEventMulticaster方法进行初始化，实际也是初始化了SimpleApplicationEventMulticaster的实例。下面分析一下广播器相关类。

3.SimpleApplicationEventMulticaster

该实现类继承自AbstractApplicationEventMulticaster，而AbstractApplicationEventMulticaster抽象类实现了ApplicationEventMulticaster接口。

AbstractApplicationEventMulticaster抽象类定义了广播器的规范实现，并且定义了ListenerRetriever内部类，ListenerRetriever将获取监听器的功能独立出来，可以通过多个方式获取监听器，这里是通过applicationListeners属性保存的监听器和applicationListenerBeans保存的监听器beanName来共同获取到监听器。

private class ListenerRetriever {
public final Set<ApplicationListener<?>> applicationListeners = new LinkedHashSet<ApplicationListener<?>>();
public final Set<String> applicationListenerBeans = new LinkedHashSet<String>();
private final boolean preFiltered;
public ListenerRetriever(boolean preFiltered) {
this.preFiltered = preFiltered;
}
public Collection<ApplicationListener<?>> getApplicationListeners() {
List<ApplicationListener<?>> allListeners = new ArrayList<ApplicationListener<?>>(
this.applicationListeners.size() + this.applicationListenerBeans.size());
allListeners.addAll(this.applicationListeners);
if (!this.applicationListenerBeans.isEmpty()) {
BeanFactory beanFactory = getBeanFactory();
for (String listenerBeanName : this.applicationListenerBeans) {
try {
ApplicationListener<?> listener = beanFactory.getBean(listenerBeanName, ApplicationListener.class);
if (this.preFiltered || !allListeners.contains(listener)) {
allListeners.add(listener);
}
}
catch (NoSuchBeanDefinitionException ex) {
// Singleton listener instance (without backing bean definition) disappeared -
// probably in the middle of the destruction phase
}
}
}
AnnotationAwareOrderComparator.sort(allListeners);
return allListeners;
}
}

SimpleApplicationEventMulticaster扩展了多线程调用监听器的功能，但如果没有从外部调用setTaskExecutor方法设置线程池，那么默认还是使用的当前线程。

public class SimpleApplicationEventMulticaster extends AbstractApplicationEventMulticaster {
private Executor taskExecutor;
private ErrorHandler errorHandler;
@Override
public void multicastEvent(ApplicationEvent event) {
multicastEvent(event, resolveDefaultEventType(event));
}
@Override
public void multicastEvent(final ApplicationEvent event, ResolvableType eventType) {
ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
for (final ApplicationListener<?> listener : getApplicationListeners(event, type)) {
Executor executor = getTaskExecutor();
if (executor != null) {
executor.execute(new Runnable() {
@Override
public void run() {
invokeListener(listener, event);
}
});
}
else {
invokeListener(listener, event);
}
}
}
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 {
listener.onApplicationEvent(event);
}
catch (ClassCastException ex) {
String msg = ex.getMessage();
if (msg == null || matchesClassCastMessage(msg, event.getClass())) {
Log logger = LogFactory.getLog(getClass());
if (logger.isDebugEnabled()) {
logger.debug("Non-matching event type for listener: " + listener, ex);
}
}
else {
throw ex;
}
}
}
}

4.事件及事件类型

所有实现ApplicationListener接口的监听器，都只能获取到实现ApplicationEvent抽象类的事件，该抽象类保存的信息只有事件的创建时间。另外ApplicationEvent抽象类继承了EventObject普通类，EventObject是java.util包下的，只有一个source属性，表示事件来源。

实现GenericApplicationListener接口的监听器，可以添加是否支持相应ResolvableType

和来源类型的判断。

ResolvableType可以通过ApplicationEvent进行构造，把对应ApplicationEvent的实例放在ResolvableType的resolved属性当中。


private ResolvableType resolveDefaultEventType(ApplicationEvent event) {
return ResolvableType.forInstance(event);
}
public static ResolvableType forInstance(Object instance) {
Assert.notNull(instance, "Instance must not be null");
if (instance instanceof ResolvableTypeProvider) {
ResolvableType type = ((ResolvableTypeProvider) instance).getResolvableType();
if (type != null) {
return type;
}
}
return ResolvableType.forClass(instance.getClass());
}
public static ResolvableType forClass(Class<?> clazz) {
return new ResolvableType(clazz);
}
private ResolvableType(Class<?> clazz) {
this.resolved = (clazz != null ? clazz : Object.class);
this.type = this.resolved;
this.typeProvider = null;
this.variableResolver = null;
this.componentType = null;
this.hash = null;
}