SpringBoot监听器源码解析

1.1 创建SpringApplication对象

public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {return new SpringApplication(primarySources).run(args);
}SpringApplication(。。){//获取到所有配置的ApplicationListener类型的监听器，放到属性中setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
}private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {ClassLoader classLoader = getClassLoader();// 读取配置Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));//遍历实例化List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);AnnotationAwareOrderComparator.sort(instnces);return instances;}

去加载META-INF下面的spring.factories文件。

在spring-boot模块下
//共计10个
org.springframework.context.ApplicationListener=\\
org.springframework.boot.ClearCachesApplicationListener,\\
org.springframework.boot.builder.ParentContextCloserApplicationListener,\\
org.springframework.boot.cloud.CloudFoundryVcapEnvironmentPostProcessor,\\
org.springframework.boot.context.FileEncodingApplicationListener,\\
org.springframework.boot.context.config.AnsiOutputApplicationListener,\\
org.springframework.boot.context.config.ConfigFileApplicationListener,\\
org.springframework.boot.context.config.DelegatingApplicationListener,\\
org.springframework.boot.context.logging.ClasspathLoggingApplicationListener,\\
org.springframework.boot.context.logging.LoggingApplicationListener,\\
org.springframework.boot.liquibase.LiquibaseServiceLocatorApplicationListener在spring-boot-autoconfigure模块下
org.springframework.context.ApplicationListener=\\
org.springframework.boot.autoconfigure.BackgroundPreinitializer
//================================以上共计11个监听器===============================//================================以上共计7个应用环境初始化器================================在spring-boot模块下
org.springframework.context.ApplicationContextInitializer=\\
org.springframework.boot.context.ConfigurationWarningsApplicationContextInitializer,\\
org.springframework.boot.context.ContextIdApplicationContextInitializer,\\
org.springframework.boot.context.config.DelegatingApplicationContextInitializer,\\
org.springframework.boot.rsocket.context.RSocketPortInfoApplicationContextInitializer,\\
org.springframework.boot.web.context.ServerPortInfoApplicationContextInitializer在spring-boot-autoconfigure模块下
org.springframework.context.ApplicationContextInitializer=\\
org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer,\\
org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener

完成上面的逻辑之后，具体对象放到了SpringApplication的

private List<ApplicationContextInitializer<?>> initializers;

private List<ApplicationListener<?>> listeners;

属性中。

1.2 执行run逻辑

1.2.1 生成EventPublishingRunListener对象

public ConfigurableApplicationContext run(String... args) {//...省略若干//得到EventPublishingRunListener对象，同时将监听器复制给了多波器SpringApplicationRunListeners listeners = getRunListeners(args);   
}

getRunListeners 即获得EventPublishingRunListener实例对象。

org.springframework.boot.SpringApplicationRunListener=\\
org.springframework.boot.context.event.EventPublishingRunListener

其中EventPublishingRunListener的构造方法

public EventPublishingRunListener(SpringApplication application, String[] args) {this.application = application;this.args = args;this.initialMulticaster = new SimpleApplicationEventMulticaster();//初始状态是11个。即SpringAPplication.listeners中保存的for (ApplicationListener<?> listener : application.getListeners()) {this.initialMulticaster.addApplicationListener(listener);}}
//完成这个操作，将监听器都放到initialMulticaster（多波器）的内部类中
//this.defaultRetriever.applicationListeners.add(listener);

1.2.2 prepareContext(…)

private void prepareContext(....) {//....省略代码。。。。applyInitializers(context); //这里应该是添加了3个//....省略代码。。。。//AbstractApplicationContext.applicationListeners 共4个了listeners.contextLoaded(context);//CloudFoundryVcapEnvironmentPostProcessor}protected void applyInitializers(ConfigurableApplicationContext context) {//遍历这7个for (ApplicationContextInitializer initializer : getInitializers()) {Class<?> requiredType = GenericTypeResolver.resolveTypeArgument(initializer.getClass(),ApplicationContextInitializer.class);Assert.isInstanceOf(requiredType, context, "Unable to call initializer.");initializer.initialize(context); // 有些初始化方法有逻辑，有些没有；RSocketPortInfoApplicationContextInitializer；ServerPortInfoApplicationContextInitializer; ConditionEvaluationReportLoggingListener 这三个加入进去}
}
AbstractApplicationContext.applicationListener属性中添加 ，共添加进去3个//======================================
public void contextLoaded(ConfigurableApplicationContext context) {//开始这是初始的11个for (ApplicationListener<?> listener : this.application.getListeners()) {if (listener instanceof ApplicationContextAware) {((ApplicationContextAware) listener).setApplicationContext(context);}//添加进监听器。之前是3个，这里开始遍历哪11个往里添加。完成之后共计14个了context.addApplicationListener(listener);}this.initialMulticaster.multicastEvent(new ApplicationPreparedEvent(this.application, this.args, context));
}    

1.2.3 prepareRefresh()

到这里赋值给AbstractApplicationContext.earlyApplicationListeners。共计14个

if (this.earlyApplicationListeners == null) {this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
}

1.2.4 invokeBeanFactoryPostProcessor()

添加了一个。

1.2.5 registerListeners

protected void registerListeners() {//获取到AbstractApplicationContex.applicationListeners(15个)for (ApplicationListener<?> listener : getApplicationListeners()) {//添加到广播器中//AbstractApplicationEventMulticaster内部类ListenerRetrievergetApplicationEventMulticaster().addApplicationListener(listener);}//&org.springframework.boot.autoconfigure.internalCachingMetadataReaderFactory//mvcResourceUrlProvider//springApplicationAdminRegistrarString[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);//添加到this.defaultRetriever.applicationListenerBeans.add(listenerBeanName);// //AbstractApplicationEventMulticaster内部类ListenerRetrieverfor (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);}}
}AbstractApplicationEventMulticaster.java
public void addApplicationListener(ApplicationListener<?> listener) {synchronized (this.retrievalMutex) {// Explicitly remove target for a proxy, if registered already,// in order to avoid double invocations of the same listener.Object singletonTarget = AopProxyUtils.getSingletonTarget(listener);if (singletonTarget instanceof ApplicationListener) {this.defaultRetriever.applicationListeners.remove(singletonTarget);}this.defaultRetriever.applicationListeners.add(listener);this.retrieverCache.clear();}}

经过以上，监听器的注入基本完成。

2. 广播执行

AbstractApplicationContext.java

@Overridepublic void publishEvent(Object event) {publishEvent(event, null);
}protected void publishEvent(Object event, @Nullable ResolvableType eventType) {//早期事件不为空if (this.earlyApplicationEvents != null) {this.earlyApplicationEvents.add(applicationEvent);}else {//调用多播器，继而调用监听器getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);}//....
}

调用多播器的逻辑，继而调用监听器的逻辑

	@Overridepublic void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));Executor executor = getTaskExecutor();//获取指定类型的所有的应用监听器，遍历处理for (ApplicationListener<?> listener : getApplicationListeners(event, type)) {//线程池去执行if (executor != null) {executor.execute(() -> invokeListener(listener, event));}else {// 直接同步执行  //listener.onApplicationEvent(event); 其实就是回调执行逻辑   invokeListener(listener, event);}}}

对于getApplicationListeners(event, type)解析。还是在AbstractApplicationEventMulticaster.java类中，调用retrieveApplicationListeners(…）

//得到所有的监听器
private Collection<ApplicationListener<?>> retrieveApplicationListeners(ResolvableType eventType, @Nullable Class<?> sourceType, @Nullable ListenerRetriever retriever) {//最终返回的监听器List<ApplicationListener<?>> allListeners = new ArrayList<>();//项目设置进来的监听器addApplicationListener方法加入的，会保存在这里面Set<ApplicationListener<?>> listeners;Set<String> listenerBeans;synchronized (this.retrievalMutex) {listeners = new LinkedHashSet<>(this.defaultRetriever.applicationListeners);listenerBeans = new LinkedHashSet<>(this.defaultRetriever.applicationListenerBeans);}// Add programmatically registered listeners, including ones coming// from ApplicationListenerDetector (singleton beans and inner beans).for (ApplicationListener<?> listener : listeners) {if (supportsEvent(listener, eventType, sourceType)) {if (retriever != null) {retriever.applicationListeners.add(listener);}allListeners.add(listener);}}if (!listenerBeans.isEmpty()) {ConfigurableBeanFactory beanFactory = getBeanFactory();for (String listenerBeanName : listenerBeans) {try {if (supportsEvent(beanFactory, listenerBeanName, eventType)) {ApplicationListener<?> listener =beanFactory.getBean(listenerBeanName, ApplicationListener.class);if (!allListeners.contains(listener) && supportsEvent(listener, eventType, sourceType)) {if (retriever != null) {if (beanFactory.isSingleton(listenerBeanName)) {retriever.applicationListeners.add(listener);}else {retriever.applicationListenerBeans.add(listenerBeanName);}}allListeners.add(listener);}}else {Object listener = beanFactory.getSingleton(listenerBeanName);if (retriever != null) {retriever.applicationListeners.remove(listener);}allListeners.remove(listener);}}catch (NoSuchBeanDefinitionException ex) {// Singleton listener instance (without backing bean definition) disappeared -// probably in the middle of the destruction phase}}}AnnotationAwareOrderComparator.sort(allListeners);if (retriever != null && retriever.applicationListenerBeans.isEmpty()) {retriever.applicationListeners.clear();retriever.applicationListeners.addAll(allListeners);}return allListeners;}

3. 自定义的监听器

所有对象实例完成之后，

@Overridepublic void preInstantiateSingletons() throws BeansException {// 将所有BeanDefinition的名字创建一个集合List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);// Trigger initialization of all non-lazy singleton beans...// 触发所有非延迟加载单例bean的初始化，遍历集合的对象for (String beanName : beanNames) {//。。。。。}// Trigger post-initialization callback for all applicable beans...// 遍历beanNames，触发所有SmartInitializingSingleton的后初始化回调for (String beanName : beanNames) {// 获取beanName对应的bean实例Object singletonInstance = getSingleton(beanName);// 判断singletonInstance是否实现了SmartInitializingSingleton接口if (singletonInstance instanceof SmartInitializingSingleton) {// 类型转换SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;// 触发SmartInitializingSingleton实现类的afterSingletonsInstantiated方法if (System.getSecurityManager() != null) {AccessController.doPrivileged((PrivilegedAction<Object>) () -> {smartSingleton.afterSingletonsInstantiated();return null;}, getAccessControlContext());}else {smartSingleton.afterSingletonsInstantiated();}}}}

EventListenerMethodProcessor.java。检查所有的bean对象

public void afterSingletonsInstantiated() {ConfigurableListableBeanFactory beanFactory = this.beanFactory;Assert.state(this.beanFactory != null, "No ConfigurableListableBeanFactory set");// 获取容器中所有bean组件的名称String[] beanNames = beanFactory.getBeanNamesForType(Object.class);for (String beanName : beanNames) {// 遍历每个bean组件，检测其中@EventListener注解方法，生成和注册ApplicationListener实例if (!ScopedProxyUtils.isScopedTarget(beanName)) {Class<?> type = null;try {type = AutoProxyUtils.determineTargetClass(beanFactory, beanName);}catch (Throwable ex) {// An unresolvable bean type, probably from a lazy bean - let's ignore it.if (logger.isDebugEnabled()) {logger.debug("Could not resolve target class for bean with name '" + beanName + "'", ex);}}if (type != null) {if (ScopedObject.class.isAssignableFrom(type)) {try {Class<?> targetClass = AutoProxyUtils.determineTargetClass(beanFactory, ScopedProxyUtils.getTargetBeanName(beanName));if (targetClass != null) {type = targetClass;}}catch (Throwable ex) {// An invalid scoped proxy arrangement - let's ignore it.if (logger.isDebugEnabled()) {logger.debug("Could not resolve target bean for scoped proxy '" + beanName + "'", ex);}}}try {// 针对一个bean的真正的@EventListener注解方法检测，ApplicationListener实例生成和注册processBean(beanName, type);}catch (Throwable ex) {throw new BeanInitializationException("Failed to process @EventListener " +"annotation on bean with name '" + beanName + "'", ex);}}}}}

processBean方法，注册监听器

private void processBean(final String beanName, final Class<?> targetType) {if (!this.nonAnnotatedClasses.contains(targetType) &&AnnotationUtils.isCandidateClass(targetType, EventListener.class) &&!isSpringContainerClass(targetType)) {Map<Method, EventListener> annotatedMethods = null;try {// 检测当前类targetType上使用了注解@EventListener的方法annotatedMethods = MethodIntrospector.selectMethods(targetType,(MethodIntrospector.MetadataLookup<EventListener>) method ->AnnotatedElementUtils.findMergedAnnotation(method, EventListener.class));}catch (Throwable ex) {// An unresolvable type in a method signature, probably from a lazy bean - let's ignore it.if (logger.isDebugEnabled()) {logger.debug("Could not resolve methods for bean with name '" + beanName + "'", ex);}}if (CollectionUtils.isEmpty(annotatedMethods)) {// 如果当前类targetType中没有任何使用了注解@EventListener的方法，则将该类保存到缓存nonAnnotatedClasses，从而// 避免当前处理方法重入该类，避免二次处理this.nonAnnotatedClasses.add(targetType);if (logger.isTraceEnabled()) {logger.trace("No @EventListener annotations found on bean class: " + targetType.getName());}}else {// Non-empty set of methods// 如果当前类targetType中有些方法使用了注解@EventListener，那么根据方法上的信息对应的创建和注册ApplicationListener实例ConfigurableApplicationContext context = this.applicationContext;Assert.state(context != null, "No ApplicationContext set");// 此处使用了this.eventListenerFactories,这些EventListenerFactory是在该类postProcessBeanFactory方法调用时被记录的List<EventListenerFactory> factories = this.eventListenerFactories;Assert.state(factories != null, "EventListenerFactory List not initialized");for (Method method : annotatedMethods.keySet()) {for (EventListenerFactory factory : factories) {if (factory.supportsMethod(method)) {Method methodToUse = AopUtils.selectInvocableMethod(method, context.getType(beanName));// 如果当前EventListenerFactory支持处理该@EventListener注解的方法，则使用它创建ApplicationListenerApplicationListener<?> applicationListener =factory.createApplicationListener(beanName, targetType, methodToUse);if (applicationListener instanceof ApplicationListenerMethodAdapter) {((ApplicationListenerMethodAdapter) applicationListener).init(context, this.evaluator);}// 将创建的ApplicationListener加入到容器中context.addApplicationListener(applicationListener);break;}}}if (logger.isDebugEnabled()) {logger.debug(annotatedMethods.size() + " @EventListener methods processed on bean '" +beanName + "': " + annotatedMethods);}}}}