SpringBoot之使用外置Servlet容器

一、SpringBoot嵌入式Servlet容器與外置Servlet容器的比較

• 嵌入式Servlet容器應用將程序打成Jar包，外置Servlet容器應用將程序打成War包。
• 嵌入式Servlet容器的優點：簡單、便攜。缺點：默認不支持JSP，優化定製較複雜。

 嵌入式Servlet容器優化定製的方法：

   ① 使用定製器：ServerProperties、自定義 EmbeddedServletContainerCustomizer
  ② 自己編寫嵌入式Servlet容器的創建工廠 【EmbeddedServletContainerFactory】

二、如何使用外置Servlet容器的步驟

1、創建一個War包項目

;File——》New——Project，選中Spring Initializr，然後單擊Next，進入到如下頁面，將默認的Jar包改成War，然後Next，直到Finish。

創建出來的目錄結構：

  由於創建的是War包項目，所以以上的目錄結構還不完整，我們需要手動創建web.xml和webapp。有兩種創建方式：

① 手動在src/main下創建webapp目錄及在/src/main/webapp/WEB-INF下創建web.xml文件。

② 在IDEA的Project Structure中完善目錄結構。

點擊Module，選中web，來到如下頁面：

雙擊上圖圈出來的url處，彈出以下對話框：

單擊OK，選擇Yes。

還是在Project Structure頁面，點擊如下圖所示的“+”,彈出如下對話框，修改生成web.xml文件的目錄/src/main/webapp，然後點擊OK。

在上一步中點擊OK後，先點擊Apply，然後選擇OK，即可創建出webapp目錄和web.xml文件。

完善後的目錄結構如下：

2、將嵌入式的tomcat指定爲provided

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

3、必須寫一個SpringBootServletInitializer 的實現子類。

  目的是調用configure方法，傳入springboot應用的主程序。

public class ServletInitializer extends SpringBootServletInitializer {

    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
        return application.sources(SpringBootWebJspApplication.class);
    }
}

4、啓動服務器

三、外部Servlet啓動SpringBoot應用原理(1.5.x)

• 將項目打成 jar包啓動方式：執行SpringBoot主類的main方法，啓動IOC容器，創建嵌入式的Servlet容器。
• 將項目打成 war包啓動方式：啓動服務器，服務器啓動SpringBoot應用【SpringBootServletInitializer】，然後啓動IOC容器。

  在Spring3.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的文件，文件內容是：

org.springframework.web.SpringServletContainerInitializer

相當於在web應用啓動的時候啓動SpringServletContainerInitializer。
【3】SpringServletContainerInitializer將@HandlesTypes(WebApplicationInitializer.class)標註的所有類型的類(感興趣的類)都傳入到onStartup方法的Set<Class<?>> webAppInitializerClasses，爲這些WebApplicationInitializer類型的類(不是接口、不是抽象類)創建實例。
【4】每一個WebApplicationInitializer都調用自己的onStartup，相當於我們的SpringBootServletInitializer的類會被創建對象，並執行onStartup方法。WebApplicationInitializer是一個接口，它的實現類如下：

//Set<Class<?>> webAppInitializerClasses表示感興趣的類
public void onStartup(Set<Class<?>> webAppInitializerClasses, ServletContext servletContext) throws ServletException {
    List<WebApplicationInitializer> initializers = new LinkedList();
    Iterator var4;
    if (webAppInitializerClasses != null) {
       var4 = webAppInitializerClasses.iterator();

    while(var4.hasNext()) {
       Class<?> waiClass = (Class)var4.next();
       //如果不死接口或者抽象類
       if (!waiClass.isInterface() && !Modifier.isAbstract(waiClass.getModifiers()) && WebApplicationInitializer.class.isAssignableFrom(waiClass)) {
          try {
              //加入到WebApplicationInitializer對象的集合中
                initializers.add((WebApplicationInitializer)waiClass.newInstance());
              } catch (Throwable var7) {
                  throw new ServletException("Failed to instantiate WebApplicationInitializer class", var7);
              }
            }
          }
       }
       
     if (initializers.isEmpty()) {
        servletContext.log("No Spring WebApplicationInitializer types detected on classpath");
     } else {
          servletContext.log(initializers.size() + " Spring WebApplicationInitializers detected on classpath");
          AnnotationAwareOrderComparator.sort(initializers);
          var4 = initializers.iterator();

          while(var4.hasNext()) {
              WebApplicationInitializer initializer = (WebApplicationInitializer)var4.next();
              //每一個WebApplicationInitializer對象調用自己的onStartup方法創建SpringBootServletInitializer對象
              initializer.onStartup(servletContext);
          }
      }
}

public class ServletInitializer extends SpringBootServletInitializer {

    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
        return application.sources(SpringBootWebJspApplication.class);
    }

}

【5】SpringBootServletInitializer實例執行onStartup方法的時候會調用createRootApplicationContext方法創建容器

public void onStartup(ServletContext servletContext) throws ServletException {
        this.logger = LogFactory.getLog(this.getClass());
        WebApplicationContext rootAppContext = this.createRootApplicationContext(servletContext);
        if (rootAppContext != null) {
            servletContext.addListener(new ContextLoaderListener(rootAppContext) {
                public void contextInitialized(ServletContextEvent event) {
                }
            });
        } else {
            this.logger.debug("No ContextLoaderListener registered, as createRootApplicationContext() did not return an application context");
        }

    }

protected WebApplicationContext createRootApplicationContext(ServletContext servletContext) {
//1、創建SpringApplicationBuilder對象
    SpringApplicationBuilder builder = this.createSpringApplicationBuilder();
    StandardServletEnvironment environment = new StandardServletEnvironment();
    environment.initPropertySources(servletContext, (ServletConfig)null);
    builder.environment(environment);
    builder.main(this.getClass());
    ApplicationContext parent = this.getExistingRootWebApplicationContext(servletContext);
    if (parent != null) {
      this.logger.info("Root context already created (using as parent).");
      servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, (Object)null);
      builder.initializers(new ApplicationContextInitializer[]{new ParentContextApplicationContextInitializer(parent)});
     }

      builder.initializers(new ApplicationContextInitializer[]{new ServletContextApplicationContextInitializer(servletContext)});
      builder.contextClass(AnnotationConfigEmbeddedWebApplicationContext.class);
      //調用configure方法，在子類重寫了這個方法，傳入SpringBoot的主程序類
      builder = this.configure(builder);
      //使用builder創建spring應用
      SpringApplication application = builder.build();
      if (application.getSources().isEmpty() && AnnotationUtils.findAnnotation(this.getClass(), Configuration.class) != null) {
          application.getSources().add(this.getClass());
      }

      Assert.state(!application.getSources().isEmpty(), "No SpringApplication sources have been defined. Either override the configure method or add an @Configuration annotation");
      if (this.registerErrorPageFilter) {
         application.getSources().add(ErrorPageFilterConfiguration.class);
      }
      //啓動spring應用
     return this.run(application);
}

protected SpringApplicationBuilder createSpringApplicationBuilder() {
    return new SpringApplicationBuilder(new Object[0]);
}

【6】啓動spring應用，並創建IOC容器

 public ConfigurableApplicationContext run(String... args) {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        ConfigurableApplicationContext context = null;
        FailureAnalyzers analyzers = null;
        this.configureHeadlessProperty();
        SpringApplicationRunListeners listeners = this.getRunListeners(args);
        listeners.starting();

        try {
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
            ConfigurableEnvironment environment = this.prepareEnvironment(listeners, applicationArguments);
            Banner printedBanner = this.printBanner(environment);
            context = this.createApplicationContext();
            new FailureAnalyzers(context);
            this.prepareContext(context, environment, listeners, applicationArguments, printedBanner);
            //刷新IOC容器
            this.refreshContext(context);
            this.afterRefresh(context, applicationArguments);
            listeners.finished(context, (Throwable)null);
            stopWatch.stop();
            if (this.logStartupInfo) {
                (new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), stopWatch);
            }

            return context;
        } catch (Throwable var9) {
            this.handleRunFailure(context, listeners, (FailureAnalyzers)analyzers, var9);
            throw new IllegalStateException(var9);
        }
    }

一句話總結：先啓動Servlet容器，啓動spring應用，再創建IOC容器。