嵌入式Servlet容器：应用打成可执行的jar 优点：简单、便携；

缺点：默认不支持JSP、优化定制比较复杂

（使用定制器【ServerProperties/自定义EmbeddedServletContainerCustomizer】）

（自己编写嵌入式Servlet容器的创建工厂【EmbeddedServletContainerFactory】）；

那么如果要使用外置的servlet呢？

应用war包的方式打包；

外置的Servlet容器：外面安装Tomcat---

步骤

一、必须创建一个war项目；（利用idea创建好目录结构）

二、将嵌入式的Tomcat指定为provided；

<groupId>org.springframework.boot</groupId>

<artifactId>spring‐boot‐starter‐tomcat</artifactId>

<scope>provided</scope>

</dependency>

三、必须编写一个SpringBootServletInitializer的子类，并调用conﬁgure方法

public  class  ServletInitializer  extends  SpringBootServletInitializer  {

@Override

protected  SpringApplicationBuilder  configure(SpringApplicationBuilder  application)  {

//传入SpringBoot应用的主程序

return  application.sources(SpringBoot04WebJspApplication.class);

}

}

四、启动服务器就可以使用；

原理

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

war包：启动服务器，服务器启动SpringBoot应用【SpringBootServletInitializer】，启动ioc容器；

servlet3.0（Spring注解版）：

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）、org\springframework\spring-web\4.3.14.RELEASE\spring-web-4.3.14.RELEASE.jar!\META- INF\services\javax.servlet.ServletContainerInitializer：

Spring的web模块里面有这个文件：org.springframework.web.SpringServletContainerInitializer

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

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

【串线篇】spring boot使用外置的Servlet容器

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

六、SpringBootServletInitializer实例执行onStartup的时候会createRootApplicationContext；创建容器

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)); 15    }

    builder.initializers(

    new  ServletContextApplicationContextInitializer(servletContext));

    builder.contextClass(AnnotationConfigEmbeddedWebApplicationContext.class);

    //调用configure方法，子类重写了这个方法，将SpringBoot的主程序类传入了进来

    builder = configure(builder); 22

        //使用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);

    }

七、Spring的应用就启动并且创建IOC容器

    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应用

秒客网