ServletWebServerApplicationContext创建Web容器（Tomcat）

一时失言乱红尘 2024-03-25 09:30 72阅读 0赞

ServletWebServerApplicationContext实现了父类AbstractApplicationContext的onRefresh模板方法，在这里进行了拓展创建了Web容器。

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

创建Web服务

private void createWebServer() {
       WebServer webServer = this.webServer;
       ServletContext servletContext = getServletContext();
       if (webServer == null && servletContext == null) {
          //一、获取Web服务器工厂
          ServletWebServerFactory factory = getWebServerFactory();
          //二、获取Web服务
          this.webServer = factory.getWebServer(getSelfInitializer());
          //三、注册Bean生命周期（在容器启动和销毁时调用）
          getBeanFactory().registerSingleton("webServerGracefulShutdown",
                new WebServerGracefulShutdownLifecycle(this.webServer));
          getBeanFactory().registerSingleton("webServerStartStop",
                new WebServerStartStopLifecycle(this, this.webServer));
       }
       else if (servletContext != null) {
          try {
             
             getSelfInitializer().onStartup(servletContext);
          }
          catch (ServletException ex) {
             throw new ApplicationContextException("Cannot initialize servlet context", ex);
          }
       }
       //四、初始化上下文环境
       initPropertySources();
    }

## 一、获取Web服务器工厂 ##

protected ServletWebServerFactory getWebServerFactory() {
       // Use bean names so that we don't consider the hierarchy
       //获取Web服务器工厂名称
       String[] beanNames = getBeanFactory().getBeanNamesForType(ServletWebServerFactory.class);
       if (beanNames.length == 0) {
          throw new ApplicationContextException("Unable to start ServletWebServerApplicationContext due to missing "
                + "ServletWebServerFactory bean.");
       }
       if (beanNames.length > 1) {
          throw new ApplicationContextException("Unable to start ServletWebServerApplicationContext due to multiple "
                + "ServletWebServerFactory beans : " + StringUtils.arrayToCommaDelimitedString(beanNames));
       }
       //从容器中获取Web服务器工厂实例
       return getBeanFactory().getBean(beanNames[0], ServletWebServerFactory.class);
    }
    复制代码

这里的Web服务器工厂是通过`ServletWebServerFactoryAutoConfiguration`自动配置类导入进来的。

@Configuration(proxyBeanMethods = false)
    @AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
    @ConditionalOnClass(ServletRequest.class)
    //Web启动环境
    @ConditionalOnWebApplication(type = Type.SERVLET)
    @EnableConfigurationProperties(ServerProperties.class)
    //2.1导入Web工厂
    @Import({ ServletWebServerFactoryAutoConfiguration.BeanPostProcessorsRegistrar.class,
          ServletWebServerFactoryConfiguration.EmbeddedTomcat.class,
          ServletWebServerFactoryConfiguration.EmbeddedJetty.class,
          ServletWebServerFactoryConfiguration.EmbeddedUndertow.class })
    public class ServletWebServerFactoryAutoConfiguration {
    
       //导入Web服务器工厂自定义程序
       @Bean
       public ServletWebServerFactoryCustomizer servletWebServerFactoryCustomizer(ServerProperties serverProperties) {
          return new ServletWebServerFactoryCustomizer(serverProperties);
       }
    
       //如果是Tomcat则导入Tomcat自定义程序
       @Bean
       @ConditionalOnClass(name = "org.apache.catalina.startup.Tomcat")
       public TomcatServletWebServerFactoryCustomizer tomcatServletWebServerFactoryCustomizer(
             ServerProperties serverProperties) {
          return new TomcatServletWebServerFactoryCustomizer(serverProperties);
       }
    
       @Bean
       @ConditionalOnMissingFilterBean(ForwardedHeaderFilter.class)
       @ConditionalOnProperty(value = "server.forward-headers-strategy", havingValue = "framework")
       public FilterRegistrationBean<ForwardedHeaderFilter> forwardedHeaderFilter() {
          ForwardedHeaderFilter filter = new ForwardedHeaderFilter();
          FilterRegistrationBean<ForwardedHeaderFilter> registration = new FilterRegistrationBean<>(filter);
          registration.setDispatcherTypes(DispatcherType.REQUEST, DispatcherType.ASYNC, DispatcherType.ERROR);
          registration.setOrder(Ordered.HIGHEST_PRECEDENCE);
          return registration;
       }
    
       /**
        * Registers a {@link WebServerFactoryCustomizerBeanPostProcessor}. Registered via
        * {@link ImportBeanDefinitionRegistrar} for early registration.
        */
       public static class BeanPostProcessorsRegistrar implements ImportBeanDefinitionRegistrar, BeanFactoryAware {
    
          private ConfigurableListableBeanFactory beanFactory;
    
          @Override
          public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
             if (beanFactory instanceof ConfigurableListableBeanFactory) {
                this.beanFactory = (ConfigurableListableBeanFactory) beanFactory;
             }
          }
    
          @Override
          public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata,
                BeanDefinitionRegistry registry) {
             if (this.beanFactory == null) {
                return;
             }
             registerSyntheticBeanIfMissing(registry, "webServerFactoryCustomizerBeanPostProcessor",
                   WebServerFactoryCustomizerBeanPostProcessor.class);
             registerSyntheticBeanIfMissing(registry, "errorPageRegistrarBeanPostProcessor",
                   ErrorPageRegistrarBeanPostProcessor.class);
          }
    
          private void registerSyntheticBeanIfMissing(BeanDefinitionRegistry registry, String name, Class<?> beanClass) {
             if (ObjectUtils.isEmpty(this.beanFactory.getBeanNamesForType(beanClass, true, false))) {
                RootBeanDefinition beanDefinition = new RootBeanDefinition(beanClass);
                beanDefinition.setSynthetic(true);
                registry.registerBeanDefinition(name, beanDefinition);
             }
          }
    
       }
    
    }
    复制代码

### 1.1 选择导入Web工厂 ###

@Configuration
    class ServletWebServerFactoryConfiguration {
        ServletWebServerFactoryConfiguration() {
        }
    
        //1.如果容器中有Servlet，Undertow，SslClientAuthMode就会创建Undertow工厂
        @Configuration
        @ConditionalOnClass({Servlet.class, Undertow.class, SslClientAuthMode.class})
        @ConditionalOnMissingBean(
            value = {ServletWebServerFactory.class},
            search = SearchStrategy.CURRENT
        )
        public static class EmbeddedUndertow {
            public EmbeddedUndertow() {
            }
    
            @Bean
            public UndertowServletWebServerFactory undertowServletWebServerFactory() {
                return new UndertowServletWebServerFactory();
            }
        }
    
        //2.如果容器中有Servlet，Server，Loader就会创建Jetty工厂
        @Configuration
        @ConditionalOnClass({Servlet.class, Server.class, Loader.class, WebAppContext.class})
        @ConditionalOnMissingBean(
            value = {ServletWebServerFactory.class},
            search = SearchStrategy.CURRENT
        )
        public static class EmbeddedJetty {
            public EmbeddedJetty() {
            }
    
            @Bean
            public JettyServletWebServerFactory JettyServletWebServerFactory() {
                return new JettyServletWebServerFactory();
            }
        }
    
        //3.如果容器中有Servlet，Tomcat，UpgradeProtocol就会创建Tomcat工厂
        @Configuration
        @ConditionalOnClass({Servlet.class, Tomcat.class, UpgradeProtocol.class})
        @ConditionalOnMissingBean(
            value = {ServletWebServerFactory.class},
            search = SearchStrategy.CURRENT
        )
        public static class EmbeddedTomcat {
            public EmbeddedTomcat() {
            }
    
            @Bean
            public TomcatServletWebServerFactory tomcatServletWebServerFactory() {
                return new TomcatServletWebServerFactory();
            }
        }
    }
    复制代码

## 二、getWebServer：获取Web服务 ##

public static final String DEFAULT_PROTOCOL = "org.apache.coyote.http11.Http11NioProtocol";
    private String protocol = DEFAULT_PROTOCOL;
    
    public WebServer getWebServer(ServletContextInitializer... initializers) {
        Tomcat tomcat = new Tomcat();
        // 给嵌入式Tomcat创建一个临时文件夹，用于存放Tomcat运行中需要的文件
        File baseDir = (this.baseDirectory != null) ? this.baseDirectory : createTempDir("tomcat");
        tomcat.setBaseDir(baseDir.getAbsolutePath());
        // Tomcat核心概念：Connector，默认放入的protocol为NIO模式
        Connector connector = new Connector(this.protocol);
        // 给Service添加Connector
        tomcat.getService().addConnector(connector);
        // 执行定制器，修改即将设置到Tomcat中的Connector
        customizeConnector(connector);
        tomcat.setConnector(connector);
        // 关闭热部署（嵌入式Tomcat不存在修改web.xml、war包等情况）
        tomcat.getHost().setAutoDeploy(false);
        // 设置backgroundProcessorDelay机制
        configureEngine(tomcat.getEngine());
        for (Connector additionalConnector : this.additionalTomcatConnectors) {
            tomcat.getService().addConnector(additionalConnector);
        }
        // 2.1 创建TomcatEmbeddedContext
        prepareContext(tomcat.getHost(), initializers);
        // 2.2. 创建TomcatWebServer
        return getTomcatWebServer(tomcat);
    }
    复制代码

### 2.1 创建TomcatEmbeddedContext ###

（注释均已在源码中标注好，小伙伴们对哪一步感兴趣可以借助IDE自己动手Debug体会一下实现）

protected void prepareContext(Host host, ServletContextInitializer[] initializers) {
        File documentRoot = getValidDocumentRoot();
        // 创建TomcatEmbeddedContext
        TomcatEmbeddedContext context = new TomcatEmbeddedContext();
        if (documentRoot != null) {
            context.setResources(new LoaderHidingResourceRoot(context));
        }
        context.setName(getContextPath());
        context.setDisplayName(getDisplayName());
        // 设置contextPath，很熟悉了
        context.setPath(getContextPath());
        // 给嵌入式Tomcat创建docbase的临时文件夹
        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);
        context.setUseRelativeRedirects(false);
        try {
            context.setCreateUploadTargets(true);
        }
        catch (NoSuchMethodError ex) {
            // Tomcat is < 8.5.39. Continue.
        }
        configureTldSkipPatterns(context);
        // 自定义的类加载器，可以加载web应用的jar包
        WebappLoader loader = new WebappLoader(context.getParentClassLoader());
        loader.setLoaderClass(TomcatEmbeddedWebappClassLoader.class.getName());
        // 指定类加载器遵循双亲委派机制
        loader.setDelegate(true);
        context.setLoader(loader);
        // 注册默认的Servlet
        if (isRegisterDefaultServlet()) {
            addDefaultServlet(context);
        }
        // 如果需要jsp支持，注册jsp的Servlet和Initializer
        if (shouldRegisterJspServlet()) {
            addJspServlet(context);
            addJasperInitializer(context);
        }
        // 注册监听器
        context.addLifecycleListener(new StaticResourceConfigurer(context));
        ServletContextInitializer[] initializersToUse = mergeInitializers(initializers);
        host.addChild(context);
        configureContext(context, initializersToUse);
        postProcessContext(context);
    }
    复制代码

### 2.2. 创建TomcatWebServer ###

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

进入`TomcatWebServer`构造方法中：

public TomcatWebServer(Tomcat tomcat, boolean autoStart) {
        Assert.notNull(tomcat, "Tomcat Server must not be null");
        this.tomcat = tomcat;
        this.autoStart = autoStart;
        //初始化服务
        initialize();
    }
    复制代码

初始化TomcatWebServer

private void initialize() throws WebServerException {
       logger.info("Tomcat initialized with port(s): " + getPortsDescription(false));
       synchronized (this.monitor) {
          try {
             //设置Engine的id
             addInstanceIdToEngineName();
             //获取Context（TomcatEmbeddedContext  2.1中创建出来的）
             Context context = findContext();
             //添加监听器 TomcatEmbeddedContext
             //在服务启动时如果有连接进来先删除连接，以便在启动服务时不会发生协议绑定。
             context.addLifecycleListener((event) -> {
                if (context.equals(event.getSource()) && Lifecycle.START_EVENT.equals(event.getType())) {
                   // Remove service connectors so that protocol binding doesn't
                   // happen when the service is started.
                   //删除ServiceConnectors，以便在启动服务时不会发生协议绑定。
                   removeServiceConnectors();
                }
             });
    
             // Start the server to trigger initialization listeners
             //2.2.1 启动Tomcat
             this.tomcat.start();
    
             // We can re-throw failure exception directly in the main thread
             //Tomcat启动有异常需要在主线程中抛出
             rethrowDeferredStartupExceptions();
    
             try {
                ContextBindings.bindClassLoader(context, context.getNamingToken(), getClass().getClassLoader());
             }
             catch (NamingException ex) {
                // Naming is not enabled. Continue
             }
    
             // Unlike Jetty, all Tomcat threads are daemon threads. We create a
             // blocking non-daemon to stop immediate shutdown
             //开启阻塞非守护线程停止web容器
             startDaemonAwaitThread();
          }
          catch (Exception ex) {
             stopSilently();
             destroySilently();
             throw new WebServerException("Unable to start embedded Tomcat", ex);
          }
       }
    }
    复制代码

#### 2.2.1 启动Tomcat ####

创建和初始化Server和Service

public void start() throws LifecycleException {
        //创建服务（Server和Service）
        getServer();
        server.start();
    }
    复制代码

启动服务

public final synchronized void start() throws LifecycleException {
    
        //如果是正在启动或启动状态
        if (LifecycleState.STARTING_PREP.equals(state) || LifecycleState.STARTING.equals(state) ||
                LifecycleState.STARTED.equals(state)) {
    
            if (log.isDebugEnabled()) {
                Exception e = new LifecycleException();
                log.debug(sm.getString("lifecycleBase.alreadyStarted", toString()), e);
            } else if (log.isInfoEnabled()) {
                log.info(sm.getString("lifecycleBase.alreadyStarted", toString()));
            }
    
            return;
        }
        //如果是新建状态
        if (state.equals(LifecycleState.NEW)) {
            //2.2.1.1 初始化服务
            init();
        //如果是失败状态    
        } else if (state.equals(LifecycleState.FAILED)) {
            //停止服务
            stop();
        //如果不是初始化也不是停止状态
        } else if (!state.equals(LifecycleState.INITIALIZED) &&
                !state.equals(LifecycleState.STOPPED)) {
            //修改状态
            invalidTransition(Lifecycle.BEFORE_START_EVENT);
        }
    
        try {
            //修改状态为准备启动
            setStateInternal(LifecycleState.STARTING_PREP, null, false);
            //2.2.1.2 启动Internal
            startInternal();
            if (state.equals(LifecycleState.FAILED)) {
                // This is a 'controlled' failure. The component put itself into the
                // FAILED state so call stop() to complete the clean-up.
                stop();
            } else if (!state.equals(LifecycleState.STARTING)) {
                // Shouldn't be necessary but acts as a check that sub-classes are
                // doing what they are supposed to.
                invalidTransition(Lifecycle.AFTER_START_EVENT);
            } else {
                setStateInternal(LifecycleState.STARTED, null, false);
            }
        } catch (Throwable t) {
            // This is an 'uncontrolled' failure so put the component into the
            // FAILED state and throw an exception.
            handleSubClassException(t, "lifecycleBase.startFail", toString());
        }
    }
    复制代码

2.2.1.1 初始化Server

public final synchronized void init() throws LifecycleException {
        if (!state.equals(LifecycleState.NEW)) {
            invalidTransition(Lifecycle.BEFORE_INIT_EVENT);
        }
    
        try {
            //设置状态为初始化
            setStateInternal(LifecycleState.INITIALIZING, null, false);
            //初始化
            initInternal();
            //设置状态为初始化完成
            setStateInternal(LifecycleState.INITIALIZED, null, false);
        } catch (Throwable t) {
            handleSubClassException(t, "lifecycleBase.initFail", toString());
        }
    }
    复制代码

初始化Server

protected void initInternal() throws LifecycleException {
        //调用父类初始化（设置名称：Tomcat，类型：Server）
        super.initInternal();
    
        // Initialize utility executor
        reconfigureUtilityExecutor(getUtilityThreadsInternal(utilityThreads));
        //注册线程池
        register(utilityExecutor, "type=UtilityExecutor");
    
        // Register global String cache
        // Note although the cache is global, if there are multiple Servers
        // present in the JVM (may happen when embedding) then the same cache
        // will be registered under multiple names
        //注册字符串缓存
        onameStringCache = register(new StringCache(), "type=StringCache");
    
        // Register the MBeanFactory
        MBeanFactory factory = new MBeanFactory();
        factory.setContainer(this);
        //注册Bean工厂
        onameMBeanFactory = register(factory, "type=MBeanFactory");
    
        // Register the naming resources
        //注册命名资源
        globalNamingResources.init();
    
        // Populate the extension validator with JARs from common and shared
        // class loaders
        if (getCatalina() != null) {
            ClassLoader cl = getCatalina().getParentClassLoader();
            // Walk the class loader hierarchy. Stop at the system class loader.
            // This will add the shared (if present) and common class loaders
            while (cl != null && cl != ClassLoader.getSystemClassLoader()) {
                if (cl instanceof URLClassLoader) {
                    URL[] urls = ((URLClassLoader) cl).getURLs();
                    for (URL url : urls) {
                        if (url.getProtocol().equals("file")) {
                            try {
                                File f = new File (url.toURI());
                                if (f.isFile() &&
                                        f.getName().endsWith(".jar")) {
                                    ExtensionValidator.addSystemResource(f);
                                }
                            } catch (URISyntaxException e) {
                                // Ignore
                            } catch (IOException e) {
                                // Ignore
                            }
                        }
                    }
                }
                cl = cl.getParent();
            }
        }
        // Initialize our defined Services
        //2.2.1.1.1 初始化service（2.2.1最开始时创建）
        for (Service service : services) {
            service.init();
        }
    }
    复制代码

2.2.1.1.1 初始化Service

初始化Service

protected void initInternal() throws LifecycleException {
        //调用父类初始化（设置名称：Tomcat，类型：Server）
        super.initInternal();
        //2.2.1.1.1.1 初始化engine
        if (engine != null) {
            engine.init();
        }
    
        // Initialize any Executors
        //2.2.1.1.1.2 初始化executor
        for (Executor executor : findExecutors()) {
            if (executor instanceof JmxEnabled) {
                ((JmxEnabled) executor).setDomain(getDomain());
            }
            executor.init();
        }
    
        // Initialize mapper listener
        //2.2.1.1.1.3 初始化mapperListener
        mapperListener.init();
    
        // Initialize our defined Connectors
        //2.2.1.1.1.4 初始化connector
        synchronized (connectorsLock) {
            for (Connector connector : connectors) {
                connector.init();
            }
        }
    }
    复制代码

2.2.1.1.1.1 初始化engine

protected void initInternal() throws LifecycleException {
        // Ensure that a Realm is present before any attempt is made to start
        // one. This will create the default NullRealm if necessary.
        // 在尝试启动一个Realm之前，请确保存在一个Realm。如有必要，这将创建默认的NullRealm
        getRealm();
        super.initInternal();
    }
    
    public Realm getRealm() {
        Realm configured = super.getRealm();
        // If no set realm has been called - default to NullRealm
        // This can be overridden at engine, context and host level
        if (configured == null) {
            configured = new NullRealm();
            this.setRealm(configured);
        }
        return configured;
    }
    复制代码

2.2.1.1.1.2 初始化executor

它还是调的父类 `LifecycleMBeanBase` 的方法

protected void initInternal() throws LifecycleException {
        super.initInternal();
    }
    复制代码

2.2.1.1.1.3 初始化mapperListener

protected void initInternal() throws LifecycleException {
        // If oname is not null then registration has already happened via preRegister().
        // 如果oname不为null，则已经通过preRegister()进行了注册
        if (oname == null) {
            mserver = Registry.getRegistry(null, null).getMBeanServer();
            oname = register(this, getObjectNameKeyProperties());
        }
    }
    复制代码

2.2.1.1.1.4 初始化connector

protected void initInternal() throws LifecycleException {
    
        super.initInternal();
    
        if (protocolHandler == null) {
            throw new LifecycleException(
                    sm.getString("coyoteConnector.protocolHandlerInstantiationFailed"));
        }
    
        // Initialize adapter
        adapter = new CoyoteAdapter(this);
        protocolHandler.setAdapter(adapter);
        if (service != null) {
            protocolHandler.setUtilityExecutor(service.getServer().getUtilityExecutor());
        }
    
        // Make sure parseBodyMethodsSet has a default
        if (null == parseBodyMethodsSet) {
            setParseBodyMethods(getParseBodyMethods());
        }
    
        if (protocolHandler.isAprRequired() && !AprStatus.isInstanceCreated()) {
            throw new LifecycleException(sm.getString("coyoteConnector.protocolHandlerNoAprListener",
                    getProtocolHandlerClassName()));
        }
        if (protocolHandler.isAprRequired() && !AprStatus.isAprAvailable()) {
            throw new LifecycleException(sm.getString("coyoteConnector.protocolHandlerNoAprLibrary",
                    getProtocolHandlerClassName()));
        }
        if (AprStatus.isAprAvailable() && AprStatus.getUseOpenSSL() &&
                protocolHandler instanceof AbstractHttp11JsseProtocol) {
            AbstractHttp11JsseProtocol<?> jsseProtocolHandler =
                    (AbstractHttp11JsseProtocol<?>) protocolHandler;
            if (jsseProtocolHandler.isSSLEnabled() &&
                    jsseProtocolHandler.getSslImplementationName() == null) {
                // OpenSSL is compatible with the JSSE configuration, so use it if APR is available
                jsseProtocolHandler.setSslImplementationName(OpenSSLImplementation.class.getName());
            }
        }
    
        try {
            //2.2.1.1.1.5 初始化protocolHandler
            protocolHandler.init();
        } catch (Exception e) {
            throw new LifecycleException(
                    sm.getString("coyoteConnector.protocolHandlerInitializationFailed"), e);
        }
    }
    复制代码

2.2.1.1.1.5初始化protocolHandler

public void init() throws Exception {
        // Upgrade protocols have to be configured first since the endpoint
        // init (triggered via super.init() below) uses this list to configure
        // the list of ALPN protocols to advertise
        // 必须先配置升级协议，因为端点初始化（通过下面的super.init()触发）使用此列表来配置要发布的ALPN协议列表
        for (UpgradeProtocol upgradeProtocol : upgradeProtocols) {
            configureUpgradeProtocol(upgradeProtocol);
        }
    
        super.init();
    }
    复制代码

Debug发现这个 `upgradeProtocols` 为空，直接走下面父类（`AbstractProtocol`）的 `init` 方法：

public void init() throws Exception {
        if (getLog().isInfoEnabled()) {
            getLog().info(sm.getString("abstractProtocolHandler.init", getName()));
            logPortOffset();
        }
    
        if (oname == null) {
            // Component not pre-registered so register it
            oname = createObjectName();
            if (oname != null) {
                Registry.getRegistry(null, null).registerComponent(this, oname, null);
            }
        }
    
        if (this.domain != null) {
            rgOname = new ObjectName(domain + ":type=GlobalRequestProcessor,name=" + getName());
            Registry.getRegistry(null, null).registerComponent(
                    getHandler().getGlobal(), rgOname, null);
        }
    
        String endpointName = getName();
        endpoint.setName(endpointName.substring(1, endpointName.length()-1));
        endpoint.setDomain(domain);
        //2.2.1.1.1.6 初始化endpoint
        endpoint.init();
    }
    复制代码

上面又是一堆初始化，这个咱暂且不关注，注意最底下有一个 `endpoint.init` ：

2.2.1.1.1.6 初始化endpoint

来到 `AbstractEndPoint` ：

public final void init() throws Exception {
        // Debug为false
        if (bindOnInit) {
            bindWithCleanup();
            bindState = BindState.BOUND_ON_INIT;
        }
        if (this.domain != null) {
            // Register endpoint (as ThreadPool - historical name)
            oname = new ObjectName(domain + ":type=ThreadPool,name="" + getName() + """);
            Registry.getRegistry(null, null).registerComponent(this, oname, null);
    
            ObjectName socketPropertiesOname = new ObjectName(domain +
                    ":type=ThreadPool,name="" + getName() + "",subType=SocketProperties");
            socketProperties.setObjectName(socketPropertiesOname);
            Registry.getRegistry(null, null).registerComponent(socketProperties, socketPropertiesOname, null);
    
            for (SSLHostConfig sslHostConfig : findSslHostConfigs()) {
                registerJmx(sslHostConfig);
            }
        }
    }
    复制代码

这里面又是初始化 `oname` ，又是配置 `socketProperties` 的，但这里面再也没见到 `init` 方法，证明这部分初始化过程已经结束了。

2.2.1.1.2 初始化小结

嵌入式 Tomcat 的组件初始化步骤顺序如下：

1.  Server
2.  Service
3.  Engine
4.  Executor
5.  MapperListener
6.  Connector
7.  Protocol
8.  EndPoint

2.2.1.2 startInternal：启动Internal

`startInternal` 方法中有两部分启动：`globalNamingResources` 启动，`services` 启动。分别来看：

protected void startInternal() throws LifecycleException {
        // 发布启动事件
        fireLifecycleEvent(CONFIGURE_START_EVENT, null);
        setState(LifecycleState.STARTING);
    
        // 2.2.1.2.1 NamingResources启动
        globalNamingResources.start();
    
        // Start our defined Services
        synchronized (servicesLock) {
            for (int i = 0; i < services.length; i++) {
                // 2.2.1.2.2 Service启动
                services[i].start();
            }
        }
    
        if (periodicEventDelay > 0) {
            monitorFuture = getUtilityExecutor().scheduleWithFixedDelay(
                    new Runnable() {
                        @Override
                        public void run() {
                            startPeriodicLifecycleEvent();
                        }
                    }, 0, 60, TimeUnit.SECONDS);
        }
    }
    复制代码

2.2.1.2.1 NamingResources启动

只是发布事件和设置状态而已

protected void startInternal() throws LifecycleException {
        fireLifecycleEvent(CONFIGURE_START_EVENT, null);
        setState(LifecycleState.STARTING);
    }
    复制代码

2.2.1.2.2 Service启动

依次启动 `Engine` 、`Executor` 、`MapperListener` 、`Connector`

protected void startInternal() throws LifecycleException {
    
        if(log.isInfoEnabled())
            log.info(sm.getString("standardService.start.name", this.name));
        setState(LifecycleState.STARTING);
    
        // Start our defined Container first
        if (engine != null) {
            synchronized (engine) {
                // 2.2.1.2.2.1 启动Engine
                engine.start();
            }
        }
    
        synchronized (executors) {
            for (Executor executor: executors) {
                // 2.2.1.2.2.3 启动Executor
                executor.start();
            }
        }
    
        // 2.2.1.2.2.4 启动MapperListener
        mapperListener.start();
    
        // Start our defined Connectors second
        synchronized (connectorsLock) {
            for (Connector connector: connectors) {
                // If it has already failed, don't try and start it
                if (connector.getState() != LifecycleState.FAILED) {
                    // 2.2.1.2.2.5 启动connector
                    connector.start();
                }
            }
        }
    }
    复制代码

2.2.1.2.2.1 启动Engine

protected synchronized void startInternal() throws LifecycleException {
        // Log our server identification information
        if (log.isInfoEnabled()) {
            log.info(sm.getString("standardEngine.start", ServerInfo.getServerInfo()));
        }
    
        // Standard container startup
        super.startInternal();
    }
    复制代码

它直接调的父类 `ContainerBase` 的 `startInternal` 方法：

protected synchronized void startInternal() throws LifecycleException {
    
        // Start our subordinate components, if any
        logger = null;
        getLogger();
        // Cluster与集群相关，SpringBoot项目中使用嵌入式Tomcat，不存在集群
        Cluster cluster = getClusterInternal();
        if (cluster instanceof Lifecycle) {
            ((Lifecycle) cluster).start();
        }
        // Realm与授权相关
        Realm realm = getRealmInternal();
        if (realm instanceof Lifecycle) {
            ((Lifecycle) realm).start();
        }
    
        // Start our child containers, if any
        // Container的类型是StandardHost
        Container children[] = findChildren();
        List<Future<Void>> results = new ArrayList<>();
        for (int i = 0; i < children.length; i++) {
            //异步初始化Host
            results.add(startStopExecutor.submit(new StartChild(children[i])));
        }
    
        MultiThrowable multiThrowable = null;
    
        for (Future<Void> result : results) {
            try {
                result.get();
            } catch (Throwable e) {
                log.error(sm.getString("containerBase.threadedStartFailed"), e);
                if (multiThrowable == null) {
                    multiThrowable = new MultiThrowable();
                }
                multiThrowable.add(e);
            }
    
        }
        if (multiThrowable != null) {
            throw new LifecycleException(sm.getString("containerBase.threadedStartFailed"),
                    multiThrowable.getThrowable());
        }
    
        // Start the Valves in our pipeline (including the basic), if any
        if (pipeline instanceof Lifecycle) {
            ((Lifecycle) pipeline).start();
        }
    
        setState(LifecycleState.STARTING);
    
        // Start our thread
        if (backgroundProcessorDelay > 0) {
            monitorFuture = Container.getService(ContainerBase.this).getServer()
                    .getUtilityExecutor().scheduleWithFixedDelay(
                            new ContainerBackgroundProcessorMonitor(), 0, 60, TimeUnit.SECONDS);
        }
    }
    复制代码

StartChild 实现了带返回值的异步多线程接口 **`Callable`** 核心方法就是在 **`call`**

private static class StartChild implements Callable<Void>
    复制代码

它实现了带返回值的异步多线程接口 **`Callable`** ！那里面的核心方法就是 **`call`** ：

public Void call() throws LifecycleException {
        child.start();
        return null;
    }
    复制代码

它在这里初始化 `child`，而通过Debug得知 `child` 的类型是 `StandardHost`，故来到 `StandardHost` 的 `start` 方法：

protected synchronized void startInternal() throws LifecycleException {
        // Set error report valve
        String errorValve = getErrorReportValveClass();
        if ((errorValve != null) && (!errorValve.equals(""))) {
            try {
                boolean found = false;
                Valve[] valves = getPipeline().getValves();
                for (Valve valve : valves) {
                    if (errorValve.equals(valve.getClass().getName())) {
                        found = true;
                        break;
                    }
                }
                if(!found) {
                    Valve valve =
                        (Valve) Class.forName(errorValve).getConstructor().newInstance();
                    getPipeline().addValve(valve);
                }
            } catch (Throwable t) {
                ExceptionUtils.handleThrowable(t);
                log.error(sm.getString(
                        "standardHost.invalidErrorReportValveClass",
                        errorValve), t);
            }
        }
        super.startInternal();
    }
    复制代码

上面的一个大if结构是设置错误提示页面的，下面又调父类的 `startInternal` ：

protected synchronized void startInternal() throws LifecycleException {
        // ......
        // Start our child containers, if any
        Container children[] = findChildren();
        List<Future<Void>> results = new ArrayList<>();
        for (int i = 0; i < children.length; i++) {
            results.add(startStopExecutor.submit(new StartChild(children[i])));
        }
    复制代码

又回来了。。。因为一个 `Host` 包含一个 `Context` 。

`Host` 搜索children就会搜到它下面的 `Context` ，之后又是下面的初始化过程，进入 Context 的初始化：

2.2.1.2.2.2 启动TomcatEmbeddedContext

在TomcatEmbeddedContext有如下组件被调用了 start 方法：

*  StandardRoot
 *  DirResourceSet
 *  WebappLoader
 *  JarResourceSet
 *  StandardWrapper
 *  StandardPineline
 *  StandardWrapperValve
 *  NonLoginAuthenticator
 *  StandardContextValve
 *  StandardManager
 *  LazySessionIdGenerator

2.2.1.2.2.3 启动Executor

但由于 `Executor` 没有实现 `startInternal` 方法，所以不会启动

synchronized (executors) {
            for (Executor executor: executors) {
                executor.start();
            }
        }
    复制代码

2.2.1.2.2.4 启动MapperListener

接下来启动 `MapperListener` ：

public void startInternal() throws LifecycleException {
        setState(LifecycleState.STARTING);
    
        Engine engine = service.getContainer();
        if (engine == null) {
            return;
        }
    
        // 获取当前部署的主机名（本地调试为localhost）
        findDefaultHost();
    
        // 把当前自身注册到Engine、Host、Context、Wrapper中
        addListeners(engine);
    
        // 取出的Container的类型为Host
        Container[] conHosts = engine.findChildren();
        for (Container conHost : conHosts) {
            Host host = (Host) conHost;
            if (!LifecycleState.NEW.equals(host.getState())) {
                // Registering the host will register the context and wrappers
                //将Host、Context、Wrapper注册到当前监听器中
                registerHost(host);
            }
        }
    }
    复制代码

2.2.1.2.2.5 启动Connector

最后一步是启动 `Connector` 。

// Start our defined Connectors second
        synchronized (connectorsLock) {
            for (Connector connector: connectors) {
                // If it has already failed, don't try and start it
                if (connector.getState() != LifecycleState.FAILED) {
                    connector.start();
                }
            }
        }
    复制代码

2.2.1.2.3 启动总结

启动过程依次启动了如下组件：

1.  NamingResources
2.  Service
3.  Engine
4.  Host
5.  Context
6.  Wrapper
7.  Executor
8.  MapperListener

## 三、注册Bean生命周期 ##

### 3.1 WebServerStartStopLifecycle（Web服务器启动-停止生命周期） ###

WebServerStartStopLifecycle实现了Lifecycle，在容器刷新完成时会调用finishRefresh()

@Override
    public void start() {
       //启动Tomcat 容器
       this.webServer.start();
       this.running = true;
       this.applicationContext
             .publishEvent(new ServletWebServerInitializedEvent(this.webServer, this.applicationContext));
    }
    复制代码

public void start() throws WebServerException {
        synchronized (this.monitor) {
            if (this.started) {
                return;
            }
            try {
                // 3.1.1 还原、启动Connector
                addPreviouslyRemovedConnectors();
                // 只拿一个Connector
                Connector connector = this.tomcat.getConnector();
                if (connector != null && this.autoStart) {
                    // 3.1.2 延迟启动
                    performDeferredLoadOnStartup();
                }
                // 检查Connector是否正常启动
                checkThatConnectorsHaveStarted();
                this.started = true;
                logger.info("Tomcat started on port(s): " + getPortsDescription(true) + " with context path '"
                        + getContextPath() + "'");
            }
            // catch ......
            finally {
                // 解除ClassLoader与TomcatEmbeddedContext的绑定关系
                Context context = findContext();
                ContextBindings.unbindClassLoader(context, context.getNamingToken(), getClass().getClassLoader());
            }
        }
    }
    复制代码

#### 3.1.1 addPreviouslyRemovedConnectors：启动Connector ####

private void addPreviouslyRemovedConnectors() {
        Service[] services = this.tomcat.getServer().findServices();
        for (Service service : services) {
            Connector[] connectors = this.serviceConnectors.get(service);
            if (connectors != null) {
                for (Connector connector : connectors) {
                    // 添加并启动
                    service.addConnector(connector);
                    if (!this.autoStart) {
                        stopProtocolHandler(connector);
                    }
                }
                this.serviceConnectors.remove(service);
            }
        }
    }
    复制代码

可以发现它将一个缓存区的 `Connector` 一个一个取出放入 `Service` 中。注意在 `service.addConnector` 中有顺便启动的部分：

public void addConnector(Connector connector) {
        synchronized (connectorsLock) {
            connector.setService(this);
            Connector results[] = new Connector[connectors.length + 1];
            System.arraycopy(connectors, 0, results, 0, connectors.length);
            results[connectors.length] = connector;
            connectors = results;
        }
    
        try {
            if (getState().isAvailable()) {
                // 启动Connector
                connector.start();
            }
        } catch (LifecycleException e) {
            throw new IllegalArgumentException(
                    sm.getString("standardService.connector.startFailed", connector), e);
        }
    
        // Report this property change to interested listeners
        support.firePropertyChange("connector", null, connector);
    }
    复制代码

前面的部分是取出 `Connector` ，并与 `Service` 绑定，之后中间部分的try块，会启动 `Connector` ：

protected void startInternal() throws LifecycleException {
    
        // Validate settings before starting
        if (getPortWithOffset() < 0) {
            throw new LifecycleException(sm.getString(
                    "coyoteConnector.invalidPort", Integer.valueOf(getPortWithOffset())));
        }
    
        setState(LifecycleState.STARTING);
    
        try {
            // 启动ProtocolHandler
            protocolHandler.start();
        } catch (Exception e) {
            throw new LifecycleException(
                    sm.getString("coyoteConnector.protocolHandlerStartFailed"), e);
        }
    }
    复制代码

`Connector` 的启动会引发 `ProtocolHandler` 的启动：

public void start() throws Exception {
        if (getLog().isInfoEnabled()) {
            getLog().info(sm.getString("abstractProtocolHandler.start", getName()));
            logPortOffset();
        }
    
        // 启动EndPoint
        endpoint.start();
        monitorFuture = getUtilityExecutor().scheduleWithFixedDelay(
                new Runnable() {
                    @Override
                    public void run() {
                        if (!isPaused()) {
                            startAsyncTimeout();
                        }
                    }
                }, 0, 60, TimeUnit.SECONDS);
    }
    复制代码

`ProtocolHandler` 的启动会引发 EndPoint 的启动，至此所有组件均已启动完毕。

#### 3.1.2 performDeferredLoadOnStartup：延迟启动 ####

这里面会延迟启动 `TomcatEmbeddedContext`

private void performDeferredLoadOnStartup() {
        try {
            for (Container child : this.tomcat.getHost().findChildren()) {
                if (child instanceof TomcatEmbeddedContext) {
                    // 延迟启动Context
                    ((TomcatEmbeddedContext) child).deferredLoadOnStartup();
                }
            }
        }
        catch (Exception ex) {
            if (ex instanceof WebServerException) {
                throw (WebServerException) ex;
            }
            throw new WebServerException("Unable to start embedded Tomcat connectors", ex);
        }
    }