tomcat源码解析二之整个执行流程

阳光穿透心脏的1/2处 2023-02-20 04:58 228阅读 0赞

### 没有标题 ###

*  Bootstrap
 *   *  Catalina
     *  Server
     *  Service
     *  Connector
     *  ProtocolHandler
     *  Endpoint
 *  start
 *   *  Catalina
     *  Server
     *  Service
     *  Engine
     *  Host
     *  HostConfig
     *  Context
     *  ContextConfig
     *  Wrapper
     *  Connector
     *  Protocol

整个容器架构设计,采用组合+责任链的形式,所以耦合非常低,可以非常方便的替换组件,以及通过增加新的阀,扩展某一块组件的功能.

其中每个父容器组件负责子容器组件的生命周期,所以只需要管理上层的组件就能够做到控制整个容器

每个容器的初始化增加了对配置文件的支持,在启动容器时,会通知消息发送给事件监听器,事件监听器这个时候就会加载配置文件

另外真正做事的是context容器,host只是负责配置主机地址映射而已,而wrapper是servlet在容器的映射

每个连接器可以设置多个,且共享同一个容器,也就是说每个连接器可以支持不同的请求协议实现,如http,tcp甚至rmi均可

特别是用service封装了最上层容器以及连接器组件,每个service又被server封装,

server只需要调用service的生命周期方法,就能够做到完美的控制整个系统

不说了开干

[源码下载][Link 1]

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

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

# Bootstrap #

初次加载

static {
        
            //分别将catalinaHomeFile和catalinaBaseFile将文件路径解析为与操作系统相关的唯一的规范形式的字符串
    
            // Will always be non-null  E:\workspace\my\spring\tomcatParse
            String userDir = System.getProperty("user.dir");
    
            // Home first  获取catalina.home目录,在执行vm配置,我这里是E:/workspace/my/spring/tomcatParse/home
            String home = System.getProperty(Globals.CATALINA_HOME_PROP);
            //E:\workspace\my\spring\tomcatParse\home
            File homeFile = null;
    
            if (home != null) {
        
                File f = new File(home);
                try {
        
                    homeFile = f.getCanonicalFile();
                } catch (IOException ioe) {
        
                    homeFile = f.getAbsoluteFile();
                }
            }
    
            if (homeFile == null) {
        
                // First fall-back. See if current directory is a bin directory
                // in a normal Tomcat install
                File bootstrapJar = new File(userDir, "bootstrap.jar");
    
                if (bootstrapJar.exists()) {
        
                    File f = new File(userDir, "..");
                    try {
        
                        homeFile = f.getCanonicalFile();
                    } catch (IOException ioe) {
        
                        homeFile = f.getAbsoluteFile();
                    }
                }
            }
    
            if (homeFile == null) {
        
                // Second fall-back. Use current directory
                File f = new File(userDir);
                try {
        
                    homeFile = f.getCanonicalFile();
                } catch (IOException ioe) {
        
                    homeFile = f.getAbsoluteFile();
                }
            }
    
            //设置catalina.home=E:\workspace\my\spring\tomcatParse\home
            catalinaHomeFile = homeFile;
            System.setProperty(
                    Globals.CATALINA_HOME_PROP, catalinaHomeFile.getPath()); 
    
            // Then base
            String base = System.getProperty(Globals.CATALINA_BASE_PROP);
            if (base == null) {
        
                catalinaBaseFile = catalinaHomeFile;
            } else {
        
                File baseFile = new File(base);
                try {
        
                    baseFile = baseFile.getCanonicalFile();
                } catch (IOException ioe) {
        
                    baseFile = baseFile.getAbsoluteFile();
                }
                catalinaBaseFile = baseFile;
            }
            System.setProperty(
                    Globals.CATALINA_BASE_PROP, catalinaBaseFile.getPath());
        }

public static void main(String args[]) {
        
    
            synchronized (daemonLock) {
        
                if (daemon == null) {
        
                    // Don't set daemon until init() has completed
                    Bootstrap bootstrap = new Bootstrap();
                    try {
        
                        //初始化,创建3个加载器,已经设置默认加载器为sharedLoader
                        bootstrap.init();
                    } catch (Throwable t) {
        
                        handleThrowable(t);
                        t.printStackTrace();
                        return;
                    }
                    daemon = bootstrap;
                } else {
        
                    // When running as a service the call to stop will be on a new
                    // thread so make sure the correct class loader is used to
                    // prevent a range of class not found exceptions.
                    Thread.currentThread().setContextClassLoader(daemon.catalinaLoader);
                }
            }
    
            try {
        
                //默认执行start指令
                String command = "start";
                if (args.length > 0) {
        
                    command = args[args.length - 1];
                }
    
                if (command.equals("startd")) {
        
                    args[args.length - 1] = "start";
                    daemon.load(args);
                    daemon.start();
                } else if (command.equals("stopd")) {
        
                    args[args.length - 1] = "stop";
                    daemon.stop();
                } else if (command.equals("start")) {
        
                    //Catalina.await()
                    daemon.setAwait(true);
                    //Catalina.load()
                    daemon.load(args);
                    //Catalina.start()
                    daemon.start();
                    if (null == daemon.getServer()) {
        
                        System.exit(1);
                    }
                } else if (command.equals("stop")) {
        
                    daemon.stopServer(args);
                } else if (command.equals("configtest")) {
        
                    daemon.load(args);
                    if (null == daemon.getServer()) {
        
                        System.exit(1);
                    }
                    System.exit(0);
                } else {
        
                    log.warn("Bootstrap: command \"" + command + "\" does not exist.");
                }
            } catch (Throwable t) {
        
                // Unwrap the Exception for clearer error reporting
                if (t instanceof InvocationTargetException &&
                        t.getCause() != null) {
        
                    t = t.getCause();
                }
                handleThrowable(t);
                t.printStackTrace();
                System.exit(1);
            }
        }

初始化类加载器

public void init() throws Exception {
        
    
            //分别创建三个类加载器
            initClassLoaders();
    
            //将catalinaLoader绑定当前线程
            Thread.currentThread().setContextClassLoader(catalinaLoader);
    
            SecurityClassLoad.securityClassLoad(catalinaLoader);
    
            // Load our startup class and call its process() method
            //使用catalinaLoader加载器创建Catalina对象
            if (log.isDebugEnabled())
                log.debug("Loading startup class");
            Class<?> startupClass = catalinaLoader.loadClass("org.apache.catalina.startup.Catalina");
            Object startupInstance = startupClass.getConstructor().newInstance();
    
            // Set the shared extensions class loader
    
            //设置Catalina的父类加载器为sharedLoader
            if (log.isDebugEnabled())
                log.debug("Setting startup class properties");
            String methodName = "setParentClassLoader";
            Class<?> paramTypes[] = new Class[1];
            paramTypes[0] = Class.forName("java.lang.ClassLoader");
            Object paramValues[] = new Object[1];
            paramValues[0] = sharedLoader;
            Method method =
                startupInstance.getClass().getMethod(methodName, paramTypes);
            method.invoke(startupInstance, paramValues);
    
            catalinaDaemon = startupInstance;
        }

private void initClassLoaders() {
        
            try {
        
                //每个web应用程序和context容器相关联的每个类加载器的父类加载器都是sharedLoader
                //创建common加载器
                commonLoader = createClassLoader("common", null);
                if (commonLoader == null) {
        
                    // no config file, default to this loader - we might be in a 'single' env.
                    commonLoader = this.getClass().getClassLoader();
                }
                //创建server加载器,可以访问commonLoader加载的所有目录
                catalinaLoader = createClassLoader("server", commonLoader);
                //创建shared加载器
                sharedLoader = createClassLoader("shared", commonLoader);
            } catch (Throwable t) {
        
                handleThrowable(t);
                log.error("Class loader creation threw exception", t);
                System.exit(1);
            }
        }

## Catalina ##

public void load() {
        
            /*
            解析server.xml
            初始化server
             */
            if (loaded) {
        
                return;
            }
            //标机正在加载
            loaded = true;
    
            long t1 = System.nanoTime();
    
            initDirs();
    
            // Before digester - it may be needed
            initNaming();
    
            // Create and execute our Digester
            //创建Digester解析xml
            Digester digester = createStartDigester();
    
            InputSource inputSource = null;
            InputStream inputStream = null;
            File file = null;
            try {
        
                try {
        
                    //E:\workspace\my\spring\tomcatParse\home\conf\server.xml
                    file = configFile();
                    inputStream = new FileInputStream(file);
                    //file:/E:/workspace/my/spring/tomcatParse/home/conf/server.xml
                    inputSource = new InputSource(file.toURI().toURL().toString());
                } catch (Exception e) {
        
                    if (log.isDebugEnabled()) {
        
                        log.debug(sm.getString("catalina.configFail", file), e);
                    }
                }
                if (inputStream == null) {
        
                    try {
        
                        inputStream = getClass().getClassLoader()
                            .getResourceAsStream(getConfigFile());
                        inputSource = new InputSource
                            (getClass().getClassLoader()
                             .getResource(getConfigFile()).toString());
                    } catch (Exception e) {
        
                        if (log.isDebugEnabled()) {
        
                            log.debug(sm.getString("catalina.configFail",
                                    getConfigFile()), e);
                        }
                    }
                }
    
                // This should be included in catalina.jar
                // Alternative: don't bother with xml, just create it manually.
                if (inputStream == null) {
        
                    try {
        
                        inputStream = getClass().getClassLoader()
                                .getResourceAsStream("server-embed.xml");
                        inputSource = new InputSource
                        (getClass().getClassLoader()
                                .getResource("server-embed.xml").toString());
                    } catch (Exception e) {
        
                        if (log.isDebugEnabled()) {
        
                            log.debug(sm.getString("catalina.configFail",
                                    "server-embed.xml"), e);
                        }
                    }
                }
    
    
                if (inputStream == null || inputSource == null) {
        
                    if  (file == null) {
        
                        log.warn(sm.getString("catalina.configFail",
                                getConfigFile() + "] or [server-embed.xml]"));
                    } else {
        
                        log.warn(sm.getString("catalina.configFail",
                                file.getAbsolutePath()));
                        if (file.exists() && !file.canRead()) {
        
                            log.warn("Permissions incorrect, read permission is not allowed on the file.");
                        }
                    }
                    return;
                }
    
                try {
        
                    inputSource.setByteStream(inputStream);
                    //Catalina入栈顶
                    digester.push(this);
                    //解析server.xml
                    digester.parse(inputSource);
                } catch (SAXParseException spe) {
        
                    log.warn("Catalina.start using " + getConfigFile() + ": " +
                            spe.getMessage());
                    return;
                } catch (Exception e) {
        
                    log.warn("Catalina.start using " + getConfigFile() + ": " , e);
                    return;
                }
            } finally {
        
                if (inputStream != null) {
        
                    try {
        
                        inputStream.close();
                    } catch (IOException e) {
        
                        // Ignore
                    }
                }
            }
    
            //server设置catalina以及home和base路径
            getServer().setCatalina(this);
            getServer().setCatalinaHome(Bootstrap.getCatalinaHomeFile());
            getServer().setCatalinaBase(Bootstrap.getCatalinaBaseFile());
    
            // Stream redirection
            //初始化日志流
            initStreams();
    
            // Start the new server
            try {
        
                //初始化server
                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("Catalina.start", e);
                }
            }
    
            long t2 = System.nanoTime();
            if(log.isInfoEnabled()) {
        
                log.info("Initialization processed in " + ((t2 - t1) / 1000000) + " ms");
            }
        }

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<>();
            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);
            digester.setFakeAttributes(fakeAttributes);
            digester.setUseContextClassLoader(true);
    
            // Configure the actions we will be using
            //解析Server,并创建StandardServer对象
            digester.addObjectCreate("Server",
                                     "org.apache.catalina.core.StandardServer",
                                     "className");
            //设置属性,StandardServer需要提供set方法
            digester.addSetProperties("Server");
            //将server对象入栈顶,并与栈下一个对象关联
            //也就是执行栈底元素Catalina的setServer方法,并传入StandardServer对象作为方法参数
            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.addObjectCreate("Server/Listener",
                                     null, // MUST be specified in the element
                                     "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"}));
            digester.addSetNext("Server/Service/Connector",
                                "addConnector",
                                "org.apache.catalina.connector.Connector");
    
            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;
    
        }

## Server ##

@Override
        protected void initInternal() throws LifecycleException {
        
    
            super.initInternal();
    
            // 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) {
        
                //获取Catalina的类加载器,sharedLoader
                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
            //初始化所有的service
            for (Service service : services) {
        
                service.init();
            }
        }

## Service ##

@Override
        protected void initInternal() throws LifecycleException {
        
    
            super.initInternal();
    
            if (engine != null) {
        
                //初始化engine
                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) {
        
                    try {
        
                        connector.init();
                    } catch (Exception e) {
        
                        String message = sm.getString(
                                "standardService.connector.initFailed", connector);
                        log.error(message, e);
    
                        if (Boolean.getBoolean("org.apache.catalina.startup.EXIT_ON_INIT_FAILURE"))
                            throw new LifecycleException(message);
                    }
                }
            }
        }

## Connector ##

@Override
        protected void initInternal() throws LifecycleException {
        
    
            super.initInternal();
    
            // Initialize adapter
            //初始化适配器,将request和response封装成servletRequest,容器接收的类型
            adapter = new CoyoteAdapter(this);
            protocolHandler.setAdapter(adapter);
    
            // 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
                protocolHandler.init();
            } catch (Exception e) {
        
                throw new LifecycleException(
                        sm.getString("coyoteConnector.protocolHandlerInitializationFailed"), e);
            }
        }

## ProtocolHandler ##

@Override
        public void init() throws Exception {
        
            if (getLog().isInfoEnabled()) {
        
                getLog().info(sm.getString("abstractProtocolHandler.init", getName()));
            }
    
            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,用于接收客户端发送的tcp/ip
            endpoint.init();
        }

## Endpoint ##

public void init() throws Exception {
        
            if (bindOnInit) {
        
                //绑定端口和host,默认使用nio
                bind();
                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=SocketProperties,name=\"" + getName() + "\"");
                socketProperties.setObjectName(socketPropertiesOname);
                Registry.getRegistry(null, null).registerComponent(socketProperties, socketPropertiesOname, null);
    
                for (SSLHostConfig sslHostConfig : findSslHostConfigs()) {
        
                    registerJmx(sslHostConfig);
                }
            }
        }

public void bind() throws Exception {
        
    
            if (!getUseInheritedChannel()) {
        
                //创建一个新的ServerSocketChannel对象，将会返回同一个未绑定的java.net.ServerSocket关联的通道
                serverSock = ServerSocketChannel.open();
                socketProperties.setProperties(serverSock.socket());
                InetSocketAddress addr = (getAddress()!=null?new InetSocketAddress(getAddress(),getPort()):new InetSocketAddress(getPort()));
                //获取socket,可通过getChannel获取通道对象
                //监听端口
                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
    
            // Initialize thread count defaults for acceptor, poller
            if (acceptorThreadCount == 0) {
        
                // FIXME: Doesn't seem to work that well with multiple accept threads
                acceptorThreadCount = 1;
            }
            if (pollerThreadCount <= 0) {
        
                //minimum one poller thread
                pollerThreadCount = 1;
            }
            setStopLatch(new CountDownLatch(pollerThreadCount));
    
            // Initialize SSL if needed
            initialiseSsl();
    
            selectorPool.open();
        }

# start #

public void start() throws Exception {
        
            if (catalinaDaemon == null) {
        
                init();
            }
    
            Method method = catalinaDaemon.getClass().getMethod("start", (Class [])null);
            //调用catalina.start()
            method.invoke(catalinaDaemon, (Object [])null);
        }

## Catalina ##

public void start() {
        
    
            //获取server为null,则重新加载
            if (getServer() == null) {
        
                load();
            }
    
            //在此判断,依旧为null,则返回
            if (getServer() == null) {
        
                log.fatal("Cannot start server. Server instance is not configured.");
                return;
            }
    
            long t1 = System.nanoTime();
    
            // Start the new server
            try {
        
                //server.start
                getServer().start();
            } catch (LifecycleException e) {
        
                log.fatal(sm.getString("catalina.serverStartFail"), e);
                try {
        
                    getServer().destroy();
                } catch (LifecycleException e1) {
        
                    log.debug("destroy() failed for failed Server ", e1);
                }
                return;
            }
    
            long t2 = System.nanoTime();
            if(log.isInfoEnabled()) {
        
                log.info("Server startup in " + ((t2 - t1) / 1000000) + " ms");
            }
    
            // Register shutdown hook
            //是否使用钩子,当出现不正当关闭程序的时候,jvm保证调用钩子方法,关闭资源
            if (useShutdownHook) {
        
                if (shutdownHook == null) {
        
                    shutdownHook = new CatalinaShutdownHook();
                }
                Runtime.getRuntime().addShutdownHook(shutdownHook);
    
                // If JULI is being used, disable JULI's shutdown hook since
                // shutdown hooks run in parallel and log messages may be lost
                // if JULI's hook completes before the CatalinaShutdownHook()
                LogManager logManager = LogManager.getLogManager();
                if (logManager instanceof ClassLoaderLogManager) {
        
                    ((ClassLoaderLogManager) logManager).setUseShutdownHook(
                            false);
                }
            }
    
            if (await) {
        
                //开启socket监听8005端口
                await();
                stop();
            }
        }

protected class CatalinaShutdownHook extends Thread {
        
    
            @Override
            public void run() {
        
                try {
        
                    if (getServer() != null) {
        
                        Catalina.this.stop();
                    }
                } catch (Throwable ex) {
        
                    ExceptionUtils.handleThrowable(ex);
                    log.error(sm.getString("catalina.shutdownHookFail"), ex);
                } finally {
        
                    // If JULI is used, shut JULI down *after* the server shuts down
                    // so log messages aren't lost
                    LogManager logManager = LogManager.getLogManager();
                    if (logManager instanceof ClassLoaderLogManager) {
        
                        ((ClassLoaderLogManager) logManager).shutdown();
                    }
                }
            }
        }

public void stop() {
        
    
            try {
        
                // Remove the ShutdownHook first so that server.stop()
                // doesn't get invoked twice
                //移除钩子方法
                if (useShutdownHook) {
        
                    Runtime.getRuntime().removeShutdownHook(shutdownHook);
    
                    // If JULI is being used, re-enable JULI's shutdown to ensure
                    // log messages are not lost
                    LogManager logManager = LogManager.getLogManager();
                    if (logManager instanceof ClassLoaderLogManager) {
        
                        ((ClassLoaderLogManager) logManager).setUseShutdownHook(
                                true);
                    }
                }
            } catch (Throwable t) {
        
                ExceptionUtils.handleThrowable(t);
                // This will fail on JDK 1.2. Ignoring, as Tomcat can run
                // fine without the shutdown hook.
            }
    
            // Shut down the server
            try {
        
                Server s = getServer();
                LifecycleState state = s.getState();
                if (LifecycleState.STOPPING_PREP.compareTo(state) <= 0
                        && LifecycleState.DESTROYED.compareTo(state) >= 0) {
        
                    // Nothing to do. stop() was already called
                } else {
        
                    //停止并销毁
                    s.stop();
                    s.destroy();
                }
            } catch (LifecycleException e) {
        
                log.error("Catalina.stop", e);
            }
    
        }

## Server ##

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)) {
        
                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);
                //调用子类实现
                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());
            }
        }

@Override
        protected void startInternal() throws LifecycleException {
        
    
            fireLifecycleEvent(CONFIGURE_START_EVENT, null);
            setState(LifecycleState.STARTING);
    
            globalNamingResources.start();
    
            // Start our defined Services
            synchronized (servicesLock) {
        
                //开启所有service
                for (Service service : services) {
        
                    service.start();
                }
            }
        }

## Service ##

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
            //开启所有engine
            if (engine != null) {
        
                synchronized (engine) {
        
                    engine.start();
                }
            }
        
            //开启所有executor
            synchronized (executors) {
        
                for (Executor executor: executors) {
        
                    executor.start();
                }
            }
            //开启mapperListener
            mapperListener.start();
    
            // Start our defined Connectors second
            synchronized (connectorsLock) {
        
                //开启所有connector
                for (Connector connector: connectors) {
        
                    try {
        
                        // If it has already failed, don't try and start it
                        if (connector.getState() != LifecycleState.FAILED) {
        
                            connector.start();
                        }
                    } catch (Exception e) {
        
                        log.error(sm.getString(
                                "standardService.connector.startFailed",
                                connector), e);
                    }
                }
            }
        }

## Engine ##

@Override
        protected synchronized void startInternal() throws LifecycleException {
        
    
            // Log our server identification information
            if(log.isInfoEnabled())
                log.info( "Starting Servlet Engine: " + ServerInfo.getServerInfo());
    
            // Standard container startup
            super.startInternal();
        }

@Override
        protected synchronized void startInternal() throws LifecycleException {
        
    
            // Start our subordinate components, if any
            logger = null;
            getLogger();
            Cluster cluster = getClusterInternal();
            if (cluster instanceof Lifecycle) {
        
                ((Lifecycle) cluster).start();
            }
            Realm realm = getRealmInternal();
            if (realm instanceof Lifecycle) {
        
                ((Lifecycle) realm).start();
            }
    
            // Start our child containers, if any
            //获取所有子容器
            Container children[] = findChildren();
            List<Future<Void>> results = new ArrayList<>();
            for (Container child : children) {
        
                results.add(startStopExecutor.submit(new StartChild(child)));
            }
    
            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
            threadStart();
        }

## Host ##

@Override
        protected synchronized void startInternal() throws LifecycleException {
        
    
            // Set error report valve
            //添加ErrorReportValve阀
            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();
        }

## HostConfig ##

public void start() {
        
    
            if (log.isDebugEnabled())
                log.debug(sm.getString("hostConfig.start"));
    
            try {
        
                ObjectName hostON = host.getObjectName();
                oname = new ObjectName
                    (hostON.getDomain() + ":type=Deployer,host=" + host.getName());
                Registry.getRegistry(null, null).registerComponent
                    (this, oname, this.getClass().getName());
            } catch (Exception e) {
        
                log.warn(sm.getString("hostConfig.jmx.register", oname), e);
            }
    
            if (!host.getAppBaseFile().isDirectory()) {
        
                log.error(sm.getString("hostConfig.appBase", host.getName(),
                        host.getAppBaseFile().getPath()));
                host.setDeployOnStartup(false);
                host.setAutoDeploy(false);
            }
    
            if (host.getDeployOnStartup())
                //部署所有指定appBase目录下所有应用
                //默认webapps,appBase由server.xml的host配置
                deployApps();
    
        }
    
      protected void deployApps() {
        
    
            File appBase = host.getAppBaseFile();
            File configBase = host.getConfigBaseFile();
            String[] filteredAppPaths = filterAppPaths(appBase.list());
            // Deploy XML descriptors from configBase
            //部署属性描述符
            deployDescriptors(configBase, configBase.list());
            // Deploy WARs
            //部署war
            deployWARs(appBase, filteredAppPaths);
            // Deploy expanded folders
            //部署目录
            deployDirectories(appBase, filteredAppPaths);
    
        }

## Context ##

hostCofig监听到开启事件后,部署webapps目录下所有项目,然后读取每个web.xml部署项目,会走context

@Override
        protected synchronized void startInternal() throws LifecycleException {
        
    
            if(log.isDebugEnabled())
                log.debug("Starting " + getBaseName());
    
            // Send j2ee.state.starting notification
            if (this.getObjectName() != null) {
        
                Notification notification = new Notification("j2ee.state.starting",
                        this.getObjectName(), sequenceNumber.getAndIncrement());
                broadcaster.sendNotification(notification);
            }
    
            //设置configured为false
            setConfigured(false);
            boolean ok = true;
    
            // Currently this is effectively a NO-OP but needs to be called to
            // ensure the NamingResources follows the correct lifecycle
            if (namingResources != null) {
        
                namingResources.start();
            }
    
            // Post work directory
            //临时工作目录
            postWorkDirectory();
    
            // Add missing components as necessary
            if (getResources() == null) {
           // (1) Required by Loader
                if (log.isDebugEnabled())
                    log.debug("Configuring default Resources");
    
                try {
        
                    setResources(new StandardRoot(this));
                } catch (IllegalArgumentException e) {
        
                    log.error(sm.getString("standardContext.resourcesInit"), e);
                    ok = false;
                }
            }
            if (ok) {
        
                //加载/WEB-INF/classes/META-INF/resources
                resourcesStart();
            }
    
            //设置加载器
            if (getLoader() == null) {
        
                WebappLoader webappLoader = new WebappLoader();
                webappLoader.setDelegate(getDelegate());
                setLoader(webappLoader);
            }
    
            // An explicit cookie processor hasn't been specified; use the default
            if (cookieProcessor == null) {
        
                cookieProcessor = new Rfc6265CookieProcessor();
            }
    
            // Initialize character set mapper
            //初始化字符集映射器
            getCharsetMapper();
    
            // Validate required extensions
            boolean dependencyCheck = true;
            try {
        
                dependencyCheck = ExtensionValidator.validateApplication
                    (getResources(), this);
            } catch (IOException ioe) {
        
                log.error(sm.getString("standardContext.extensionValidationError"), ioe);
                dependencyCheck = false;
            }
    
            if (!dependencyCheck) {
        
                // do not make application available if dependency check fails
                ok = false;
            }
    
            // Reading the "catalina.useNaming" environment variable
            String useNamingProperty = System.getProperty("catalina.useNaming");
            if ((useNamingProperty != null)
                && (useNamingProperty.equals("false"))) {
        
                useNaming = false;
            }
    
            if (ok && isUseNaming()) {
        
                if (getNamingContextListener() == null) {
        
                    NamingContextListener ncl = new NamingContextListener();
                    ncl.setName(getNamingContextName());
                    ncl.setExceptionOnFailedWrite(getJndiExceptionOnFailedWrite());
                    addLifecycleListener(ncl);
                    setNamingContextListener(ncl);
                }
            }
    
            // Standard container startup
            if (log.isDebugEnabled())
                log.debug("Processing standard container startup");
    
    
            // Binding thread
            ClassLoader oldCCL = bindThread();
    
            try {
        
                if (ok) {
        
                    // Start our subordinate components, if any
                    //start loader,内部会设置仓库,以及资源地址
                    Loader loader = getLoader();
                    if (loader instanceof Lifecycle) {
        
                        ((Lifecycle) loader).start();
                    }
    
                    // since the loader just started, the webapp classloader is now
                    // created.
                    setClassLoaderProperty("clearReferencesRmiTargets",
                            getClearReferencesRmiTargets());
                    setClassLoaderProperty("clearReferencesStopThreads",
                            getClearReferencesStopThreads());
                    setClassLoaderProperty("clearReferencesStopTimerThreads",
                            getClearReferencesStopTimerThreads());
                    setClassLoaderProperty("clearReferencesHttpClientKeepAliveThread",
                            getClearReferencesHttpClientKeepAliveThread());
                    setClassLoaderProperty("clearReferencesObjectStreamClassCaches",
                            getClearReferencesObjectStreamClassCaches());
                    setClassLoaderProperty("clearReferencesThreadLocals",
                            getClearReferencesThreadLocals());
    
                    // By calling unbindThread and bindThread in a row, we setup the
                    // current Thread CCL to be the webapp classloader
                    unbindThread(oldCCL);
                    oldCCL = bindThread();
    
                    // Initialize logger again. Other components might have used it
                    // too early, so it should be reset.
                    logger = null;
                    getLogger();
    
                    Realm realm = getRealmInternal();
                    if(null != realm) {
        
                        if (realm instanceof Lifecycle) {
        
                            ((Lifecycle) realm).start();
                        }
    
                        // Place the CredentialHandler into the ServletContext so
                        // applications can have access to it. Wrap it in a "safe"
                        // handler so application's can't modify it.
                        CredentialHandler safeHandler = new CredentialHandler() {
        
                            @Override
                            public boolean matches(String inputCredentials, String storedCredentials) {
        
                                return getRealmInternal().getCredentialHandler().matches(inputCredentials, storedCredentials);
                            }
    
                            @Override
                            public String mutate(String inputCredentials) {
        
                                return getRealmInternal().getCredentialHandler().mutate(inputCredentials);
                            }
                        };
                        context.setAttribute(Globals.CREDENTIAL_HANDLER, safeHandler);
                    }
    
                    // Notify our interested LifecycleListeners
                    //ContextConfig监听后,会执行configureStart方法,内部加载配置项,成功则设置configured为true,标记加载配置成功
                    fireLifecycleEvent(Lifecycle.CONFIGURE_START_EVENT, null);
    
                    // Start our child containers, if not already started
                    //启动子容器
                    for (Container child : findChildren()) {
        
                        if (!child.getState().isAvailable()) {
        
                            child.start();
                        }
                    }
    
                    // Start the Valves in our pipeline (including the basic),
                    // if any
                    //启动管道
                    if (pipeline instanceof Lifecycle) {
        
                        ((Lifecycle) pipeline).start();
                    }
    
                    // Acquire clustered manager
    
                    Manager contextManager = null;
                    Manager manager = getManager();
                    if (manager == null) {
        
                        if (log.isDebugEnabled()) {
        
                            log.debug(sm.getString("standardContext.cluster.noManager",
                                    Boolean.valueOf((getCluster() != null)),
                                    Boolean.valueOf(distributable)));
                        }
                        if ((getCluster() != null) && distributable) {
        
                            try {
        
                                contextManager = getCluster().createManager(getName());
                            } catch (Exception ex) {
        
                                log.error("standardContext.clusterFail", ex);
                                ok = false;
                            }
                        } else {
        
                            contextManager = new StandardManager();
                        }
                    }
    
                    // Configure default manager if none was specified
                    if (contextManager != null) {
        
                        if (log.isDebugEnabled()) {
        
                            log.debug(sm.getString("standardContext.manager",
                                    contextManager.getClass().getName()));
                        }
                        setManager(contextManager);
                    }
    
                    //session广播支持
                    if (manager!=null && (getCluster() != null) && distributable) {
        
                        //let the cluster know that there is a context that is distributable
                        //and that it has its own manager
                        getCluster().registerManager(manager);
                    }
                }
    
                if (!getConfigured()) {
        
                    log.error(sm.getString("standardContext.configurationFail"));
                    ok = false;
                }
    
                // We put the resources into the servlet context
                if (ok) {
        
                    getServletContext().setAttribute
                        (Globals.RESOURCES_ATTR, getResources());
    
                    if (getInstanceManager() == null) {
        
                        javax.naming.Context context = null;
                        if (isUseNaming() && getNamingContextListener() != null) {
        
                            context = getNamingContextListener().getEnvContext();
                        }
                        Map<String, Map<String, String>> injectionMap = buildInjectionMap(
                                getIgnoreAnnotations() ? new NamingResourcesImpl(): getNamingResources());
                        setInstanceManager(new DefaultInstanceManager(context,
                                injectionMap, this, this.getClass().getClassLoader()));
                    }
                    getServletContext().setAttribute(
                            InstanceManager.class.getName(), getInstanceManager());
                    InstanceManagerBindings.bind(getLoader().getClassLoader(), getInstanceManager());
    
                    // Create context attributes that will be required
                    getServletContext().setAttribute(
                            JarScanner.class.getName(), getJarScanner());
    
                    // Make the version info available
                    getServletContext().setAttribute(Globals.WEBAPP_VERSION, getWebappVersion());
                }
    
                // Set up the context init params
                mergeParameters();
    
                // Call ServletContainerInitializers
                for (Map.Entry<ServletContainerInitializer, Set<Class<?>>> entry :
                    initializers.entrySet()) {
        
                    try {
        
                        entry.getKey().onStartup(entry.getValue(),
                                getServletContext());
                    } catch (ServletException e) {
        
                        log.error(sm.getString("standardContext.sciFail"), e);
                        ok = false;
                        break;
                    }
                }
    
                // Configure and call application event listeners
                if (ok) {
        
                    if (!listenerStart()) {
        
                        log.error(sm.getString("standardContext.listenerFail"));
                        ok = false;
                    }
                }
    
                // Check constraints for uncovered HTTP methods
                // Needs to be after SCIs and listeners as they may programmatically
                // change constraints
                if (ok) {
        
                    checkConstraintsForUncoveredMethods(findConstraints());
                }
    
                try {
        
                    // Start manager
                    //启动session管理器
                    Manager manager = getManager();
                    if (manager instanceof Lifecycle) {
        
                        ((Lifecycle) manager).start();
                    }
                } catch(Exception e) {
        
                    log.error(sm.getString("standardContext.managerFail"), e);
                    ok = false;
                }
    
                // Configure and call application filters
                if (ok) {
        
                    if (!filterStart()) {
        
                        log.error(sm.getString("standardContext.filterFail"));
                        ok = false;
                    }
                }
    
                // Load and initialize all "load on startup" servlets
                if (ok) {
        
                    if (!loadOnStartup(findChildren())){
        
                        log.error(sm.getString("standardContext.servletFail"));
                        ok = false;
                    }
                }
    
                // Start ContainerBackgroundProcessor thread
                super.threadStart();
            } finally {
        
                // Unbinding thread
                unbindThread(oldCCL);
            }
    
            // Set available status depending upon startup success
            if (ok) {
        
                if (log.isDebugEnabled())
                    log.debug("Starting completed");
            } else {
        
                log.error(sm.getString("standardContext.startFailed", getName()));
            }
    
            startTime=System.currentTimeMillis();
    
            // Send j2ee.state.running notification
            if (ok && (this.getObjectName() != null)) {
        
                Notification notification =
                    new Notification("j2ee.state.running", this.getObjectName(),
                                     sequenceNumber.getAndIncrement());
                broadcaster.sendNotification(notification);
            }
    
            // The WebResources implementation caches references to JAR files. On
            // some platforms these references may lock the JAR files. Since web
            // application start is likely to have read from lots of JARs, trigger
            // a clean-up now.
            //释放资源
            getResources().gc();
    
            // Reinitializing if something went wrong
            if (!ok) {
        
                setState(LifecycleState.FAILED);
                // Send j2ee.object.failed notification
                if (this.getObjectName() != null) {
        
                    Notification notification = new Notification("j2ee.object.failed",
                            this.getObjectName(), sequenceNumber.getAndIncrement());
                    broadcaster.sendNotification(notification);
                }
            } else {
        
                setState(LifecycleState.STARTING);
            }
        }

## ContextConfig ##

当context发送CONFIGURE\_START\_EVENT类型事件会加载web.xml从而生成wrapper对象(每个warpper对应一个servlet)

protected synchronized void configureStart() {
        
            // Called from StandardContext.start()
    
            if (log.isDebugEnabled()) {
        
                log.debug(sm.getString("contextConfig.start"));
            }
    
            if (log.isDebugEnabled()) {
        
                log.debug(sm.getString("contextConfig.xmlSettings",
                        context.getName(),
                        Boolean.valueOf(context.getXmlValidation()),
                        Boolean.valueOf(context.getXmlNamespaceAware())));
            }
            //加载web.xml配置文件
            webConfig();
            //
            context.addServletContainerInitializer(new JasperInitializer(),null);
    
            if (!context.getIgnoreAnnotations()) {
        
                applicationAnnotationsConfig();
            }
            if (ok) {
        
                validateSecurityRoles();
            }
    
            // Configure an authenticator if we need one
            if (ok) {
        
                authenticatorConfig();
            }
    
            // Dump the contents of this pipeline if requested
            if (log.isDebugEnabled()) {
        
                log.debug("Pipeline Configuration:");
                Pipeline pipeline = context.getPipeline();
                Valve valves[] = null;
                if (pipeline != null) {
        
                    valves = pipeline.getValves();
                }
                if (valves != null) {
        
                    for (Valve valve : valves) {
        
                        log.debug("  " + valve.getClass().getName());
                    }
                }
                log.debug("======================");
            }
    
            // Make our application available if no problems were encountered
            if (ok) {
        
                context.setConfigured(true);
            } else {
        
                log.error(sm.getString("contextConfig.unavailable"));
                context.setConfigured(false);
            }
    
        }

protected void webConfig() {
        
            /*
             * Anything and everything can override the global and host defaults.
             * This is implemented in two parts
             * - Handle as a web fragment that gets added after everything else so
             *   everything else takes priority
             * - Mark Servlets as overridable so SCI configuration can replace
             *   configuration from the defaults
             */
    
            /*
             * The rules for annotation scanning are not as clear-cut as one might
             * think. Tomcat implements the following process:
             * - As per SRV.1.6.2, Tomcat will scan for annotations regardless of
             *   which Servlet spec version is declared in web.xml. The EG has
             *   confirmed this is the expected behaviour.
             * - As per http://java.net/jira/browse/SERVLET_SPEC-36, if the main
             *   web.xml is marked as metadata-complete, JARs are still processed
             *   for SCIs.
             * - If metadata-complete=true and an absolute ordering is specified,
             *   JARs excluded from the ordering are also excluded from the SCI
             *   processing.
             * - If an SCI has a @HandlesType annotation then all classes (except
             *   those in JARs excluded from an absolute ordering) need to be
             *   scanned to check if they match.
             */
            WebXmlParser webXmlParser = new WebXmlParser(context.getXmlNamespaceAware(),
                    context.getXmlValidation(), context.getXmlBlockExternal());
    
            Set<WebXml> defaults = new HashSet<>();
            defaults.add(getDefaultWebXmlFragment(webXmlParser));
    
            WebXml webXml = createWebXml();
    
            // Parse context level web.xml
            //解析web.xml
            InputSource contextWebXml = getContextWebXmlSource();
            if (!webXmlParser.parseWebXml(contextWebXml, webXml, false)) {
        
                ok = false;
            }
    
            ServletContext sContext = context.getServletContext();
    
            // Ordering is important here
    
            // Step 1. Identify all the JARs packaged with the application and those
            // provided by the container. If any of the application JARs have a
            // web-fragment.xml it will be parsed at this point. web-fragment.xml
            // files are ignored for container provided JARs.
            Map<String,WebXml> fragments = processJarsForWebFragments(webXml, webXmlParser);
    
            // Step 2. Order the fragments.
            Set<WebXml> orderedFragments = null;
            orderedFragments =
                    WebXml.orderWebFragments(webXml, fragments, sContext);
    
            // Step 3. Look for ServletContainerInitializer implementations
            if (ok) {
        
                processServletContainerInitializers();
            }
    
            if  (!webXml.isMetadataComplete() || typeInitializerMap.size() > 0) {
        
                // Steps 4 & 5.
                processClasses(webXml, orderedFragments);
            }
    
            if (!webXml.isMetadataComplete()) {
        
                // Step 6. Merge web-fragment.xml files into the main web.xml
                // file.
                if (ok) {
        
                    ok = webXml.merge(orderedFragments);
                }
    
                // Step 7. Apply global defaults
                // Have to merge defaults before JSP conversion since defaults
                // provide JSP servlet definition.
                webXml.merge(defaults);
    
                // Step 8. Convert explicitly mentioned jsps to servlets
                if (ok) {
        
                    convertJsps(webXml);
                }
    
                // Step 9. Apply merged web.xml to Context
                if (ok) {
        
                    configureContext(webXml);
                }
            } else {
        
                webXml.merge(defaults);
                convertJsps(webXml);
                configureContext(webXml);
            }
    
            if (context.getLogEffectiveWebXml()) {
        
                log.info("web.xml:\n" + webXml.toXml());
            }
    
            // Always need to look for static resources
            // Step 10. Look for static resources packaged in JARs
            if (ok) {
        
                // Spec does not define an order.
                // Use ordered JARs followed by remaining JARs
                Set<WebXml> resourceJars = new LinkedHashSet<>(orderedFragments);
                for (WebXml fragment : fragments.values()) {
        
                    if (!resourceJars.contains(fragment)) {
        
                        resourceJars.add(fragment);
                    }
                }
                processResourceJARs(resourceJars);
                // See also StandardContext.resourcesStart() for
                // WEB-INF/classes/META-INF/resources configuration
            }
    
            // Step 11. Apply the ServletContainerInitializer config to the
            // context
            if (ok) {
        
                for (Map.Entry<ServletContainerInitializer,
                        Set<Class<?>>> entry :
                            initializerClassMap.entrySet()) {
        
                    if (entry.getValue().isEmpty()) {
        
                        context.addServletContainerInitializer(
                                entry.getKey(), null);
                    } else {
        
                        context.addServletContainerInitializer(
                                entry.getKey(), entry.getValue());
                    }
                }
            }
        }

## Wrapper ##

@Override
        protected synchronized void startInternal() throws LifecycleException {
        
    
            // Send j2ee.state.starting notification
            if (this.getObjectName() != null) {
        
                Notification notification = new Notification("j2ee.state.starting",
                                                            this.getObjectName(),
                                                            sequenceNumber++);
                broadcaster.sendNotification(notification);
            }
    
            // Start up this component
            super.startInternal();
    
            setAvailable(0L);
    
            // Send j2ee.state.running notification
            if (this.getObjectName() != null) {
        
                Notification notification =
                    new Notification("j2ee.state.running", this.getObjectName(),
                                    sequenceNumber++);
                broadcaster.sendNotification(notification);
            }
    
        }

## Connector ##

@Override
        protected void startInternal() throws LifecycleException {
        
    
            // Validate settings before starting
            if (getPort() < 0) {
        
                throw new LifecycleException(sm.getString(
                        "coyoteConnector.invalidPort", Integer.valueOf(getPort())));
            }
    
            setState(LifecycleState.STARTING);
    
            try {
        
                //开启protocolHandler
                protocolHandler.start();
            } catch (Exception e) {
        
                throw new LifecycleException(
                        sm.getString("coyoteConnector.protocolHandlerStartFailed"), e);
            }
        }

## Protocol ##

@Override
        public void start() throws Exception {
        
            if (getLog().isInfoEnabled()) {
        
                getLog().info(sm.getString("abstractProtocolHandler.start", getName()));
            }
    
            //enpoint开启
            endpoint.start();
    
            // Start timeout thread
            //新开守护线程监控超时
            asyncTimeout = new AsyncTimeout();
            Thread timeoutThread = new Thread(asyncTimeout, getNameInternal() + "-AsyncTimeout");
            int priority = endpoint.getThreadPriority();
            if (priority < Thread.MIN_PRIORITY || priority > Thread.MAX_PRIORITY) {
        
                priority = Thread.NORM_PRIORITY;
            }
            timeoutThread.setPriority(priority);
            timeoutThread.setDaemon(true); 
            timeoutThread.start();
        }

[Link 1]: https://mirror.bit.edu.cn/apache/tomcat/tomcat-8/v8.5.56/src/apache-tomcat-8.5.56-src.zip
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200623152557798.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/2020062315274554.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw==,size_16,color_FFFFFF,t_70