SpringBoot内置Tomcat如何实现？启动原理与源码解析

<dependency>
    <groupid>org.springframework.boot</groupid>
    <artifactid>spring-boot-starter-web</artifactid>
</dependency>

<dependency>
<groupid>org.springframework.boot</groupid>
<artifactid>spring-boot-starter-tomcat</artifactid>
<version>2.1.2.release</version>
<scope>compile</scope>
</dependency>

public static configurableapplicationcontext run(class<?> primarysource,
string... args) {
return run(new class<?>[] { primarysource }, args);
}

//继续点击进入run方法
public static configurableapplicationcontext run(class<?>[] primarysources,
string[] args) {
return new springapplication(primarysources).run(args);
}

/**
* run the spring application, creating and refreshing a new
* {@link applicationcontext}.
* @param args the application arguments (usually passed from a java main method)
* @return a running {@link applicationcontext}
*/
public configurableapplicationcontext run(string... args) {
stopwatch stopwatch = new stopwatch();
stopwatch.start();
configurableapplicationcontext context = null;
collection<springbootexceptionreporter> exceptionreporters = new arraylist<>();
/**1、配置系统属性*/
configureheadlessproperty();
/**2.获取监听器*/
springapplicationrunlisteners listeners = getrunlisteners(args);
/**发布应用开始启动事件 */
listeners.starting();
try {
/** 3.初始化参数 */
applicationarguments applicationarguments = new defaultapplicationarguments(
args);
/** 4.配置环境*/
configurableenvironment environment = prepareenvironment(listeners,
applicationarguments);

configureignorebeaninfo(environment);
banner printedbanner = printbanner(environment);
/**5.创建应用上下文*/
context = createapplicationcontext();
exceptionreporters = getspringfactoriesinstances(
springbootexceptionreporter.class,
new class[] { configurableapplicationcontext.class }, context);
/**6.预处理上下文*/
preparecontext(context, environment, listeners, applicationarguments,
printedbanner);

/**6.刷新上下文*/
refreshcontext(context);
afterrefresh(context, applicationarguments);
stopwatch.stop();
if (this.logstartupinfo) {
new startupinfologger(this.mainapplicationclass)
.logstarted(getapplicationlog(), stopwatch);
}
/** 8.发布应用已经启动事件 */
listeners.started(context);
callrunners(context, applicationarguments);
}
catch (throwable ex) {
handlerunfailure(context, ex, exceptionreporters, listeners);
throw new illegalstateexception(ex);
}

try {
/** 9.发布应用已经启动完成的监听事件 */
listeners.running(context);
}
catch (throwable ex) {
handlerunfailure(context, ex, exceptionreporters, null);
throw new illegalstateexception(ex);
}
return context;
}

@override
public void refresh() throws beansexception, illegalstateexception {
synchronized (this.startupshutdownmonitor) {
// prepare this context for refreshing.
//初始化前的准备工作，主要是一些系统属性、环境变量的校验，比如spring启动需要某些环境变量，可以在这个地方进行设置和校验
preparerefresh();

// tell the subclass to refresh the internal bean factory.
configurablelistablebeanfactory beanfactory = obtainfreshbeanfactory();

// prepare the bean factory for use in this context.
//准备bean工厂 注册了部分类
preparebeanfactory(beanfactory);

try {
// allows post-processing of the bean factory in context subclasses.
postprocessbeanfactory(beanfactory);

// invoke factory processors registered as beans in the context.
//注册bean工厂后置处理器，并解析java代码配置bean定义
invokebeanfactorypostprocessors(beanfactory);

// register bean processors that intercept bean creation.
//注册bean后置处理器，并不会执行后置处理器，在后面实例化的时候执行
registerbeanpostprocessors(beanfactory);

// initialize message source for this context.
initmessagesource();

// initialize event multicaster for this context.
//初始化事件监听多路广播器
initapplicationeventmulticaster();

// initialize other special beans in specific context subclasses.
//待子类实现，springboot在这里实现创建内置的tomact容器
onrefresh();

// 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();
}
}
}

/** 得到servlet工厂 **/
this.webserver = factory.getwebserver(getselfinitializer());

this.webserver = factory.getwebserver (getselfinitializer ());

@override
public webserver getwebserver(servletcontextinitializer... initializers) {

/** 1、创建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);
/** 2、给创建好的tomcat设置连接器connector **/
tomcat.setconnector(connector);
/** 3.设置不自动部署 **/
tomcat.gethost().setautodeploy(false);
/** 4.配置tomcat容器引擎 **/
configureengine(tomcat.getengine());
for (connector additionalconnector : this.additionaltomcatconnectors) {
tomcat.getservice().addconnector(additionalconnector);
}
/**准备tomcat的standardcontext，并添加到tomcat中*/
preparecontext(tomcat.gethost(), initializers);
/** 将创建好的tomcat包装成webserver返回**/
return gettomcatwebserver(tomcat);
}

// start the server to trigger initialization listeners
//启动tomcat服务
this.tomcat.start();
//开启阻塞非守护进程
startdaemonawaitthread();