一、传统Servlet
spring boot默认是嵌入式的tomcat，把项目打包成jar包运行，如果你想把项目打包成war包放在外部容器中运行，
除了将pom.xml中打包方式改成war包，还需要让启动类实现org.springframework.boot.web.support.SpringBootServletInitializer，并覆盖其configure方法。
调用顺序：
SpringServletContainerInitializer#onStartup()
->WebApplicationInitializer#onStartup()
->WebApplicationInitializer/SpringBootServletInitializer#createRootApplicationContext()
->SpringBootServletInitializer#configure(),SpringBootServletInitializer#run()
注意：
SpringServletContainerInitializer这个类比较特殊，实现的是interface ServletContainerInitializer，SpringServletContainerInitializer#onStartup()是由外部容器比如Tomcat去调用。
那么tomcat是怎么找到它的呢？因为ServletContainerInitializer的实现类就是通过SPI机制去加载的。去搜寻的这个资源文件META-INF/services/javax.servlet.ServletContainerInitializer，而在spring的包spring-web-xxxx.jar包里正好有这个文件，它注册的恰恰就是这个类。
在SpringServletContainerInitializer上有个注解@HandlesTypes({WebApplicationInitializer.class})，表示会把所有的WebApplicationInitializer的实现类都传给onStartup()作为参数。
onStartup()过滤出所有非interface，非抽象的WebApplicationInitializer子类，全都实例化并一个个调用他们的onStartup()。
在SpringBootServletInitializer#createRootApplicationContext()中，最终会初始化SpringApplication,调用其run(),跟直接运行入口的main是一样的了。
既然从application.run()以后走的逻辑都是一样的，那么是不是需要启动内嵌web服务器的分支在哪儿呢？因为我们要打成war包，就不需要启动内嵌的tomcat容器。
参考https://www.cnblogs.com/jpfss/p/9719629.html
SpringApplication.run(String...)
SpringApplication.createAndRefreshContext(SpringApplicationRunListeners, ApplicationArguments)
SpringApplication.refresh(ApplicationContext)
AnnotationConfigEmbeddedWebApplicationContext(EmbeddedWebApplicationContext).refresh()
AnnotationConfigEmbeddedWebApplicationContext(AbstractApplicationContext).refresh()
AnnotationConfigEmbeddedWebApplicationContext(EmbeddedWebApplicationContext).onRefresh()
AnnotationConfigEmbeddedWebApplicationContext(EmbeddedWebApplicationContext).createEmbeddedServletContainer()
有下面一个分支代码:
if (localContainer == null && localServletContext == null) {
EmbeddedServletContainerFactory containerFactory = getEmbeddedServletContainerFactory();
this.embeddedServletContainer = containerFactory
.getEmbeddedServletContainer(getSelfInitializer());
}
localContainer在初始化的时候没有赋值过程，一直会是null，主要是localServletContext，看看什么时候为null，什么时候有值。
它的赋值有三个地方，两个构造函数，一个set方法:
public GenericWebApplicationContext(ServletContext servletContext) {
this.servletContext = servletContext;
}
public GenericWebApplicationContext(DefaultListableBeanFactory beanFactory, ServletContext servletContext) {
super(beanFactory);
this.servletContext = servletContext;
}
public void setServletContext(ServletContext servletContext) {
this.servletContext = servletContext;
}
查找一下，发现构造函数并没有地方调用，调用的是这个set方法，过程如下:
SpringApplication.run(String...)
SpringApplication.createAndRefreshContext(SpringApplicationRunListeners, ApplicationArguments)
SpringApplication.applyInitializers(ConfigurableApplicationContext)
ServletContextApplicationContextInitializer.initialize(ConfigurableApplicationContext)
ServletContextApplicationContextInitializer.initialize(ConfigurableWebApplicationContext)
AnnotationConfigEmbeddedWebApplicationContext(GenericWebApplicationContext).setServletContext(ServletContext)
你会发现，至少到SpringApplication.applyInitializers(ConfigurableApplicationContext)这一步，部署不部署到tomcat，都会执行这个方法的，那么区别在哪儿呢？
先看看这个方法的内容:
protected void applyInitializers(ConfigurableApplicationContext context) {
for (ApplicationContextInitializer initializer : getInitializers()) {
Class<?> requiredType = GenericTypeResolver.resolveTypeArgument(
initializer.getClass(), ApplicationContextInitializer.class);
Assert.isInstanceOf(requiredType, context, "Unable to call initializer.");
initializer.initialize(context);
}
}
也就是说，如果注入的initializers里是否包含了ServletContextApplicationContextInitializer，就能决定是否会调用以后的逻辑。
那么返回到文章的开头，看看抽象类SpringBootServletInitializer，就会发现在方法createRootApplicationContext里，类ServletContextApplicationContextInitializer的注入过程。
builder.initializers(new ServletContextApplicationContextInitializer(servletContext));
内部实现：
public SpringApplicationBuilder initializers(
ApplicationContextInitializer<?>... initializers) {
this.application.addInitializers(initializers);
return this;
}
从上面的分析，我们可以发现，项目打成war包的操作会比直接springApplication.run()前面多一些步骤:
SpringServletContainerInitializer#onStartup()
->WebApplicationInitializer#onStartup()
->WebApplicationInitializer/SpringBootServletInitializer#createRootApplicationContext()
->SpringBootServletInitializer#configure(),SpringBootServletInitializer#run()
二、Servlet相关基础知识：
servlet容器启动的时候，创建一个applicationContext，
一个servletContext
比如SPRING BOOT中就可以有两个ApplicationContext，
一个是提供服务的WEBApplicationContext，还有一个是用于管理的ManagementApplicationContext
SERVLET3.0以后，
用注解和API的方式来替代web.XML,未来可以通过JAR的方式启动，不再通过WAR.
嵌入式的web容器，tomcat为什么可以做到嵌入式？很大程度是因为Servlet做了改革。
AsyncContext:异步的上下文，
SERVLET3.0和WebSocket有紧密关联。
通过API的方式动态注册：
javax.servlet.Context#addServlet()
Filter需要配置它要拦截的Servlet（可能不止一个），所以Filter和Servlet之间有一个mapping关系。
可以通过Filter和ServletName进行mapping，也可以通过Filter和Urlpattern进行mapping。
Servlet3.0之前必须要用web.xml去配置组装Servlet，Filter等组件，
3.0之后提供了一个初始化器javax.servlet.ServletContainerInitializer，
spring对它的实现类是org.springframework.web.SpringServletContainerInitializer，
这个实现类是通过ＳＰＩ机制去加载的。
ServiceLoader去加载META-INF/services/javax.servlet.ServletContainerInitializer文件中定义的类。
类型过滤器：@HandlesTypes(WebApplicationInitializer.class)
会过滤出所有的(WebApplicationInitializer.class)类及其子类传给onStartup(),作为参数。
然后会依次调用每个WebApplicationInitializer的onStartup()
一个ServletContext中可以放多个ApplicationContext。
每个WebApplicationInitializer会create自己的ApplicationContext()?
比如org.springframework.boot.web.support.SpringBootServletInitializer#onStartup()
中会createRootApplicationContext().
比如在AbstractDispatcherServletInitializer中会createServletApplicationContext();
AbstractAnnotationConfigDispatcherServletInitializer
->继承 AbstractDispatcherServletInitializer
->继承 AbstractContextLoaderInitializer
->继承 WebApplicationInitializer
那我用SpringBootServletInitializer启动的时候是否需要用到createServletApplicationContext()?
servlet会先被Filter拦截，通过所有的Filter后才会执行Servlet的service()。
责任链的最后一环是Servlet
filter1->filter2->filter3->servlet..
具体可以看org.apache.catalina.core.ApplicationFilterChain的实现。
***采用传统部署web项目的方式，打个断点走一遍。
三、实战：Servlet ON spring boot
1，Servlet组件扫描：
org.springframework.boot.web.servlet.ServletComponentScan
springboot默认不支持Servlet标准Api的解释执行，
在启动类上标记@ServletComponentScan
2，javax.servlet下的Servlet API注册组件：
Servlet：
如何声明一个Servlet组件：
(1)扩展javax.servlet.Servlet:
javax.servlet.http.HttpServlet
org.springframework.web.servlet.FrameworkServlet
(2)上面写得Servlet类标记为javax.servlet.annotation.WebServlet
Filter：
（1）继承javax.servlet.Filter接口
（2）自定义的Filter标记为javax.servlet.annotation.WebFilter
Listener：
（1）继承某个EventListener，比如ServletRequestListener
（2）标记为@WebListener
tomcat容器的线程池概念。
3，使用springbootApi的方式注册
Servlet：
（1）扩展javax.servlet.Servlet接口
（2）将自定义的servlet注册到ServletRegistrationBean，并配置ServletRegistrationBean
Filter：
Listener：
自定义的Listener是可以重复注册的。可以注册到ServletListenerRegistrationBean，也可以标记为@WebListener
同一个请求Listener将会执行两次
三、JSP on Spring boot
1，为了支持JSP，必须用传统Servlet的方式部署，需激活org.springframework.boot.web.support.SpringBootServletInitializer
2，组装
覆盖父类SpringBootServletInitializer的configure():
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
builder.sources(SpringBoot4Application.class);
return builder;
}
3，在application.properties中配置spring.mvc.view
spring.mvc.view.prefix = /WEB-INF/jsp
spring.mvc.view.suffix = .jsp
4，pom.xml修改：
引入：
<!--为了打成war包，引入tomcat-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
</dependency>
<!-- JSP 渲染引擎 -->
<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-jasper</artifactId>
<scope>provided</scope>
</dependency>
<!-- JSTL -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
</dependency>
修改打包方式为war
5，如何以war的方式启动：
terminal：
四、问答
