一、前沿

Spring Boot 是 Spring 的衍生产品，是基于Spring4的条件注册的一套快速开发整合包，它实现了自动配置，降低了项目搭建的复杂度。但是Spring Boot本身并不提供Spring框架的核心特性以及扩展功能，只是用于快速、敏捷地开发新一代基于Spring框架的应用程序，是用于提升Spring开发者体验的工具。

Spring Boot 集成了大量常用的第三方库配置(例如Jackson、JDBC、Mongo、Redis、MQ、Mail等等)，Spring Boot应用中这些第三方库几乎可以做到零配置的开箱即用(out-of-the-box)，大部分的Spring Boot应用都只需要非常少量的配置代码即可，开发者能够更加专注于业务逻辑。

Spring Boot 集成了 tomcat 和 jetty WEB 服务器，Spring Boot 默认使用 tomcat 做 WEB 服务器，如果你使用的是 tomcat，则不需要单独配置 tocmat 了

Spring Boot 和 Spring 的区别

1）、Spring Boot 实现了自动配置，例如 Mybatis、Redis、JDBC、MQ、Mongo等

2）、Spring Boot 集成了 WEB 服务器，例如 Tomcat 和 Jetty

3）、Spring Boot 实现了配置文件的环境隔离，通过 spring.profiles.active 属性可以指定加载某个环境的下的配置文件

接下来我们探究一下 Spring Boot 的启动流程

二、启动流程图

Spring Boot 启动流程图如下：

详细的流程图如下：

从上图中可知，Spring Boot 启动共分为三个部分

1）、SpringApplication 的初始化模块，即配置了 source、web环境、初始化构造器、应用监听器和main方法所在类

2）、SpringApplication 的启动模块，即启动了流程的监听器、加载环境配置和创建上下文 ApplicationContext

3）、Spring Boot 的自动化配置模块，即调用 ApplicationContext 的 refresh 方法刷新上下文，完成了所有非lazy的Singleton Bean 的加载，其中包括最核心的 Spring Boot 的各种自动化配置类的加载

下面从源码角度分别对这三个部分展开详细分析

3.1 初始化模块

Spring Boot 的入口在带有 @SpringBootApplication 注解的 main 方法中，在 main 方法中主要做了两件事

1）、构造 SpringApplication，即 new SpringApplication()，进行初始化模块操作

2）、调用 SpringApplication 的 run 方法完成 Spring Boot 的启动

代码如下：

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ImportResource;
import org.springframework.core.env.ConfigurableEnvironment;/*** springBoot主入口** @create 2019-12-31 11:36**/
@SpringBootApplication(scanBasePackages = "com.springboot.demo")
@MapperScan("com.springboot.db.mapper")
@ImportResource("classpath:config/application.xml")
public class MainApplication {public static void main(String[] args) {SpringApplication application = new SpringApplication(MainApplication.class);ConfigurableApplicationContext ctx = application.run(args);}
}

从启动类中可知 @SpringBootApplication 注解很关键，下面看一下其作用，源码如下：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = {@Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),@Filter(type = FilterType.CUSTOM,classes = AutoConfigurationExcludeFilter.class) })
@ConfigurationPropertiesScan
public @interface SpringBootApplication {// 排除特定的自动配置类@AliasFor(annotation = EnableAutoConfiguration.class)Class<?>[] exclude() default {};// 排除特定的自动配置类的名称@AliasFor(annotation = EnableAutoConfiguration.class)String[] excludeName() default {};// 扫描 scanBasePackages 配置的包下的组件，比如 @Service、@Component 等// 默认扫描主类所在包下的所有组件@AliasFor(annotation = ComponentScan.class, attribute = "basePackages")String[] scanBasePackages() default {};// 扫描 scanBasePackageClasses 配置的类所在的包组件@AliasFor(annotation = ComponentScan.class, attribute = "basePackageClasses")Class<?>[] scanBasePackageClasses() default {};// 是否代理 bean，默认是 true@AliasFor(annotation = Configuration.class)boolean proxyBeanMethods() default true;}

@SpringBootApplication 注解中有包含三个核心注解，分别如下：

@SpringBootConfiguration（内部是 @Configuration 注解） ： 这个注解和 @Configuration 注解的作用一样，用来表示被标注的类是一个配置类，会将被标注的类中的所有带 @Bean 注解修饰的方法添加到 Spring 容器中，实例的名称默认是方法名，Spring 会创建出对应的实例 Bean

@EnableAutoConfiguration：开启了 SpringBoot 自动配置，在程序启动时会自动加载 SpringBoot 的自动默认配置，如果有对一些参数进行配置（比如在配置文件中修改了配置属性值），则会在程序启动时或调用时进行追加或者覆盖

@ComponentScan：包扫描注解，默认扫描主类包路径下的组件类，所以最好将启动类 MainApplication 存放在根路径下，这里可以配置自己想要扫描的任何包的路径

@ImportResource：引入某路径下的资源文件

下面看构造 SpringApplication 的具体过程，入口在 SpringApplication 的构造方法，源码如下：

	// 1、 SpringApplication 的构造方法public SpringApplication(Class<?>... primarySources) {this(null, primarySources);}// 2、 SpringApplication 的构造方法@SuppressWarnings({ "unchecked", "rawtypes" })public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {// 配置resourcethis.resourceLoader = resourceLoader;Assert.notNull(primarySources, "PrimarySources must not be null");this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));// 配置是否是web环境，web环境的话后续需要启动web服务器，比如 tomcatthis.webApplicationType = WebApplicationType.deduceFromClasspath();// 创建初始化构造器，加载所有 MATE-INF/spring.factories 文件中的配置，所有配置缓存到 cache 对象中// 根据 ApplicationContextInitializer 类型从 cache 中获取所有的初始化器，通过反射创建所有初始化器实例setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));// 根据 ApplicationListener 类型从 cache 中获取所有的应用监听器，通过反射创建所有应用监听器实例setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));// 设置应用main方法所在的主类this.mainApplicationClass = deduceMainApplicationClass();}// 3、SpringApplication 的 getSpringFactoriesInstances 方法private <T> Collection<T> getSpringFactoriesInstances(Class<T> type) {// 从 MATE-INF/Spring.factories 文件中加载指定 type 类型的 Beanreturn getSpringFactoriesInstances(type, new Class<?>[] {});}// 4、SpringApplication 的 getSpringFactoriesInstances 方法private <T> Collection<T> getSpringFactoriesInstances(Class<T> type,Class<?>[] parameterTypes, Object... args) {// 默认是当前线程上下文的 ClassLoader，resourceLoader 可以指定 ClassLoaderClassLoader classLoader = getClassLoader();// Use names and ensure unique to protect against duplicates// SpringFactoriesLoader 加载所有 MATE-INF/Spring.factories 文件中的配置Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));// 反射创建指定 Type 类型的所有 BeanList<T> instances = createSpringFactoriesInstances(type, parameterTypes,classLoader, args, names);AnnotationAwareOrderComparator.sort(instances);return instances;}

MATE-INF/Spring.factories 文件中的配置内容如下：

上述代码逻辑相对简单，代码注释已经讲得非常清楚了，这里不在做过多赘述了

3.2 启动模块

Spring Boot 的启动从 SpringApplication 的 run 方法开始，源码如下：

	// SpringApplication 的 run 方法public ConfigurableApplicationContext run(String... args) {StopWatch stopWatch = new StopWatch();// 构建 StopWatch，记录启动时间stopWatch.start();ConfigurableApplicationContext context = null;Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();// 配置 Headless ，默认是 trueconfigureHeadlessProperty();// 通过读取缓存 cache 创建 SpringApplicationRunListener 实例SpringApplicationRunListeners listeners = getRunListeners(args);// 启动流程的监听器，即发布 ApplicationStartingEvent 事件listeners.starting();try {ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);// 准备环境 ConfigurableEnvironment，即配置环境ConfigurableEnvironment environment = prepareEnvironment(listeners,applicationArguments);// 配置 spring.beaninfo.ignore 属性值，默认是 trueconfigureIgnoreBeanInfo(environment);// 配置 Banner，这里可以自定义 Spring Boot 启动时输出的 banner 信息Banner printedBanner = printBanner(environment);// 创建 ApplicationContext 上下文，默认是 AnnotationConfigApplicationContextcontext = createApplicationContext();// 创建 SpringBootExceptionReporter 实例exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,new Class[] { ConfigurableApplicationContext.class }, context);// 准备上下文，即配置上下文prepareContext(context, environment, listeners, applicationArguments,printedBanner);// 刷新上下文，加载所有非lazy的Singleton Bean，Spring Boot 的自动配置就是在这里完成的refreshContext(context);// 刷新上下文后的操作，这里是空实现，可以作为扩展afterRefresh(context, applicationArguments);// 记录总启动时间stopWatch.stop();if (this.logStartupInfo) {new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);}// 发布 ApplicationStartedEvent 事件listeners.started(context);// 调用命令的回调方法callRunners(context, applicationArguments);}catch (Throwable ex) {handleRunFailure(context, ex, exceptionReporters, listeners);throw new IllegalStateException(ex);}try {// 发布 ApplicationReadyEvent 事件listeners.running(context);}catch (Throwable ex) {handleRunFailure(context, ex, exceptionReporters, null);throw new IllegalStateException(ex);}return context;}

run 方法中主要实现了以下逻辑：

1）、准备环境 ConfigurableEnvironment，即配置环境

2）、创建 ApplicationContext 上下文

3）、准备上下文，即配置上下文

4）、刷新上下文，加载所有非lazy的Singleton Bean，Spring Boot 的自动配置就是在这里完成的

下面着重分析前三步骤，因为第四个步骤在自动配置模块讲解

3.2.1 配置环境 ConfigurableEnvironment

配置环境入口在 SpringApplication 的 prepareEnvironment 方法，源码如下：

	// 1、SpringApplication 的 prepareEnvironment 方法private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,ApplicationArguments applicationArguments) {// Create and configure the environment// 创建配置环境，默认是 StandardEnvironment，ConfigurableEnvironment environment = getOrCreateEnvironment();// 设置环境配置，即设置 ConversionService、PropertySources 和 Profiles（spring.profiles.active 指定的环境文件）configureEnvironment(environment, applicationArguments.getSourceArgs());// 发布 ApplicationEnvironmentPreparedEvent 事件listeners.environmentPrepared(environment);// 绑定环境到 SpringApplication 应用上bindToSpringApplication(environment);if (!this.isCustomEnvironment) {// 非自定义环境时，使用环境转换器转换环境environment = new EnvironmentConverter(getClassLoader()).convertEnvironmentIfNecessary(environment, deduceEnvironmentClass());}// PropertySource 设置 SpringConfigurationPropertySourcesConfigurationPropertySources.attach(environment);return environment;}// 2、SpringApplication 的 getOrCreateEnvironment 方法private ConfigurableEnvironment getOrCreateEnvironment() {if (this.environment != null) {return this.environment;}// 根据 webApplicationType 配置决定环境对象，默认是 StandardEnvironmentswitch (this.webApplicationType) {case SERVLET:return new StandardServletEnvironment();case REACTIVE:return new StandardReactiveWebEnvironment();default:return new StandardEnvironment();}}

在加载配置环境的过程中会判断是否是 web 容器启动，如果是容器启动会加载 StandardServletEnvironment，其继承了 ConfigurableEnvironment，结构图如下：

从上图可以看出，xxxEnvironment 最终都实现了PropertyResolver 接口，而 PropertyResolver 接口是用于解析任何基础源的属性的接口

我们平时通过 Environment 对象获取配置文件中指定 Key 对应的 value 时，就是调用了 PropertyResolver 接口的 getProperty 方法

3.2.2 创建上下文 ApplicationContext

创建上下文 ApplicationContext 入口在 SpringApplication 的 createApplicationContext 方法，源码如下：

	// SpringApplication 的 createApplicationContext 方法protected ConfigurableApplicationContext createApplicationContext() {Class<?> contextClass = this.applicationContextClass;if (contextClass == null) {try {// 根据 webApplicationType 决定实例上下文对象，默认是 AnnotationConfigApplicationContextswitch (this.webApplicationType) {case SERVLET:// web 环境对应的是 AnnotationConfigServletWebServerApplicationContext 上下文contextClass = Class.forName(DEFAULT_SERVLET_WEB_CONTEXT_CLASS);break;case REACTIVE:contextClass = Class.forName(DEFAULT_REACTIVE_WEB_CONTEXT_CLASS);break;default:contextClass = Class.forName(DEFAULT_CONTEXT_CLASS);}}catch (ClassNotFoundException ex) {throw new IllegalStateException("Unable create a default ApplicationContext, "+ "please specify an ApplicationContextClass",ex);}}// 使用构造反射法创建 ApplicationContext 实例return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);}

3.2.3  配置上下文

配置上下文入口在 SpringApplication 的 prepareContext 方法，源码如下：

	// SpringApplication 的 prepareContext 方法private void prepareContext(ConfigurableApplicationContext context,ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,ApplicationArguments applicationArguments, Banner printedBanner) {// 上下文配置环境context.setEnvironment(environment);// BeanFactory 设置 beanNameGenerator 和 ConversionService，context 设置 ResourceLoader 或者 ClassLoaderpostProcessApplicationContext(context);// 调用所有 ApplicationContextInitializer 的 initialize 方法applyInitializers(context);// 发布 ApplicationContextInitializedEvent 事件listeners.contextPrepared(context);if (this.logStartupInfo) {logStartupInfo(context.getParent() == null);logStartupProfileInfo(context);}// Add boot specific singleton beans// 获取 BeanFactory 并注册 ApplicationArguments、Banner等ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();beanFactory.registerSingleton("springApplicationArguments", applicationArguments);if (printedBanner != null) {beanFactory.registerSingleton("springBootBanner", printedBanner);}if (beanFactory instanceof DefaultListableBeanFactory) {((DefaultListableBeanFactory) beanFactory).setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);}if (this.lazyInitialization) {context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());}// Load the sourcesSet<Object> sources = getAllSources();Assert.notEmpty(sources, "Sources must not be empty");// 加载所有source下的所有 Bean 定义 BeanDefinitionload(context, sources.toArray(new Object[0]));// 实现了 ApplicationContextAware 的设置 ApplicationContext，并发布 ApplicationPreparedEvent 事件listeners.contextLoaded(context);}

配置上下文主要实现了以下逻辑：

1）、上下文配置环境

2）、BeanFactory 的一些常规属性设置

3）、调用所有初始化器 ApplicationContextInitializer 的 initialize 方法

4）、加载所有source下的所有 Bean 定义 BeanDefinition，即配置文件中的所有bean配置都转化为 BeanDefinition

5）、设置 ApplicationContext，并发布 ApplicationPreparedEvent 事件

3.3  自动化配置模块

Spring Boot 完成了创建上下文 ApplicationContext 和 配置上下文之后，接下来的工作就是刷新上下文了，Spring Boot 的刷新上下文除了兼具Spring所有功能之外，主要完成了以下工作：

1）、创建了web服务器

2）、加载所有非lazy的Singleton Bean

3）、加载自动化配置

4）、启动 WEB 服务器

下面我们以 WEB 环境为例，通过源码来探讨其过程，刷新上下文入口在 SpringApplication 的 refresh 方法，源码如下：

	// 1、SpringApplication 的 refresh 方法protected void refresh(ApplicationContext applicationContext) {Assert.isInstanceOf(AbstractApplicationContext.class, applicationContext);// web环境的话，这里调用的是 ServletWebServerApplicationContext 的 refresh 方法((AbstractApplicationContext) applicationContext).refresh();}// 2、ServletWebServerApplicationContext 的 refresh 方法@Overridepublic final void refresh() throws BeansException, IllegalStateException {try {// 调用 AbstractApplicationContext 的 refresh 方法super.refresh();}catch (RuntimeException ex) {stopAndReleaseWebServer();throw ex;}}

AbstractApplicationContext 的 refresh 方法实现的所有逻辑我们已经在 Spring源码系列之ApplicationContext refresh 刷新 中讲解过了，这里不在重复分析和Spring做了同样事情的步骤，只分析 Spring Boot 主要实现的自己关键业务步骤，即 onRefresh 方法、finishBeanFactoryInitialization 方法 和 finishRefresh 方法，下面分别介绍

3.3.1 onRefresh 方法

Spring Boot 的 onRefresh 方法主要实现了创建WEB服务器并启动Server和Service功能，入口在 ServletWebServerApplicationContext 的 onRefresh 方法，源码如下：

	// 1、ServletWebServerApplicationContext 的 onRefresh 方法@Overrideprotected void onRefresh() {// 初始化上下文主题资源super.onRefresh();try {// 创建WEB服务器createWebServer();}catch (Throwable ex) {throw new ApplicationContextException("Unable to start web server", ex);}}// 2、ServletWebServerApplicationContext 的 createWebServer 方法private void createWebServer() {WebServer webServer = this.webServer;ServletContext servletContext = getServletContext();if (webServer == null && servletContext == null) {// 获取 ServletWebServerFactory 实例ServletWebServerFactory factory = getWebServerFactory();// getSelfInitializer 方法初始化 ServletContext// ServletWebServerFactory(TomcatServletWebServerFactory) 的 getWebServer 方法获取 web 服务器this.webServer = factory.getWebServer(getSelfInitializer());}else if (servletContext != null) {try {getSelfInitializer().onStartup(servletContext);}catch (ServletException ex) {throw new ApplicationContextException("Cannot initialize servlet context",ex);}}// 初始化属性资源initPropertySources();}// 3、ServletContextInitializer 的 getSelfInitializer 方法private org.springframework.boot.web.servlet.ServletContextInitializer getSelfInitializer() {return this::selfInitialize;}// 4、ServletContextInitializer 的 getSelfInitializer 方法private void selfInitialize(ServletContext servletContext) throws ServletException {// ServletContext 属性设置prepareWebApplicationContext(servletContext);// BeanFactory 中注册 application 类型的 scoperegisterApplicationScope(servletContext);WebApplicationContextUtils.registerEnvironmentBeans(getBeanFactory(),servletContext);// ServletContextInitializer 的 onStartup 方法做初始化操作，// 例如 DispatcherServletRegistrationBean 的 onStartup 方法实现了 ServletContext 增加 DispatcherServlet，// TomcatEmbeddedContext 增加 dispatcherServlet 中配置的 url 与 Wrapper 的映射关系// FilterRegistrationBean 的 onStartup 方法实现了 ServletContext 增加 CharacterEncodingFilter、HiddenHttpMethodFilter、FormContentFilter// 和 RequestContextFilter，TomcatEmbeddedContext 增加 characterEncodingFilter、hiddenHttpMethodFilter、formContentFilter 和 requestContextFilter// 中配置的 url 组成的FilterMap// 总结：ServletContext 绑定 Servlet 与 Filter 的实现for (ServletContextInitializer beans : getServletContextInitializerBeans()) {beans.onStartup(servletContext);}}// 5、TomcatServletWebServerFactory 的 getWebServer 方法@Overridepublic WebServer getWebServer(ServletContextInitializer... initializers) {Tomcat tomcat = new Tomcat();File baseDir = (this.baseDirectory != null) ? this.baseDirectory: createTempDir("tomcat");tomcat.setBaseDir(baseDir.getAbsolutePath());Connector connector = new Connector(this.protocol);// Service 与 Connector 绑定，此时 Connector 不会启动tomcat.getService().addConnector(connector);// Connector 的 bindOnInit 属性值决定了是否立即启动 Socket 绑定套接字，如果是应用启动较慢，这里建议设置为 false，即应用启动之后再启动 Socket 绑定套接字监听customizeConnector(connector);tomcat.setConnector(connector);tomcat.getHost().setAutoDeploy(false);// Engine 中的 Pipeline 与 Valve 关系绑定configureEngine(tomcat.getEngine());for (Connector additionalConnector : this.additionalTomcatConnectors) {// Service 与 Connector 绑定tomcat.getService().addConnector(additionalConnector);}// 创建并初始化设置 TomcatEmbeddedContextprepareContext(tomcat.getHost(), initializers);// 初始化 tomcat web 服务器，并返回 TomcatWebServerreturn getTomcatWebServer(tomcat);}// 6、TomcatServletWebServerFactory 的 getTomcatWebServer 方法protected TomcatWebServer getTomcatWebServer(Tomcat tomcat) {return new TomcatWebServer(tomcat, getPort() >= 0);}// 7、TomcatWebServer 的构造方法public TomcatWebServer(Tomcat tomcat, boolean autoStart) {Assert.notNull(tomcat, "Tomcat Server must not be null");this.tomcat = tomcat;this.autoStart = autoStart;// 启动 tomcat 服务initialize();}// 8、TomcatWebServer 的 initialize 方法private void initialize() throws WebServerException {logger.info("Tomcat initialized with port(s): " + getPortsDescription(false));synchronized (this.monitor) {try {addInstanceIdToEngineName();Context context = findContext();context.addLifecycleListener((event) -> {if (context.equals(event.getSource())&& Lifecycle.START_EVENT.equals(event.getType())) {// Remove service connectors so that protocol binding doesn't// happen when the service is started.// 这里将 Service 和 Connector 关系移除了，防止启动 Service 时将 Connector 启动，这里就是将tomcat的真正启动放在了应用启动之后，提高性能removeServiceConnectors();}});// Start the server to trigger initialization listeners// 启动 tomcat 服务器，并触发初始化监听器// 注意这里只启动了 Server 和 Service，而没有启动 Connector 和 Socket 套接字，等到应用启动完成之后再启动 Connector 和 Socketthis.tomcat.start();// We can re-throw failure exception directly in the main threadrethrowDeferredStartupExceptions();try {ContextBindings.bindClassLoader(context, context.getNamingToken(),getClass().getClassLoader());}catch (NamingException ex) {// Naming is not enabled. Continue}// Unlike Jetty, all Tomcat threads are daemon threads. We create a// blocking non-daemon to stop immediate shutdownstartDaemonAwaitThread();}catch (Exception ex) {stopSilently();throw new WebServerException("Unable to start embedded Tomcat", ex);}}}

onRefresh 方法主要实现了以下逻辑：

1）、创建 ServletContext ，并绑定 DispatcherServlet 和 Filter

2）、创建 tomcat web 服务器并启动 tomcat，这里为了性能优化，通过设置 Connector 的 bindOnInit 属性为false来禁止完全启动 tomcat，这里只启动了 Tomcat 的 Server 和 Service，待应用启动好之后再启动 tomcat，即启动 Connector 和 Socket 套接字

3.3.2  finishBeanFactoryInitialization 方法

finishBeanFactoryInitialization 方法同样加载了所有非lazy的Singleton Bean，Spring Boot 正是在此过程中实现了自动化配置的加载，这个是 Spring Boot 的核心，我们在下一节对其单独分析，这里不在赘述了

3.3.3  finishRefresh 方法

Spring Boot 的 finishRefresh 方法除了实现Spring原有方法的逻辑之外，还实现了完全启动WEB服务器（启动 Tomcat 的 Connector 和 Socket 套接字）功能，入口在 ServletWebServerApplicationContext 的 finishRefresh 方法，源码如下：

	// 1、ServletWebServerApplicationContext 的 finishRefresh 方法@Overrideprotected void finishRefresh() {// Spring 原有方法的逻辑，这里不在分析super.finishRefresh();// 启动web服务器WebServer webServer = startWebServer();if (webServer != null) {// 发布 ServletWebServerInitializedEvent 事件，即宣告web应用启动完成publishEvent(new ServletWebServerInitializedEvent(webServer, this));}}// 2、ServletWebServerApplicationContext 的 startWebServer 方法private WebServer startWebServer() {WebServer webServer = this.webServer;if (webServer != null) {// 调用 WebServer(TomcatWebServer) 的 start 方法启动服务webServer.start();}return webServer;}// 3、TomcatWebServer 的 start 方法@Overridepublic void start() throws WebServerException {//  加对象锁，防止重复启动synchronized (this.monitor) {if (this.started) {return;}try {// connector 与 service 重新绑定，并启动 Connector，从而打开 Socket 套接字 完成 tomcat 的整个启动addPreviouslyRemovedConnectors();Connector connector = this.tomcat.getConnector();if (connector != null && this.autoStart) {// 加载 ServletperformDeferredLoadOnStartup();}checkThatConnectorsHaveStarted();this.started = true;logger.info("Tomcat started on port(s): " + getPortsDescription(true)+ " with context path '" + getContextPath() + "'");}catch (ConnectorStartFailedException ex) {stopSilently();throw ex;}catch (Exception ex) {throw new WebServerException("Unable to start embedded Tomcat server",ex);}finally {Context context = findContext();ContextBindings.unbindClassLoader(context, context.getNamingToken(),getClass().getClassLoader());}}}// 4、TomcatWebServer 的 addPreviouslyRemovedConnectors 方法private void addPreviouslyRemovedConnectors() {Service[] services = this.tomcat.getServer().findServices();for (Service service : services) {Connector[] connectors = this.serviceConnectors.get(service);if (connectors != null) {for (Connector connector : connectors) {// connector 与 service 绑定，并启动 Connector，从而打开 Socket 套接字 完成 tomcat 的整个启动service.addConnector(connector);if (!this.autoStart) {stopProtocolHandler(connector);}}// 启动 tomcat 完成之后，移除缓存this.serviceConnectors.remove(service);}}}

finishRefresh 方法主要实现了完全启动 Tomcat 服务器的功能，具体启动的是 Connector，进而打开 Socket 套接字来完成 tomcat 的整个启动

四、总结

Spring Boot 的启动过程不是特别复杂，其中最难理解的就是 Tomcat 的启动，Tomcat 的启动分为了两部分，在 onRefresh 方法时启动了 Tomcat 的 Server 和 Service，而在 finishRefresh 方法中启动了 Tomcat 的 Connector，从而达到了待应用启动之后再完全启动 Tomcat 服务器的目的，这样做是为了防止应用启动过慢导致整个服务启动慢而优化的

如果大家想学习 tomcat 的启动过程，请查看 tomcat9源码 写篇文章