1.IDEA Spring Initializer自动构建的war包项目，自动生成的Initializer类，用于外部Tomcat容器启动该项目时调用，如果仍然使用主类main函数方式启动则与此类无关（Debug验证过了）

2.自动构建的war包项目，pom.xml中引入了：

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

注释的scope是我注释的，生成时打开着，这样引入，scope造成main方式运行时没有内嵌Tomcat（只有编译时有），虽然引入了：

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
</dependency>

仍然提示错误：

Unregistering JMX-exposed beans on shutdown

所以需要注释掉scope,这样以main方式运行，内嵌的Tomcat可以启动Spring Boot Web项目。参考：https://blog.csdn.net/sun20100912/article/details/52013463

但打war包放在外置Tomcat时就不需要了，要使用exclude干掉内嵌Tomcat,或像这里IDEA自动构建的war包项目一样，使用scope在运行时不使用内嵌Tomcat，这时需要外置Tomcat使用这里生成的Initializer类：

package com.xiaobai.springbootwebdemo;

import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;

public class ServletInitializer extends SpringBootServletInitializer {

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

}

Initializer类分析

跟踪方法：通过启动IDEA断点Debug，一直按F8,无论哪里有断点。这样走完所有我们打断点的类后可以进入更外层类，即Web容器启动时先行运行的Tomcat的类当中，再一路F8,注意这时是层层向上倒置返回的，不断层层向上打断点，从这一层的子类方法到上一层调用它的父类模板方法（因为进入的一些层的类不过是前一层类的抽象父类，是父类的模板方法调用了子类的方法，实际仍然在子类实例中），从这一层的方法到上一层另一个类调用它的方法。F8走完和打完这次断点后，再从头Debug一遍，F8调试，这样可以先进入上层，哪里F8后程序直接跑完了，就删除这个断点（因为这个断点并不是一个会倒置返回的上层调用，而是一个完整模块调用），再从头Debug,F8,直到从上层最终能进入我们最初打断点的内层，继续，内层已跟踪过的断点适当使用Alt+F9跳过,走到差不多内层出口处再换回F8,进入外层。这样层层向上找，打断点，从头Debug,F8,修改断点，再Debug,F8,最终找到最初启动入口类和方法，它初始化加载的文件，创建的类，传入的参数等

0.Tomcat启动时调用MBeanFactory的下面方法：

public String createStandardContext(String parent, String path, String docBase) throws Exception {
    return this.createStandardContext(parent, path, docBase, false, false);
}

该方法调用：

public String createStandardContext(String parent, String path, String docBase, boolean xmlValidation, boolean xmlNamespaceAware) throws Exception {
    StandardContext context = new StandardContext();
    path = this.getPathStr(path);
    context.setPath(path);
    context.setDocBase(docBase);
    context.setXmlValidation(xmlValidation);
    context.setXmlNamespaceAware(xmlNamespaceAware);
    ContextConfig contextConfig = new ContextConfig();
    context.addLifecycleListener(contextConfig);
    ObjectName pname = new ObjectName(parent);
    ObjectName deployer = new ObjectName(pname.getDomain() + ":type=Deployer,host=" + pname.getKeyProperty("host"));
    if (mserver.isRegistered(deployer)) {
        String contextName = context.getName();
        mserver.invoke(deployer, "addServiced", new Object[]{contextName}, new String[]{"java.lang.String"});
        String configPath = (String)mserver.getAttribute(deployer, "configBaseName");
        String baseName = context.getBaseName();
        File configFile = new File(new File(configPath), baseName + ".xml");
        if (configFile.isFile()) {
            context.setConfigFile(configFile.toURI().toURL());
        }

        mserver.invoke(deployer, "manageApp", new Object[]{context}, new String[]{"org.apache.catalina.Context"});
        mserver.invoke(deployer, "removeServiced", new Object[]{contextName}, new String[]{"java.lang.String"});
    } else {
        log.warn("Deployer not found for " + pname.getKeyProperty("host"));
        Service service = this.getService(pname);
        Engine engine = service.getContainer();
        Host host = (Host)engine.findChild(pname.getKeyProperty("host"));
        host.addChild(context);
    }

    return context.getObjectName().toString();
}

方法，创建了org.apache.catalina.core.StandardContext

注意里面加粗的反射调用逻辑，与创建的org.apache.catalina.core.StandardContext有关，留意一下这些类中的属性字段尤其是static字段，有些可能事先由其他类加载并初始化了，在一些方法里直接用。

这时使用Alt+F9跳到我们的下一个断点：org.apache.catalina.core.StandardContext的startInternal方法

1.（循环）调用org.apache.catalina.core.StandardContext的startInternal方法，其中一个调用走到我们的Web服务，在这个调用里循环调用该服务的每个ServletContainerInitializer的onStartup方法：

while(i$.hasNext()) {
    Entry entry = (Entry)i$.next();

    try {
((ServletContainerInitializer)entry.getKey()).onStartup((Set)entry.getValue(), this.getServletContext());
    } catch (ServletException var22) {
        log.error(sm.getString("standardContext.sciFail"), var22);
        ok = false;
        break;
    }
}

这里传入的ServletContext是使用上面创建的org.apache.catalina.core.StandardContext初始化的：

this.context = new ApplicationContext(this);//this:org.apache.catalina.core.StandardContext

其中一个就是SpringServletContainerInitializer的onStartup方法（也是循环调用，多个SpringServletContainerInitializer），该方法最后通过：

while(var4.hasNext()) {
    WebApplicationInitializer initializer = (WebApplicationInitializer)var4.next();
initializer.onStartup(servletContext);
}

这是一个循环调用，其中一个调用SpringBootServletInitializer的onStartup方法（ServletContext已传入）：

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

}

该方法调用方法（继续传入ServletContext）：

protected WebApplicationContext createRootApplicationContext(ServletContext servletContext) {
SpringApplicationBuilder builder = this.createSpringApplicationBuilder();
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(AnnotationConfigServletWebServerApplicationContext.class);
builder = this.configure(builder);
    builder.listeners(new ApplicationListener[]{new SpringBootServletInitializer.WebEnvironmentPropertySourceInitializer(servletContext, null)});
SpringApplication application = builder.build();
    if (application.getAllSources().isEmpty() && AnnotationUtils.findAnnotation(this.getClass(), Configuration.class) != null) {
        application.addPrimarySources(Collections.singleton(this.getClass()));
    }

    Assert.state(!application.getAllSources().isEmpty(), "No SpringApplication sources have been defined. Either override the configure method or add an @Configuration annotation");
    if (this.registerErrorPageFilter) {
        application.addPrimarySources(Collections.singleton(ErrorPageFilterConfiguration.class));
    }

    return this.run(application);
}

该方法创建了一个SpringApplicationBuilder，以Spring Boot War项目自动生成的我们的ServletInitializer为mainApplicationClass，使用传入的ServletContext（Tomcat为我们的应用所创建）设置了Spring Boot上下文的Initializer和Listener（将Web环境和Spring Boot互相加入），调用了我们ServletInitializer中重载的：

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

将带有@SpringBootApplication注解的我们的SpringbootwebdemoApplication类注入到SpringApplicationBuilder作为source.说明无论是main函数启动方式还是Tomcat以Web项目启动方式，关键的是运行带有@SpringBootApplication注解的类完成Spring Boot配置。

然后SpringApplication由SpringApplicationBuilder来build出来：

SpringApplication application = builder.build();

并运行起来：

return this.run(application);

该方法调用SpringApplication本身的run方法，和main方法启动方式完全一样了。这样就由Tomcat初始化并启动了Spring Boot，并加入到了Web环境（ServletContext）

最后调用SpringApplication本身的run方法是创建了一个AnnotationConfigServletWebServerApplicationContext作为Spring Boot的Web环境上下文对象

2.org.apache.catalina.core.StandardContext的startInternal方法接续1继续执行：

if (ok && !this.listenerStart()) {
    log.error(sm.getString("standardContext.listenerFail"));
    ok = false;
}

进入org.apache.catalina.core.StandardContext的listenerStart方法（也循环多次调用了该方法），该方法方法体内调用：

for(int i = 0; i < instances.length; ++i) {
    if (instances[i] instanceof ServletContextListener) {
        ServletContextListener listener = (ServletContextListener)instances[i];

        try {
            this.fireContainerEvent("beforeContextInitialized", listener);
            if (this.noPluggabilityListeners.contains(listener)) {
listener.contextInitialized(tldEvent);
            } else {
                listener.contextInitialized(event);
            }

            this.fireContainerEvent("afterContextInitialized", listener);
        } catch (Throwable var12) {
            ExceptionUtils.handleThrowable(var12);
            this.fireContainerEvent("afterContextInitialized", listener);
            this.getLogger().error(sm.getString("standardContext.listenerStart", new Object[]{instances[i].getClass().getName()}), var12);
            ok = false;
        }
    }
}

这又是一个循环，其中有一个就是上面SpringBootServletInitializer的onStartup方法中注册的该服务的Listener:

    if (rootAppContext != null) {
        servletContext.addListener(new ContextLoaderListener(rootAppContext) {
            public void contextInitialized(ServletContextEvent event) {
            }
        });
    } 

执行其contextInitialized方法。

这里注册的ContextLoaderListener重写的contextInitialize方法里面没有任何实现，所以什么都不做。

至此我们的服务已经启动完成。

进一步研究提示：StandardContext的外层相关类包括

LifecycleBase

ContainerBase

StandardHost

HostConfig

其中LifecycleBase为LifecycleMBeanBase父类，LifecycleMBeanBase为ContainerBase父类，ContainerBase为StandardContext和StandardHost父类，那么调用采用的是模板模式，由父类方法调用子类方法。

更外层的HostConfig使用了StandardHost：

this.host.addChild(context);

因为StandardHost实现了Host接口。

最外面还有一个工具类BaseModelMBean不断执行其invoke方法，反射执行一些方法，反复配合第0步开始的MBeanFactory的createStandardContext方法里面的：

mserver.invoke(deployer, "manageApp", new Object[]{context}, new String[]{"org.apache.catalina.Context"});
mserver.invoke(deployer, "removeServiced", new Object[]{contextName}, new String[]{"java.lang.String"});

最后从这里（MBeanFactory的createStandardContext方法，经过Debug,正向层次调用和逆向层次返回，整个上面都是从这个方法出发的各层次调用流程，最后回到该方法）结束Tomcat所有启动流程，项目可通过浏览器访问了。

整合jsp提示：无法通过main/jar启动方式配置、访问jsp,只能以Tomcat运行，IDEA配置Web模块及其根目录，再在application.yml中配置mvc view相关前后缀属性。

尝试main方式访问jsp的一个错误参考：

https://blog.csdn.net/universsky2015/article/details/77965402