SpringBoot 2.7.2 入门到精通教程笔记

图灵课堂-大都督周瑜

引入依赖的几种方式

parent方式

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-parent</artifactId>
    <version>2.7.2</version>
</parent>

dependencyManagement方式

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>2.7.2</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

这两种方式，只能说几乎是等价的，因为通过parent的方式不仅引入了spring-boot-dependencies，还引入了其他依赖，但是这些依赖作用并不是特别大，所以它两基本上是等价的。

直接指定version

当然还有就是第三种依赖方式，也是最不推荐的方式，就是

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
    <version>2.7.2</version>
</dependency>

启动SpringBoot应用的几种方式

@SpringBootApplication

@SpringBootApplication
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

三注解方式

@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

SpringApplication对象的方式

@SpringBootApplication
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication application = new SpringApplication(MyApplication.class);
//        application.setEnvironmentPrefix("zhouyu");
//        application.setDefaultProperties();
        application.run(args);
    }
}

Starter机制

SpringBoot的Starter机制是帮助我们管理了依赖，使得我们在需要使用某个功能时，不需要关心要依赖哪些依赖包，只需要引入SpringBoot给我们提供的对应的Starter就行了

比如：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
</dependency>

会间接的依赖：

1. spring-boot：SpringBoot的核心实现
2. spring-boot-autoconfigure：自动配置模块
3. spring-boot-starter-logging：日志Starter
4. spring-core：Spring的核心实现

而spring-boot-starter-logging这个Starter又依赖了logback-classic。

比如：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

会间接的依赖：

1. spring-boot-starter：会引入SpringBoot核心模块、自动配置模块
2. spring-boot-starter-json：会引入jackson相关的依赖
3. spring-boot-starter-tomcat：会引入tomcat相关的依赖
4. spring-web：web核心模块
5. spring-webmvc：mvc核心模块

自动配置

在使用SpringBoot时，如果我们使用注解@SpringBootApplication，那么则会自动开启SpringBoot的自动配置功能，因为@SpringBootApplication中使用了@EnableAutoConfiguration注解，表示开启自动配置。

@EnableAutoConfiguration会负责加载项目ClassPath中的META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports文件中所定义的自动配置类，然后根据配置类定义的条件注解来判断是否满足条件，如果满足则解析该配置类上的其他注解或通过@Bean定义的一些Bean。

所以SpringBoot的自动配置其实就是帮助开发者在一定条件下帮我们定义了一些Bean，或使用了一些注解，如果我们不使用SpringBoot，而直接使用Spring，那么这些Bean或注解得由我们自己来定义，使用了SpringBoot就不需要程序员来做了。

比如AopAutoConfiguration这个自动配置类就帮我们使用了@EnableAspectJAutoProxy注解，从而使得我们的项目支持AspectJ。

在SpringBoot2.7.0之前，@EnableAutoConfiguration是从ClassPath下的META-INF/spring.factories文件中去加载自动配置类的。

SpringBoot中的条件注解

1. @ConditionalOnClass：判断类是否存在，利用应用的类加载器来加载，加载到了则表示存在，否则表示不存在
2. @ConditionalOnMissingClass：判断类是否缺失
3. @ConditionalOnBean：判断某个类型、或某个名字的Bean是否存在，利用BeanFactory来进行判断
4. @ConditionalOnMissingBean：判断Bean是否缺失
5. @ConditionalOnProperty：判断某个参数的请求，比如是否配置了，比如配置的值是什么，利用Environment对象来进行判断

SpringBoot中的配置优先级

https://www.processon.com/view/link/62d399e71e08530a89222b23

SpringBoot启动过程

构造SpringApplication对象

1、推测web应用类型

1. 如果项目依赖中存在org.springframework.web.reactive.DispatcherHandler，并且不存在org.springframework.web.servlet.DispatcherServlet，那么应用类型为WebApplicationType.REACTIVE
2. 如果项目依赖中不存在org.springframework.web.reactive.DispatcherHandler，也不存在org.springframework.web.servlet.DispatcherServlet，那么应用类型为WebApplicationType.NONE

3. 否则，应用类型为WebApplicationType.SERVLET

   2、获取BootstrapRegistryInitializer对象

4. 从”META-INF/spring.factories”中读取key为BootstrapRegistryInitializer类型的扩展点，并实例化出对应扩展点对象

5. BootstrapRegistryInitializer的作用是可以初始化BootstrapRegistry
6. 上面的DefaultBootstrapContext对象就是一个BootstrapRegistry，可以用来注册一些对象，这些对象可以用在从SpringBoot启动到Spring容器初始化完成的过程中
7. 我的理解：没有Spring容器之前就利用BootstrapRegistry来共享一些对象，有了Spring容器之后就利用Spring容器来共享一些对象

3、获取ApplicationContextInitializer对象

1. 从”META-INF/spring.factories”中读取key为ApplicationContextInitializer类型的扩展点，并实例化出对应扩展点对象

2. 顾名思义，ApplicationContextInitializer是用来初始化Spring容器ApplicationContext对象的，比如可以利用ApplicationContextInitializer来向Spring容器中添加ApplicationListener

   4、获取ApplicationListener对象

3. 从”META-INF/spring.factories”中读取key为ApplicationListener类型的扩展点，并实例化出对应扩展点对象

4. ApplicationListener是Spring中的监听器，并不是SpringBoot中的新概念，不多解释了

   5、推测出Main类（main()方法所在的类）

   没什么具体的作用，逻辑是根据当前线程的调用栈来判断main()方法在哪个类，哪个类就是Main类

run(String… args)方法

1. 创建DefaultBootstrapContext对象
2. 利用BootstrapRegistryInitializer初始化DefaultBootstrapContext对象
3. 获取SpringApplicationRunListeners

这三个步骤没什么特殊的

5、触发SpringApplicationRunListener的starting()

默认情况下SpringBoot提供了一个EventPublishingRunListener，它实现了SpringApplicationRunListener接口，默认情况下会利用EventPublishingRunListener发布一个ApplicationContextInitializedEvent事件，程序员可以通过定义ApplicationListener来消费这个事件

6、创建Environment对象

Environment对象表示环境变量，该对象内部主要包含了:

1. 当前操作系统的环境变量
2. JVM的一些配置信息
3. -D方式所配置的JVM环境变量

   7、触发SpringApplicationRunListener的environmentPrepared()

   默认情况下会利用EventPublishingRunListener发布一个ApplicationEnvironmentPreparedEvent事件，程序员可以通过定义ApplicationListener来消费这个事件，比如默认情况下会有一个EnvironmentPostProcessorApplicationListener来消费这个事件，而这个ApplicationListener接收到这个事件之后，就会解析application.properties、application.yml文件，并添加到Environment对象中去。

   8、打印Banner

   没什么特殊的

9、创建Spring容器对象（ApplicationContext）

会利用ApplicationContextFactory.DEFAULT，根据应用类型创建对应的Spring容器。
ApplicationContextFactory.DEFAULT为：

ApplicationContextFactory DEFAULT = (webApplicationType) -> {
    try {
        switch (webApplicationType) {
            case SERVLET:
                return new AnnotationConfigServletWebServerApplicationContext();
            case REACTIVE:
                return new AnnotationConfigReactiveWebServerApplicationContext();
            default:
                return new AnnotationConfigApplicationContext();
        }
    }
    catch (Exception ex) {
        throw new IllegalStateException("Unable create a default ApplicationContext instance, "
                                        + "you may need a custom ApplicationContextFactory", ex);
    }
};

所以：

1. 应用类型为SERVLET，则对应AnnotationConfigServletWebServerApplicationContext
2. 应用类型为REACTIVE，则对应AnnotationConfigReactiveWebServerApplicationContext
3. 应用类型为普通类型，则对应AnnotationConfigApplicationContext

10、利用ApplicationContextInitializer初始化Spring容器对象

默认情况下SpringBoot提供了多个ApplicationContextInitializer，其中比较重要的有ConditionEvaluationReportLoggingListener，别看到它的名字叫XXXListener，但是它确实是实现了ApplicationContextInitializer接口的。

在它的initialize()方法中会：

1. 将Spring容器赋值给它的applicationContext属性
2. 并且往Spring容器中添加一个ConditionEvaluationReportListener（ConditionEvaluationReportLoggingListener的内部类），它是一个ApplicationListener
3. 并生成一个ConditionEvaluationReport对象赋值给它的report属性

ConditionEvaluationReportListener会负责接收ContextRefreshedEvent事件，也就是Spring容器一旦启动完毕就会触发ContextRefreshedEvent，ConditionEvaluationReportListener就会打印自动配置类的条件评估报告。

11、触发SpringApplicationRunListener的contextPrepared()

默认情况下会利用EventPublishingRunListener发布一个ApplicationContextInitializedEvent事件，默认情况下暂时没有ApplicationListener消费了这个事件

12、调用DefaultBootstrapContext对象的close()

没什么特殊的，忽略

13、将启动类作为配置类注册到Spring容器中（load()方法）

将SpringApplication.run(MyApplication.class);中传入进来的类，比如MyApplication.class，作为Spring容器的配置类

14、 触发SpringApplicationRunListener的contextLoaded()

默认情况下会利用EventPublishingRunListener发布一个ApplicationPreparedEvent事件

15、刷新Spring容器

调用Spring容器的refresh()方法，结合第9、13步，相当于执行了这样一个流程：

1. AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
2. applicationContext .register(MyApplication.class)
3. applicationContext .refresh()

   16、触发SpringApplicationRunListener的started()

   发布ApplicationStartedEvent事件和AvailabilityChangeEvent事件，AvailabilityChangeEvent事件表示状态变更状态，变更后的状态为LivenessState.CORRECT

LivenessState枚举有两个值：

1. CORRECT：表示当前应用正常运行中

2. BROKEN：表示当前应用还在运行，但是内部出现问题，暂时还没发现哪里用到了

   17、调用ApplicationRunner和CommandLineRunner

3. 获取Spring容器中的ApplicationRunner类型的Bean

4. 获取Spring容器中的CommandLineRunner类型的Bean
5. 执行它们的run()

   18、触发SpringApplicationRunListener的ready()

   发布ApplicationReadyEvent事件和AvailabilityChangeEvent事件，AvailabilityChangeEvent事件表示状态变更状态，变更后的状态为ReadinessState.ACCEPTING_TRAFFIC

ReadinessState枚举有两个值：

1. ACCEPTING_TRAFFIC：表示当前应用准备接收请求
2. REFUSING_TRAFFIC：表示当前应用拒绝接收请求，比如Tomcat关闭时，就会发布AvailabilityChangeEvent事件，并且状态为REFUSING_TRAFFIC

   19、上述过程抛异常了就触发SpringApplicationRunListener的failed()

   发布ApplicationFailedEvent事件

SpringBoot整合Tomcat底层原理

通过前面我们会SpringBoot的自动配置机制、Starter机制、启动过程的底层分析，我们拿一个实际的业务案例来串讲一下，那就是SpringBoot和Tomcat的整合。

我们知道，只要我们的项目添加的starter为：spring-boot-starter-web，那么我们启动项目时，SpringBoot就会自动启动一个Tomcat。

那么这是怎么做到的呢？

首先我们可以发现，在spring-boot-starter-web这个starter中，其实简介的引入了spring-boot-starter-tomcat这个starter，这个spring-boot-starter-tomcat又引入了tomcat-embed-core依赖，所以只要我们项目中依赖了spring-boot-starter-web就相当于依赖了Tomcat。

然后在SpringBoot众多的自动配置类中，有一个自动配置类叫做ServletWebServerFactoryAutoConfiguration，定义为：

@Configuration(proxyBeanMethods = false)
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
@ConditionalOnClass(ServletRequest.class)
@ConditionalOnWebApplication(type = Type.SERVLET)
@EnableConfigurationProperties(ServerProperties.class)
@Import({ ServletWebServerFactoryAutoConfiguration.BeanPostProcessorsRegistrar.class,
        ServletWebServerFactoryConfiguration.EmbeddedTomcat.class,
        ServletWebServerFactoryConfiguration.EmbeddedJetty.class,
        ServletWebServerFactoryConfiguration.EmbeddedUndertow.class })
public class ServletWebServerFactoryAutoConfiguration {
    // ...
}

首先看这个自动配置类所需要的条件：

1. @ConditionalOnClass(ServletRequest.class)：表示项目依赖中要有ServletRequest类（server api）
2. @ConditionalOnWebApplication(type = Type.SERVLET)：表示项目应用类型得是SpringMVC（讲启动过程的时候就知道如何判断一个SpringBoot应用的类型了）

在上面提到的spring-boot-starter-web中，其实还间接的引入了spring-web、spring-webmvc等依赖，这就使得第二个条件满足，而对于第一个条件的ServletRequest类，虽然它是Servlet规范中的类，但是在我们所依赖的tomcat-embed-core这个jar包中是存在这个类的，这是因为Tomcat在自己的源码中把Servlet规范中的一些代码也包含进去了，比如：

这就使得ServletWebServerFactoryAutoConfiguration这个自动配置的两个条件都符合，那么Spring就能去解析它，一解析它就发现这个自动配置类Import进来了三个类：

1. ServletWebServerFactoryConfiguration.EmbeddedTomcat.class
2. ServletWebServerFactoryConfiguration.EmbeddedJetty.class
3. ServletWebServerFactoryConfiguration.EmbeddedUndertow.class

很明显，Import进来的这三个类应该是差不多，我们看EmbeddedTomcat这个类：

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass({ Servlet.class, Tomcat.class, UpgradeProtocol.class })
@ConditionalOnMissingBean(value = ServletWebServerFactory.class, search = SearchStrategy.CURRENT)
static class EmbeddedTomcat {
    @Bean
    TomcatServletWebServerFactory tomcatServletWebServerFactory(
        ObjectProvider<TomcatConnectorCustomizer> connectorCustomizers,
        ObjectProvider<TomcatContextCustomizer> contextCustomizers,
        ObjectProvider<TomcatProtocolHandlerCustomizer<?>> protocolHandlerCustomizers) {
        TomcatServletWebServerFactory factory = new TomcatServletWebServerFactory();
        // orderedStream()调用时会去Spring容器中找到TomcatConnectorCustomizer类型的Bean，默认是没有的，程序员可以自己定义
        factory.getTomcatConnectorCustomizers()
            .addAll(connectorCustomizers.orderedStream().collect(Collectors.toList()));
        factory.getTomcatContextCustomizers()
            .addAll(contextCustomizers.orderedStream().collect(Collectors.toList()));
        factory.getTomcatProtocolHandlerCustomizers()
            .addAll(protocolHandlerCustomizers.orderedStream().collect(Collectors.toList()));
        return factory;
    }
}

可以发现这个类是一个配置类，所以Spring也会来解析它，不过它也有两个条件：

1. @ConditionalOnClass({ Servlet.class, Tomcat.class, UpgradeProtocol.class })：项目依赖中要有Servlet.class、Tomcat.class、UpgradeProtocol.class这三个类，这个条件比较容易理解，项目依赖中有Tomcat的类，那这个条件就符合。
2. @ConditionalOnMissingBean(value = ServletWebServerFactory.class, search = SearchStrategy.CURRENT)，项目中没有ServletWebServerFactory类型的Bean，因为这个配置类的内部就是定义了一个TomcatServletWebServerFactory类型的Bean，TomcatServletWebServerFactory实现了ServletWebServerFactory接口，所以这个条件注解的意思就是，如果程序员自己没有定义ServletWebServerFactory类型的Bean，那么就符合条件，不然，如果程序员自己定义了ServletWebServerFactory类型的Bean，那么条件就不符合，也就导致SpringBoot给我们定义的TomcatServletWebServerFactory这个Bean就不会生效，最终生效的就是程序员自己定义的。

所以，通常只要我们项目依赖中有Tomcat依赖，那就符合条件，那最终Spring容器中就会有TomcatServletWebServerFactory这个Bean。

对于另外的EmbeddedJetty和EmbeddedUndertow，也差不多，都是判断项目依赖中是否有Jetty和Undertow的依赖，如果有，那么对应在Spring容器中就会存在JettyServletWebServerFactory类型的Bean、或者存在UndertowServletWebServerFactory类型的Bean。

总结一下：

1. 有Tomcat依赖，就有TomcatServletWebServerFactory这个Bean
2. 有Jetty依赖，就有JettyServletWebServerFactory这个Bean
3. 有Undertow依赖，就有UndertowServletWebServerFactory这个Bean

那么SpringBoot给我们配置的这几个Bean到底有什么用呢？

我们前面说到，TomcatServletWebServerFactory实现了ServletWebServerFactory这个接口，这个接口的定义为：

public interface ServletWebServerFactory {
    WebServer getWebServer(ServletContextInitializer... initializers);
}

public interface WebServer {
    void start() throws WebServerException;
    void stop() throws WebServerException;
    int getPort();
}

我们发现ServletWebServerFactory其实就是用来获得WebServer对象的，而WebServer拥有启动、停止、获取端口等方法，那么很自然，我们就发现WebServer其实指的就是Tomcat、Jetty、Undertow，而TomcatServletWebServerFactory就是用来生成Tomcat所对应的WebServer对象，具体一点就是TomcatWebServer对象，并且在生成TomcatWebServer对象时会把Tomcat给启动起来，在源码中，调用TomcatServletWebServerFactory对象的getWebServer()方法时就会启动Tomcat。

我们再来看TomcatServletWebServerFactory这个Bean的定义：

@Bean
TomcatServletWebServerFactory tomcatServletWebServerFactory(
    ObjectProvider<TomcatConnectorCustomizer> connectorCustomizers,
    ObjectProvider<TomcatContextCustomizer> contextCustomizers,
    ObjectProvider<TomcatProtocolHandlerCustomizer<?>> protocolHandlerCustomizers) {
    TomcatServletWebServerFactory factory = new TomcatServletWebServerFactory();
    // orderedStream()调用时会去Spring容器中找到TomcatConnectorCustomizer类型的Bean，默认是没有的，程序员可以自己定义
    factory.getTomcatConnectorCustomizers()
        .addAll(connectorCustomizers.orderedStream().collect(Collectors.toList()));
    factory.getTomcatContextCustomizers()
        .addAll(contextCustomizers.orderedStream().collect(Collectors.toList()));
    factory.getTomcatProtocolHandlerCustomizers()
        .addAll(protocolHandlerCustomizers.orderedStream().collect(Collectors.toList()));
    return factory;
}

要构造这个Bean，Spring会从Spring容器中获取到TomcatConnectorCustomizer、TomcatContextCustomizer、TomcatProtocolHandlerCustomizer这三个类型的Bean，然后把它们添加到TomcatServletWebServerFactory对象中去，很明显这三种Bean是用来配置Tomcat的，比如：

1. TomcatConnectorCustomizer：是用来配置Tomcat中的Connector组件的
2. TomcatContextCustomizer：是用来配置Tomcat中的Context组件的
3. TomcatProtocolHandlerCustomizer：是用来配置Tomcat中的ProtocolHandler组件的

也就是我们可以通过定义TomcatConnectorCustomizer类型的Bean，来对Tomcat进行配置，比如：

@SpringBootApplication
public class MyApplication {
    @Bean
    public TomcatConnectorCustomizer tomcatConnectorCustomizer(){
        return new TomcatConnectorCustomizer() {
            @Override
            public void customize(Connector connector) {
                connector.setPort(8888);
            }
        };
    }
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class);
    }
}

这样Tomcat就会绑定8888这个端口。

有了TomcatServletWebServerFactory这个Bean之后，在SpringBoot的启动过程中，会执行ServletWebServerApplicationContext的onRefresh()方法，而这个方法会调用createWebServer()方法，而这个方法中最为重要的两行代码为：

ServletWebServerFactory factory = getWebServerFactory();
this.webServer = factory.getWebServer(getSelfInitializer());

很明显，getWebServerFactory()负责获取具体的ServletWebServerFactory对象，要么是TomcatServletWebServerFactory对象，要么是JettyServletWebServerFactory对象，要么是UndertowServletWebServerFactory对象，注意只能获取到一个，然后调用该对象的getWebServer方法，启动对应的Tomcat、或者Jetty、或者Undertow。

getWebServerFactory方法中的逻辑比较简单，获取Spring容器中的ServletWebServerFactory类型的Bean对象，如果没有获取到则抛异常，如果找到多个也抛异常，也就是在Spring容器中只能有一个ServletWebServerFactory类型的Bean对象。

拿到TomcatServletWebServerFactory对象后，就调用它的getWebServer方法，而在这个方法中就会生成一个Tomcat对象，并且利用前面的TomcatConnectorCustomizer等等会Tomcat对象进行配置，最后启动Tomcat。

这样在启动应用时就完成了Tomcat的启动，到此我们通过这个案例也看到了具体的Starter机制、自动配置的具体使用。

不过额外有一点要提一下，我们前面提到了我们可以利用TomcatConnectorCustomizer对Tomca中的Connector组件进行配置，我们可能会想到默认情况下，SpringBoot是不是就是提供了一个TomcatConnectorCustomizer的Bean，然后给Connector配置了8080端口，或者从Environment对象中获取server.port配置，并设置到Connector中去呢？

并不是，因为如果SpringBoot这么实现，那么默认就得提供三个ConnectorCustomizer的Bean，一个TomcatConnectorCustomizer、一个JettyConnectorCustomizer、一个UndertowConnectorCustomizer，这是比较不恰当的，我们知道默认情况下，不管我们是用Tomcat，还是Jetty，还是Undertow，它们启动时绑定的都是8080端口，也就是说SpringBoot并不会根据不同的WebServer设置不同的端口，也就是说SpringBoot只会给WebServer设置端口，而不会区分WebServer的不同实现。

所以在自动配置类ServletWebServerFactoryAutoConfiguration中，会定义一个ServletWebServerFactoryCustomizer类型的Bean，定义为：

@Bean
public ServletWebServerFactoryCustomizer servletWebServerFactoryCustomizer(ServerProperties serverProperties,
                                                                           ObjectProvider<WebListenerRegistrar> webListenerRegistrars,
                                                                           ObjectProvider<CookieSameSiteSupplier> cookieSameSiteSuppliers) {
    return new ServletWebServerFactoryCustomizer(serverProperties,
                                                 webListenerRegistrars.orderedStream().collect(Collectors.toList()),
                                                 cookieSameSiteSuppliers.orderedStream().collect(Collectors.toList()));
}

这个Bean会接收一个ServerProperties的Bean，ServerProperties的Bean对应的就是properties文件中前缀为server的配置，我们可以利用ServerProperties对象的getPort方法获取到我们所配置的server.port的值。

而ServletWebServerFactoryCustomizer是针对一个ServletWebServerFactory的自定义器，也就是用来配置TomcatServletWebServerFactory这个Bean的，到时候ServletWebServerFactoryCustomizer就会利用ServerProperties对象来对TomcatServletWebServerFactory对象进行设置。

在ServletWebServerFactoryAutoConfiguration这个自动配置上，除开Import了EmbeddedTomcat、EmbeddedJetty、EmbeddedUndertow这三个配置类，还Import了一个ServletWebServerFactoryAutoConfiguration.BeanPostProcessorsRegistrar.class，这个BeanPostProcessorsRegistrar会向Spring容器中注册一个WebServerFactoryCustomizerBeanPostProcessor类型的Bean。

WebServerFactoryCustomizerBeanPostProcessor是一个BeanPosrtProcessor，它专门用来处理类型为WebServerFactory的Bean对象，而我们的TomcatServletWebServerFactory、JettyServletWebServerFactory、UndertowServletWebServerFactory也都实现了这个接口，所以不管当前项目依赖的情况，只要在Spring在创建比如TomcatServletWebServerFactory这个Bean时，WebServerFactoryCustomizerBeanPostProcessor就会对它进行处理，处理的逻辑为：

1. 从Spring容器中拿到WebServerFactoryCustomizer类型的Bean，也就是前面说的ServletWebServerFactoryCustomizer对象
2. 然后调用ServletWebServerFactoryCustomizer对象的customize方法，把TomcatServletWebServerFactory对象传入进去
3. customize方法中就会从ServerProperties对象获取各种配置，然后设置给TomcatServletWebServerFactory对象

比如：

这样当TomcatServletWebServerFactory这个Bean对象创建完成后，它里面的很多属性，比如port，就已经是程序员所配置的值了，后续执行getWebServer方法时，就直接获取自己的属性，比如port属性，设置给Tomcat，然后再利用TomcatConnectorCustomizer等会下进行处理，最后启动Tomcat。

到此，SpringBoot整合Tomcat的核心原理就分析完了，主要涉及的东西有：

1. spring-boot-starter-web：会自动引入Tomcat、SpringMVC的依赖
2. ServletWebServerFactoryAutoConfiguration：自动配置类
3. ServletWebServerFactoryAutoConfiguration.BeanPostProcessorsRegistrar：用来注册WebServerFactoryCustomizerBeanPostProcessor
4. ServletWebServerFactoryConfiguration.EmbeddedTomcat：配置TomcatServletWebServerFactory
5. ServletWebServerFactoryConfiguration.EmbeddedJetty：配置JettyServletWebServerFactory
6. ServletWebServerFactoryConfiguration.EmbeddedUndertow：配置UndertowServletWebServerFactory
7. ServletWebServerFactoryCustomizer：用来配置ServletWebServerFactory
8. WebServerFactoryCustomizerBeanPostProcessor：是一个BeanPostProcessor，利用ServletWebServerFactoryCustomizer来配置ServletWebServerFactory
9. ServletWebServerApplicationContext中的onRefresh()方法：负责启动Tomcat

SpringBoot整合Mybatis底层原理

SpringBoot默认是没有提供整合Mybatis的自动配置类的，所以我们需要引入：

<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.2.2</version>
</dependency>

在mybatis-spring-boot-starter中，就间接的依赖了：

1. mybatis
2. mybatis-spring：spring整合mybatis的核心实现
3. mybatis-spring-boot-autoconfigure：springboot整合mybatis对应的自动配置类

如果我们是spring整合mybatis，我们需要使用：
1、引入mybatis-spring
2、配置mapper的扫描路径
3、配置SqlSessionFactory的Bean

要么通过@MapperScan来定义mapper的扫描路径，比如：

@SpringBootApplication
@MapperScan("com.zhouyu.mapper")
public class MyApplication {
    public static void main(String[] args) {
     SpringApplication.run(MyApplication.class);
    }
}

要么通过定义MapperScannerConfigurer的Bean来定义扫描路径，比如：

@Bean
public MapperScannerConfigurer mapperScannerConfigurer(){
    MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();
    mapperScannerConfigurer.setBasePackage("com.zhouyu.mapper");
    return mapperScannerConfigurer;
}

而如果我们使用SpringBoot，那么则不需要了，因为在mybatis-spring-boot-autoconfigure依赖中存在一个MybatisAutoConfiguration的自动配置类，该类中就定义了一个SqlSessionFactory的Bean，并会根据MybatisProperties中的参数进行配置。

比如可以通过mybatis.config-location来配置mybatis的配置文件。

还通过MapperScannerRegistrarNotFoundConfiguration类Import了AutoConfiguredMapperScannerRegistrar，而这个类会负责向Spring容器中添加一个MapperScannerConfigurer的Bean，从而配置了mapper的扫描路径，默认情况下拿到的就是SpringBoot启动配置类所在的包路径，值得注意的是在SpringBoot中还添加了一个限制，就是只有一个接口上存在@Mapper注解，那么在扫描Mapper时才会扫描出来，也就是在使用SpringBoot时，一定要在Mapper接口上加上@Mapper注解。

有同学可能会说，我开发的时候没有在Mapper上加@Mapper注解也能功能，这是为什么呢？那可能是因为你用了@MapperScan注解，如果你用了这个注解，这个注解也会扫描，而不会关心Mapper上有没有@Mapper注解。