SpringBoot源码学习系列之嵌入式Servlet容器

1、前言简单介绍

SpringBoot的自动配置就是SpringBoot的精髓所在；对于SpringBoot项目是不需要配置Tomcat、jetty等等Servlet容器，直接启动application类既可，SpringBoot为什么能做到这么简捷？原因就是使用了内嵌的Servlet容器，默认是使用Tomcat的，具体原因是什么？为什么启动application就可以启动内嵌的Tomcat或者其它Servlet容器？ok，本文就已SpringBoot嵌入式Servlet的启动原理简单介绍一下

环境准备：

  • SmartGit
  • IntelliJ IDEA
  • Maven
  • SpringBoot2.2.1

本文先创建一个SpringBoot项目，基于最新的2.2.1版本，阅读源码之前先进行一些必要的应用代码实践，先学习应用实践，有助于理解源码

在SpringBoot官网找到嵌入式Servlet容器相关的描述：

Under the hood, Spring Boot uses a different type of ApplicationContext for embedded servlet container support. The ServletWebServerApplicationContext is a special type of WebApplicationContext that bootstraps itself by searching for a single ServletWebServerFactory bean. Usually a TomcatServletWebServerFactory, JettyServletWebServerFactory, or UndertowServletWebServerFactory has been auto-configured.

这是比较重要的信息，简单翻译一下，里面提到ServletWebServerApplicationContext这是一种特殊的ApplicationContext 类，也就是启动时候，用来扫描ServletWebServerFactory类型的类的，ServletWebServerFactory类是一个接口类，具体的实现类是TomcatServletWebServerFactory, JettyServletWebServerFactory, or UndertowServletWebServerFactory etc.

2、定制servlet容器

然后如何自定义嵌入式Servlet容器的配置？在官方文档里找到如图对应的描述：

方法1：修改application配置

从官方文档可以看出支持的配置有如下所示，所以要修改servlet容器配置，直接在application配置文件修改即可：

  • 网络设置: 监听端口(server.port)、服务器地址(server.address)等等
  • Session设置: 会话是否持久 (server.servlet.session.persistent),会话超时(server.servlet.session.timeout), 会话数据的位置 (server.servlet.session.store-dir), 会话对应的cookie配置 (server.servlet.session.cookie.*) 等等
  • 错误管理: 错误页面位置 (server.error.path)等等
  • SSL设置：具体参考Configure SSL
  • HTTP compression：具体参考Enable HTTP Response Compression

方法2：自定义WebServerFactoryCustomizer定制器类

从文档里还找到了通过新建自定义的WebServerFactoryCustomizer类来实现属性配置修改，WebServerFactoryCustomizer也就是一种定制器类：


import org.springframework.boot.web.server.WebServerFactoryCustomizer;
import org.springframework.boot.web.servlet.server.ConfigurableServletWebServerFactory;
import org.springframework.stereotype.Component;

/**
 * <pre>
 *  自定义的WebServerFactory定制器类
 * </pre>
 * @author nicky
 * <pre>
 * 修改记录
 *    修改后版本:     修改人：  修改日期: 2019年12月01日  修改内容:
 * </pre>
 */
@Component
public class WebServerFactoryCustomizationBean implements WebServerFactoryCustomizer<ConfigurableServletWebServerFactory> {

    @Override
    public void customize(ConfigurableServletWebServerFactory server) {
        server.setPort(8081);
    }

}

ok，官方文档里提供了如上的代码实例，当然也可以通过@bean注解进行设置，代码实例如：

@Configuration
public class MyServerConfig {

    /**
     * 自定义的WebServerFactory定制器类
     * @return
     */
    @Bean
    public WebServerFactoryCustomizer<ConfigurableServletWebServerFactory> webServerFactoryCustomizer(){
        return new WebServerFactoryCustomizer<ConfigurableServletWebServerFactory>() {
            @Override
            public void customize(ConfigurableServletWebServerFactory factory) {
                factory.setPort(8082);
            }
        };
    }
}

3、变换servlet容器

SpringBoot2.2.1版本支持的内嵌servlet容器有tomcat、jetty(适用于长连接)、undertow(高并发性能不错，但是默认不支持jsp)，不过项目默认使用的是Tomcat的

我们可以找新建的一个SpringBoot项目，要求是集成了spring-boot-starter-web的工程，在pom文件右键->Diagrams->Show Dependencies，可以看到对应的jar关系图：

ok，从图可以看出，SpringBoot默认使用是Servlet容器是Tomcat，然后如果要切换其它嵌入式Servlet容器，要怎么实现？我们可以在图示选择spring-boot-starter-tomcat右键exclusion，然后引入其它的servlet容器，pom配置如图：

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

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

4、servlet容器启动原理

ok，有了前面应用方面的学习之后，就可以简单跟一下Springboot是怎么对servlet容器进行自动配置的？内嵌的默认Tomcat容器是怎么样启动的？

从之前博客的学习，可以知道Springboot的自动配置都是通过一些AutoConfiguration类进行自动配置的，所以同理本博客也找一些对应的类，ServletWebServerFactoryAutoConfiguration 就是嵌入式servlet容器的自动配置类，简单跟一下其源码

@Configuration(proxyBeanMethods = false)
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
@ConditionalOnClass(ServletRequest.class)
@ConditionalOnWebApplication(type = Type.SERVLET)
@EnableConfigurationProperties(ServerProperties.class)//使ServerProperties配置类起效
@Import({ ServletWebServerFactoryAutoConfiguration.BeanPostProcessorsRegistrar.class,
        ServletWebServerFactoryConfiguration.EmbeddedTomcat.class,
        ServletWebServerFactoryConfiguration.EmbeddedJetty.class,
        ServletWebServerFactoryConfiguration.EmbeddedUndertow.class })//@Import是Spring框架的注解，作用是将对应组件加载到容器，这里关键的是BeanPostProcessorsRegistrar，一个后置处理类
public class ServletWebServerFactoryAutoConfiguration {

    @Bean
    public ServletWebServerFactoryCustomizer servletWebServerFactoryCustomizer(ServerProperties serverProperties) {
        return new ServletWebServerFactoryCustomizer(serverProperties);
    }

//Tomcat的定制器类，起作用的条件是有Tomcat对应jar有引入项目的情况，默认是引入的，所以会执行Tomcat的servletWeb工厂定制类
    @Bean
    @ConditionalOnClass(name = "org.apache.catalina.startup.Tomcat")
    public TomcatServletWebServerFactoryCustomizer tomcatServletWebServerFactoryCustomizer(
            ServerProperties serverProperties) {
        return new TomcatServletWebServerFactoryCustomizer(serverProperties);
    }

    ....

    //注册重要的后置处理器类WebServerFactoryCustomizerBeanPostProcessor，在ioc容器启动的时候会调用后置处理器
    public static class BeanPostProcessorsRegistrar implements ImportBeanDefinitionRegistrar, BeanFactoryAware {

        private ConfigurableListableBeanFactory beanFactory;

        //设置ConfigurableListableBeanFactory
        @Override
        public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
            if (beanFactory instanceof ConfigurableListableBeanFactory) {
                this.beanFactory = (ConfigurableListableBeanFactory) beanFactory;
            }
        }

        @Override
        public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata,
                BeanDefinitionRegistry registry) {
            if (this.beanFactory == null) {
                return;
            }
            registerSyntheticBeanIfMissing(registry, "webServerFactoryCustomizerBeanPostProcessor",
                    WebServerFactoryCustomizerBeanPostProcessor.class);
            registerSyntheticBeanIfMissing(registry, "errorPageRegistrarBeanPostProcessor",
                    ErrorPageRegistrarBeanPostProcessor.class);
        }

        private void registerSyntheticBeanIfMissing(BeanDefinitionRegistry registry, String name, Class<?> beanClass) {
            if (ObjectUtils.isEmpty(this.beanFactory.getBeanNamesForType(beanClass, true, false))) {
                RootBeanDefinition beanDefinition = new RootBeanDefinition(beanClass);
                beanDefinition.setSynthetic(true);
                registry.registerBeanDefinition(name, beanDefinition);
            }
        }

    }

}

从自动配置类里，我们并不能很明确地理解自动配置是怎么运行的，只看重关键的一些信息点，比如注册了Tomcat的ServletWebServer工厂的定制器类，方法是tomcatServletWebServerFactoryCustomizer，还有一个后置处理类BeanPostProcessorsRegistrar，后置处理是Spring源码里是很关键的，所以这里可以继续点一下TomcatServletWebServerFactoryCustomizer，Tomcat的webServer工厂定制器类

也是一个WebServerFactoryCustomizer类型的类，从前面的应用学习，这个类是进行servlet容器的一些定制

这个是关键的方法，主要是拿ServerProperties配置类里的信息进行特定属性定制

所以，这里就可以知道Tomcat的配置是通过定制器类TomcatServletWebServerFactoryCustomizer进行定制的，其工厂类是TomcatServletWebServerFactory

TomcatServletWebServerFactory工厂类进行Tomcat对象的创建，必要参数的自动配置

ok，简单跟了一下源码之后，我们知道了TomcatServletWebServerFactoryCustomizer是Tomcat的定制器类，Tomcat对象的创建是通过TomcatServletWebServerFactory类的，然后，有个疑问，这个定制器类是什么时候创建的？为什么一启动Application类，嵌入式的Tomcat也启动了？打成jar格式的Springboot项目，只要运行jar命令，不需要启动任何servlet容器，项目也是正常运行的？然后这个BeanPostProcessorsRegistrar后置处理类有什么作用？ok，带着这些疑问，我们还是用调试一下源码

如图，打断点调试，看看Tomcat定制器是怎么创建的？

定制器类被调用了，其对应的工厂类也会起作用，打个断点，看看工厂类是怎么调用的？

ok，启动Application类，在idea里调试，如图，可以跟着调用顺序，一点点跟源码，如图所示，调用了Springboot的run方法

run方法里的刷新上下文方法，refreshContext其实也就是创建ioc容器，初始化ioc容器，并创建容器的每一个组件

这里注意到了，调用到了ServletWebServerApplicationContext类的refresh方法，ServletWebServerApplicationContext类前面也介绍到了，这个类是一种特殊的ApplicationContext类，也就是一些ioc的上下文类，作用于WebServer类型的类

创建webServer类，先创建ioc容器，调用基类的onRefresh方法，然后再调用createWebServer方法

ioc的servletContext组件没被创建的情况，调用ServletWebServerFactory类获取WebServer类，有servletContext的情况，直接从ioc容器获取

扫描ioc容器里是否有对应的ServletWebServerFactory类，TomcatServletWebServerFactory是其中一种，通过调试，是有扫描到的，所以从ioc容器里将这个bean对应的信息封装到ServletWebServerFactory对象

接着是ioc容器创建bean的过程，这个一个比较复杂的过程，因为是单例的，所以是调用singleObjects进行存储

bean被创建之后，调用了后置处理器，这个其实就是Spring的源码里的bean的创建过程，后置处理器是很关键的，在bean被创建，还没进行属性赋值时候，就调用了后置处理器

关键点，这里是检测是否有WebServerFactory工厂类，前面的调试发现已经有Tomcat的WebServer工厂类，所以是会调用后置处理器的

调用了WebServerFactoryCustomizerBeanPostProcessor这个后置处理类，然后拿到一个WebServerFactoryCustomizer定制器类，也就是TomcatWebServerFactoryCustomizer，通过后置处理器调用定制方法customize

然后WebServerFactoryCustomizerBeanPostProcessor这个后置处理器是什么注册的？往前翻Springboot的自动配置类，在这里找到了WebServerFactoryCustomizerBeanPostProcessor的注册

ok，继续调试源码，BeanWrapperImpl创建bean实例

ok，Tomcat定制器类被调用了，是通过后置处理器调用的

然后就是之前跟过的定制方法customize执行：

Tomcat的WebServer工厂类创建Tomcat对象实例，进行属性配置，引擎设置等等

端口有设置就创建TomcatwebServer对象

TomcatWebServer启动Tomcat，如图代码所示：

ok，跟了源码，您是否有一个疑问？Tomcat的工厂类TomcatServletWebServerFactory是什么时候创建的？好的，返回前面配置类看看，如图，这里用import引入了EmbeddedTomcat类

ok，EmbeddedTomcat是一个内部的配置类，条件是有引入Tomcat对应的jar，就会自动创建工厂类，很显然，Springboot默认是有引入的

ok，经过源码比较简单的学习，思路就很清晰了

Springboot的ServletWebServerFactoryAutoConfiguration是嵌入式Servlet容器的自动配置类，这个类的主要作用是创建TomcatServletWebServerFactory工厂类，创建定制器类TomcatServletWebServerFactoryCustomizer，创建FilterRegistrationBean类，同时很关键的一步是注册后置处理器webServerFactoryCustomizerBeanPostProcessor

然后Springboot的Application类一启动，就会执行run方法，run经过一系列调用会通过ServletWebServerApplicationContext的onRefresh方法创建ioc容器，然后通过createWebServer方法，createWebServer方法会去ioc容器里扫描是否有对应的ServletWebServerFactory工厂类(TomcatServletWebServerFactory是其中一种)，扫描得到，就会触发webServerFactoryCustomizerBeanPostProcessor后置处理器类，这个处理器类会获取TomcatServletWebServerFactoryCustomizer定制器，并调用customize方法进行定制，这时候工厂类起作用，调用getWebServer方法进行Tomcat属性配置和引擎设置等等，再创建TomcatWebServer启动Tomcat容器

ok，本问只是简单跟一下嵌入式Tomcat容器的启动过程，可以看出Springboot的强大，还是基于Spring框架的，比如本博客提到的后置处理器，以及bean工程创建bean实例的过程，都是通过Spring框架实现的

原文地址：https://blog.51cto.com/14230003/2456912

时间： 2024-10-27 09:28:13

SpringBoot源码学习系列之嵌入式Servlet容器的相关文章

SpringBoot源码学习系列之异常处理自动配置

1.源码学习 先给个SpringBoot中的异常例子,假如访问一个错误链接,让其返回404页面 在浏览器访问: 而在其它的客户端软件,比如postman软件: 很显然,在浏览器里访问才会返回页面,而在Postman直接返回json数据了,所以基于此现象,可以跟一下Springboot异常自动配置的原理,本博客基于学习了尚硅谷课程之后,自己动手实践再做的笔录 SpringBoot的异常自动配置类是ErrorMvcAutoConfiguration.java,可以简单跟一下源码: package o

SpringBoot源码学习系列之启动原理简介

本博客通过debug方式简单跟一下Springboot application启动的源码,Springboot的启动源码是比较复杂的,本博客只是简单梳理一下源码,浅析其原理 为了方便跟源码,先找个Application类,打个断点,进行调试,如图所示: step into,run方法调用了SpringApplication的run方法 通过debug,Springboot启动过程,会先执行如下关键的构造函数 分析构造函数源码: public SpringApplication(ResourceL

JDK源码学习系列07----Stack

                                                               JDK源码学习系列07----Stack 1.Stack源码非常简单 package java.util; public class Stack<E> extends Vector<E> { // 版本ID.这个用于版本升级控制,这里不须理会! private static final long serialVersionUID = 122446316454

JDK源码学习系列08----HashMap

                                                          JDK源码学习系列08----HashMap 1.HashMap简介 HashMap 是一个散列表,它存储的内容是键值对(key-value)映射. HashMap 继承于AbstractMap,实现了Map.Cloneable.java.io.Serializable接口. HashMap 的实现不是同步的,这意味着它不是线程安全的.它的key.value都可以为null.此外,

JDK源码学习系列06----Vector

                                            JDK源码学习系列06----Vector 1.Vector简介 Vector的内部是数组实现的,它和ArrayList非常相似,最大的不同就是 Vector 是线程安全(同步)的. public class Vector<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.S

JDK源码学习系列05----LinkedList

                                         JDK源码学习系列05----LinkedList 1.LinkedList简介 LinkedList是基于双向链表实现的,它也可以被当作堆栈.队列或双端队列进行操作. public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, jav

【JDK1.8】 Java小白的源码学习系列：HashMap

目录 Java小白的源码学习系列:HashMap 官方文档解读 基本数据结构 基本源码解读 基本成员变量 构造器 巧妙的tableSizeFor put方法 巧妙的hash方法 JDK1.8的putVal方法 JDK1.8的resize方法 初始化部分 数组搬移部分 Java小白的源码学习系列:HashMap 春节拜年取消,在家花了好多天时间啃一啃HashMap的源码,同样是找了很多很多的资料,有JDK1.7的,也有JDK1.8的,当然本文基于JDK1.8.将所学到的东西进行整理,希望回过头再看

Spring 源码学习（二） IOC容器启动过程

这一节主要是记录一下Spring Ioc 容器的启动过程. Spring 的 Ioc 容器是怎么被加载和使用的? web容器为它提供了宿主环境 ServlectContext,  Tomcat 启动时会读取web.xml. 并且实例化web.xml中配置的ContextLoaderListener ,下面看一下ContextLoaderListener的创建过程: 在实例化ContextLoaderListener 之后,通过接口回调执行ContextLoaderListener 类中的cont

Java 源码学习系列（三）——Integer

Integer 类在对象中包装了一个基本类型 int 的值.Integer 类型的对象包含一个 int 类型的字段. 此外,该类提供了多个方法,能在 int 类型和 String 类型之间互相转换,还提供了处理 int 类型时非常有用的其他一些常量和方法. 类定义 public final class Integer extends Number implements Comparable<Integer> 从类定义中我们可以知道以下几点: 1.Integer类不能被继承 2.Integer类