Day46——SpringBoot2.x版本的嵌入式Servlet容器自动配置原理

向右看齐 2023-03-01 13:25 44阅读 0赞

### 文章目录 ###

*  一. 回顾
 *  二. 嵌入式Servlet容器自动配置原理
 *   *  2.1 切入点分析
     *  2.2 初步了解ServletWebServerFactoryAutoConfiguration
     *   *  2.2.1 EmbeddedTomcat、EmbeddedJetty、EmbeddedUndertow
         *  2.2.2 BeanPostProcessorsRegistrar

# 一. 回顾 #

前面学习了[Day45——切换其他嵌入式容器（比如Jetty、Undertow）][Day45_Jetty_Undertow]，今天学习嵌入式Servlet容器自动配置原理。

参考自：[SpringBoot2.3.1嵌入式Servlet容器自动配置原理][SpringBoot2.3.1_Servlet]

# 二. 嵌入式Servlet容器自动配置原理 #

## 2.1 切入点分析 ##

我们知道SpringBoot所有的自动配置都是由xxxAutoConfiguration来进行的。要配置的信息是从xxxProperties获取。

之前了解过WebMvcAutoConfiguration，但是它里面没有相关的Servlet容器配置。那么看看它所在的包里面有没有类是对Servlet容器进行自动配置的。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNjM0ODQ2_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNjM0ODQ2_size_16_color_FFFFFF_t_70 1]

**总结：嵌入式的Servlet容器自动配置由ServletWebServerFactoryAutoConfiguration来进行。**

## 2.2 初步了解ServletWebServerFactoryAutoConfiguration ##

### 2.2.1 EmbeddedTomcat、EmbeddedJetty、EmbeddedUndertow ###

我们打开这个ServletWebServerFactoryAutoConfiguration类，（这里只给出关键的源代码）如下：（注意代码中的注释）

@ConditionalOnClass({ ServletRequest.class})//有ServletRequest这个类是此配置类才生效
    @ConditionalOnWebApplication(
        type = Type.SERVLET
    )//要求当前环境是web应用环境
    @EnableConfigurationProperties({ ServerProperties.class})//配置信息从ServerProperties获取
    @Import({ ServletWebServerFactoryAutoConfiguration.BeanPostProcessorsRegistrar.class, EmbeddedTomcat.class, EmbeddedJetty.class, EmbeddedUndertow.class})//导入这几个类到容器中（后面详细分析阐述）
    public class ServletWebServerFactoryAutoConfiguration { 
    ...
    }

首先看看EmbeddedTomcat这个类，如下：（注意代码中的注释）

class ServletWebServerFactoryConfiguration { 
    ...
    	@Configuration(
    	      proxyBeanMethods = false
    	  )
    	  //当前导入的类是Tomcat类才生效，同理，Jetty以及Undertow也是如此，三者只能有一个存在
    	  @ConditionalOnClass({ Servlet.class, Tomcat.class, UpgradeProtocol.class})
    	  //没有ServletWebServerFactory才会使用下面的注册方法，
    	  //否则使用用户自定义的ServletWebServerFactory
    	  @ConditionalOnMissingBean(
    	      value = { ServletWebServerFactory.class},
    	      search = SearchStrategy.CURRENT
    	  )
    	  static class EmbeddedTomcat { 
    	      EmbeddedTomcat() { 
    	  }
    	
    	  @Bean
    	  TomcatServletWebServerFactory tomcatServletWebServerFactory(ObjectProvider<TomcatConnectorCustomizer> connectorCustomizers, ObjectProvider<TomcatContextCustomizer> contextCustomizers, ObjectProvider<TomcatProtocolHandlerCustomizer<?>> protocolHandlerCustomizers) { 
    	      TomcatServletWebServerFactory factory = new TomcatServletWebServerFactory();
    	      factory.getTomcatConnectorCustomizers().addAll((Collection)connectorCustomizers.orderedStream().collect(Collectors.toList()));
    	      factory.getTomcatContextCustomizers().addAll((Collection)contextCustomizers.orderedStream().collect(Collectors.toList()));
    	      factory.getTomcatProtocolHandlerCustomizers().addAll((Collection)protocolHandlerCustomizers.orderedStream().collect(Collectors.toList()));
    	      return factory;
    	  }
    	}
    
    }

EmbeddedTomcat是ServletWebServerFactoryConfiguration中的一个静态内部类，同理EmbeddedJetty以及EmbeddedUndertow也是它的静态内部类。其实三者的自动配置原理差不多，了解一个即可。上面的方法其实就是注册一个TomcatServletWebServerFactory到容器中，我们来看看TomcatServletWebServerFactory类，里面有关关键的方法getWebServer()，如下:

public WebServer getWebServer(ServletContextInitializer... initializers) { 
            if (this.disableMBeanRegistry) { 
                Registry.disableRegistry();
            }
            //用Java创建一个Tomcat类
            Tomcat tomcat = new Tomcat();
            //设置tomcat实例的一些配置信息
            File baseDir = this.baseDirectory != null ? this.baseDirectory : this.createTempDir("tomcat");
            tomcat.setBaseDir(baseDir.getAbsolutePath());
            Connector connector = new Connector(this.protocol);
            connector.setThrowOnFailure(true);
            tomcat.getService().addConnector(connector);
            this.customizeConnector(connector);
            tomcat.setConnector(connector);
            tomcat.getHost().setAutoDeploy(false);
            this.configureEngine(tomcat.getEngine());
            Iterator var5 = this.additionalTomcatConnectors.iterator();
    
            while(var5.hasNext()) { 
                Connector additionalConnector = (Connector)var5.next();
                tomcat.getService().addConnector(additionalConnector);
            }
    
            this.prepareContext(tomcat.getHost(), initializers);
            //传入tomcat实例，调用getTomcatWebServer()
            return this.getTomcatWebServer(tomcat);
        }

点击getTomcatWebServer()，如下：

protected TomcatWebServer getTomcatWebServer(Tomcat tomcat) { 
            //new一个TomcatWebServer实例，传入tomcat实例以及一个boolean值
            //这里的this.getPort()返回的默认值是8080，所以Tomcat的默认端口是这样来的，它由一个port属性决定
            return new TomcatWebServer(tomcat, this.getPort() >= 0);
        }

点击看new TomcatWebServer()，如下：

//boolean值的入参是一个名为autoStart变量，联系上面的this.getPort()
    public TomcatWebServer(Tomcat tomcat, boolean autoStart) { 
            this.monitor = new Object();
            this.serviceConnectors = new HashMap();
            Assert.notNull(tomcat, "Tomcat Server must not be null");
            this.tomcat = tomcat;
            this.autoStart = autoStart;
            this.initialize();//进行初始化
        }

点击initialize()方法，如下:

private void initialize() throws WebServerException { 
            logger.info("Tomcat initialized with port(s): " + this.getPortsDescription(false));
            synchronized(this.monitor) { 
                try { 
                    this.addInstanceIdToEngineName();
                    Context context = this.findContext();
                    context.addLifecycleListener((event) -> { 
                        if (context.equals(event.getSource()) && "start".equals(event.getType())) { 
                            this.removeServiceConnectors();
                        }
    
                    });
                    this.tomcat.start();//启动Tomcat，就是在这里启动的
                    this.rethrowDeferredStartupExceptions();
    
                    try { 
                        ContextBindings.bindClassLoader(context, context.getNamingToken(), this.getClass().getClassLoader());
                    } catch (NamingException var5) { 
                    }
    
                    this.startDaemonAwaitThread();
                } catch (Exception var6) { 
                    this.stopSilently();
                    this.destroySilently();
                    throw new WebServerException("Unable to start embedded Tomcat", var6);
                }
    
            }
        }

同理EmbeddedJetty以及EmbeddedUndertow都是如此。

**总结1：EmbeddedTomcat类中，注册了TomcatServletWebServerFactory，TomcatServletWebServerFactory中有一个关键方法是getWebServer()，其中new了一个Tomcat，然后配置tomcat实例的一些必要信息，最后return this.getTomcatWebServer(tomcat)。getTomcatWebServer()方法中new了一个TomcatWebServer。TomcatWebServer的构造方法中调用了this.initialize()方法。initialize()方法中启动了tomcat（this.tomcat.start）。**

**总结2：SpringBoot无需使用外部的Tomcat，它是使用Java创建一个Tomcat并配置好放到容器中，然后就可以使用**

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

**前面我们学习过，自定义Servlet容器配置有2方式：**

1.  在application.properties里面配置
2.  注册WebServerFactoryCustomizer到容器中，并重写customize()方法

**那么能这样做的原理是什么？**

方式一的原理，如下：

@ConditionalOnClass({ ServletRequest.class})
    @ConditionalOnWebApplication(
        type = Type.SERVLET
    )
    //将application.properties中关于Servlet容器的配置与ServerProperties对应的属性绑定起来
    @EnableConfigurationProperties({ ServerProperties.class})
    @Import({ ServletWebServerFactoryAutoConfiguration.BeanPostProcessorsRegistrar.class, EmbeddedTomcat.class, EmbeddedJetty.class, EmbeddedUndertow.class})
    public class ServletWebServerFactoryAutoConfiguration { 
    ...
    }

application.properties中与ServerProperties以下属性对应：

@ConfigurationProperties(
        prefix = "server",
        ignoreUnknownFields = true
    )
    public class ServerProperties { 
        private Integer port;
        private InetAddress address;
        @NestedConfigurationProperty
        private final ErrorProperties error = new ErrorProperties();
        private ServerProperties.ForwardHeadersStrategy forwardHeadersStrategy;
        private String serverHeader;
        private DataSize maxHttpHeaderSize = DataSize.ofKilobytes(8L);
        private Duration connectionTimeout;
        @NestedConfigurationProperty
        private Ssl ssl;
        @NestedConfigurationProperty
        private final Compression compression = new Compression();
        @NestedConfigurationProperty
        private final Http2 http2 = new Http2();
        private final ServerProperties.Servlet servlet = new ServerProperties.Servlet();
        private final ServerProperties.Tomcat tomcat = new ServerProperties.Tomcat();
        private final ServerProperties.Jetty jetty = new ServerProperties.Jetty();
        private final ServerProperties.Netty netty = new ServerProperties.Netty();
        private final ServerProperties.Undertow undertow = new ServerProperties.Undertow();

需要配置的信息已经绑定并准备好了，那么SpringBoot是怎么使用这些配置信息的？如下：

public class ServletWebServerFactoryAutoConfiguration { 
        public ServletWebServerFactoryAutoConfiguration() { 
        }
    
        @Bean
        public ServletWebServerFactoryCustomizer servletWebServerFactoryCustomizer(ServerProperties serverProperties) { 
            //serverProperties传入有参构造中
            return new ServletWebServerFactoryCustomizer(serverProperties);
        }
    
        @Bean
        @ConditionalOnClass(
            name = { "org.apache.catalina.startup.Tomcat"}
        )
        public TomcatServletWebServerFactoryCustomizer tomcatServletWebServerFactoryCustomizer(ServerProperties serverProperties) { 
            //serverProperties传入有参构造中
            return new TomcatServletWebServerFactoryCustomizer(serverProperties);
        }

如上，通过有参构造，将serverProperties传入进去，这样SpringBoot就能使用这些配置信息了。

两个有参构造所在的类如下：

public class ServletWebServerFactoryCustomizer implements WebServerFactoryCustomizer<ConfigurableServletWebServerFactory>, Ordered { 
        private final ServerProperties serverProperties;
    
        public ServletWebServerFactoryCustomizer(ServerProperties serverProperties) { 
            this.serverProperties = serverProperties;
        }
    
        public int getOrder() { 
            return 0;
        }
    
        public void customize(ConfigurableServletWebServerFactory factory) { 
            PropertyMapper map = PropertyMapper.get().alwaysApplyingWhenNonNull();
            ServerProperties var10001 = this.serverProperties;
            var10001.getClass();
            map.from(var10001::getPort).to(factory::setPort);
            var10001 = this.serverProperties;
            var10001.getClass();
            map.from(var10001::getAddress).to(factory::setAddress);
            Servlet var3 = this.serverProperties.getServlet();
            var3.getClass();
            map.from(var3::getContextPath).to(factory::setContextPath);
            var3 = this.serverProperties.getServlet();
            var3.getClass();
            map.from(var3::getApplicationDisplayName).to(factory::setDisplayName);
            var3 = this.serverProperties.getServlet();
            var3.getClass();
            map.from(var3::getSession).to(factory::setSession);
            var10001 = this.serverProperties;
            var10001.getClass();
            map.from(var10001::getSsl).to(factory::setSsl);
            var3 = this.serverProperties.getServlet();
            var3.getClass();
            map.from(var3::getJsp).to(factory::setJsp);
            var10001 = this.serverProperties;
            var10001.getClass();
            map.from(var10001::getCompression).to(factory::setCompression);
            var10001 = this.serverProperties;
            var10001.getClass();
            map.from(var10001::getHttp2).to(factory::setHttp2);
            var10001 = this.serverProperties;
            var10001.getClass();
            map.from(var10001::getServerHeader).to(factory::setServerHeader);
            var3 = this.serverProperties.getServlet();
            var3.getClass();
            map.from(var3::getContextParameters).to(factory::setInitParameters);
        }
    }

public class TomcatServletWebServerFactoryCustomizer implements WebServerFactoryCustomizer<TomcatServletWebServerFactory>, Ordered { 
        private final ServerProperties serverProperties;
    
        public TomcatServletWebServerFactoryCustomizer(ServerProperties serverProperties) { 
            this.serverProperties = serverProperties;
        }
    
        public int getOrder() { 
            return 0;
        }
    
        public void customize(TomcatServletWebServerFactory factory) { 
            Tomcat tomcatProperties = this.serverProperties.getTomcat();
            if (!ObjectUtils.isEmpty(tomcatProperties.getAdditionalTldSkipPatterns())) { 
                factory.getTldSkipPatterns().addAll(tomcatProperties.getAdditionalTldSkipPatterns());
            }
    
            if (tomcatProperties.getRedirectContextRoot() != null) { 
                this.customizeRedirectContextRoot(factory, tomcatProperties.getRedirectContextRoot());
            }
    
            if (tomcatProperties.getUseRelativeRedirects() != null) { 
                this.customizeUseRelativeRedirects(factory, tomcatProperties.getUseRelativeRedirects());
            }
    
            factory.setDisableMBeanRegistry(!tomcatProperties.getMbeanregistry().isEnabled());
        }
    
        private void customizeRedirectContextRoot(ConfigurableTomcatWebServerFactory factory, boolean redirectContextRoot) { 
            factory.addContextCustomizers(new TomcatContextCustomizer[]{ (context) -> { 
                context.setMapperContextRootRedirectEnabled(redirectContextRoot);
            }});
        }
    
        private void customizeUseRelativeRedirects(ConfigurableTomcatWebServerFactory factory, boolean useRelativeRedirects) { 
            factory.addContextCustomizers(new TomcatContextCustomizer[]{ (context) -> { 
                context.setUseRelativeRedirects(useRelativeRedirects);
            }});
        }
    }

可以看到两个类都有一个customize()方法，那么它很大可能会被调用到，那么它在哪里调用的呢？这就涉及到一开始ServletWebServerFactoryAutoConfiguration类就Import进BeanPostProcessorRegistrar。看下面一小节

方式二的原理也是看下面一小节

### 2.2.2 BeanPostProcessorsRegistrar ###

在ServletWebServerFactoryAutoConfiguration中，如下：

@ConditionalOnClass({ ServletRequest.class})
    @ConditionalOnWebApplication(
        type = Type.SERVLET
    )
    @EnableConfigurationProperties({ ServerProperties.class})
    @Import({ ServletWebServerFactoryAutoConfiguration.BeanPostProcessorsRegistrar.class, EmbeddedTomcat.class, EmbeddedJetty.class, EmbeddedUndertow.class})
    public class ServletWebServerFactoryAutoConfiguration {

我们点击@Import中的BeanPostProcessorRegistrar看看，里面有个关键的方法registerBeanDefinitions()，如下：

public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) { 
                if (this.beanFactory != null) { 
                    this.registerSyntheticBeanIfMissing(registry, 
                    "webServerFactoryCustomizerBeanPostProcessor", 
                    //传入了WebServerFactoryCustomizerBeanPostProcessor类
                    WebServerFactoryCustomizerBeanPostProcessor.class);
                    
                    this.registerSyntheticBeanIfMissing(registry, 
                    "errorPageRegistrarBeanPostProcessor", 
                    ErrorPageRegistrarBeanPostProcessor.class);
                }
            }

点进看看WebServerFactoryBeanPostProcessor，里面有个关键方法postProcessBeforeInitialization()如下：

private void postProcessBeforeInitialization(WebServerFactory webServerFactory) { 
            //this.getCustomizers()拿到所有的Customizer，然后执行它的customize()方法
            ((Callbacks)LambdaSafe.callbacks(WebServerFactoryCustomizer.class, 
            this.getCustomizers(), webServerFactory, new Object[0])
            .withLogger(WebServerFactoryCustomizerBeanPostProcessor.class))
            .invoke((customizer) -> { 
                customizer.customize(webServerFactory);
            });
        }

**如上，this.getCustomizers()它会拿到所有的Customizer，然后执行customize()方法。**

**因此前面讲到ServletWebServerFactoryCustomizer以及TomcatServletWebServerFactoryCustomizer中的customize()都会在上面的postProcessorBeforeInitialization()中调用到。**

前面讲到的配置Servlet容器方式二的原理也是在这里被调用到。

**总结：BeanPostProcessorsRegistrar中有一个关键方法registerBeanDefinitions()，WebServerFactoryCustomizerBeanPostProcessor被传入registerBeanDefinitions()中。WebServerFactoryCustomizerBeanPostProcessor中有一个关键方法postProcessBeforeInitialization()，它会拿到所有的Customizer，并且调用它的customize()方法。**

[Day45_Jetty_Undertow]: https://blog.csdn.net/qq_40634846/article/details/107588114
[SpringBoot2.3.1_Servlet]: https://www.cnblogs.com/wxw7blog/p/13270152.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNjM0ODQ2_size_16_color_FFFFFF_t_70]: /images/20230208/a05ebfb8354d4b42aaffaf84e2ce64f5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNjM0ODQ2_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200726170208651.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNjM0ODQ2,size_16,color_FFFFFF,t_70