创建完SpringApplication对象之后,接下来就是调用其run方法了,源码如下:
public ConfigurableApplicationContext run(String... args) {
StopWatch stopWatch = new StopWatch();
stopWatch.start();
ConfigurableApplicationContext context = null;
FailureAnalyzers analyzers = null;
//即便没有显示器,也允许其启动
configureHeadlessProperty();
SpringApplicationRunListeners listeners = getRunListeners(args);
listeners.starting();
try {
ApplicationArguments applicationArguments = new DefaultApplicationArguments(
args);
ConfigurableEnvironment environment = prepareEnvironment(listeners,
applicationArguments);
Banner printedBanner = printBanner(environment);
context = createApplicationContext();
analyzers = new FailureAnalyzers(context);
prepareContext(context, environment, listeners, applicationArguments,
printedBanner);
refreshContext(context);
afterRefresh(context, applicationArguments);
listeners.finished(context, null);
stopWatch.stop();
if (this.logStartupInfo) {
new StartupInfoLogger(this.mainApplicationClass)
.logStarted(getApplicationLog(), stopWatch);
}
return context;
}
catch (Throwable ex) {
handleRunFailure(context, listeners, analyzers, ex);
throw new IllegalStateException(ex);
}
}
一步一步看吧。
一、StopWatch
这是一个秒表,用于记录程序的耗时时间,源码非常简单,一个StopWatch代表一组任务(taskList),其中有一个内部类TaskInfo代表一组任务中的某一个任务,内部类中记录了该任务的耗时时间和任务名称,用法如下:
二、获取SpringApplicationRunListeners
那么问题又来了,什么是SpringApplicationRunListeners?如何获取的?该类的注释写的非常好:Listener for the SpringApplication run method. SpringApplicationRunListeners are loaded via the SpringFactoriesLoader and should declare a public constructor that accepts a SpringApplication instance and a String[] of arguments. A new SpringApplicationRunListener instance will be created for each run.
意思就是该类是SpringApplication类中run方法的监听器,SpringApplicationRunListeners和ApplicationContextInitializer、ApplicationListener一样是通过SpringFactoriesLoader在spring.factories中获取的。debug了一下源代码,发现只有spring-boot-1.5.8.RELEASE.jar的spring.factories有org.springframework.boot.SpringApplicationRunListener对应的值:org.springframework.boot.context.event.EventPublishingRunListener,而SpringApplicationRunListeners表示的是SpringApplicationRunListener的集合,该集合的长度为1。
接下来会执行listeners.starting()
这段代码:
public void starting() {
for (SpringApplicationRunListener listener : this.listeners) {
listener.starting();
}
}
接着调用SpringApplicationRunListener的starting方法,按照上面我们说的,此处SpringApplicationRunListener对应的实现类为org.springframework.boot.context.event.EventPublishingRunListener,那就来看看它的starting方法是什么样的:
public void starting() {
this.initialMulticaster
.multicastEvent(new ApplicationStartedEvent(this.application, this.args));
}
从代码的命名来看,像是一个组播器initialMulticaster发布了一个ApplicationStartedEvent事件,在真正发布事件之前,会先将事件解析为ResolvableType,流程图如下:
从代码来看,就是根据ApplicationStartedEvent构造出来一个ResolvableType,什么是ResolvableType呢:
其实对于它的定位就是一个反射的工具类,可以让我们更方便地获取类的信息,解析完这个事件之后,就要真正发布事件了:
我们看到,在真正发布事件之前,会先调用图5中的方法,获取与该事件匹配的监听器,代码如下:
final Map<ListenerCacheKey, ListenerRetriever> retrieverCache =
new ConcurrentHashMap<ListenerCacheKey, ListenerRetriever>(64);
private Object retrievalMutex = this.defaultRetriever;
private final ListenerRetriever defaultRetriever = new ListenerRetriever(false);
private Object retrievalMutex = this.defaultRetriever;
protected Collection<ApplicationListener<?>> getApplicationListeners(
ApplicationEvent event, ResolvableType eventType) {
//获取事件源
Object source = event.getSource();
Class<?> sourceType = (source != null ? source.getClass() : null);
//由下面代码的命名可以大致猜测出,这一部分的代码想使用缓存,而下面的一行代码就是创建一个缓存键,ListenerCacheKey类是本类的一个内部类
ListenerCacheKey cacheKey = new ListenerCacheKey(eventType, sourceType);
// Quick check for existing entry on ConcurrentHashMap...
//ListenerRetriever是该类中的一个变量,数据结构为ConcurrentHashMap
//获取上一个cacheKey对应的ListenerRetriever,ListenerRetriever是该类的一个内部类,retrieve的意思是检索,
ListenerRetriever retriever = this.retrieverCache.get(cacheKey);
//此处retriever的值为null,所以if方法体的代码不会被执行
if (retriever != null) {
return retriever.getApplicationListeners();
}
if (this.beanClassLoader == null ||
(ClassUtils.isCacheSafe(event.getClass(), this.beanClassLoader) &&
(sourceType == null || ClassUtils.isCacheSafe(sourceType, this.beanClassLoader)))) {
// Fully synchronized building and caching of a ListenerRetriever
//retrievalMutex是该类的一个变量,它的值为ListenerRetriever的一个实例对象,它有一个属性Set<ApplicationListener<?>> applicationListeners的值为SpringApplication对象中存储的所有ApplicationListener,一共10个,该ListenerRetriever对象该属性的初始化是发生在实例化EventPublishingRunListener对象是赋值的。
synchronized (this.retrievalMutex) {
//retriever是该类的一个变量,值为一个空的ConcurrentHashMap,此处get的结果为null
retriever = this.retrieverCache.get(cacheKey);
if (retriever != null) {
return retriever.getApplicationListeners();
}
//新建一个ListenerRetriever
retriever = new ListenerRetriever(true);
Collection<ApplicationListener<?>> listeners =
retrieveApplicationListeners(eventType, sourceType, retriever);
this.retrieverCache.put(cacheKey, retriever);
return listeners;
}
}
else {
// No ListenerRetriever caching -> no synchronization necessary
return retrieveApplicationListeners(eventType, sourceType, null);
}
}
private Collection<ApplicationListener<?>> retrieveApplicationListeners(
ResolvableType eventType, Class<?> sourceType, ListenerRetriever retriever) {
//存放所有的监听器
LinkedList<ApplicationListener<?>> allListeners = new LinkedList<ApplicationListener<?>>();
Set<ApplicationListener<?>> listeners;
Set<String> listenerBeans;
synchronized (this.retrievalMutex) {
//把上面我们提到的10个监听器赋值给listeners
listeners = new LinkedHashSet<ApplicationListener<?>>(this.defaultRetriever.applicationListeners);
//listenerBeans初始化,集合内没有元素,因为applicationListenerBeans的长度为0
listenerBeans = new LinkedHashSet<String>(this.defaultRetriever.applicationListenerBeans);
}
for (ApplicationListener<?> listener : listeners) {
//判断是否是符合该listener的时间
if (supportsEvent(listener, eventType, sourceType)) {
if (retriever != null) {
//添加符合条件的listener
retriever.applicationListeners.add(listener);
}
allListeners.add(listener);
}
}
if (!listenerBeans.isEmpty()) {
//获取BeanFactory
BeanFactory beanFactory = getBeanFactory();
for (String listenerBeanName : listenerBeans) {
try {
Class<?> listenerType = beanFactory.getType(listenerBeanName);
if (listenerType == null || supportsEvent(listenerType, eventType)) {
ApplicationListener<?> listener =
beanFactory.getBean(listenerBeanName, ApplicationListener.class);
if (!allListeners.contains(listener) && supportsEvent(listener, eventType, sourceType)) {
if (retriever != null) {
retriever.applicationListenerBeans.add(listenerBeanName);
}
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;
}
protected boolean supportsEvent(ApplicationListener<?> listener, ResolvableType eventType, Class<?> sourceType) {
GenericApplicationListener smartListener = (listener instanceof GenericApplicationListener ?
(GenericApplicationListener) listener : new GenericApplicationListenerAdapter(listener));
return (smartListener.supportsEventType(eventType) && smartListener.supportsSourceType(sourceType));
}
对于上面代码,这里做一个简单总结,在初始化SpringApplication对象的时候,我们初始化了一个监听器对象列表,这里通过getApplicationListeners(event, type)筛选出监听应用启动事件的监听器,一共有四个:
然后就是发布事件了:
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);
}
}
}
接下来分别执行这四个监听器的onApplicationEvent方法,它们分别做了什么事呢?
1、LoggingApplicationListener
private LoggingSystem loggingSystem;
private void onApplicationStartingEvent(ApplicationStartingEvent event) {
this.loggingSystem = LoggingSystem
.get(event.getSpringApplication().getClassLoader());
this.loggingSystem.beforeInitialize();
}
从代码来看,应该是初始化日志系统,因为这里不涉及比较核心的东西,就一笔带过。
2、BackgroundPreinitializer
@Override
public void onApplicationEvent(SpringApplicationEvent event) {
if (event instanceof ApplicationEnvironmentPreparedEvent) {
if (preinitializationStarted.compareAndSet(false, true)) {
performPreinitialization();
}
}
if ((event instanceof ApplicationReadyEvent
|| event instanceof ApplicationFailedEvent)
&& preinitializationStarted.get()) {
try {
preinitializationComplete.await();
}
catch (InterruptedException ex) {
Thread.currentThread().interrupt();
}
}
}
debug了一下发现,上面的方法体中if的条件均不满足,没有执行任何实质性的代码。
3、DelegatingApplicationListener
public void onApplicationEvent(ApplicationEvent event) {
if (event instanceof ApplicationEnvironmentPreparedEvent) {
List<ApplicationListener<ApplicationEvent>> delegates = getListeners(
((ApplicationEnvironmentPreparedEvent) event).getEnvironment());
if (delegates.isEmpty()) {
return;
}
this.multicaster = new SimpleApplicationEventMulticaster();
for (ApplicationListener<ApplicationEvent> listener : delegates) {
this.multicaster.addApplicationListener(listener);
}
}
if (this.multicaster != null) {
this.multicaster.multicastEvent(event);
}
}
和上一步一样,什么都没执行。
4、LiquibaseServiceLocatorApplicationListener
public void onApplicationEvent(ApplicationStartingEvent event) {
if (ClassUtils.isPresent("liquibase.servicelocator.ServiceLocator", null)) {
new LiquibasePresent().replaceServiceLocator();
}
}
也没做什么实质的东西,这里主要就是看下类路径有没有liquibase.servicelocator.ServiceLocator这个类,如果有就替换一下,猜想可能是为了修复什么漏洞而添加的一个监听器。
三、总结
本篇主要介绍了如下几个要点:
- 启动StopWatch
- 从spring.factories中获取SpringApplicationRunListeners的实例,该监听器可以理解为整个run方法的监听器,调用它的starting方法,发布一个ApplicationStartedEvent事件
- 从SpringApplication中所有的监听器中筛选出监听改事件的监听器,一共筛选出了四个
- 筛选出的四个监听器分别响应该事件,只有LoggingApplicationListener做了一些实质性的工作,那就是日志系统的初始化。
四、the next…
解析以下三行代码:
- ApplicationArguments applicationArguments = new DefaultApplicationArguments(
args); - ConfigurableEnvironment environment = prepareEnvironment(listeners,
applicationArguments); - Banner printedBanner = printBanner(environment);