Tomcat 9.0 源码分析(2)-连接器 Connector 的启动

小咪咪 2023-10-03 11:18 9阅读 0赞

#### 文章目录 ####

*  1. Connector 连接器启动流程
 *  2. 源码分析
 *   *   *  2.1 Connector 连接器对象的创建
         *  2.2 Connector 连接器初始化
         *  2.3 Connector 连接器启动

## 1. Connector 连接器启动流程 ##

在 [Tomcat源码分析(1)-结构组成与核心组件][Tomcat_1_-] 中笔者大致分析了 Tomcat 的组成，`Connector` 连接器是直接和底层 socket 交互的重要组件。 在 Tomcat 的启动过程中，`Connector` 连接器的初始化及启动流程如下图所示，可以看到主要流程分为 3 个步骤：

> 1.  解析配置文件，创建 Connector 连接器对象
> 2.  初始化 Connector 连接器各个构件，完成端口绑定监听
> 3.  启动 Connector 连接器，开始监听 socket 连接

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUwNTMxMw_size_16_color_FFFFFF_t_70_pic_center]

## 2. 源码分析 ##

#### 2.1 Connector 连接器对象的创建 ####

1.  Tomcat 服务器的启动一般是通过 `startup.sh` 脚本，另外也可以直接以 jar 包形式启动，二者实际流程差异不大。本文为方便分析，以 `Tomcat#main()` 方法开始，其实现如下所示，可以看到主要流程如下：
    
    > 1.  首先新建抽象整个服务器的 Tomcat 对象
    > 2.  调用 `Tomcat#init()` 方法完成服务器初始化
    > 3.  调用 `Tomcat#start()` 方法启动服务器各个组件
    
        public static void main(String[] args) throws Exception {
              
             // Process some command line parameters
             for (int i = 0; i < args.length; i++) {
              
                 if (args[i].equals("--no-jmx")) {
              
                     Registry.disableRegistry();
                 }
             }
             SecurityClassLoad.securityClassLoad(Thread.currentThread().getContextClassLoader());
             org.apache.catalina.startup.Tomcat tomcat = new org.apache.catalina.startup.Tomcat();
             // Create a Catalina instance and let it parse the configuration files
             // It will also set a shutdown hook to stop the Server when needed
             // Use the default configuration source
             tomcat.init(null);
             boolean await = false;
             String path = "";
             // Process command line parameters
             for (int i = 0; i < args.length; i++) {
              
                 if (args[i].equals("--war")) {
              
                     if (++i >= args.length) {
              
                         throw new IllegalArgumentException(sm.getString("tomcat.invalidCommandLine", args[i - 1]));
                     }
                     File war = new File(args[i]);
                     tomcat.addWebapp(path, war.getAbsolutePath());
                 } else if (args[i].equals("--path")) {
              
                     if (++i >= args.length) {
              
                         throw new IllegalArgumentException(sm.getString("tomcat.invalidCommandLine", args[i - 1]));
                     }
                     path = args[i];
                 } else if (args[i].equals("--await")) {
              
                     await = true;
                 } else if (args[i].equals("--no-jmx")) {
              
                     // This was already processed before
                 } else {
              
                     throw new IllegalArgumentException(sm.getString("tomcat.invalidCommandLine", args[i]));
                 }
             }
             tomcat.start();
             // Ideally the utility threads are non daemon
             if (await) {
              
                 tomcat.getServer().await();
             }
         }
2.  Tomcat 对象的创建很简单，不需要关注，我们直接从 `Tomcat#init()` 方法开始分析。这个方法的主要逻辑是新建 `Catalina` 对象，并通过该对象的 `Catalina#load()` 方法去加载 xml 配置文件，完成关键组件对象的创建
    
        public void init(ConfigurationSource source) {
              
             ConfigFileLoader.setSource(source);
             addDefaultWebXmlToWebapp = false;
             Catalina catalina = new Catalina();
             // Load the Catalina instance with the regular configuration files
             // from specified source
             catalina.load();
             // Retrieve and set the server
             server = catalina.getServer();
         }
3.  `Catalina#load()` 方法源码如下，最关键的操作可以分为两步：
    
    > 1.  调用 `Catalina#createStartDigester()` 方法创建 `Digester` 对象，该对象中会完成关键组件规则定义，比如指定 `Server` 的实现类为 `StandardServer`，并指定其属性注入的反射方法
    > 2.  调用 `Digester#parse()` 方法解析 `server.xml` 文件，完成核心类对象的创建
    > 3.  `getServer().init()` 调用 `StandardServer#init()` 开始服务器初始化
    
        public void load() {
              
        
             if (loaded) {
              
                 return;
             }
             loaded = true;
        
             long t1 = System.nanoTime();
        
             initDirs();
        
             // Before digester - it may be needed
             initNaming();
        
             // Set configuration source
             ConfigFileLoader.setSource(new CatalinaBaseConfigurationSource(Bootstrap.getCatalinaBaseFile(), getConfigFile()));
             File file = configFile();
        
             // Create and execute our Digester
             Digester digester = createStartDigester();
        
             try (ConfigurationSource.Resource resource = ConfigFileLoader.getSource().getServerXml()) {
              
                 InputStream inputStream = resource.getInputStream();
                 InputSource inputSource = new InputSource(resource.getURI().toURL().toString());
                 inputSource.setByteStream(inputStream);
                 digester.push(this);
                 digester.parse(inputSource);
             } catch (Exception e) {
              
                 log.warn(sm.getString("catalina.configFail", file.getAbsolutePath()), e);
                 if (file.exists() && !file.canRead()) {
              
                     log.warn(sm.getString("catalina.incorrectPermissions"));
                 }
                 return;
             }
        
             getServer().setCatalina(this);
             getServer().setCatalinaHome(Bootstrap.getCatalinaHomeFile());
             getServer().setCatalinaBase(Bootstrap.getCatalinaBaseFile());
        
             // Stream redirection
             initStreams();
        
             // Start the new server
             try {
              
                 getServer().init();
             } catch (LifecycleException e) {
              
                 if (Boolean.getBoolean("org.apache.catalina.startup.EXIT_ON_INIT_FAILURE")) {
              
                     throw new java.lang.Error(e);
                 } else {
              
                     log.error(sm.getString("catalina.initError"), e);
                 }
             }
        
             long t2 = System.nanoTime();
             if(log.isInfoEnabled()) {
              
                 log.info(sm.getString("catalina.init", Long.valueOf((t2 - t1) / 1000000)));
             }
         }
4.  `Catalina#createStartDigester()` 方法的实现如下，可以看到核心就是创建了 `Digester`，并为其添加了解析 `server.xml` 文件的规则引擎，这些规则将在解析动作触发时完成关键对象的创建
    
        protected Digester createStartDigester() {
              
             long t1=System.currentTimeMillis();
             // Initialize the digester
             Digester digester = new Digester();
             digester.setValidating(false);
             digester.setRulesValidation(true);
             Map<Class<?>, List<String>> fakeAttributes = new HashMap<>();
             // Ignore className on all elements
             List<String> objectAttrs = new ArrayList<>();
             objectAttrs.add("className");
             fakeAttributes.put(Object.class, objectAttrs);
             // Ignore attribute added by Eclipse for its internal tracking
             List<String> contextAttrs = new ArrayList<>();
             contextAttrs.add("source");
             fakeAttributes.put(StandardContext.class, contextAttrs);
             // Ignore Connector attribute used internally but set on Server
             List<String> connectorAttrs = new ArrayList<>();
             connectorAttrs.add("portOffset");
             fakeAttributes.put(Connector.class, connectorAttrs);
             digester.setFakeAttributes(fakeAttributes);
             digester.setUseContextClassLoader(true);
        
             // Configure the actions we will be using
             digester.addObjectCreate("Server",
                                      "org.apache.catalina.core.StandardServer",
                                      "className");
             digester.addSetProperties("Server");
             digester.addSetNext("Server",
                                 "setServer",
                                 "org.apache.catalina.Server");
        
             digester.addObjectCreate("Server/GlobalNamingResources",
                                      "org.apache.catalina.deploy.NamingResourcesImpl");
             digester.addSetProperties("Server/GlobalNamingResources");
             digester.addSetNext("Server/GlobalNamingResources",
                                 "setGlobalNamingResources",
                                 "org.apache.catalina.deploy.NamingResourcesImpl");
        
             digester.addRule("Server/Listener",
                     new ListenerCreateRule(null, "className"));
             digester.addSetProperties("Server/Listener");
             digester.addSetNext("Server/Listener",
                                 "addLifecycleListener",
                                 "org.apache.catalina.LifecycleListener");
        
             digester.addObjectCreate("Server/Service",
                                      "org.apache.catalina.core.StandardService",
                                      "className");
             digester.addSetProperties("Server/Service");
             digester.addSetNext("Server/Service",
                                 "addService",
                                 "org.apache.catalina.Service");
        
             digester.addObjectCreate("Server/Service/Listener",
                                      null, // MUST be specified in the element
                                      "className");
             digester.addSetProperties("Server/Service/Listener");
             digester.addSetNext("Server/Service/Listener",
                                 "addLifecycleListener",
                                 "org.apache.catalina.LifecycleListener");
        
             //Executor
             digester.addObjectCreate("Server/Service/Executor",
                              "org.apache.catalina.core.StandardThreadExecutor",
                              "className");
             digester.addSetProperties("Server/Service/Executor");
        
             digester.addSetNext("Server/Service/Executor",
                                 "addExecutor",
                                 "org.apache.catalina.Executor");
        
        
             digester.addRule("Server/Service/Connector",
                              new ConnectorCreateRule());
             digester.addRule("Server/Service/Connector", new SetAllPropertiesRule(
                     new String[]{
              "executor", "sslImplementationName", "protocol"}));
             digester.addSetNext("Server/Service/Connector",
                                 "addConnector",
                                 "org.apache.catalina.connector.Connector");
        
             digester.addRule("Server/Service/Connector", new AddPortOffsetRule());
        
             digester.addObjectCreate("Server/Service/Connector/SSLHostConfig",
                                      "org.apache.tomcat.util.net.SSLHostConfig");
             digester.addSetProperties("Server/Service/Connector/SSLHostConfig");
             digester.addSetNext("Server/Service/Connector/SSLHostConfig",
                     "addSslHostConfig",
                     "org.apache.tomcat.util.net.SSLHostConfig");
        
             digester.addRule("Server/Service/Connector/SSLHostConfig/Certificate",
                              new CertificateCreateRule());
             digester.addRule("Server/Service/Connector/SSLHostConfig/Certificate",
                              new SetAllPropertiesRule(new String[]{
              "type"}));
             digester.addSetNext("Server/Service/Connector/SSLHostConfig/Certificate",
                                 "addCertificate",
                                 "org.apache.tomcat.util.net.SSLHostConfigCertificate");
        
             digester.addObjectCreate("Server/Service/Connector/SSLHostConfig/OpenSSLConf",
                                      "org.apache.tomcat.util.net.openssl.OpenSSLConf");
             digester.addSetProperties("Server/Service/Connector/SSLHostConfig/OpenSSLConf");
             digester.addSetNext("Server/Service/Connector/SSLHostConfig/OpenSSLConf",
                                 "setOpenSslConf",
                                 "org.apache.tomcat.util.net.openssl.OpenSSLConf");
        
             digester.addObjectCreate("Server/Service/Connector/SSLHostConfig/OpenSSLConf/OpenSSLConfCmd",
                                      "org.apache.tomcat.util.net.openssl.OpenSSLConfCmd");
             digester.addSetProperties("Server/Service/Connector/SSLHostConfig/OpenSSLConf/OpenSSLConfCmd");
             digester.addSetNext("Server/Service/Connector/SSLHostConfig/OpenSSLConf/OpenSSLConfCmd",
                                 "addCmd",
                                 "org.apache.tomcat.util.net.openssl.OpenSSLConfCmd");
        
             digester.addObjectCreate("Server/Service/Connector/Listener",
                                      null, // MUST be specified in the element
                                      "className");
             digester.addSetProperties("Server/Service/Connector/Listener");
             digester.addSetNext("Server/Service/Connector/Listener",
                                 "addLifecycleListener",
                                 "org.apache.catalina.LifecycleListener");
        
             digester.addObjectCreate("Server/Service/Connector/UpgradeProtocol",
                                       null, // MUST be specified in the element
                                       "className");
             digester.addSetProperties("Server/Service/Connector/UpgradeProtocol");
             digester.addSetNext("Server/Service/Connector/UpgradeProtocol",
                                 "addUpgradeProtocol",
                                 "org.apache.coyote.UpgradeProtocol");
        
             // Add RuleSets for nested elements
             digester.addRuleSet(new NamingRuleSet("Server/GlobalNamingResources/"));
             digester.addRuleSet(new EngineRuleSet("Server/Service/"));
             digester.addRuleSet(new HostRuleSet("Server/Service/Engine/"));
             digester.addRuleSet(new ContextRuleSet("Server/Service/Engine/Host/"));
             addClusterRuleSet(digester, "Server/Service/Engine/Host/Cluster/");
             digester.addRuleSet(new NamingRuleSet("Server/Service/Engine/Host/Context/"));
        
             // When the 'engine' is found, set the parentClassLoader.
             digester.addRule("Server/Service/Engine",
                              new SetParentClassLoaderRule(parentClassLoader));
             addClusterRuleSet(digester, "Server/Service/Engine/Cluster/");
        
             long t2=System.currentTimeMillis();
             if (log.isDebugEnabled()) {
              
                 log.debug("Digester for server.xml created " + ( t2-t1 ));
             }
             return digester;
        
         }
5.  一个典型的 `server.xml` 文件结构如下，在解析 xml 文件过程中会依次创建 `StandardServer、StandardService、Connector` 对象，本文关注的是连接器的 Connector，故以连接器对象为重点分析
    
        <Server>
         <Service>
             <Connector />
             <Engine>
                 <Host>
                     <Context />
                 </Host>
             </Engine>
         </Service>

1.  `Connector` 的构造方法如下，该部分在[Tomcat源码分析(1)-Connector 连接器][Tomcat_1_-Connector] 中也有提及，该部分涉及的其他关键对象的创建参考链接即可，此处不再赘述，至此 Connector 连接器对象的创建告一段落
    
        public Connector() {
              
             this("org.apache.coyote.http11.Http11NioProtocol");
         }
        
        
         public Connector(String protocol) {
              
             boolean aprConnector = AprLifecycleListener.isAprAvailable() &&
                     AprLifecycleListener.getUseAprConnector();
        
             if ("HTTP/1.1".equals(protocol) || protocol == null) {
              
                 if (aprConnector) {
              
                     protocolHandlerClassName = "org.apache.coyote.http11.Http11AprProtocol";
                 } else {
              
                     protocolHandlerClassName = "org.apache.coyote.http11.Http11NioProtocol";
                 }
             } else if ("AJP/1.3".equals(protocol)) {
              
                 if (aprConnector) {
              
                     protocolHandlerClassName = "org.apache.coyote.ajp.AjpAprProtocol";
                 } else {
              
                     protocolHandlerClassName = "org.apache.coyote.ajp.AjpNioProtocol";
                 }
             } else {
              
                 protocolHandlerClassName = protocol;
             }
        
             // Instantiate protocol handler
             ProtocolHandler p = null;
             try {
              
                 Class<?> clazz = Class.forName(protocolHandlerClassName);
                 p = (ProtocolHandler) clazz.getConstructor().newInstance();
             } catch (Exception e) {
              
                 log.error(sm.getString(
                         "coyoteConnector.protocolHandlerInstantiationFailed"), e);
             } finally {
              
                 this.protocolHandler = p;
             }
        
             // Default for Connector depends on this system property
             setThrowOnFailure(Boolean.getBoolean("org.apache.catalina.startup.EXIT_ON_INIT_FAILURE"));
         }

#### 2.2 Connector 连接器初始化 ####

1.  在上一节步骤3 `Catalina#load()` 方法的逻辑中，最后一步是通过代码 `getServer().init()` 调用 `StandardServer#init()` 方法开始服务器初始化，本节就从此处开始分析。实际上`StandardServer#init()` 方法是其父类 `LifecycleBase` 生命周期基类的实现，最终调用到的是 `StandardServer#initInternal()` 方法。这里是服务器开始初始化的入口，结合 Tomcat 的组件结构，不难看出此处的关键其实是方法最后一部分，遍历 Server 中包含的 Service 对象，依次调用其初始化方法
    
        protected void initInternal() throws LifecycleException {
              
        
             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);
             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
             for (int i = 0; i < services.length; i++) {
              
                 services[i].init();
             }
         }
2.  `Service` 的实现类为 `StandardService`，与 `Server` 类似，`Service#init()` 最终其实会调用到 `StandardService#initInternal()` 方法，可以看到这里比较关键的以下两个操作：
    
    > 1.  `engine.init()` 调用容器的初始化方法进行容器初始化，本文暂不分析这部分
    > 2.  遍历 `Connector 连接器`列表，依次初始化各个连接器
    
        protected void initInternal() throws LifecycleException {
              
        
             super.initInternal();
        
             if (engine != null) {
              
                 engine.init();
             }
        
             // Initialize any Executors
             for (Executor executor : findExecutors()) {
              
                 if (executor instanceof JmxEnabled) {
              
                     ((JmxEnabled) executor).setDomain(getDomain());
                 }
                 executor.init();
             }
        
             // Initialize mapper listener
             mapperListener.init();
        
             // Initialize our defined Connectors
             synchronized (connectorsLock) {
              
                 for (Connector connector : connectors) {
              
                     connector.init();
                 }
             }
         }
3.  `Connector#init()` 还是老套路，最终调用到 `Connector#initInternal()` 方法。这里最重要的逻辑有两处：
    
    > 1.  创建 `CoyoteAdapter` 对象作为 Adapter 适配器，并通过 `protocolHandler.setAdapter(adapter)` 使得协议处理器能够持有适配器对象
    > 2.  通过 `protocolHandler.init()` 调用到协议处理器的初始化方法，最终将调用到 `Http11NioProtocol#init()` 方法
    
        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() && !AprLifecycleListener.isInstanceCreated()) {
              
                 throw new LifecycleException(sm.getString("coyoteConnector.protocolHandlerNoAprListener",
                         getProtocolHandlerClassName()));
             }
             if (protocolHandler.isAprRequired() && !AprLifecycleListener.isAprAvailable()) {
              
                 throw new LifecycleException(sm.getString("coyoteConnector.protocolHandlerNoAprLibrary",
                         getProtocolHandlerClassName()));
             }
             if (AprLifecycleListener.isAprAvailable() && AprLifecycleListener.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 {
              
                 protocolHandler.init();
             } catch (Exception e) {
              
                 throw new LifecycleException(
                         sm.getString("coyoteConnector.protocolHandlerInitializationFailed"), e);
             }
         }
4.  `Http11NioProtocol#init()` 方法的重要实现其实是其父类 `AbstractProtocol#init()` 方法，可以看到这里会通过 `endpoint.init()` 调用到端点 `NioEndpoint#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);
        
            endpoint.init();
        }
5.  `NioEndpoint#init()` 方法其实也是父类 `AbstractEndpoint#init()` 实现，此处的关键如下：
    
    > 首先调用 `AbstractEndpoint#bindWithCleanup()`进入绑定监听端口的流程，在这个方法里再调用 `AbstractEndpoint#bind()` 进入子类实现的实质性绑定处理，这里其实就是调用 `NioEndpoint#bind()` 方法
    
        public final void init() throws Exception {
              
             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);
                 }
             }
         }
        
        private void bindWithCleanup() throws Exception {
              
             try {
              
                 bind();
             } catch (Throwable t) {
              
                 // Ensure open sockets etc. are cleaned up if something goes
                 // wrong during bind
                 ExceptionUtils.handleThrowable(t);
                 unbind();
                 throw t;
             }
         }
6.  `NioEndpoint#bind()` 方法如下，可知关键逻辑是调用 `NioEndpoint#initServerSocket()` 方法完成服务端的端口监听，至此 Connector 连接器的初始化完毕
    
        public void bind() throws Exception {
              
             initServerSocket();
        
             setStopLatch(new CountDownLatch(1));
        
             // Initialize SSL if needed
             initialiseSsl();
        
             selectorPool.open(getName());
         }
         
         protected void initServerSocket() throws Exception {
              
             if (!getUseInheritedChannel()) {
              
                 serverSock = ServerSocketChannel.open();
                 socketProperties.setProperties(serverSock.socket());
                 InetSocketAddress addr = new InetSocketAddress(getAddress(), getPortWithOffset());
                 serverSock.socket().bind(addr,getAcceptCount());
             } else {
              
                 // Retrieve the channel provided by the OS
                 Channel ic = System.inheritedChannel();
                 if (ic instanceof ServerSocketChannel) {
              
                     serverSock = (ServerSocketChannel) ic;
                 }
                 if (serverSock == null) {
              
                     throw new IllegalArgumentException(sm.getString("endpoint.init.bind.inherited"));
                 }
             }
             serverSock.configureBlocking(true); //mimic APR behavior
         }

#### 2.3 Connector 连接器启动 ####

1.  此时回到2.1 节步骤1，可知道服务器的启动其实是由 `Tomcat#start()` 方法调用触发的，此处最主要的逻辑是调用 `StandardServer#start()` 方法启动服务器
    
        public void start() throws LifecycleException {
              
             getServer();
             server.start();
         }
         public Server getServer() {
              
        
             if (server != null) {
              
                 return server;
             }
        
             System.setProperty("catalina.useNaming", "false");
        
             server = new StandardServer();
        
             initBaseDir();
        
             // Set configuration source
             ConfigFileLoader.setSource(new CatalinaBaseConfigurationSource(new File(basedir), null));
        
             server.setPort( -1 );
        
             Service service = new StandardService();
             service.setName("Tomcat");
             server.addService(service);
             return server;
         }
2.  `StandardServer#start()` 方法其实是基类方法，最终的逻辑在 `StandardServer#startInternal()` 方法中。这里与服务器初始化的流程类似，同样是组件一级一级往下启动，最终将调用到 `Connector#startInternal()` 方法
    
        protected void startInternal() throws LifecycleException {
              
        
             fireLifecycleEvent(CONFIGURE_START_EVENT, null);
             setState(LifecycleState.STARTING);
        
             globalNamingResources.start();
        
             // Start our defined Services
             synchronized (servicesLock) {
              
                 for (int i = 0; i < services.length; i++) {
              
                     services[i].start();
                 }
             }
        
             if (periodicEventDelay > 0) {
              
                 monitorFuture = getUtilityExecutor().scheduleWithFixedDelay(
                         new Runnable() {
              
                             @Override
                             public void run() {
              
                                 startPeriodicLifecycleEvent();
                             }
                         }, 0, 60, TimeUnit.SECONDS);
             }
         }
3.  `Connector#startInternal()` 方法的重要逻辑是调用 `Http11NioProtocol#start()` 启动协议处理器
    
        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.start();
             } catch (Exception e) {
              
                 throw new LifecycleException(
                         sm.getString("coyoteConnector.protocolHandlerStartFailed"), e);
             }
         }
4.  `Http11NioProtocol#start()` 方法其实是父类实现 `AbstractProtocol#start()`，这里需要关注的有两个点：
    
    > 1.  调用 `NioEndpoint#start()` 方法使端点开始接收连接并处理 socket 数据，这个方法其实继承自父类 `AbstractEndpoint#start()` 方法
    > 2.  启动周期线程池，把 `Http11NioProtocol#startAsyncTimeout()` 方法包装成任务扔进池子中。需注意，`Http11NioProtocol#startAsyncTimeout()` 方法其实也会开启每秒 1 次的周期任务，主要用于检查等待处理的 Processor 是否超时，此处是 DeferredResult 等异步请求超时处理的关键，读者如有兴趣可参考 [Spring WebMVC 源码分析(3)-异步请求 DeferredResult 的原理][Spring WebMVC _3_-_ DeferredResult]
    
        public void start() throws Exception {
              
             if (getLog().isInfoEnabled()) {
              
                 getLog().info(sm.getString("abstractProtocolHandler.start", getName()));
                 logPortOffset();
             }
        
             endpoint.start();
             monitorFuture = getUtilityExecutor().scheduleWithFixedDelay(
                     new Runnable() {
              
                         @Override
                         public void run() {
              
                             if (!isPaused()) {
              
                                 startAsyncTimeout();
                             }
                         }
                     }, 0, 60, TimeUnit.SECONDS);
         }
        
        protected void startAsyncTimeout() {
              
             if (timeoutFuture == null || (timeoutFuture != null && timeoutFuture.isDone())) {
              
                 if (timeoutFuture != null && timeoutFuture.isDone()) {
              
                     // There was an error executing the scheduled task, get it and log it
                     try {
              
                         timeoutFuture.get();
                     } catch (InterruptedException | ExecutionException e) {
              
                         getLog().error(sm.getString("abstractProtocolHandler.asyncTimeoutError"), e);
                     }
                 }
                 timeoutFuture = getUtilityExecutor().scheduleAtFixedRate(
                         new Runnable() {
              
                             @Override
                             public void run() {
              
                                 long now = System.currentTimeMillis();
                                 for (Processor processor : waitingProcessors) {
              
                                     processor.timeoutAsync(now);
                                 }
                             }
                         }, 1, 1, TimeUnit.SECONDS);
             }
         }
5.  `AbstractEndpoint#start()` 方法的核心是调用子类的实现，在本文中也就是`NioEndPoint#startInternal()` 方法
    
        public final void start() throws Exception {
              
             if (bindState == BindState.UNBOUND) {
              
                 bindWithCleanup();
                 bindState = BindState.BOUND_ON_START;
             }
             startInternal();
         }
6.  `NioEndPoint#startInternal()` 方法的关键操作是两步：
    
    > 1.  创建 Poller 轮询器，并将其放在另一个线程中启动
    > 2.  调用父类 `AbstractEndpoint#startAcceptorThread()` 方法启动连接接收器，开始接受外部连接
    
        public void startInternal() throws Exception {
              
        
             if (!running) {
              
                 running = true;
                 paused = false;
        
                 if (socketProperties.getProcessorCache() != 0) {
              
                     processorCache = new SynchronizedStack<>(SynchronizedStack.DEFAULT_SIZE,
                             socketProperties.getProcessorCache());
                 }
                 if (socketProperties.getEventCache() != 0) {
              
                     eventCache = new SynchronizedStack<>(SynchronizedStack.DEFAULT_SIZE,
                             socketProperties.getEventCache());
                 }
                 if (socketProperties.getBufferPool() != 0) {
              
                     nioChannels = new SynchronizedStack<>(SynchronizedStack.DEFAULT_SIZE,
                             socketProperties.getBufferPool());
                 }
        
                 // Create worker collection
                 if (getExecutor() == null) {
              
                     createExecutor();
                 }
        
                 initializeConnectionLatch();
        
                 // Start poller thread
                 poller = new Poller();
                 Thread pollerThread = new Thread(poller, getName() + "-ClientPoller");
                 pollerThread.setPriority(threadPriority);
                 pollerThread.setDaemon(true);
                 pollerThread.start();
        
                 startAcceptorThread();
             }
         }
        
        protected void startAcceptorThread() {
              
             acceptor = new Acceptor<>(this);
             String threadName = getName() + "-Acceptor";
             acceptor.setThreadName(threadName);
             Thread t = new Thread(acceptor, threadName);
             t.setPriority(getAcceptorThreadPriority());
             t.setDaemon(getDaemon());
             t.start();
         }
7.  首先来看下连接接收器 `Acceptor#run()`的处理流程，可知其关键步骤如下：
    
    > 1.  如果端点 `EndPoint` 处于运行状态，则一直 while 循环不断接收新连接
    > 2.  实际接收连接的操作由 `endpoint.serverSocketAccept()` 调用 `NioEndpoint#serverSocketAccept()` 方法完成
    > 3.  通过 `endpoint.setSocketOptions(socket)` 设置监听新建的 socket 上的读写事件，此处实际调用 `NioEndpoint#setSocketOptions()` 方法
    
        public void run() {
              
        
             int errorDelay = 0;
        
             // Loop until we receive a shutdown command
             while (endpoint.isRunning()) {
              
        
                 // Loop if endpoint is paused
                 while (endpoint.isPaused() && endpoint.isRunning()) {
              
                     state = AcceptorState.PAUSED;
                     try {
              
                         Thread.sleep(50);
                     } catch (InterruptedException e) {
              
                         // Ignore
                     }
                 }
        
                 if (!endpoint.isRunning()) {
              
                     break;
                 }
                 state = AcceptorState.RUNNING;
        
                 try {
              
                     //if we have reached max connections, wait
                     endpoint.countUpOrAwaitConnection();
        
                     // Endpoint might have been paused while waiting for latch
                     // If that is the case, don't accept new connections
                     if (endpoint.isPaused()) {
              
                         continue;
                     }
        
                     U socket = null;
                     try {
              
                         // Accept the next incoming connection from the server
                         // socket
                         socket = endpoint.serverSocketAccept();
                     } catch (Exception ioe) {
              
                         // We didn't get a socket
                         endpoint.countDownConnection();
                         if (endpoint.isRunning()) {
              
                             // Introduce delay if necessary
                             errorDelay = handleExceptionWithDelay(errorDelay);
                             // re-throw
                             throw ioe;
                         } else {
              
                             break;
                         }
                     }
                     // Successful accept, reset the error delay
                     errorDelay = 0;
        
                     // Configure the socket
                     if (endpoint.isRunning() && !endpoint.isPaused()) {
              
                         // setSocketOptions() will hand the socket off to
                         // an appropriate processor if successful
                         if (!endpoint.setSocketOptions(socket)) {
              
                             endpoint.closeSocket(socket);
                         }
                     } else {
              
                         endpoint.destroySocket(socket);
                     }
                 } catch (Throwable t) {
              
                     ExceptionUtils.handleThrowable(t);
                     String msg = sm.getString("endpoint.accept.fail");
                     // APR specific.
                     // Could push this down but not sure it is worth the trouble.
                     if (t instanceof Error) {
              
                         Error e = (Error) t;
                         if (e.getError() == 233) {
              
                             // Not an error on HP-UX so log as a warning
                             // so it can be filtered out on that platform
                             // See bug 50273
                             log.warn(msg, t);
                         } else {
              
                             log.error(msg, t);
                         }
                     } else {
              
                             log.error(msg, t);
                     }
                 }
             }
             state = AcceptorState.ENDED;
         }
8.  `NioEndpoint#setSocketOptions()` 方法非常关键，核心步骤如下：
    
    > 1.  使用新建立的 socket 连接创建 NioChannel 对象，并将其包装到 NioSocketWrapper 对象中
    > 2.  通过 `poller.register(channel, socketWrapper)` 调用轮询器 `Poller#register()` 方法将 Channel 注册到 Selector 上，这样就能通过 Selector 实现监听连接上的读写事件
    
        protected boolean setSocketOptions(SocketChannel socket) {
              
             NioSocketWrapper socketWrapper = null;
             try {
              
                 // Allocate channel and wrapper
                 NioChannel channel = null;
                 if (nioChannels != null) {
              
                     channel = nioChannels.pop();
                 }
                 if (channel == null) {
              
                     SocketBufferHandler bufhandler = new SocketBufferHandler(
                             socketProperties.getAppReadBufSize(),
                             socketProperties.getAppWriteBufSize(),
                             socketProperties.getDirectBuffer());
                     if (isSSLEnabled()) {
              
                         channel = new SecureNioChannel(bufhandler, selectorPool, this);
                     } else {
              
                         channel = new NioChannel(bufhandler);
                     }
                 }
                 NioSocketWrapper newWrapper = new NioSocketWrapper(channel, this);
                 channel.reset(socket, newWrapper);
                 connections.put(socket, newWrapper);
                 socketWrapper = newWrapper;
        
                 // Set socket properties
                 // Disable blocking, polling will be used
                 socket.configureBlocking(false);
                 socketProperties.setProperties(socket.socket());
        
                 socketWrapper.setReadTimeout(getConnectionTimeout());
                 socketWrapper.setWriteTimeout(getConnectionTimeout());
                 socketWrapper.setKeepAliveLeft(NioEndpoint.this.getMaxKeepAliveRequests());
                 socketWrapper.setSecure(isSSLEnabled());
                 poller.register(channel, socketWrapper);
                 return true;
             } catch (Throwable t) {
              
                 ExceptionUtils.handleThrowable(t);
                 try {
              
                     log.error(sm.getString("endpoint.socketOptionsError"), t);
                 } catch (Throwable tt) {
              
                     ExceptionUtils.handleThrowable(tt);
                 }
                 if (socketWrapper == null) {
              
                     destroySocket(socket);
                 }
             }
             // Tell to close the socket if needed
             return false;
         }
9.  `Poller#register()` 的处理如下，可以看到注册并不是直接完成的，而是创建了一个 `PollerEvent` 异步任务，并将其添加到任务队列中
    
        public void register(final NioChannel socket, final NioSocketWrapper socketWrapper) {
              
                 socketWrapper.interestOps(SelectionKey.OP_READ);//this is what OP_REGISTER turns into.
                 PollerEvent r = null;
                 if (eventCache != null) {
              
                     r = eventCache.pop();
                 }
                 if (r == null) {
              
                     r = new PollerEvent(socket, OP_REGISTER);
                 } else {
              
                     r.reset(socket, OP_REGISTER);
                 }
                 addEvent(r);
             }
10. 任务队列中任务的处理其实在 `Poller#run` 方法中，可以看到轮询器的关键操作如下：
    
    > 1.  每个 while 循环周期首先调用 `Poller#events()` 方法优先处理队列中的异步任务
    > 2.  调用 `Selector#selectedKeys()` 获取有读写事件的连接，调用 `Poller#processKey()` 方法进行分发处理，这部分本文暂不深入分析
    
        public void run() {
              
                // Loop until destroy() is called
                while (true) {
              
        
                    boolean hasEvents = false;
        
                    try {
              
                        if (!close) {
              
                            hasEvents = events();
                            if (wakeupCounter.getAndSet(-1) > 0) {
              
                                // If we are here, means we have other stuff to do
                                // Do a non blocking select
                                keyCount = selector.selectNow();
                            } else {
              
                                keyCount = selector.select(selectorTimeout);
                            }
                            wakeupCounter.set(0);
                        }
                        if (close) {
              
                            events();
                            timeout(0, false);
                            try {
              
                                selector.close();
                            } catch (IOException ioe) {
              
                                log.error(sm.getString("endpoint.nio.selectorCloseFail"), ioe);
                            }
                            break;
                        }
                    } catch (Throwable x) {
              
                        ExceptionUtils.handleThrowable(x);
                        log.error(sm.getString("endpoint.nio.selectorLoopError"), x);
                        continue;
                    }
                    // Either we timed out or we woke up, process events first
                    if (keyCount == 0) {
              
                        hasEvents = (hasEvents | events());
                    }
        
                    Iterator<SelectionKey> iterator =
                        keyCount > 0 ? selector.selectedKeys().iterator() : null;
                    // Walk through the collection of ready keys and dispatch
                    // any active event.
                    while (iterator != null && iterator.hasNext()) {
              
                        SelectionKey sk = iterator.next();
                        NioSocketWrapper socketWrapper = (NioSocketWrapper) sk.attachment();
                        // Attachment may be null if another thread has called
                        // cancelledKey()
                        if (socketWrapper == null) {
              
                            iterator.remove();
                        } else {
              
                            iterator.remove();
                            processKey(sk, socketWrapper);
                        }
                    }
        
                    // Process timeouts
                    timeout(keyCount,hasEvents);
                }
        
                getStopLatch().countDown();
            }
11. `Poller#events()` 方法会遍历任务队列，取出其中的任务依次执行，也就是会调用 `PollerEvent#run()` 方法
    
        public boolean events() {
              
                boolean result = false;
        
                PollerEvent pe = null;
                for (int i = 0, size = events.size(); i < size && (pe = events.poll()) != null; i++ ) {
              
                    result = true;
                    try {
              
                        pe.run();
                        pe.reset();
                        if (running && !paused && eventCache != null) {
              
                            eventCache.push(pe);
                        }
                    } catch ( Throwable x ) {
              
                        log.error(sm.getString("endpoint.nio.pollerEventError"), x);
                    }
                }
        
                return result;
            }
12. `PollerEvent#run()` 方法如下，其处理逻辑可以分为两部分，至此 Connector 连接器的启动全部完成，可以接收网络连接进行 socket 数据读取了
    
    > 1.  对于 `OP_REGISTER` 事件类型，主要处理为将 Channel 注册到指定的 Selector 上，并为其指定事件监听位为 `SelectionKey.OP_READ`
    > 2.  对于其他事件类型，则主要进行关闭 socket、修改 Channel 的事件监听位等处理
    
        public void run() {
              
                if (interestOps == OP_REGISTER) {
              
                    try {
              
                        socket.getIOChannel().register(socket.getSocketWrapper().getPoller().getSelector(), SelectionKey.OP_READ, socket.getSocketWrapper());
                    } catch (Exception x) {
              
                        log.error(sm.getString("endpoint.nio.registerFail"), x);
                    }
                } else {
              
                    final SelectionKey key = socket.getIOChannel().keyFor(socket.getSocketWrapper().getPoller().getSelector());
                    try {
              
                        if (key == null) {
              
                            // The key was cancelled (e.g. due to socket closure)
                            // and removed from the selector while it was being
                            // processed. Count down the connections at this point
                            // since it won't have been counted down when the socket
                            // closed.
                            try {
              
                                socket.socketWrapper.close();
                            } catch (Exception ignore) {
              
                            }
                        } else {
              
                            final NioSocketWrapper socketWrapper = (NioSocketWrapper) key.attachment();
                            if (socketWrapper != null) {
              
                                // We are registering the key to start with, reset the fairness counter.
                                int ops = key.interestOps() | interestOps;
                                socketWrapper.interestOps(ops);
                                key.interestOps(ops);
                            } else {
              
                                socket.getSocketWrapper().getPoller().cancelledKey(key, socket.getSocketWrapper());
                            }
                        }
                    } catch (CancelledKeyException ckx) {
              
                        try {
              
                            socket.getSocketWrapper().getPoller().cancelledKey(key, socket.getSocketWrapper());
                        } catch (Exception ignore) {
              }
                    }
                }
            }

[Tomcat_1_-]: https://blog.csdn.net/weixin_45505313/article/details/118631533
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUwNTMxMw_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/2021071712500199.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUwNTMxMw==,size_16,color_FFFFFF,t_70#pic_center
[Tomcat_1_-Connector]: https://blog.csdn.net/weixin_45505313/article/details/118631533#2_Connector__12
[Spring WebMVC _3_-_ DeferredResult]: https://blog.csdn.net/weixin_45505313/article/details/118194918