SpringBoot配置嵌入式Servlet容器

系统管理员 2022-04-25 02:00 252阅读 0赞

Spring Boot配置嵌入式Servlet容器的一些思考 ：

## 注册 Servlet Filter、Listener ##

当使用嵌入式的Servlet容器（Tomcat、Jetty等）时，我们通过将Servlet、Filter和Listener声明为Spring Bean而达到注册的效果；或者注册ServletRegistrationBean、FilterRegistrationBean 和 ServletListenerRegistrationBean的Bean。Spring Boot默认内嵌的Tomcat为servlet容器。通用的Servlet容器配置都以“server”作为前缀，而Tomcat特有配置都以“server.tomcat”作为前缀。

由于SpringBoot默认是以jar包的方式启动嵌入式的Servlet容器来启动SpringBoot的web应用,没有web.xml文件。

![A6xDl8.png][]

## 问题 ##

如何定制和修改Servlet容器中的相关配置；

SpringBoot能不能支持其他的Servlet容器；

配置Servler容器

## 配置文件 ##

<table> 
 <tbody> 
 <tr> 
 <td><pre>1 2 3 4 5 6 </pre></td> 
 <td><pre>#默认程序端口为8080 server.port=8080 #用户会话session过期事件,以秒为单位 server.session.cookie.comment=60 #配配置默认的访问路径,默认为/ server.context-path= / </pre></td> 
 </tr> 
 </tbody> 
</table>

通常的Servlet容器设置为为server.xxx=XXX 而Tomcat的设置则为server.tomcat=XXX

## 源码 ##

<table> 
 <tbody> 
 <tr> 
 <td><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 </pre></td> 
 <td><pre>@ConfigurationProperties(prefix = "server", ignoreUnknownFields = true) public class ServerProperties implements EmbeddedServletContainerCustomizer, EnvironmentAware, Ordered {
 	private Integer port; 	private InetAddress address; 	private String contextPath; 	private String displayName = "application"; 	@NestedConfigurationProperty 	private ErrorProperties error = new ErrorProperties(); 	private String servletPath = "/"; 	private final Map&lt;String, String&gt; contextParameters = new HashMap&lt;String, String&gt;(); 	private Boolean useForwardHeaders; 	private String serverHeader; 	private int maxHttpHeaderSize = 0; // bytes 	private int maxHttpPostSize = 0; // bytes 	private Integer connectionTimeout; 	private Session session = new Session(); 	@NestedConfigurationProperty 	private Ssl ssl; 	@NestedConfigurationProperty 	private Compression compression = new Compression(); 	@NestedConfigurationProperty 	private JspServlet jspServlet; 	private final Tomcat tomcat = new Tomcat(); 	private final Jetty jetty = new Jetty(); 	private final Undertow undertow = new Undertow(); 	private Environment environment; </pre></td> 
 </tr> 
 </tbody> 
</table>

## 代码配置 ##

启动服务

![Ac90EQ.png][]

这个两个配置本质上都是差不多的都调用了 embeddedServletContainerCustomizer() 方法在SpringBoot中我们也会遇到很多的xxCustomizer帮助我们进行定制配置。

## 注册三大组件 ##

<table> 
 <tbody> 
 <tr> 
 <td><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 </pre></td> 
 <td><pre>package com.hph.springboot.config; import com.hph.springboot.filter.MyFilter; import com.hph.springboot.listener.MyListener; import com.hph.springboot.servlet.MyServlet; import org.springframework.boot.context.embedded.ConfigurableEmbeddedServletContainer; import org.springframework.boot.context.embedded.EmbeddedServletContainerCustomizer; import org.springframework.boot.web.servlet.FilterRegistrationBean; import org.springframework.boot.web.servlet.ServletListenerRegistrationBean; import org.springframework.boot.web.servlet.ServletRegistrationBean; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import java.util.Arrays; @Configuration public class MyServerConfig {
 //注册三大组件 @Bean public ServletRegistrationBean myServlet(){
 ServletRegistrationBean registrationBean = new ServletRegistrationBean(new MyServlet(),"/myServlet"); registrationBean.setLoadOnStartup(1); return registrationBean; } @Bean public FilterRegistrationBean myFilter(){
 FilterRegistrationBean registrationBean = new FilterRegistrationBean(); registrationBean.setFilter(new MyFilter()); registrationBean.setUrlPatterns(Arrays.asList("/hello","/myServlet")); return registrationBean; } @Bean public ServletListenerRegistrationBean myListener(){
 ServletListenerRegistrationBean&lt;MyListener&gt; registrationBean = new ServletListenerRegistrationBean&lt;&gt;(new MyListener()); return registrationBean; } //配置嵌入式的Servlet容器 @Bean public EmbeddedServletContainerCustomizer embeddedServletContainerCustomizer(){
 return new EmbeddedServletContainerCustomizer() {
 //定制嵌入式的Servlet容器相关的规则 @Override public void customize(ConfigurableEmbeddedServletContainer container) {
 container.setPort(8083); } }; } } </pre></td> 
 </tr> 
 </tbody> 
</table>

点击ServletRegistrationBean进入

![AcCrZD.png][]

点击FilterRegistrationBean进入

![AcPmwD.png][]

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

## 替换为其他的嵌入式Servlet容器 ##

![AcHPaV.png][]

SpringBoot默认支持

### Tomcat(默认使用) ###

<table> 
 <tbody> 
 <tr> 
 <td><pre>1 2 3 4 5 </pre></td> 
 <td><pre>&lt;!-- 引入web模块 --&gt; &lt;dependency&gt; 	&lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; 	&lt;artifactId&gt;spring-boot-starter-web&lt;/artifactId&gt; &lt;/dependency&gt; </pre></td> 
 </tr> 
 </tbody> 
</table>

引入web模块时默认的时Tomcat

### Jetty ###

![Acb40I.png][]

只需要修改pom文件即可

### Undertow ###

![Acq0gg.png][]

### 原理 ###

EmbeddedServletContainerAutoConfiguration:嵌入式的Servlet容器自动配置。

<table> 
 <tbody> 
 <tr> 
 <td><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 </pre></td> 
 <td><pre>@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE) @Configuration @ConditionalOnWebApplication @Import(BeanPostProcessorsRegistrar.class) //导入BeanPostProcessorsRegistrar：给容器中导入一些组件 //导入了EmbeddedServletContainerCustomizerBeanPostProcessor： //后置处理器：bean初始化前后（创建完对象，还没赋值赋值）执行初始化工作 public class EmbeddedServletContainerAutoConfiguration {
 @Configuration 	@ConditionalOnClass({ Servlet.class, Tomcat.class })//判断当前是否引入了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(); 		} 	} </pre></td> 
 </tr> 
 </tbody> 
</table>

1.  EmbeddedServletContainerFactory(嵌入式Servlet容器工厂)

![AcOJtP.png][]

<table> 
 <tbody> 
 <tr> 
 <td><pre>1 2 3 4 5 </pre></td> 
 <td><pre>public interface EmbeddedServletContainerFactory {
 	EmbeddedServletContainer getEmbeddedServletContainer( ServletContextInitializer... initializers); } </pre></td> 
 </tr> 
 </tbody> 
</table>

1.  EmbeddedServletContainer：（嵌入式的Servlet容器）

![AcOa6g.png][]

在

以TomcatEmbeddedServletContainerFactory为例分析

<table> 
 <tbody> 
 <tr> 
 <td><pre>1 2 3 4 </pre></td> 
 <td><pre>protected TomcatEmbeddedServletContainer getTomcatEmbeddedServletContainer( Tomcat tomcat) {
 	return new TomcatEmbeddedServletContainer(tomcat, getPort() &gt;= 0); } </pre></td> 
 </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
 <tr> 
 <td><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 </pre></td> 
 <td><pre>public TomcatEmbeddedServletContainer(Tomcat tomcat, boolean autoStart) {
 	Assert.notNull(tomcat, "Tomcat Server must not be null"); 	this.tomcat = tomcat; 	this.autoStart = autoStart; 	initialize(); } private void initialize() throws EmbeddedServletContainerException {
 	TomcatEmbeddedServletContainer.logger 			.info("Tomcat initialized with port(s): " + getPortsDescription(false)); 	synchronized (this.monitor) {
 		try {
 			addInstanceIdToEngineName(); 			try {
 				// Remove service connectors to that protocol binding doesn't happen 				// yet 				removeServiceConnectors(); 				// Start the server to trigger initialization listeners 				this.tomcat.start(); 				// We can re-throw failure exception directly in the main thread 				rethrowDeferredStartupExceptions(); 				Context context = findContext(); 				try {
 					ContextBindings.bindClassLoader(context, getNamingToken(context), 							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 shutdown 				startDaemonAwaitThread(); 			} 			catch (Exception ex) {
 				containerCounter.decrementAndGet(); 				throw ex; 			} 		} 		catch (Exception ex) {
 			throw new EmbeddedServletContainerException( 					"Unable to start embedded Tomcat", ex); 		} 	} } </pre></td> 
 </tr> 
 </tbody> 
</table>

如何对嵌入式容器的配置修改时怎么样生效的。

1.  使用serverProperties
2.  EmbeddedServletContainerCustomizer : 定制器帮我们修改了Servlet容器的配置导入BeanPostProcessorsRegistrar：给容器中导入一些组件

容器中导入了**EmbeddedServletContainerCustomizerBeanPostProcessor**

<table> 
 <tbody> 
 <tr> 
 <td><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 </pre></td> 
 <td><pre>//初始化之前 @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&lt;EmbeddedServletContainerCustomizer&gt; getCustomizers() {
 if (this.customizers == null) {
 // Look up does not include the parent context this.customizers = new ArrayList&lt;EmbeddedServletContainerCustomizer&gt;( 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也是定制器 </pre></td> 
 </tr> 
 </tbody> 
</table>

### 步骤 ###

步骤：

1）、SpringBoot根据导入的依赖情况，给容器中添加相应的EmbeddedServletContainerFactory【TomcatEmbeddedServletContainerFactory】

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

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

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

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

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

获取嵌入式的Servlet容器工厂：

1）、SpringBoot应用启动运行run方法

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

3）、refresh(context);**刷新刚才创建好的ioc容器；**

<table> 
 <tbody> 
 <tr> 
 <td><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 </pre></td> 
 <td><pre>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(); } } } </pre></td> 
 </tr> 
 </tbody> 
</table>

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容器；

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

**IOC容器启动创建嵌入式的Servlet容器**

[A6xDl8.png]: /images/20220210/e808a5cdce0747c18fab2c5f43d726ef.png
[Ac90EQ.png]: /images/20220210/dc52d4fb4d7141e3a31569ef88a80a48.png
[AcCrZD.png]: /images/20220210/5d28377f2207420995657a962095b4e6.png
[AcPmwD.png]: /images/20220210/d5c29c58dea843faad892eacd30c6ff6.png
[AcHPaV.png]: /images/20220210/0c5b4dfe4e3445579b031d474b6247bc.png
[Acb40I.png]: /images/20220210/f3c9fa9d5530417f93e55241d4ec6f58.png
[Acq0gg.png]: /images/20220210/f17c634bfc964d55992c43c6e40040e7.png
[AcOJtP.png]: /images/20220210/a0672003917341ebb9f0965e9b4c63c3.png
[AcOa6g.png]: /images/20220210/656ffea961c548d78531e98af4215442.png