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依賴；
@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容器工廠）

public interface EmbeddedServletContainerFactory {

//獲取嵌入式的Servlet容器
EmbeddedServletContainer getEmbeddedServletContainer(
ServletContextInitializer... initializers);

}

2）、EmbeddedServletContainer：（嵌入式的Servlet容器）

3）、以TomcatEmbeddedServletContainerFactory為例

@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）、我們對嵌入式容器的配置修改是怎麽生效？

ServerProperties、EmbeddedServletContainerCustomizer

**EmbeddedServletContainerCustomizer**：定制器幫我們修改了Servlet容器的配置？

怎麽修改的原理？

5）、容器中導入了**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也是定制器

步驟：

1）、SpringBoot根據導入的依賴情況，給容器中添加相應的EmbeddedServletContainerFactory【TomcatEmbeddedServletContainerFactory】

2）、容器中某個組件要創建對象就會驚動後置處理器；EmbeddedServletContainerCustomizerBeanPostProcessor；

只要是嵌入式的Servlet容器工廠，後置處理器就工作；

3）、後置處理器，從容器中獲取所有的EmbeddedServletContainerCustomizer，調用定制器的定制方法

5）、嵌入式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容器；

先啟動嵌入式的Servlet容器，再將ioc容器中剩下沒有創建出的對象獲取出來；

**==IOC容器啟動創建嵌入式的Servlet容器==**

嵌入式Servlet容器自動配置和啟動原理