首页  思维导图  详情

springboot启动过程思维导图

2022-01-27 15:09:42   0  举报





AI智能生成

介绍了springboot启动的详细过程

项目流程

作者其他创作

大纲/内容

new SpringApplication(primarySources).run(args);

SpringApplication的构造方法

判断容器类型
this.webApplicationType = deduceWebApplicationType();

通过判断classpath下是否有servlet或者react的相关类来决定容器类型

设置this.initializers
setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
获取ApplicationContextInitializer类型的配置类，存储在this.initializers中

getSpringFactoriesInstances(ApplicationContextInitializer.class)

SpringFactoriesLoader类，用于加载META-INF/spring.factories配置中的类
持有一个cache静态变量

读取META-INF/spring.factories

存入cache

实例化

setInitializers(被实例化的类的列表);//设置this.initializers

设置this.listeners
setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));

getSpringFactoriesInstances(ApplicationListener.class)

直接从SpringFactoriesLoader的cache中获取

实例化

setListeners(被实例化的类的列表);//设置this.listeners

设置this.mainApplicationClass

通过抛出一个异常，然后在异常堆栈中找到包含main方法的类

run(String... args)

创建一个SpringApplicationRunListeners对象
SpringApplicationRunListeners listeners = getRunListeners(args);

new SpringApplicationRunListeners(logger, getSpringFactoriesInstances(
SpringApplicationRunListener.class, types, this, args));

getSpringFactoriesInstances(SpringApplicationRunListener.class)

实例化，默认只有一个类被实例化EventPublishingRunListener

实例化EventPublishingRunListener

EventPublishingRunListener持有2个成员变量application和initialMulticaster

this.application = application;

this.initialMulticaster = new SimpleApplicationEventMulticaster();

持有几个成员变量如下：

private final ListenerRetriever defaultRetriever=new ListenerRetriever(false);

ListenerRetriever持有3个成员变量如下，构造器中初始化它们

public final Set<ApplicationListener<?>> applicationListeners;

public final Set<String> applicationListenerBeans;

private final boolean preFiltered;

其他待补充

获取容器所有的ApplicationListener：application.getListeners()，然后放入initialMulticaster的defaultRetriever中
this.initialMulticaster.addApplicationListener(listener);

this.defaultRetriever.applicationListeners.add(listener);

new SpringApplicationRunListeners(被实例化的类的列表)

SpringApplicationRunListeners持有一个this.listeners变量，在其构造方法中给该变量赋值

private final List<SpringApplicationRunListener> listeners;

this.listeners = new ArrayList<>(SpringApplicationRunListener列表);

默认只有一个元素：SimpleApplicationEventMulticaster的实例

启动监听
listeners.starting();

默认情况下只有一个SpringApplicationRunListener实例，即EventPublishingRunListener实例
调用该实例的starting方法

SimpleApplicationEventMulticaster的multicastEvent方法

获取ApplicationListeners：getApplicationListeners(event, type)

SimpleApplicationEventMulticaster创建时持有this.defaultRetriever对象，包含了从容器获得的ApplicationListener列表
从这些ApplicationListeners中获取支持ApplicationStartingEvent类型的对象返回
并把获取到的list存储到this.retrieverCache中：this.retrieverCache.put(cacheKey, retriever);

遍历获取到的ApplicationStartingEvent类型的ApplicationListeners
并调用invokeListener(listener, event);

listener.onApplicationEvent(event);

普通springboot项目包含4个支持ApplicationStartingEvent类型的listener，如下

LoggingApplicationListener

onApplicationStartingEvent((ApplicationStartingEvent) event);
在这里指定日志系统，如果没有指定，则根据LoggingSystem.SYSTEMS中指定的第一个作为日志系统(即logback)

BackgroundPreinitializer

另起一个线程进行预初始化(用处好像不大，预初始化的类也没有注入容器中)

DelegatingApplicationListener

什么也不做

LiquibaseServiceLocatorApplicationListener

什么也不做

准备环境
ConfigurableEnvironment environment
= prepareEnvironment(listeners);

创建environment
environment = getOrCreateEnvironment();

new StandardServletEnvironment();

类继承关系如下
StandardServletEnvironment，无显式构造方法
StandardEnvironment，无显式构造方法
AbstractEnvironment，有显式构造方法
StandardServletEnvironment实例化的时候，调用AbstractEnvironment构造方法，在该构造方法中调用了customizePropertySources(this.propertySources);
因此会执行孙类的customizePropertySources方法，
孙类通过super调用子类的customizePropertySources方法。
完成初始化。创建的该environment只是一个空壳无实际有用内容。

配置environment
configureEnvironment(environment);

configurePropertySources(environment, args);

默认什么都不做；如果有命令行参数则向environment的MutablePropertySources变量增加一个SimpleCommandLinePropertySource实例

configureProfiles(environment, args);

默认什么都不做；

listeners.environmentPrepared(environment);

EventPublishingRunListener.environmentPrepared()

SimpleApplicationEventMulticaster.multicastEvent()

根据事件类型ApplicationEnvironmentPreparedEvent获取ApplicationListener列表
getApplicationListeners(event, type)

遍历获取到的ApplicationListener列表，执行invokeListener(listener, event);

普通的springboot项目会调用如下ApplicationListener

ConfigFileApplicationListener

从spring.factories获取EnvironmentPostProcessor类型，并实例化，返回实例列表
List<EnvironmentPostProcessor> postProcessors = loadPostProcessors();

对springboot

对springcloud

遍历返回的EnvironmentPostProcessor类型实例的列表
并调用postProcessor.postProcessEnvironment(environment)

对于springboot默认由如下processor

SystemEnvironmentPropertySourceEnvironmentPostProcessor

SpringApplicationJsonEnvironmentPostProcessor

ConfigFileApplicationListener也就是调用者自身也是一个postProcessor

addPropertySources(environment, application.getResourceLoader());

会进行如下两步：

RandomValuePropertySource.addToEnvironment(environment);

new Loader(environment, resourceLoader).load();

创建Loader对象

Load构造器中从spring.facories中加载PropertySourceLoader类型的类(默认PropertiesPropertySourceLoader，YamlPropertySourceLoader)，并实例化，返回列表
this.propertySourceLoaders = SpringFactoriesLoader.loadFactories(
PropertySourceLoader.class, getClass().getClassLoader());

load方法

还没读懂，待完善

AnsiOutputApplicationListener

不重要，如果电脑支持ANSI字符格式，输出日志添加彩色显示。

LoggingApplicationListener

初始化日志系统，包括设定日志级别等等。内容挺多，后面如果有需要再探究其源码

ClasspathLoggingApplicationListener

什么也不做

BackgroundPreinitializer

什么也不做

DelegatingApplicationListener

如果配置文件中配置了context.listener.classes，则实例化该类并且放入SimpleApplicationEventMulticaster对象所持有的this.defaultRetriever.applicationListeners中

FileEncodingApplicationListener

不重要

创建容器
context = createApplicationContext();

实例化AnnotationConfigServletWebServerApplicationContext

该类的继承关系如下

AnnotationConfigServletWebServerApplicationContext

this.reader = new AnnotatedBeanDefinitionReader(this);

构造器中调用AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);

该方法注册如下bean到beanFactory中

internalConfigurationAnnotationProcessor

internalAutowiredAnnotationProcessor

internalRequiredAnnotationProcessor

internalCommonAnnotationProcessor

internalEventListenerProcessor

internalEventListenerFactory

this.scanner = new ClassPathBeanDefinitionScanner(this);

构造器中做如下三件事

注册默认Filter：registerDefaultFilters();

this.includeFilters.add(new AnnotationTypeFilter(Component.class));

this.includeFilters.add(new AnnotationTypeFilter(ManagedBean.class));

this.includeFilters.add(new AnnotationTypeFilter(Named.class));

this.environment = environment;

setResourceLoader(resourceLoader);

ServletWebServerApplicationContext

GenericWebApplicationContext

GenericApplicationContext

this.beanFactory = new DefaultListableBeanFactory();

AbstractApplicationContext

this.resourcePatternResolver = getResourcePatternResolver();

DefaultResourceLoader

this.classLoader = ClassUtils.getDefaultClassLoader();

prepareContext(context, environment, listeners);

context.setEnvironment(environment);

context类型为AnnotationConfigServletWebServerApplicationContext，在实例化的时候默认持有一个environment，但是该environment的propertySourceList为4个默认的元素，这里使用在SpringApplication中创建的environment代替，propertySourceList有9个元素。

postProcessApplicationContext(context);

默认情况下什么都不做

applyInitializers(context);

对于springboot默认有如下initializer的initialize方法被执行

DelegatingApplicationContextInitializer

获取配置文件配置的context.initializer.classes，用逗号分割，得到一个list

遍历这个list，执行这些initializer的initialize方法

ContextIdApplicationContextInitializer

实例化ContextIdApplicationContextInitializer$ContextId并放入beanFactory的registeredSingletons中

ConfigurationWarningsApplicationContextInitializer

创建一个postProcessor：new ConfigurationWarningsPostProcessor(getChecks())

把这个postProcessor放入context的this.beanFactoryPostProcessors中：context.addBeanFactoryPostProcessor(创建的postProcessor);

ServerPortInfoApplicationContextInitializer

把当前对象放入applicationContext的this.applicationListeners中：
applicationContext.addApplicationListener(this);

SharedMetadataReaderFactoryContextInitializer

创建一个postProcessor：new CachingMetadataReaderFactoryPostProcessor()

把这个postProcessor放入context的this.beanFactoryPostProcessors中：context.addBeanFactoryPostProcessor(创建的postProcessor);

ConditionEvaluationReportLoggingListener

创建一个applicationListener：new ConditionEvaluationReportListener()

把这个applicationListener放入context的this.applicationListeners中：applicationContext.addApplicationListener(创建的applicationListener);

listeners.contextPrepared(context);

此处还是在SpringApplication类中，listeners是SpringApplicationRunListeners对象

SpringApplicationRunListeners对象的listeners只有一个元素，即EventPublishingRunListener实例，该实例的contextPrepared方法是空的，什么也不做。

context.getBeanFactory().registerSingleton("springApplicationArguments",
applicationArguments);

把applicationArguments放入beanFactory的registeredSingletons列表中

load(context, sources);

子主题

BeanDefinitionLoader loader = new BeanDefinitionLoader(registry, sources);

该实例包含如下属性：

this.annotatedReader = new AnnotatedBeanDefinitionReader(registry);

该实例包含如下属性：

this.registry = 当前context对象;

this.beanNameGenerator = new AnnotationBeanNameGenerator();用于生成beanname

this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);//用在@Condition注解上判断是否注入到容器

注册默认的postProcessor
AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);

在创建context时已经注册过了，这里其实什么也不做，需要注册的postProcessor如下：

internalConfigurationAnnotationProcessor

internalAutowiredAnnotationProcessor

internalRequiredAnnotationProcessor

internalCommonAnnotationProcessor

internalEventListenerProcessor

internalEventListenerFactory

创建xmlReader：
this.xmlReader = new XmlBeanDefinitionReader(registry);

this.scanner = new ClassPathBeanDefinitionScanner(registry);

context创建时我们已经见过这个scanner的创建过程，在这里loader也创建一个并作为loader的成员变量

和context中的scanner区别：this.scanner.addExcludeFilter(new ClassExcludeFilter(sources));作用？

loader.load();

loader持有一个this.sources，根据source类型分别调用不同的load方法，如下：

springboot默认类型：
source instanceof Class<?>

this.annotatedReader.register(source);

子主题

创建BeanDefinition实例：
AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);

AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);

处理Common注解，包括以下几种：
是否含有@Lazy注解---abd设置this.lazyInit
是否有@Primary注解---abd设置this.primary
是否有@DependsOn注解---abd设置this.dependsOn
是否有@Role注解---abd设置this.role
是否有@Description注解---abd设置this.description

BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);

definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);

这里判断是否带有@Scope注解，根据注解value的值判断是否创建代理对象，以及cglib代理还是proxy代理
enum ScopedProxyMode {DEFAULT,NO,INTERFACES,TARGET_CLASS}共四种代理模式

如果是DEFAULT或者NO，则直接返回该definitionHolder

如果是后两种，则新创建一个definitionHolder返回。使用代理

BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);

注册到beanFactory的如下几个属性中：
this.beanDefinitionMap.put(beanName, beanDefinition);
this.beanDefinitionNames.add(beanName);
this.manualSingletonNames.remove(beanName);

source instanceof Resource

source instanceof Package

source instanceof CharSequence

listeners.contextLoaded(context);

这里的listeners是SpringApplicationRunListeners对象，调用了EventPublishingRunListener对象的contextLoaded方法

在EventPublishingRunListener中做如下几件事：

1、在SpringApplication中获取所有的ApplicationListener

2、遍历这些listeners
2.1 context添加ApplicationListener：context.addApplicationListener(listener);
2.2 如果listener instanceof ApplicationContextAware则((ApplicationContextAware) listener).setApplicationContext(context);

3、广播ApplicationPreparedEvent事件
该对象持有一个SimpleApplicationEventMulticaster类型的this.initialMulticaster实例，调用this.initialMulticaster实例的multicastEvent方法
this.initialMulticaster.multicastEvent(new ApplicationPreparedEvent(this.application, this.args, context));

SimpleApplicationEventMulticaster的multicastEvent方法做如下几件事

getApplicationListeners(event, type)

该对象已经缓存了ApplicationListener列表，在this.defaultRetriever.applicationListeners中，是该对象实例化时在SpringApplication的listeners获取的

遍历this.defaultRetriever.applicationListeners，判断是否支持ApplicationPreparedEvent事件类型，返回符合条件的实例列表

遍历获取到的支持ApplicationPreparedEvent事件类型的ApplicationListener列表
调用invokeListener(listener, event);

调用的listener有如下几个：

ConfigFileApplicationListener

context中新增了一个postProcessor：new PropertySourceOrderingPostProcessor(context)

LoggingApplicationListener

不重要

BackgroundPreinitializer

什么也不做

DelegatingApplicationListener

什么也不做

refreshContext(context);

调用springframework的refresh()方法

prepareRefresh();

initPropertySources();

获取environment
ConfigurableEnvironment env = getEnvironment();

如果是StandardServletEnvironment，则：WebApplicationContextUtils.initServletPropertySources(getPropertySources(), servletContext, servletConfig);

getPropertySources()返回environment持有的this.propertySources实例

对于springboot默认配置，WebApplicationContextUtils.initServletPropertySources(getPropertySources(), servletContext, servletConfig);什么也不做

得到beanFactory：
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

prepareBeanFactory(beanFactory);

beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
这里创建一个StandardBeanExpressionResolver实例，并设置到beanFactory的this.beanExpressionResolver属性
用于解析spel表达式

beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

添加一个postProcessor
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));

向beanFactory的this.ignoredDependencyInterfaces添加接口，有什么用？后续补充，添加的接口有如下几个：
EnvironmentAware
EmbeddedValueResolverAware
ResourceLoaderAware
ApplicationEventPublisherAware
MessageSourceAware
ApplicationContextAware

向beanFactory的this.resolvableDependencies添加接口，有什么用？后续补充，添加的接口有如下几个：
BeanFactory
ResourceLoader
ApplicationEventPublisher
ApplicationContext

添加一个postProcessor
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

判断本地beanFactory是否包含名称为environment,systemProperties,systemEnvironment的bean
如果不包含，则beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());

beanFactory.containsLocalBean方法，只在当前beanFactory中查找，不查找parentBeanFactory

postProcessBeanFactory(beanFactory);

beanFactory.addBeanPostProcessor(new WebApplicationContextServletContextAwareProcessor(this));
beanFactory.ignoreDependencyInterface(ServletContextAware.class);

invokeBeanFactoryPostProcessors(beanFactory);

获取context的postProcessor列表：getBeanFactoryPostProcessors()

调用PostProcessorRegistrationDelegate的如下方法：
invokeBeanFactoryPostProcessors(beanFactory, postProcessor列表);

定义两个list，分别存放两种不同的postProcessor
List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<>();
List<BeanDefinitionRegistryPostProcessor> registryProcessors = new LinkedList<>();

遍历beanFactoryPostProcessors
1、如果是BeanDefinitionRegistryPostProcessor类型，则：
registryProcessor.postProcessBeanDefinitionRegistry(registry);
registryProcessors.add(registryProcessor);
2、如果不是BeanDefinitionRegistryPostProcessor类型，则：
regularPostProcessors.add(postProcessor);

ConfigurationWarningsApplicationContextInitializer$ConfigurationWarningsPostProcessor

postProcessBeanDefinitionRegistry方法什么也不做

SharedMetadataReaderFactoryContextInitializer$CachingMetadataReaderFactoryPostProcessor

postProcessBeanDefinitionRegistry方法

注册internalCachingMetadataReaderFactory

为beanFactory中注册的internalConfigurationAnnotationProcessor的BeanDefinition添加ropertyValue---internalCachingMetadataReaderFactory

ConfigFileApplicationListener$PropertySourceOrderingPostProcessor

是regularPostProcessor

经过上面一步，regularPostProcessors含有1个元素：ConfigFileApplicationListener$PropertySourceOrderingPostProcessor
registryProcessors含有两个元素：[ConfigurationWarningsApplicationContextInitializer$ConfigurationWarningsPostProcessor，SharedMetadataReaderFactoryContextInitializer$CachingMetadataReaderFactoryPostProcessor]
this.beanDefinitionMap新增了3个实例

首先处理实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor

从注册的bean中获取BeanDefinitionRegistryPostProcessor列表：
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);

只获取到一个元素：postProcessorNames={internalConfigurationAnnotationProcessor}

遍历postProcessorNames,如果实现了PriorityOrdered接口，则添加到registryProcessors列表
此时，registryProcessors含有3个元素：[ConfigurationWarningsApplicationContextInitializer$ConfigurationWarningsPostProcessor，SharedMetadataReaderFactoryContextInitializer$CachingMetadataReaderFactoryPostProcessor，ConfigurationClassPostProcessor]

invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);

currentRegistryProcessors只有一个元素，是上一步获取到的ConfigurationClassPostProcessor

遍历currentRegistryProcessors，调用postProcessor.postProcessBeanDefinitionRegistry(registry);

ConfigurationClassPostProcessor的postProcessBeanDefinitionRegistry方法

processConfigBeanDefinitions(registry);

获取到所有注册的bean列表

遍历该列表,判断是否是配置类，并把配置类放入configCandidates列表中
带有@Configuration注解的是full配置
带有@Component,@ComponentScan,@Import,@ImportResource注解的类是lite配置

最后我们获取到的配置类往往只有一个：App.class

实例化配置类解析器
ConfigurationClassParser parser = new ConfigurationClassParser()

实例化注解扫描器
this.componentScanParser = new ComponentScanAnnotationParser

解析配置类
parser.parse(configCandidates);

sourceClass = doProcessConfigurationClass(configClass, sourceClass);

处理内置类processMemberClasses(configClass, sourceClass);

是否有@PropertySource注解，并处理该注解

处理@ComponentScan注解，会递归查找子注解

处理@Import，，会递归查找子注解,比较复杂后续补充，this.deferredImportSelectors的值就是在这里赋值的，下面会用到

处理@ImportResource注解

处理@Bean methods

processInterfaces(configClass, sourceClass);

处理父类

如果sourceClass非空，说明有父类，继续处理父类

processDeferredImportSelectors();

这个方法比较复杂，一时难以读懂，有一步比较重要，返回spring.factories中配置的EnableAutoConfiguration类，并注册到beanFactory，如下：

grouping.getImports()

DeferredImportSelectorGrouping持有个this.group实例，该实例调用this.group.process()方法

String[] imports = deferredImportSelector.selectImports(annotationMetadata);

List<String> configurations = getCandidateConfigurations();

List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader());
该方法返回spring.factories中配置的EnableAutoConfiguration类

this.reader.loadBeanDefinitions(configClasses);

注册上一步获取到的configClasses，注册到beanFactory。细节待补充

然后处理实现了Ordered接口的BeanDefinitionRegistryPostProcessor

步骤和上面一样

把符合条件的postProcessor添加到registryProcessors，
此时，registryProcessors含有4个元素：[ConfigurationWarningsApplicationContextInitializer$ConfigurationWarningsPostProcessor，SharedMetadataReaderFactoryContextInitializer$CachingMetadataReaderFactoryPostProcessor，ConfigurationClassPostProcessor，RefreshScope]

最后处理[实现了PriorityOrdered接口和Ordered接口]之外的BeanDefinitionRegistryPostProcessor

步骤和上面一样

把符合条件的postProcessor添加到registryProcessors

invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
上面步骤调用了postProcessor的postProcessBeanDefinitionRegistry(registry);方法注册了spring.factories中配置的EnableAutoConfiguration类
这一步调用postProcessor的postProcessBeanFactory(registry);方法做一些处理

调用的配置类有如下几种

ConfigurationWarningsApplicationContextInitializer的postProcessBeanFactory方法

空方法

SharedMetadataReaderFactoryContextInitializer的postProcessBeanFactory方法

空方法

ConfigurationClassPostProcessor的postProcessBeanFactory方法

enhanceConfigurationClasses(beanFactory);

获取所有注册的bean

遍历所有注册的bean，判断是否是FullConfiguration，得到所有的FullConfiguration列表

ConfigurationClassEnhancer enhancer = new ConfigurationClassEnhancer();

遍历FullConfiguration列表
enhancedClass = enhancer.enhance(configClass, this.beanClassLoader);
beanDefinition中的beanClass用创建的cglib代理类代替

新增一个postProcessor
beanFactory.addBeanPostProcessor(new ImportAwareBeanPostProcessor(beanFactory));

invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);

调用的配置类有如下几种

ConfigFileApplicationListener的postProcessBeanFactory方法

不重要

上面第二步：遍历beanFactoryPostProcessors
1、如果是BeanDefinitionRegistryPostProcessor类型，则：
registryProcessor.postProcessBeanDefinitionRegistry(registry);
registryProcessors.add(registryProcessor);
2、如果不是BeanDefinitionRegistryPostProcessor类型，则：
regularPostProcessors.add(postProcessor);

上面步骤中已经把beanPostProcessor都注册到beanFactory中，而且过程中有新增的beanPostProcessor

这里从所有已注册的bean中获取beanPostProcessor，得到一个列表

从所有已注册的bean中获取到beanPostProcessor列表

遍历该列表，区分三种情况，分别放入如下list中
priorityOrderedPostProcessors
orderedPostProcessorNames
nonOrderedPostProcessorNames

首先，处理PriorityOrdered
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

调用的processor有如下几种

PropertySourcesPlaceholderConfigurer的postProcessBeanFactory方法

方法较复杂，待后续补充
可参考：https://www.jianshu.com/p/420899939449
下面解析过程是根据该文档总结的

PropertySourcesPlaceholderConfigurer持有一个this.propertySources列表
分别是：environmentProperties和localProperties，分别表示servlet环境属性和本地属性

占位符解析
processProperties(beanFactory, new PropertySourcesPropertyResolver(this.propertySources));

调用父类PlaceholderConfigurerSupport的如下方法
doProcessProperties(beanFactoryToProcess, valueResolver);

获取到所有已注册bean的列表

BeanDefinitionVisitor visitor = new BeanDefinitionVisitor(valueResolver);

遍历这个列表，依次处理
visitor.visitBeanDefinition(bd);

这是核心方法，在这里处理占位符替换事宜，将占位符替换为属性文件中的值

其次，处理Ordered
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

列表为空

最后，处理nonOrdered
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

调用的processor有如下几种

ConfigurationBeanFactoryMetadata的postProcessBeanFactory方法

ErrorMvcAutoConfiguration$PreserveErrorControllerTargetClassPostProcessor的postProcessBeanFactory方法

registerBeanPostProcessors(beanFactory);

调用PostProcessorRegistrationDelegate的如下方法：
PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);

beanFactory中获取注册的BeanPostProcessor类型的bean列表
遍历该列表，区分三种情况，分别放入如下list中
priorityOrderedPostProcessors
orderedPostProcessorNames
nonOrderedPostProcessorNames

首先处理实现了PriorityOrdered接口的BeanPostProcessor

registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

遍历该列表，向beanFactory中添加BeanPostProcessor
beanFactory.addBeanPostProcessor(postProcessor);

其次处理实现了Ordered接口的BeanPostProcessor

registerBeanPostProcessors(beanFactory, orderedPostProcessors);

步骤相同

最后处理其他BeanPostProcessor

registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

步骤相同

initApplicationEventMulticaster();

实例化applicationEventMulticaster并注册到beanFactory
this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);

onRefresh();

super.onRefresh();

this.themeSource = UiApplicationContextUtils.initThemeSource(this);

createWebServer();

ServletWebServerFactory factory = getWebServerFactory();

从beanFactory获取注册的ServletWebServerFactory
并实例化TomcatServletWebServerFactory

调用factory.getWebServer返回一个WebServer实例
this.webServer = factory.getWebServer(getSelfInitializer());

getSelfInitializer()返回一个方法，但是并不执行，请注意
return this::selfInitialize;//jdk8新特性

TomcatServletWebServerFactory的getWebServer()方法，实例化并启动tomcat容器

Tomcat tomcat = new Tomcat();

创建临时目录
File baseDir =createTempDir("tomcat")

tomcat.setBaseDir(baseDir.getAbsolutePath());

Connector connector = new Connector(this.protocol);//this.protocol=org.apache.coyote.http11.Http11NioProtocol

创建Server

server = new StandardServer();

server.setCatalinaBase(baseFile);
server.setCatalinaHome(baseFile);

Service service = new StandardService();

server.addService(service);

server.service.addConnector(connector);

customizeConnector(connector);

connector.setPort(port);

设置ssl等其他一些设置

prepareContext(tomcat.getHost(), initializers);

返回 getTomcatWebServer(tomcat);

实例化new TomcatWebServer(tomcat, getPort() >= 0);

initialize();

启动tomcat
this.tomcat.start();

onrefresh方法主要工作是初始化tomcat容器，和tomcat容器相关的bean也会实例化。我们可以看到该函数执行完毕后，实例化列表实例数目骤增。

registerListeners();

获取context的ApplicationListener列表，添加到context的applicationEventMulticaster中
applicationEventMulticaster.defaultRetriever.applicationListeners.add(listener);

从beanFactory已注册的bean中获取ApplicationListener类型的列表，添加到context的applicationEventMulticaster中
this.defaultRetriever.applicationListenerBeans.add(listenerBeanName);

finishBeanFactoryInitialization(beanFactory);

冻结所有bean定义，不会再有修改
beanFactory.freezeConfiguration();

实例化所有bean
beanFactory.preInstantiateSingletons();

finishRefresh();

启动web容器
WebServer webServer = startWebServer();

afterRefresh(context);