SpringBoot源码学习之路（十一、嵌入式Servlet容器的配置、切换和启动原理）

落日映苍穹つ 2022-05-19 09:00 243阅读 0赞

## 嵌入式Servlet容器 ##

**SpringBoot默认使用Tomcat作为嵌入式的Servlet容器**  
![这里写图片描述][70]

#### 一、如何定制和修改Servlet容器的相关配置？ ####

**方式1**、修改和server有关的配置（ServerProperties【也是EmbeddedServletContainerCustomizer】）；

#通用的Servlet容器设置
    #server.xxx
    #Tomcat的设置
    #server.tomcat.xxx
    #如：
    
    server.port=8081
    server.context-path=/crud
    server.tomcat.uri-encoding=UTF-8

**方式2**、编写一个**EmbeddedServletContainerCustomizer（嵌入式的Servlet容器的定制器）**，来修改Servlet容器的配置

@Bean  //一定要将这个定制器加入到容器中
    public EmbeddedServletContainerCustomizer embeddedServletContainerCustomizer(){
        return new EmbeddedServletContainerCustomizer() {
    
            //定制嵌入式的Servlet容器相关的规则
            @Override
            public void customize(ConfigurableEmbeddedServletContainer container) {
                container.setPort(8083);
            }
        };
    }

--------------------

#### 二、如何注册Servlet三大组件【Servlet、Filter、Listener】？？ ####

以前注册这些组件都是在web.xml中配置，由于SpringBoot默认是以jar包的方式启动嵌入式的Servlet容器来启动SpringBoot的web应用，没有web.xml文件。

注册三大组件用以下方式：

①、借助`ServletRegistrationBean`注册自定义Servlet组件；  
自定义【MyServlet】：

public class MyServlet extends HttpServlet { 
        //处理get请求
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            doPost(req,resp);
        }
    
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            resp.getWriter().write("Hello MyServlet");
        }
    }

定义【ServletRegistrationBean】并放入容器中：

@Bean
    public ServletRegistrationBean myServlet(){
        ServletRegistrationBean registrationBean = new ServletRegistrationBean(new MyServlet(),"/myServlet");
        return registrationBean;
    }

②、借助`FilterRegistrationBean`注册自定义Filter组件；(自定义的`MyFilter`忽略)

@Bean
    public FilterRegistrationBean myFilter(){
        FilterRegistrationBean registrationBean = new FilterRegistrationBean();
        registrationBean.setFilter(new MyFilter());
        registrationBean.setUrlPatterns(Arrays.asList("/hello","/myServlet"));
        return registrationBean;
    }

③、借助`ServletListenerRegistrationBean`注册自定义Listener组件；(自定义的`MyListener`忽略)

@Bean
    public ServletListenerRegistrationBean myListener(){
        ServletListenerRegistrationBean<MyListener> registrationBean = new ServletListenerRegistrationBean<>(new MyListener());
        return registrationBean;
    }

SpringBoot帮我们自动配置SpringMVC的时候，自动的注册SpringMVC的前端控制器；DIspatcherServlet；

在：DispatcherServletAutoConfiguration中：

@Bean(name = DEFAULT_DISPATCHER_SERVLET_REGISTRATION_BEAN_NAME)
    @ConditionalOnBean(value = DispatcherServlet.class, name = DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)
    public ServletRegistrationBean dispatcherServletRegistration(
          DispatcherServlet dispatcherServlet) {
       ServletRegistrationBean registration = new ServletRegistrationBean(
             dispatcherServlet, this.serverProperties.getServletMapping());
        //默认拦截： "/" 拦截所有请求；包静态资源，但是不拦截jsp请求；（" /* " 会拦截jsp）
        //可以通过server.servletPath来修改SpringMVC前端控制器默认拦截的请求路径
    
       registration.setName(DEFAULT_DISPATCHER_SERVLET_BEAN_NAME);
       registration.setLoadOnStartup(
             this.webMvcProperties.getServlet().getLoadOnStartup());
       if (this.multipartConfig != null) {
          registration.setMultipartConfig(this.multipartConfig);
       }
       return registration;
    }

--------------------

#### 三、如何切换嵌入式的Servlet容器？（三种容器） ####

![这里写图片描述][70 1]

**Tomcat**（默认使用）

<dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-web</artifactId>
       引入web模块默认就是使用嵌入式的Tomcat作为Servlet容器；
    </dependency>

如何切换**Jetty**？

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

切换**Undertow**？（更支持高并发）

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

--------------------

#### 四、嵌入式Servlet容器自动配置原理； ####

**EmbeddedServletContainerAutoConfiguration：嵌入式的Servlet容器自动配置类**

@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
    @Configuration
    @ConditionalOnWebApplication
    @Import(BeanPostProcessorsRegistrar.class)
    //导入BeanPostProcessorsRegistrar：Spring注解版；给容器中导入一些组件
    //导入了EmbeddedServletContainerCustomizerBeanPostProcessor：
    //后置处理器：bean初始化前后（创建完对象，还没赋值赋值）执行初始化工作
    public class EmbeddedServletContainerAutoConfiguration { 
    
        @Configuration
        @ConditionalOnClass({ Servlet.class, Tomcat.class })//判断当前是否引入了Tomcat依赖；默认有tomcat
        @ConditionalOnMissingBean(value = EmbeddedServletContainerFactory.class, search = SearchStrategy.CURRENT)//判断当前容器没有用户自己定义EmbeddedServletContainerFactory：嵌入式的Servlet容器工厂；作用：创建嵌入式的Servlet容器
        public static class EmbeddedTomcat { 
    
            @Bean
            public TomcatEmbeddedServletContainerFactory tomcatEmbeddedServletContainerFactory() {
                return new TomcatEmbeddedServletContainerFactory();
            }
    
        }
    
        /** * Nested configuration if Jetty is being used. */
        @Configuration
        @ConditionalOnClass({ Servlet.class, Server.class, Loader.class,
                WebAppContext.class })
        @ConditionalOnMissingBean(value = EmbeddedServletContainerFactory.class, search = SearchStrategy.CURRENT)
        public static class EmbeddedJetty { 
    
            @Bean
            public JettyEmbeddedServletContainerFactory jettyEmbeddedServletContainerFactory() {
                return new JettyEmbeddedServletContainerFactory();
            }
    
        }
    
        /** * Nested configuration if Undertow is being used. */
        @Configuration
        @ConditionalOnClass({ Servlet.class, Undertow.class, SslClientAuthMode.class })
        @ConditionalOnMissingBean(value = EmbeddedServletContainerFactory.class, search = SearchStrategy.CURRENT)
        public static class EmbeddedUndertow { 
    
            @Bean
            public UndertowEmbeddedServletContainerFactory undertowEmbeddedServletContainerFactory() {
                return new UndertowEmbeddedServletContainerFactory();
            }
    
        }

我们需要了解以下几个组件：  
**1）、EmbeddedServletContainerFactory（嵌入式Servlet容器工厂，用于获取嵌入式的Servlet容器）**

public interface EmbeddedServletContainerFactory { 
    
       EmbeddedServletContainer getEmbeddedServletContainer(
             ServletContextInitializer... initializers);
    
    }

![这里写图片描述][70 2]

**2）、EmbeddedServletContainer：（嵌入式的Servlet容器，用于运行应用）**  
![这里写图片描述][70 3]

**3）、分析下*\*TomcatEmbeddedServletContainerFactory***嵌入式Tomcat的容器工厂\*

@Override
    public EmbeddedServletContainer getEmbeddedServletContainer(
          ServletContextInitializer... initializers) {
        //创建一个Tomcat
       Tomcat tomcat = new Tomcat();
    
        //配置Tomcat
       File baseDir = (this.baseDirectory != null ? this.baseDirectory
             : createTempDir("tomcat"));
       tomcat.setBaseDir(baseDir.getAbsolutePath());
       Connector connector = new Connector(this.protocol);
       tomcat.getService().addConnector(connector);
       customizeConnector(connector);
       tomcat.setConnector(connector);
       tomcat.getHost().setAutoDeploy(false);
       configureEngine(tomcat.getEngine());
       for (Connector additionalConnector : this.additionalTomcatConnectors) {
          tomcat.getService().addConnector(additionalConnector);
       }
       prepareContext(tomcat.getHost(), initializers);
    
        //将配置好的Tomcat传入进去，返回一个EmbeddedServletContainer，并且启动Tomcat服务器
       return getTomcatEmbeddedServletContainer(tomcat);
    }

**4）、我们对嵌入式容器的配置修改是怎么生效？**  
其原理是因为**EmbeddedServletContainerCustomizer（嵌入式容器定制器）**：帮我们修改了Servlet容器的配置。  
分析容器中导入的**EmbeddedServletContainerCustomizerBeanPostProcessor**组件。

//初始化之前
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName)
          throws BeansException {
        //如果当前初始化的是一个ConfigurableEmbeddedServletContainer类型的组件
       if (bean instanceof ConfigurableEmbeddedServletContainer) {
           //
          postProcessBeforeInitialization((ConfigurableEmbeddedServletContainer) bean);
       }
       return bean;
    }
    
    private void postProcessBeforeInitialization(
                ConfigurableEmbeddedServletContainer bean) {
        //获取所有的定制器，调用每一个定制器的customize方法来给Servlet容器进行属性赋值；
        for (EmbeddedServletContainerCustomizer customizer : getCustomizers()) {
            customizer.customize(bean);
        }
    }
    
    private Collection<EmbeddedServletContainerCustomizer> getCustomizers() {
        if (this.customizers == null) {
            // Look up does not include the parent context
            this.customizers = new ArrayList<EmbeddedServletContainerCustomizer>(
                this.beanFactory
                //从容器中获取所有这些类型的组件：EmbeddedServletContainerCustomizer
                //定制Servlet容器，给容器中可以添加一个EmbeddedServletContainerCustomizer类型的组件
                .getBeansOfType(EmbeddedServletContainerCustomizer.class, false, false).values());
            Collections.sort(this.customizers, AnnotationAwareOrderComparator.INSTANCE);
            this.customizers = Collections.unmodifiableList(this.customizers);
        }
        return this.customizers;
    }
    //ServerProperties也是定制器；

**由以上源码总结得出：**  
①、SpringBoot根据导入的依赖情况，给容器中添加相应的EmbeddedServletContainerFactory【TomcatEmbeddedServletContainerFactory】

②、容器中某个组件要创建对象就会惊动后置处理器；EmbeddedServletContainerCustomizerBeanPostProcessor；

只要是嵌入式的Servlet容器工厂，后置处理器就工作；

③、后置处理器，从容器中获取所有的**EmbeddedServletContainerCustomizer**，调用定制器的定制方法

--------------------

#### 五、嵌入式Servlet容器启动原理 ####

什么时候创建嵌入式的Servlet容器工厂？什么时候获取嵌入式的Servlet容器并启动Tomcat？

**获取嵌入式的Servlet容器工厂流程分析：**  
\*\*1）、\*\*SpringBoot应用启动运行run方法

**2）、\*\*refreshContext(context)：SpringBoot刷新IOC容器【创建IOC容器对象，并初始化容器，创建容器中的每一个组件】；如果是web应用创建\*\*AnnotationConfigEmbeddedWebApplicationContext**，否则：**AnnotationConfigApplicationContext**

**3）、*\*refresh(context);***刷新刚才创建好的ioc容器；\*（源码如下）

public void refresh() throws BeansException, IllegalStateException {
       synchronized (this.startupShutdownMonitor) {
          // Prepare this context for refreshing.
          prepareRefresh();
    
          // Tell the subclass to refresh the internal bean factory.
          ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    
          // Prepare the bean factory for use in this context.
          prepareBeanFactory(beanFactory);
    
          try {
             // Allows post-processing of the bean factory in context subclasses.
             postProcessBeanFactory(beanFactory);
    
             // Invoke factory processors registered as beans in the context.
             invokeBeanFactoryPostProcessors(beanFactory);
    
             // Register bean processors that intercept bean creation.
             registerBeanPostProcessors(beanFactory);
    
             // Initialize message source for this context.
             initMessageSource();
    
             // Initialize event multicaster for this context.
             initApplicationEventMulticaster();
    
             // Initialize other special beans in specific context subclasses.
             onRefresh();
    
             // Check for listener beans and register them.
             registerListeners();
    
             // Instantiate all remaining (non-lazy-init) singletons.
             finishBeanFactoryInitialization(beanFactory);
    
             // Last step: publish corresponding event.
             finishRefresh();
          }
    
          catch (BeansException ex) {
             if (logger.isWarnEnabled()) {
                logger.warn("Exception encountered during context initialization - " +
                      "cancelling refresh attempt: " + ex);
             }
    
             // Destroy already created singletons to avoid dangling resources.
             destroyBeans();
    
             // Reset 'active' flag.
             cancelRefresh(ex);
    
             // Propagate exception to caller.
             throw ex;
          }
    
          finally {
             // Reset common introspection caches in Spring's core, since we
             // might not ever need metadata for singleton beans anymore...
             resetCommonCaches();
          }
       }
    }

**4）、** onRefresh(); web的ioc容器重写了onRefresh方法；  
**5）、\*\*webioc容器会创建嵌入式的Servlet容器；\*\*createEmbeddedServletContainer**();  
**6）、获取嵌入式的Servlet容器工厂：**  
`EmbeddedServletContainerFactory containerFactory = getEmbeddedServletContainerFactory();`  
从ioc容器中获取EmbeddedServletContainerFactory 组件；**TomcatEmbeddedServletContainerFactory**创建对象，后置处理器一看是这个对象，就获取所有的定制器来先定制Servlet容器的相关配置；  
**7）、使用容器工厂获取嵌入式的Servlet容器**：  
`this.embeddedServletContainer = containerFactory .getEmbeddedServletContainer(getSelfInitializer());`  
**8）、**嵌入式的Servlet容器创建对象并启动Servlet容器；

**IOC容器启动创建嵌入式的Servlet容器，再启动嵌入式的Servlet容器，再将ioc容器中剩下没有创建出的对象获取出来；**

[70]: /images/20220519/afc16d11c4184d52a62107b117badb09.png
[70 1]: /images/20220519/ee2a1d34022b45cabb2b901874ec9fe4.png
[70 2]: /images/20220519/0b31e8825c3c4581a47803627d25c666.png
[70 3]: /images/20220519/eb3827eb61b54a0ca90b6ca4333ec856.png