配置嵌入式Servlet容器Tomcat

目录

• 8.配置嵌入式Servlet容器Tomcat
  • 1.定制和修改Servlet容器的相关配置
    • 方式一：配置文件修改与server有关的配置
    • 方式二：配置类修改Servlet容器的配置
  • 2.注册Servlet三大组件Servlet、Filter、Listener
    • Servlet
    • Filter
    • Listener
  • 3.切换其他嵌入式Servlet容器
  • 4.嵌入式Servlet容器自动配置原理
    • TomcatEmbeddedServletContainerFactory示例
    • 对嵌入式容器的配置修改是怎么生效的？
      • 方式1：EmbeddedServletContainerCustomizer通过servlet容器定制器
      • 方式2：修改ServerProperties配置类中属性
    • 小结
  • 5.嵌入式Servlet容器启动原理
    • 获取嵌入式的Servlet容器工厂
  • 6.使用外置的Servlet容器
    • 操作步骤
    • 外部Servlet容器启动原理
      • 规则
      • 流程

8.配置嵌入式Servlet容器Tomcat

SpringBoot默认使用Tomcat作为嵌入式的Servlet容器；

1.定制和修改Servlet容器的相关配置

方式一：配置文件修改与server有关的配置

• ServerProperties源码：

@ConfigurationProperties(prefix = "server", ignoreUnknownFields = true)
public class ServerProperties
		implements EmbeddedServletContainerCustomizer, EnvironmentAware, Ordered {
    /**
	 * Server HTTP port.
	 */
	private Integer port;
 
	/**
	 * Network address to which the server should bind to.
	 */
	private InetAddress address;
 
	/**
	 * Context path of the application.
	 */
	private String contextPath;
}

application.properties

# 修改端口号
server.port=8081         
# 修改访问路径
server.context-path=/crud
# 修改访问路径编码
server.tomcat.uri-encoding=UTF-8
# 通用的Servlet容器设置
server.xxx
# Tomcat的设置
server.tomcat.xxx

方式二：配置类修改Servlet容器的配置

编写EmbeddedServletContainerCustomizer嵌入式的Servlet容器的定制器，修改Servlet容器配置

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

ServerProperties源码：

@ConfigurationProperties(prefix = "server", ignoreUnknownFields = true)
public class ServerProperties
		implements EmbeddedServletContainerCustomizer, EnvironmentAware, Ordered {
    @Override
	public void customize(ConfigurableEmbeddedServletContainer container) {
		if (getPort() != null) {
			container.setPort(getPort());
		}
		if (getAddress() != null) {
			container.setAddress(getAddress());
		}
    }
}

通过源码可以看到无论使用配置文件方式还是配置类配置，两种方式的底层原理相同，都是实现了接口EmbeddedServletContainerCustomizer容器定制器，将我们配置的属性通过container配置到容器中。

2.注册Servlet三大组件Servlet、Filter、Listener

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

注册三大组件用以下方式

1、三大组件都可以自定义类实现相应组件的接口，重写其中接口方法

2、三个组件bean都在扩展springmvc配置类中注入容器中，并进行相应配置

Servlet

注册Servlet通过ServletRegistrationBean。

自定义类继承HttpServlet

public class MyServletConfig extends HttpServlet {
 
    @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");
    }
}

配置类注册Servlet bean

@Configuration
public class MvcConfig {
 
    @Bean
    public ServletRegistrationBean myServletBean() {
        return new ServletRegistrationBean(new MyServletConfig(), "/myServlet");
    }
}

ServletRegistrationBean源码：

public class ServletRegistrationBean extends RegistrationBean {
    // 有参构造设置 servlet 和拦截的路径
    public ServletRegistrationBean(Servlet servlet, String... urlMappings) {
		this(servlet, true, urlMappings);
	}
}

Filter

注册Filter 通过 FilterRegistrationBean。

自定义Filter配置类实现javax.servlet.Filter接口

public class MyFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
 
    }
 
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        chain.doFilter(request,response);
    }
 
    @Override
    public void destroy() {
 
    }
}

配置类注册Filter bean

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

Listener

注册Listener 通过 ServletListenerRegistrationBean

自定义Listener配置实现ServletContextListener接口

public class MyListener implements ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        System.out.println("Context 容器初始化");
    }
 
    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        System.out.println("Context 容器销毁");
    }
}

配置类注册Listener bean

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

说明：

凡是springmvc中可以设置的组件，都可以在扩展springmvc配置类中设置，注入到容器中使用。

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

全局配置文件中可以通过 server.servletPath 来修改SpringMVC前端控制器默认拦截的请求路径

DispatcherServletAutoConfiguration源码：

@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
@Configuration
@ConditionalOnWebApplication
@ConditionalOnClass(DispatcherServlet.class)
@AutoConfigureAfter(EmbeddedServletContainerAutoConfiguration.class)
public class 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());
        
        registration.setName(DEFAULT_DISPATCHER_SERVLET_BEAN_NAME);
        
        registration.setLoadOnStartup(this.webMvcProperties.getServlet().getLoadOnStartup());
        if (this.multipartConfig != null) {
            registration.setMultipartConfig(this.multipartConfig);
        }
        return registration;
    }
}

从以上源码可以看到，DispatcherServlet自动配置也是通过ServletRegistrationBean注册servlet，设置的拦截路径是

@ConfigurationProperties(prefix = "server", ignoreUnknownFields = true)
public class ServerProperties
		implements EmbeddedServletContainerCustomizer, EnvironmentAware, Ordered {
    /*
    默认拦截：'/' 代表所有请求；包括静态资源，但是不拦截jsp。而 '/*' 路径会拦截jsp。
    可以通过server.servletPath来在配置文件中修改SpringMVC的前端控制器拦截的请求路径
    */
    private String servletPath = "/";
 
    public String getServletMapping() {
        if (this.servletPath.equals("") || this.servletPath.equals("/")) {
            return "/";
        }
        if (this.servletPath.contains("*")) {
            return this.servletPath;
        }
        if (this.servletPath.endsWith("/")) {
            return this.servletPath + "*";
        }
        return this.servletPath + "/*";
    }
}

3.切换其他嵌入式Servlet容器

从上图可以看出ConfigurableEmbeddedServletContainer定制器还支持Jetty、Undertow的servlet容器。

• Tomcat（默认使用）

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

• Jetty

若使用其他容器，如：Jetty，需要先排除web模块默认的Tomcat容器，再引入其他容器依赖

<!-- 引入web模块 -->
<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>
 
<!--引入其他的Servlet容器-->
<dependency>
   <artifactId>spring-boot-starter-jetty</artifactId>
   <groupId>org.springframework.boot</groupId>
</dependency>

• Undertow

<!-- 引入web模块 -->
<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>
 
<!--引入其他的Servlet容器-->
<dependency>
   <artifactId>spring-boot-starter-undertow</artifactId>
   <groupId>org.springframework.boot</groupId>
</dependency>

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

嵌入式的Servlet容器自动配置源码：

@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
@Configuration
// web应用配置下才生效
@ConditionalOnWebApplication
//导入BeanPostProcessorsRegistrar：给容器中导入一些组件
@Import(BeanPostProcessorsRegistrar.class)
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();
		}
 
	}
    
    /**
	 * 以下两个容器同理，判断是否导入jetty或undertow依赖，根据条件创建不同容器工厂
	 */
	@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容器）

TomcatEmbeddedServletContainerFactory示例

TomcatEmbeddedServletContainerFactory源码：

public class TomcatEmbeddedServletContainerFactory
    extends AbstractEmbeddedServletContainerFactory implements ResourceLoaderAware {
 
    @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);
    }
 
 
    protected TomcatEmbeddedServletContainer getTomcatEmbeddedServletContainer(
        Tomcat tomcat) {
        // 端口号大于0 作为自动启动tomcat条件
        return new TomcatEmbeddedServletContainer(tomcat, getPort() >= 0);
    }
 
}

public class TomcatEmbeddedServletContainer implements EmbeddedServletContainer {
    
    private final Tomcat tomcat;
 
	private final boolean autoStart; // 自动启动条件
    
    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();
 
                      // 这里启动了Tomcat容器
					// 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);
			}
		}
	}
    
}

对嵌入式容器的配置修改是怎么生效的？

方式1：EmbeddedServletContainerCustomizer通过servlet容器定制器

EmbeddedServletContainerCustomizer：定制器帮我们修改了Servlet容器的配置？

修改的原理：

容器中导入了EmbeddedServletContainerCustomizerBeanPostProcessor

@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
@Configuration
@ConditionalOnWebApplication
@Import(BeanPostProcessorsRegistrar.class)
public class EmbeddedServletContainerAutoConfiguration {
    public static class BeanPostProcessorsRegistrar
			implements ImportBeanDefinitionRegistrar, BeanFactoryAware {
 
		private ConfigurableListableBeanFactory beanFactory;
        
        @Override
		public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata,
				BeanDefinitionRegistry registry) {
			if (this.beanFactory == null) {
				return;
			}
			registerSyntheticBeanIfMissing(registry,
					"embeddedServletContainerCustomizerBeanPostProcessor",
					EmbeddedServletContainerCustomizerBeanPostProcessor.class);
			registerSyntheticBeanIfMissing(registry,
					"errorPageRegistrarBeanPostProcessor",
					ErrorPageRegistrarBeanPostProcessor.class);
		}
    }
}

//导入了EmbeddedServletContainerCustomizerBeanPostProcessor：后置处理器;
//作用：bean初始化前后（创建完对象，还没赋值赋值）执行初始化工作
public class EmbeddedServletContainerCustomizerBeanPostProcessor
		implements BeanPostProcessor, BeanFactoryAware {
    
    //初始化之前
    @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;
    }
    
}

示例：

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

方式2：修改ServerProperties配置类中属性

通过application.properties配置文件中 server 属性配置容器配置。

ServerProperties源码：

可以看出ServerProperties实现了EmbeddedServletContainerCustomizer也是一个容器定制器。

@ConfigurationProperties(prefix = "server", ignoreUnknownFields = true)
public class ServerProperties
		implements EmbeddedServletContainerCustomizer, EnvironmentAware, Ordered {
    
    /**
	 * Server HTTP port.
	 */
	private Integer port;
 
	/**
	 * Network address to which the server should bind to.
	 */
	private InetAddress address;
 
	/**
	 * Context path of the application.
	 */
	private String contextPath;
 
	/**
	 * Display name of the application.
	 */
	private String displayName = "application";
 
	@NestedConfigurationProperty
	private ErrorProperties error = new ErrorProperties();
 
	/**
	 * Path of the main dispatcher servlet.
	 */
	private String servletPath = "/";
    
    
}

小结

步骤：

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

2）容器中某个组件要创建对象就会启动后置处理器；EmbeddedServletContainerCustomizerBeanPostProcessor；只要是嵌入式的Servlet容器工厂，后置处理器就工作；

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

5.嵌入式Servlet容器启动原理

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

获取嵌入式的Servlet容器工厂

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

@SpringBootApplication
@MapperScan({"com.example.demo.mapper"})
public class DemoApplication {
 
	public static void main(String[] args) {
		SpringApplication.run(DemoApplication.class, args);
	}
 
}

refreshContext(context);SpringBoot刷新IOC容器【创建IOC容器对象，并初始化容器，创建容器中的每一个组件】；

如果是web应用创建AnnotationConfigEmbeddedWebApplicationContext，否则：AnnotationConfigApplicationContext

public class SpringApplication {
    
    public static final String DEFAULT_CONTEXT_CLASS = "org.springframework.context."
			+ "annotation.AnnotationConfigApplicationContext";
    
    public static final String DEFAULT_WEB_CONTEXT_CLASS = "org.springframework."
			+ "boot.context.embedded.AnnotationConfigEmbeddedWebApplicationContext";
    
    public ConfigurableApplicationContext run(String... args) {
		StopWatch stopWatch = new StopWatch();
		stopWatch.start();
		ConfigurableApplicationContext context = null;
		FailureAnalyzers analyzers = null;
		configureHeadlessProperty();
		SpringApplicationRunListeners listeners = getRunListeners(args);
		listeners.starting();
		try {
			ApplicationArguments applicationArguments = new DefaultApplicationArguments(
					args);
			ConfigurableEnvironment environment = prepareEnvironment(listeners,
					applicationArguments);
			Banner printedBanner = printBanner(environment);
             // 创建IOC容器
			context = createApplicationContext();
			analyzers = new FailureAnalyzers(context);
			prepareContext(context, environment, listeners, applicationArguments,
					printedBanner);
             // SpringBoot刷新IOC容器
			refreshContext(context);
			afterRefresh(context, applicationArguments);
			listeners.finished(context, null);
			stopWatch.stop();
			if (this.logStartupInfo) {
				new StartupInfoLogger(this.mainApplicationClass)
						.logStarted(getApplicationLog(), stopWatch);
			}
			return context;
		}
		catch (Throwable ex) {
			handleRunFailure(context, listeners, analyzers, ex);
			throw new IllegalStateException(ex);
		}
	}
    
    protected ConfigurableApplicationContext createApplicationContext() {
		Class<?> contextClass = this.applicationContextClass;
		if (contextClass == null) {
			try {
                 // 判断是不是web环境，是web环境创建AnnotationConfigEmbeddedWebApplicationContext
				contextClass = Class.forName(this.webEnvironment
						? DEFAULT_WEB_CONTEXT_CLASS : DEFAULT_CONTEXT_CLASS);
			}
			catch (ClassNotFoundException ex) {
				throw new IllegalStateException(
						"Unable create a default ApplicationContext, "
								+ "please specify an ApplicationContextClass",
						ex);
			}
		}
		return (ConfigurableApplicationContext) BeanUtils.instantiate(contextClass);
	}
    
}

• 2、refresh(context);刷新刚才创建好的ioc容器

public class SpringApplication {
    
    private void refreshContext(ConfigurableApplicationContext context) {
        refresh(context);
        if (this.registerShutdownHook) {
            try {
                context.registerShutdownHook();
            }
            catch (AccessControlException ex) {
                // Not allowed in some environments.
            }
        }
    }
    
}

public abstract class AbstractApplicationContext extends DefaultResourceLoader
    implements ConfigurableApplicationContext, DisposableBean {
    
    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(); // web容器重写了此方法
 
                // 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();
            }
        }
    }
 
}

• 3、onRefresh(); web的ioc容器重写了onRefresh方法

// 嵌入式web的IOC容器
public class EmbeddedWebApplicationContext extends GenericWebApplicationContext {
 
    @Override
    protected void onRefresh() {
        super.onRefresh();
        try {
            // 创建嵌入式的Servlet容器
            createEmbeddedServletContainer();
        }
        catch (Throwable ex) {
            throw new ApplicationContextException("Unable to start embedded container",
                                                  ex);
        }
    }
 
    private void createEmbeddedServletContainer() {
        EmbeddedServletContainer localContainer = this.embeddedServletContainer;
        ServletContext localServletContext = getServletContext();
        if (localContainer == null && localServletContext == null) {
            // 获取嵌入式的Servlet容器工厂
            EmbeddedServletContainerFactory containerFactory = getEmbeddedServletContainerFactory();
            this.embeddedServletContainer = containerFactory
                .getEmbeddedServletContainer(getSelfInitializer());
        }
        else if (localServletContext != null) {
            try {
                getSelfInitializer().onStartup(localServletContext);
            }
            catch (ServletException ex) {
                throw new ApplicationContextException("Cannot initialize servlet context",
                                                      ex);
            }
        }
        initPropertySources();
    }
    
}

• 4、获取嵌入式的Servlet容器工厂

public class EmbeddedWebApplicationContext extends GenericWebApplicationContext {
    
    /*
    从ioc容器中获取EmbeddedServletContainerFactory 组件
    引入的Tomcat依赖，TomcatEmbeddedServletContainerFactory创建对象，后置处理器一看是这个对象，就获取所有的定制器来先定制Servlet容器的相关配置
     */
    protected EmbeddedServletContainerFactory getEmbeddedServletContainerFactory() {
        // Use bean names so that we don't consider the hierarchy
        String[] beanNames = getBeanFactory()
            .getBeanNamesForType(EmbeddedServletContainerFactory.class);
        if (beanNames.length == 0) {
            throw new ApplicationContextException(
                "Unable to start EmbeddedWebApplicationContext due to missing "
                + "EmbeddedServletContainerFactory bean.");
        }
        if (beanNames.length > 1) {
            throw new ApplicationContextException(
                "Unable to start EmbeddedWebApplicationContext due to multiple "
                + "EmbeddedServletContainerFactory beans : "
                + StringUtils.arrayToCommaDelimitedString(beanNames));
        }
        return getBeanFactory().getBean(beanNames[0],
                                        EmbeddedServletContainerFactory.class);
    }
}

• 5、使用容器工厂获取嵌入式的Servlet容器

public class EmbeddedWebApplicationContext extends GenericWebApplicationContext {
    
    private void createEmbeddedServletContainer() {
        EmbeddedServletContainer localContainer = this.embeddedServletContainer;
        ServletContext localServletContext = getServletContext();
        if (localContainer == null && localServletContext == null) {
            EmbeddedServletContainerFactory containerFactory = getEmbeddedServletContainerFactory();
            // 获取到容器工厂后，使用容器工厂获取嵌入式的Servlet容器
            this.embeddedServletContainer = containerFactory
                .getEmbeddedServletContainer(getSelfInitializer());
        }
        else if (localServletContext != null) {
            try {
                getSelfInitializer().onStartup(localServletContext);
            }
            catch (ServletException ex) {
                throw new ApplicationContextException("Cannot initialize servlet context",
                                                      ex);
            }
        }
        initPropertySources();
    }
    
}

• 6、嵌入式的Servlet容器创建对象并启动Servlet容器

public class TomcatEmbeddedServletContainerFactory
		extends AbstractEmbeddedServletContainerFactory implements ResourceLoaderAware {
    
    @Override
	public EmbeddedServletContainer getEmbeddedServletContainer(
			ServletContextInitializer... initializers) {
		Tomcat tomcat = new 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);
		return getTomcatEmbeddedServletContainer(tomcat);
	}
    
}

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

• 嵌入式Servlet容器优缺点

嵌入式Servlet容器：应用打成可执行的jar

优点：简单、便携；

缺点：默认不支持JSP、优化定制比较复杂（使用定制器【ServerProperties、自定义EmbeddedServletContainerCustomizer】，自己编写嵌入式Servlet容器的创建工厂【EmbeddedServletContainerFactory】）；

6.使用外置的Servlet容器

外置的Servlet容器：外面安装Tomcat---应用war包的方式打包

操作步骤

1）、必须创建一个war项目

2）、将嵌入式的Tomcat指定为provided

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-tomcat</artifactId>
   <scope>provided</scope>
</dependency>

3）、必须编写一个SpringBootServletInitializer的子类，并调用configure方法

public class ServletInitializer extends SpringBootServletInitializer {
 
   @Override
   protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
       //传入SpringBoot应用的主程序
      return application.sources(SpringBoot04WebJspApplication.class);
   }
 
}

4）、启动服务器就可以使用

外部Servlet容器启动原理

jar包：执行SpringBoot主类的main方法，启动ioc容器，创建嵌入式的Servlet容器；

war包：启动服务器，服务器启动SpringBoot应用（核心就是SpringBootServletInitializer），启动ioc容器；

servlet3.0规范：

8.2.4 Shared libraries / runtimes pluggability章节

规则

1）、服务器启动（web应用启动）会创建当前web应用里面每一个jar包里面ServletContainerInitializer实

2）、ServletContainerInitializer的实现放在jar包的META-INF/services文件夹下，有一个名为javax.servlet.ServletContainerInitializer的文件，内容就是ServletContainerInitializer的实现类的全类名

3）、还可以使用@HandlesTypes，在应用启动的时候加载我们感兴趣的类

流程

1）、启动Tomcat

2）、Spring的web模块里面有这个文件

3）、SpringServletContainerInitializer将@HandlesTypes(WebApplicationInitializer.class)标注的所有这个类型的类都传入到onStartup方法的Set<Class<?>> webAppInitializerClasses，为这些WebApplicationInitializer类型的类创建实例；

@HandlesTypes(WebApplicationInitializer.class)
public class SpringServletContainerInitializer implements ServletContainerInitializer {
    
    @Override
    public void onStartup(Set<Class<?>> webAppInitializerClasses, ServletContext servletContext)
        throws ServletException {
 
        List<WebApplicationInitializer> initializers = new LinkedList<WebApplicationInitializer>();
 
        if (webAppInitializerClasses != null) {
            for (Class<?> waiClass : webAppInitializerClasses) {
                // Be defensive: Some servlet containers provide us with invalid classes,
                // no matter what @HandlesTypes says...
                if (!waiClass.isInterface() && !Modifier.isAbstract(waiClass.getModifiers()) &&
                    WebApplicationInitializer.class.isAssignableFrom(waiClass)) {
                    try {
                        // 为WebApplicationInitializer类型的类创建实例
                        initializers.add((WebApplicationInitializer) waiClass.newInstance());
                    }
                    catch (Throwable ex) {
                        throw new ServletException("Failed to instantiate WebApplicationInitializer class", ex);
                    }
                }
            }
        }
 
        if (initializers.isEmpty()) {
            servletContext.log("No Spring WebApplicationInitializer types detected on classpath");
            return;
        }
 
        servletContext.log(initializers.size() + " Spring WebApplicationInitializers detected on classpath");
        AnnotationAwareOrderComparator.sort(initializers);
        for (WebApplicationInitializer initializer : initializers) {
            // 每一个WebApplicationInitializer都调用自己的onStartup方法
            initializer.onStartup(servletContext);
        }
    }
}

4）、每一个WebApplicationInitializer都调用自己的onStartup

public interface WebApplicationInitializer {
 
	void onStartup(ServletContext servletContext) throws ServletException;
 
}

接口有如下几个实现类：

5）、相当于我们的SpringBootServletInitializer的类会被创建对象，并执行onStartup方法

import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.support.SpringBootServletInitializer;
 
public class ServletInitializer extends SpringBootServletInitializer {
    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
        // DemoApplication.class启动类
        return application.sources(DemoApplication.class);
    }
}

6）、SpringBootServletInitializer实例执行onStartup的时候会createRootApplicationContext;创建容器

public abstract class SpringBootServletInitializer implements WebApplicationInitializer {
    
    @Override
	public void onStartup(ServletContext servletContext) throws ServletException {
		// Logger initialization is deferred in case a ordered
		// LogServletContextInitializer is being used
		this.logger = LogFactory.getLog(getClass());
         // 创建容器
		WebApplicationContext rootAppContext = createRootApplicationContext(
				servletContext);
		if (rootAppContext != null) {
			servletContext.addListener(new ContextLoaderListener(rootAppContext) {
				@Override
				public void contextInitialized(ServletContextEvent event) {
					// no-op because the application context is already initialized
				}
			});
		}
		else {
			this.logger.debug("No ContextLoaderListener registered, as "
					+ "createRootApplicationContext() did not "
					+ "return an application context");
		}
	}
 
	protected WebApplicationContext createRootApplicationContext(
			ServletContext servletContext) {
        //1、创建SpringApplicationBuilder构建器
		SpringApplicationBuilder builder = createSpringApplicationBuilder();
		StandardServletEnvironment environment = new StandardServletEnvironment();
		environment.initPropertySources(servletContext, null);
		builder.environment(environment); // 设置环境
		builder.main(getClass()); // 设置主类
		ApplicationContext parent = getExistingRootWebApplicationContext(servletContext);
		if (parent != null) {
			this.logger.info("Root context already created (using as parent).");
			servletContext.setAttribute(
					WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, null);
			builder.initializers(new ParentContextApplicationContextInitializer(parent));
		}
		builder.initializers(
				new ServletContextApplicationContextInitializer(servletContext));
		builder.contextClass(AnnotationConfigEmbeddedWebApplicationContext.class);
        //调用configure方法，我们自定义的ServletInitializer子类重写了这个方法，将SpringBoot的主程序类传入了进来
		builder = configure(builder);
        //使用builder创建一个Spring应用
		SpringApplication application = builder.build();
		if (application.getSources().isEmpty() && AnnotationUtils
				.findAnnotation(getClass(), Configuration.class) != null) {
			application.getSources().add(getClass());
		}
		Assert.state(!application.getSources().isEmpty(),
				"No SpringApplication sources have been defined. Either override the "
						+ "configure method or add an @Configuration annotation");
		// Ensure error pages are registered
		if (this.registerErrorPageFilter) {
			application.getSources().add(ErrorPageFilterConfiguration.class);
		}
         //启动Spring应用
		return run(application);
	}
    
}

7）、Spring的应用就启动并且创建IOC容器（同上面小结 5.嵌入式Servlet容器启动原理相同流程）

public class SpringApplication {
    public ConfigurableApplicationContext run(String... args) {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        ConfigurableApplicationContext context = null;
        FailureAnalyzers analyzers = null;
        configureHeadlessProperty();
        SpringApplicationRunListeners listeners = getRunListeners(args);
        listeners.starting();
        try {
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(
                args);
            ConfigurableEnvironment environment = prepareEnvironment(listeners,
                                                                     applicationArguments);
            Banner printedBanner = printBanner(environment);
            context = createApplicationContext();
            analyzers = new FailureAnalyzers(context);
            prepareContext(context, environment, listeners, applicationArguments,
                           printedBanner);
 
            //刷新IOC容器
            refreshContext(context);
            afterRefresh(context, applicationArguments);
            listeners.finished(context, null);
            stopWatch.stop();
            if (this.logStartupInfo) {
                new StartupInfoLogger(this.mainApplicationClass)
                    .logStarted(getApplicationLog(), stopWatch);
            }
            return context;
        }
        catch (Throwable ex) {
            handleRunFailure(context, listeners, analyzers, ex);
            throw new IllegalStateException(ex);
        }
    }
}

启动Servlet容器，再启动SpringBoot应用