@Override
public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");

        // Prepare this context for refreshing.
        prepareRefresh();

        // Tell the subclass to refresh the internal bean factory.
        /*
         * 通过new DefaultListableBeanFactory()的方式创建容器,
         * 这一步会加载bean的定义
         */
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

        // Prepare the bean factory for use in this context.
        prepareBeanFactory(beanFactory);

        try {
            // Allows post-processing of the bean factory in context subclasses.
            // 会注册web作用域
            postProcessBeanFactory(beanFactory);

            StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
            // Invoke factory processors registered as beans in the context.
            /*
             * 执行BeanFactoryPostProcessor
             */
            invokeBeanFactoryPostProcessors(beanFactory);

            // Register bean processors that intercept bean creation.
            /*
             * 往beanPostProcessors属性中add后置处理器并整理好顺序，便于后续执行
             */
            registerBeanPostProcessors(beanFactory);
            beanPostProcess.end();

            // Initialize message source for this context.
            /*
             * 这一步较简单，向容器里注册一个一个事件源的单例Bean：MessageSource
             */
            initMessageSource();

            // Initialize event multicaster for this context.
            /*
             * 初始化Spring的事件多播器：ApplicationEventMulticaster
             */
            initApplicationEventMulticaster();

            // Initialize other special beans in specific context subclasses.
            /*
             * 模板方法，子类会实现
             * 比如在Spring Boot中，会在该方法中创建web服务器
             */
            onRefresh();

            // Check for listener beans and register them.
            /*
             * 注册事件监听器
             */
            registerListeners();

            // Instantiate all remaining (non-lazy-init) singletons.
            /*
             * ---- 极其重要步骤 ----
             * 会实例化单例bean
             */
            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();
            contextRefresh.end();
        }
    }
}

@Override
protected void onRefresh() {
    super.onRefresh();
    try {
        // 创建web容器
        createWebServer();
    }
    catch (Throwable ex) {
        throw new ApplicationContextException("Unable to start web server", ex);
    }
}

private void createWebServer() {
    WebServer webServer = this.webServer;
    ServletContext servletContext = getServletContext();
    // 如果webServer为null，则新建一个。一般都是这种情况。
    if (webServer == null && servletContext == null) {
        StartupStep createWebServer = this.getApplicationStartup().start("spring.boot.webserver.create");
        // 获取WebServer工厂，这里关注TomcatServletWebServerFactory就是了
        ServletWebServerFactory factory = getWebServerFactory();
        createWebServer.tag("factory", factory.getClass().toString());
        // 创建WebServer实例，并传入ServletContainerInitializer
        this.webServer = factory.getWebServer(getSelfInitializer());
        createWebServer.end();
        // 向容器中注入两个bean
        getBeanFactory().registerSingleton("webServerGracefulShutdown",
                new WebServerGracefulShutdownLifecycle(this.webServer)); // 负责设置running标志位和停止WebServer
        getBeanFactory().registerSingleton("webServerStartStop",
                new WebServerStartStopLifecycle(this, this.webServer)); // 负责实际启动和停止WebServer
    }
    else if (servletContext != null) { // 如果servletContext对象存在
        try {
            // 则通过SCI来初始化
            getSelfInitializer().onStartup(servletContext);
        }
        catch (ServletException ex) {
            throw new ApplicationContextException("Cannot initialize servlet context", ex);
        }
    }
    initPropertySources();
}

protected ServletWebServerFactory getWebServerFactory() {
    // Use bean names so that we don't consider the hierarchy
    // 获取容器中所有ServletWebServerFactory类型的bean名称
    String[] beanNames = getBeanFactory().getBeanNamesForType(ServletWebServerFactory.class);
    // 如果一个也没有，则抛出异常
    if (beanNames.length == 0) {
        throw new MissingWebServerFactoryBeanException(getClass(), ServletWebServerFactory.class,
                WebApplicationType.SERVLET);
    }
    // 如果大于1个，也会抛出异常
    if (beanNames.length > 1) {
        throw new ApplicationContextException("Unable to start ServletWebServerApplicationContext due to multiple "
                + "ServletWebServerFactory beans : " + StringUtils.arrayToCommaDelimitedString(beanNames));
    }
    // 获取WebServerFactory实例
    return getBeanFactory().getBean(beanNames[0], ServletWebServerFactory.class);
}

@Import({ ServletWebServerFactoryAutoConfiguration.BeanPostProcessorsRegistrar.class,
		ServletWebServerFactoryConfiguration.EmbeddedTomcat.class,
		ServletWebServerFactoryConfiguration.EmbeddedJetty.class,
		ServletWebServerFactoryConfiguration.EmbeddedUndertow.class })

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass({ Servlet.class, Tomcat.class, UpgradeProtocol.class })
@ConditionalOnMissingBean(value = ServletWebServerFactory.class, search = SearchStrategy.CURRENT)
static class EmbeddedTomcat {

    // 注入TomcatServletWebServerFactory实例
    @Bean
    TomcatServletWebServerFactory tomcatServletWebServerFactory(
            ObjectProvider<TomcatConnectorCustomizer> connectorCustomizers,
            ObjectProvider<TomcatContextCustomizer> contextCustomizers,
            ObjectProvider<TomcatProtocolHandlerCustomizer<?>> protocolHandlerCustomizers) {
        // 创建工厂类对象
        TomcatServletWebServerFactory factory = new TomcatServletWebServerFactory();
        factory.getTomcatConnectorCustomizers()
                .addAll(connectorCustomizers.orderedStream().collect(Collectors.toList()));
        factory.getTomcatContextCustomizers()
                .addAll(contextCustomizers.orderedStream().collect(Collectors.toList()));
        factory.getTomcatProtocolHandlerCustomizers()
                .addAll(protocolHandlerCustomizers.orderedStream().collect(Collectors.toList()));
        return factory;
    }

}

// 返回一个SCI对象
private org.springframework.boot.web.servlet.ServletContextInitializer getSelfInitializer() {
    return this::selfInitialize;
}

// 该方法负责初始化servletContext对象
private void selfInitialize(ServletContext servletContext) throws ServletException {
    // 设置上下文attr属性
    prepareWebApplicationContext(servletContext);
    // 向spring容器中注入ServletContextScope
    registerApplicationScope(servletContext);
    // 将servletContext对象注入到容器中
    WebApplicationContextUtils.registerEnvironmentBeans(getBeanFactory(), servletContext);
    // 遍历容器中设置的其他Servlet上下文初始化器对象
    for (ServletContextInitializer beans : getServletContextInitializerBeans()) {
        // 执行Servlet上下文初始化器
        beans.onStartup(servletContext);
    }
}

@Override
public WebServer getWebServer(ServletContextInitializer... initializers) {
    // 禁用JMX注册
    if (this.disableMBeanRegistry) {
        Registry.disableRegistry();
    }
    // 创建Tomcat实例
    Tomcat tomcat = new Tomcat();
    // 获取或者创建Tomcat的工作目录
    File baseDir = (this.baseDirectory != null) ? this.baseDirectory : createTempDir("tomcat");
    // 设置工作目录
    tomcat.setBaseDir(baseDir.getAbsolutePath());
    for (LifecycleListener listener : this.serverLifecycleListeners) {
        tomcat.getServer().addLifecycleListener(listener);
    }
    // 创建连接器组件
    Connector connector = new Connector(this.protocol);
    // 设置在失败时抛出异常
    connector.setThrowOnFailure(true);
    // 获取service组件，不存在则会创建，然后添加连接器组件
    tomcat.getService().addConnector(connector);
    // 定制化连接器，会设置监听端口
    customizeConnector(connector);
    // 为tomcat实例设置连接器
    tomcat.setConnector(connector);
    // 获取Host组件，内部会先获取Engine组件，如果不存在则新建；然后设置主机自动部署任务为false
    tomcat.getHost().setAutoDeploy(false);
    // 配置Engine组件
    configureEngine(tomcat.getEngine());
    // 添加额外的连接器组件
    for (Connector additionalConnector : this.additionalTomcatConnectors) {
        tomcat.getService().addConnector(additionalConnector);
    }
    // 创建Tomcat中的Context组件，并设置其属性，然后将其添加到Host组件下
    prepareContext(tomcat.getHost(), initializers);
    // 根据Tomcat实例，创建TomcatWebServer实例对象
    return getTomcatWebServer(tomcat);
}

protected TomcatWebServer getTomcatWebServer(Tomcat tomcat) {
    return new TomcatWebServer(tomcat, getPort() >= 0, getShutdown());
}

protected void prepareContext(Host host, ServletContextInitializer[] initializers) {
    File documentRoot = getValidDocumentRoot();
    // 创建tomcat中的context组件，该类是Spring Boot中实现的，继承tomcat中的StandardContext
    TomcatEmbeddedContext context = new TomcatEmbeddedContext();
    if (documentRoot != null) {
        context.setResources(new LoaderHidingResourceRoot(context));
    }
    // 为context组件设置一些属性
    context.setName(getContextPath());
    context.setDisplayName(getDisplayName());
    context.setPath(getContextPath());
    File docBase = (documentRoot != null) ? documentRoot : createTempDir("tomcat-docbase");
    context.setDocBase(docBase.getAbsolutePath());
    context.addLifecycleListener(new FixContextListener());
    context.setParentClassLoader((this.resourceLoader != null) ? this.resourceLoader.getClassLoader()
            : ClassUtils.getDefaultClassLoader());
    resetDefaultLocaleMapping(context);
    addLocaleMappings(context);
    try {
        context.setCreateUploadTargets(true);
    }
    catch (NoSuchMethodError ex) {
        // Tomcat is < 8.5.39. Continue.
    }
    configureTldPatterns(context);
    WebappLoader loader = new WebappLoader();
    // 设置类加载器名称
    loader.setLoaderClass(TomcatEmbeddedWebappClassLoader.class.getName());
    loader.setDelegate(true);
    // 设置web应用加载器
    context.setLoader(loader);
    // 是否注册默认servlet，该方法默认返回false
    if (isRegisterDefaultServlet()) {
        // 注册默认的servlet
        addDefaultServlet(context);
    }
    // JSP相关
    if (shouldRegisterJspServlet()) {
        addJspServlet(context);
        addJasperInitializer(context);
    }
    // 添加声明周期监听器，用于配置静态资源
    context.addLifecycleListener(new StaticResourceConfigurer(context));
    // 添加一些默认的初始化器，并和上层传递过来的合并在一起
    ServletContextInitializer[] initializersToUse = mergeInitializers(initializers);
    // 为host添加context子组件
    host.addChild(context);
    // 将initializers设置到context中
    configureContext(context, initializersToUse);
    // 默认是空操作
    postProcessContext(context);
}

@Override
public void onStartup(Set<Class<?>> classes, ServletContext servletContext) throws ServletException {
    try {
        // 遍历servlet上下文初始化器
        for (ServletContextInitializer initializer : this.initializers) {
            // 调用其onStartup方法
            initializer.onStartup(servletContext);
        }
    }
    catch (Exception ex) {
        this.startUpException = ex;
        // Prevent Tomcat from logging and re-throwing when we know we can
        // deal with it in the main thread, but log for information here.
        if (logger.isErrorEnabled()) {
            logger.error("Error starting Tomcat context. Exception: " + ex.getClass().getName() + ". Message: "
                    + ex.getMessage());
        }
    }
}

public TomcatWebServer(Tomcat tomcat, boolean autoStart, Shutdown shutdown) {
    Assert.notNull(tomcat, "Tomcat Server must not be null");
    this.tomcat = tomcat;
    this.autoStart = autoStart;
    this.gracefulShutdown = (shutdown == Shutdown.GRACEFUL) ? new GracefulShutdown(tomcat) : null;
    // 初始化tomcat
    initialize();
}

@Override
public void start() {
    // 启动WebServer
    this.webServer.start();
    this.running = true;
    // 发布WebServer初始化完成的事件
    this.applicationContext
            .publishEvent(new ServletWebServerInitializedEvent(this.webServer, this.applicationContext));
}

@Override
public void start() throws WebServerException {
    synchronized (this.monitor) {
        if (this.started) {
            return;
        }
        try {
            addPreviouslyRemovedConnectors();
            // 获取Connector
            Connector connector = this.tomcat.getConnector();
            if (connector != null && this.autoStart) {
                // 执行延迟启动时加载时加载
                performDeferredLoadOnStartup();
            }
            checkThatConnectorsHaveStarted();
            this.started = true;
            logger.info("Tomcat started on port(s): " + getPortsDescription(true) + " with context path '"
                    + getContextPath() + "'");
        }
        catch (ConnectorStartFailedException ex) {
            stopSilently();
            throw ex;
        }
        catch (Exception ex) {
            PortInUseException.throwIfPortBindingException(ex, () -> this.tomcat.getConnector().getPort());
            throw new WebServerException("Unable to start embedded Tomcat server", ex);
        }
        finally {
            Context context = findContext();
            ContextBindings.unbindClassLoader(context, context.getNamingToken(), getClass().getClassLoader());
        }
    }
}

private void createWebServer() {
    WebServerManager serverManager = this.serverManager;
    if (serverManager == null) {
        StartupStep createWebServer = this.getApplicationStartup().start("spring.boot.webserver.create");
        // 获取WebServer工厂的名称
        String webServerFactoryBeanName = getWebServerFactoryBeanName();
        // 从容器中获取WebServer工厂实例
        ReactiveWebServerFactory webServerFactory = getWebServerFactory(webServerFactoryBeanName);
        createWebServer.tag("factory", webServerFactory.getClass().toString());
        // 获取是否延迟初始化，对于NettyReactiveWebServerFactory来说是false
        boolean lazyInit = getBeanFactory().getBeanDefinition(webServerFactoryBeanName).isLazyInit();
        // 创建WebServerManager对象并传入WebServer工厂，内部会创建WebServer
        this.serverManager = new WebServerManager(this, webServerFactory, this::getHttpHandler, lazyInit);
        getBeanFactory().registerSingleton("webServerGracefulShutdown",
                new WebServerGracefulShutdownLifecycle(this.serverManager.getWebServer()));
        getBeanFactory().registerSingleton("webServerStartStop",
                /*
                 * 该bean是一个SmartLifecycle类型实例
                 * （AbstractApplicationContext#refresh方法的finishRefresh阶段会处理），
                 * 负责WebServer的启动和关闭
                 */
                new WebServerStartStopLifecycle(this.serverManager));
        createWebServer.end();
    }
    initPropertySources();
}

protected String getWebServerFactoryBeanName() {
    // Use bean names so that we don't consider the hierarchy
    /*
     * 至于是哪种类型的server被注入到了bean容器中，参考ReactiveWebServerFactoryAutoConfiguration。
     */
    String[] beanNames = getBeanFactory().getBeanNamesForType(ReactiveWebServerFactory.class);
    if (beanNames.length == 0) {
        throw new MissingWebServerFactoryBeanException(getClass(), ReactiveWebServerFactory.class,
                WebApplicationType.REACTIVE);
    }
    if (beanNames.length > 1) { // 只允许有一个ReactiveWebServerFactory类型的bean
        throw new ApplicationContextException("Unable to start ReactiveWebApplicationContext due to multiple "
                + "ReactiveWebServerFactory beans : " + StringUtils.arrayToCommaDelimitedString(beanNames));
    }
    return beanNames[0];
}

/*
 * 这里注入了多个，那么在ReactiveWebServerApplicationContext#getWebServerFactoryBeanName方法中
 * 会判断是否只有一个ReactiveWebServerFactory实例，如果有多个会报错，那为什么这里还会注入这么多个？
 *
 * 这些都是配置类，类上有注解@ConditionalOnMissingBean(ReactiveWebServerFactory.class)，
 * 如果项目中配置了下面多种serverFactory需要的依赖，那么只有排在下面顺序中前面的才能生效。
 * 因为其先导入，后导入的在检测上面的注解时，发现已经存在了ReactiveWebServerFactory类型的bean，所以不会生效。
 */
@Import({ ReactiveWebServerFactoryAutoConfiguration.BeanPostProcessorsRegistrar.class,
		ReactiveWebServerFactoryConfiguration.EmbeddedJetty.class,
		ReactiveWebServerFactoryConfiguration.EmbeddedUndertow.class,
		// 会注入NettyReactiveWebServerFactory
		ReactiveWebServerFactoryConfiguration.EmbeddedNetty.class,
		// 为了测试Reactor-Netty，把tomcat的放在后面
		ReactiveWebServerFactoryConfiguration.EmbeddedTomcat.class,
})

@Configuration(proxyBeanMethods = false)
// 此注解的目的是避免导入多种serverFactory，如果先导入了其他类型的，那么该配置类不会被加载。
@ConditionalOnMissingBean(ReactiveWebServerFactory.class)
@ConditionalOnClass({ HttpServer.class })
static class EmbeddedNetty {

    @Bean
    @ConditionalOnMissingBean
    ReactorResourceFactory reactorServerResourceFactory() {
        return new ReactorResourceFactory();
    }

    @Bean
    NettyReactiveWebServerFactory nettyReactiveWebServerFactory(ReactorResourceFactory resourceFactory,
            ObjectProvider<NettyRouteProvider> routes, ObjectProvider<NettyServerCustomizer> serverCustomizers) {
        // 创建WebServer工厂对象
        NettyReactiveWebServerFactory serverFactory = new NettyReactiveWebServerFactory();
        serverFactory.setResourceFactory(resourceFactory);
        routes.orderedStream().forEach(serverFactory::addRouteProviders);
        serverFactory.getServerCustomizers().addAll(serverCustomizers.orderedStream().collect(Collectors.toList()));
        return serverFactory; // 返回对象并被加载到spring容器中
    }

}

protected ReactiveWebServerFactory getWebServerFactory(String factoryBeanName) {
    return getBeanFactory().getBean(factoryBeanName, ReactiveWebServerFactory.class);
}

protected HttpHandler getHttpHandler() {
    // Use bean names so that we don't consider the hierarchy
    /*
     * 从bean工厂中获取请求处理器信息，在HttpHandlerAutoConfiguration中会注入该类型的bean。
     */
    String[] beanNames = getBeanFactory().getBeanNamesForType(HttpHandler.class);
    // 不能一个都不存在
    if (beanNames.length == 0) {
        throw new ApplicationContextException(
                "Unable to start ReactiveWebApplicationContext due to missing HttpHandler bean.");
    }
    // 也不能存在多个
    if (beanNames.length > 1) {
        throw new ApplicationContextException(
                "Unable to start ReactiveWebApplicationContext due to multiple HttpHandler beans : "
                        + StringUtils.arrayToCommaDelimitedString(beanNames));
    }
    return getBeanFactory().getBean(beanNames[0], HttpHandler.class);
}

@AutoConfiguration(after = { WebFluxAutoConfiguration.class })
@ConditionalOnClass({ DispatcherHandler.class, HttpHandler.class })
@ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.REACTIVE)
@ConditionalOnMissingBean(HttpHandler.class)
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE + 10)
public class HttpHandlerAutoConfiguration {

	@Configuration(proxyBeanMethods = false)
	public static class AnnotationConfig {

		private final ApplicationContext applicationContext;

		public AnnotationConfig(ApplicationContext applicationContext) {
			this.applicationContext = applicationContext;
		}

		@Bean
		public HttpHandler httpHandler(ObjectProvider<WebFluxProperties> propsProvider) {
			// 创建HTTP处理器，WebHttpHandlerBuilder属于spring-web模块，其实这里创建的是HttpWebHandlerAdapter，该bean同时也是WebHandler
			HttpHandler httpHandler = WebHttpHandlerBuilder.applicationContext(this.applicationContext).build();
			WebFluxProperties properties = propsProvider.getIfAvailable();
			if (properties != null && StringUtils.hasText(properties.getBasePath())) {
				Map<String, HttpHandler> handlersMap = Collections.singletonMap(properties.getBasePath(), httpHandler);
				return new ContextPathCompositeHandler(handlersMap);
			}
			return httpHandler;
		}

	}

}

WebServerManager(ReactiveWebServerApplicationContext applicationContext, ReactiveWebServerFactory factory,
        Supplier<HttpHandler> handlerSupplier, boolean lazyInit) {
    this.applicationContext = applicationContext;
    Assert.notNull(factory, "Factory must not be null");
    this.handler = new DelayedInitializationHttpHandler(handlerSupplier, lazyInit);
    // 创建WebServer
    this.webServer = factory.getWebServer(this.handler);
}

@Override
public WebServer getWebServer(HttpHandler httpHandler) {
    // 创建server，类型是HttpServerBind
    HttpServer httpServer = createHttpServer();
    /*
     * 创建适配器，该适配器是Reactor-Netty和Spring的适配器，
     * 在该适配器的apply方法中会调用httpHandler来处理请求，即请求进入了Spring的范畴。
     * 至于这里的httpHandler是什么，参考HttpHandlerAutoConfiguration，该类中会注入该类型的bean。
     */
    ReactorHttpHandlerAdapter handlerAdapter = new ReactorHttpHandlerAdapter(httpHandler);
    // 创建NettyWebServer实例，对httpServer进行了封装，并传入了请求处理器handlerAdapter
    NettyWebServer webServer = createNettyWebServer(httpServer, handlerAdapter, this.lifecycleTimeout,
            getShutdown());
    webServer.setRouteProviders(this.routeProviders);
    return webServer;
}

private HttpServer createHttpServer() {
    // 创建的是HttpServerBind类型的实例
    HttpServer server = HttpServer.create();
    if (this.resourceFactory != null) {
        LoopResources resources = this.resourceFactory.getLoopResources();
        Assert.notNull(resources, "No LoopResources: is ReactorResourceFactory not initialized yet?");
        // 设置绑定所需的地址信息，this::getListenAddress会返回所要监听的地址和端口信息
        server = server.runOn(resources).bindAddress(this::getListenAddress);
    }
    else {
        server = server.bindAddress(this::getListenAddress);
    }
    // SSL相关
    if (getSsl() != null && getSsl().isEnabled()) {
        server = customizeSslConfiguration(server);
    }
    // 压缩相关
    if (getCompression() != null && getCompression().getEnabled()) {
        CompressionCustomizer compressionCustomizer = new CompressionCustomizer(getCompression());
        server = compressionCustomizer.apply(server);
    }
    // 设置协议
    server = server.protocol(listProtocols()).forwarded(this.useForwardHeaders);
    // 应用自定义设置
    return applyCustomizers(server);
}

private InetSocketAddress getListenAddress() {
    if (getAddress() != null) {
        return new InetSocketAddress(getAddress().getHostAddress(), getPort());
    }
    return new InetSocketAddress(getPort());
}

NettyWebServer createNettyWebServer(HttpServer httpServer, ReactorHttpHandlerAdapter handlerAdapter,
        Duration lifecycleTimeout, Shutdown shutdown) {
    return new NettyWebServer(httpServer, handlerAdapter, lifecycleTimeout, shutdown);
}

@Override
public void start() {
    // 启动webServer
    this.weServerManager.start();
    this.running = true;
}

void start() {
    // 初始化请求处理器（特殊的请求处理器，其实是适配器）
    this.handler.initializeHandler();
    // 启动WebServer
    this.webServer.start();
    this.applicationContext
            .publishEvent(new ReactiveWebServerInitializedEvent(this.webServer, this.applicationContext));
}

@Override
public void start() throws WebServerException {
    if (this.disposableServer == null) {
        try {
            // 启动httpServer
            this.disposableServer = startHttpServer();
        }
        catch (Exception ex) {
            PortInUseException.ifCausedBy(ex, ChannelBindException.class, (bindException) -> {
                if (bindException.localPort() > 0 && !isPermissionDenied(bindException.getCause())) {
                    throw new PortInUseException(bindException.localPort(), ex);
                }
            });
            throw new WebServerException("Unable to start Netty", ex);
        }
        if (this.disposableServer != null) { // 启动成功，打印日志
            logger.info("Netty started" + getStartedOnMessage(this.disposableServer));
        }

        // 创建线程
        startDaemonAwaitThread(this.disposableServer);
    }
}

DisposableServer startHttpServer() {
    HttpServer server = this.httpServer;
    // 下面这个条件默认是true
    if (this.routeProviders.isEmpty()) {
        // 设置请求处理器
        server = server.handle(this.handler);
    }
    else {
        server = server.route(this::applyRouteProviders);
    }
    if (this.lifecycleTimeout != null) {
        return server.bindNow(this.lifecycleTimeout);
    }
    /*
     * 执行bind操作，HttpServer是reactor-netty提供的，所以离开了spring-boot范畴，
     * 最后会一直执行到netty层面的ServerBootstrap#bind()
     */
    return server.bindNow();
}

private void startDaemonAwaitThread(DisposableServer disposableServer) {
    Thread awaitThread = new Thread("server") {

        @Override
        public void run() {
            // 阻塞直到服务停止，onDispose方法在DisposeChannel类中
            disposableServer.onDispose().block();
        }

    };
    awaitThread.setContextClassLoader(getClass().getClassLoader());
    awaitThread.setDaemon(false);
    // 启动线程
    awaitThread.start();
}