Tomcat 9.0 源码分析(3)-容器 Container 的启动

ゝ一世哀愁。 2023-10-03 11:43 11阅读 0赞

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

*  1. 容器 Container 的启动流程
 *  2. 源码分析
 *   *   *  2.1 顶级容器 Engine 的创建及初始化
         *  2.2 容器的启动
         *  2.3 web 应用的加载

## 1. 容器 Container 的启动流程 ##

在 [Tomcat源码分析(1)-结构组成与核心组件][Tomcat_1_-] 中笔者分析了 Tomcat 的大致组成，Container 容器是和上层业务逻辑强相关的核心组件，并且划分为了 4 个层级。在 Tomcat 的启动过程中，Container 容器和 Connector 连接器的启动流程基本一致，不过因为 Container 容器分为 4 层，且一个 Tomcat 服务器是可以加载多个 web 应用的，所以应用层级的容器创建会被推迟，流程大致如下：

> 1.  解析配置文件，创建顶级 Container 容器对象 Engine 并初始化
> 2.  启动顶层容器，完成环境构建
> 3.  加载 web 应用，完成应用级别容器创建及启动，将 servlet 加载进容器中

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

## 2. 源码分析 ##

#### 2.1 顶级容器 Engine 的创建及初始化 ####

1.  容器的创建流程其实和连接器的创建是一致的，读者可参考 [Connector 连接器对象的创建][Connector]，主要处理为解析 server.xml 文件 完成容器对象的实例创建。一般 server.xml 文件 中不会配置 Context 容器，因为 Tomcat 服务器支持自动部署，可以在 Tomcat 运行时通过定期扫描指定目录来实现动态加载 web 应用，不需要重启服务器。而server.xml 是不可动态重加载的资源，如果要修改在这个文件中配置的 web 应用，就得重启服务器才能生效。综上，在服务器初始化的过程中，通常只会创建 Engine 和 Host 两个层级的容器，我们首先来看下 Engine 容器的实现类为 `StandardEngine` 的构造方法
    
    > 可以看到，构造方法中的逻辑比较简单，值得注意的是新建了 `StandardEngineValve` 对象，并将其添加到了 `StandardEngine` 内部的 pipeline 流水线中。这是容器对象的常规操作，往后读者会看到，每个容器对象新建的时候都会创建一个默认的 `Valve` 处理器
    
        public StandardEngine() {
              
        
             super();
             pipeline.setBasic(new StandardEngineValve());
             /* Set the jmvRoute using the system property jvmRoute */
             try {
              
                 setJvmRoute(System.getProperty("jvmRoute"));
             } catch(Exception ex) {
              
                 log.warn(sm.getString("standardEngine.jvmRouteFail"));
             }
             // By default, the engine will hold the reloading thread
             backgroundProcessorDelay = 10;
        
         }
2.  Host 容器的实现类为 `StandardHost`，这个类的构造方法很简单，不作赘述。需注意创建 Host 容器时，也会创建 HostConfig 配置对象并将其添加到 Host 容器的生命周期监听器列表中，这个 HostConfig 将随着容器生命周期变化完成容器的配置
    
        public StandardHost() {
              
        
             super();
             pipeline.setBasic(new StandardHostValve());
        
         }
3.  容器对象创建完毕，接下来就是容器的初始化过程。我们知道，在 Tomcat 中一个 Service 由若干个连接器 Connector 和一个容器 Egine 组成，实际上 Service 初始化的时候会同时进行这两个组件的初始化，详细触发流程可参考 [Connector 连接器初始化][Connector 1]，直接的触发点在 `StandardService#initInternal()` 方法中，此处 `engine.init()` 实际将调用到 `StandardEngine#initInternal()`方法
    
        @Override
         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();
                 }
             }
         }
4.  `StandardEngine#initInternal()`方法暂不深入，主要是做一些容器公共组件的初始化操作，至此整个容器的初始化告一段落
    
        @Override
         protected void initInternal() throws LifecycleException {
              
             // Ensure that a Realm is present before any attempt is made to start
             // one. This will create the default NullRealm if necessary.
             getRealm();
             super.initInternal();
         }

#### 2.2 容器的启动 ####

1.  Tomcat 容器的启动过程中伴随着容器的启动，容器启动的详细触发流程参考 [Connector 连接器启动][Connector 2]，直接触发点在`StandardService#startInternal()` 方法中，此处 `engine.start()` 最终将调用到 `StandardEngine#startInternal()` 方法
    
        @Override
         protected void startInternal() throws LifecycleException {
              
        
             if(log.isInfoEnabled())
                 log.info(sm.getString("standardService.start.name", this.name));
             setState(LifecycleState.STARTING);
        
             // Start our defined Container first
             if (engine != null) {
              
                 synchronized (engine) {
              
                     engine.start();
                 }
             }
        
             synchronized (executors) {
              
                 for (Executor executor: executors) {
              
                     executor.start();
                 }
             }
        
             mapperListener.start();
        
             // Start our defined Connectors second
             synchronized (connectorsLock) {
              
                 for (Connector connector: connectors) {
              
                     // If it has already failed, don't try and start it
                     if (connector.getState() != LifecycleState.FAILED) {
              
                         connector.start();
                     }
                 }
             }
         }
2.  `StandardEngine#startInternal()` 方法比较简单，真正的重要逻辑其实封装在其父类 `ContainerBase#startInternal()` 方法
    
        protected synchronized void startInternal() throws LifecycleException {
              
        
             // Log our server identification information
             if (log.isInfoEnabled()) {
              
                 log.info(sm.getString("standardEngine.start", ServerInfo.getServerInfo()));
             }
        
             // Standard container startup
             super.startInternal();
         }
3.  `ContainerBase#startInternal()` 方法的核心如下：
    
    > 1.  首先调用容器对象自身的 `ContainerBase#findChildren()` 取得当前容器的下一级容器列表，对于 Engine 容器来说，其下一级容器 Host 在容器对象创建的过程中已经添加进来了，此处将获得 Host 容器的列表
    > 2.  将每一个子容器对象封装在 `StartChild` 异步任务中，并将异步任务投入到线程池中运行
    > 3.  异步任务处理，触发 child.start() ，此处最终将触发 `StandardHost#startInternal()` 方法
    > 4.  调用 `setState()` 方法更新容器生命周期，这个过程将回调生命周期监听器
    
        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 (int i = 0; i < children.length; i++) {
              
                 results.add(startStopExecutor.submit(new StartChild(children[i])));
             }
        
             MultiThrowable multiThrowable = null;
        
             for (Future<Void> result : results) {
              
                 try {
              
                     result.get();
                 } catch (Throwable e) {
              
                     log.error(sm.getString("containerBase.threadedStartFailed"), e);
                     if (multiThrowable == null) {
              
                         multiThrowable = new MultiThrowable();
                     }
                     multiThrowable.add(e);
                 }
        
             }
             if (multiThrowable != null) {
              
                 throw new LifecycleException(sm.getString("containerBase.threadedStartFailed"),
                         multiThrowable.getThrowable());
             }
        
             // Start the Valves in our pipeline (including the basic), if any
             if (pipeline instanceof Lifecycle) {
              
                 ((Lifecycle) pipeline).start();
             }
        
             setState(LifecycleState.STARTING);
        
             // Start our thread
             if (backgroundProcessorDelay > 0) {
              
                 monitorFuture = Container.getService(ContainerBase.this).getServer()
                         .getUtilityExecutor().scheduleWithFixedDelay(
                                 new ContainerBackgroundProcessorMonitor(), 0, 60, TimeUnit.SECONDS);
             }
         }
4.  `StandardHost#startInternal()` 方法的实现如下，主要处理如下：
    
    > 1.  首先查找处理错误报告的处理器 Valve，并将其添加到 Host 容器的 pipline 流水线中
    > 2.  `super.startInternal()` 调用父类 `ContainerBase#startInternal()` 方法
    
        protected synchronized void startInternal() throws LifecycleException {
              
        
             // Set error report valve
             String errorValve = getErrorReportValveClass();
             if ((errorValve != null) && (!errorValve.equals(""))) {
              
                 try {
              
                     boolean found = false;
                     Valve[] valves = getPipeline().getValves();
                     for (Valve valve : valves) {
              
                         if (errorValve.equals(valve.getClass().getName())) {
              
                             found = true;
                             break;
                         }
                     }
                     if(!found) {
              
                         Valve valve =
                             (Valve) Class.forName(errorValve).getConstructor().newInstance();
                         getPipeline().addValve(valve);
                     }
                 } catch (Throwable t) {
              
                     ExceptionUtils.handleThrowable(t);
                     log.error(sm.getString(
                             "standardHost.invalidErrorReportValveClass",
                             errorValve), t);
                 }
             }
             super.startInternal();
         }
5.  回到 `ContainerBase#startInternal()` 方法，此时我们关注的是容器生命周期的更新，也就是 `setState()` 方法的调用。跟踪调用链可知道，这个方法最终将调用到 `LifecycleBase#setStateInternal()` 方法
    
    > 对于继承了 `LifecycleBase` 的容器对象，其生命周期发生变化的时候都会向监听器发送事件通知，对于 Host 容器，也就会通知到 HostConfig，触发其回调方法 `HostConfig#lifecycleEvent()`
    
        private synchronized void setStateInternal(LifecycleState state, Object data, boolean check)
                 throws LifecycleException {
              
        
             if (log.isDebugEnabled()) {
              
                 log.debug(sm.getString("lifecycleBase.setState", this, state));
             }
        
             if (check) {
              
                 // Must have been triggered by one of the abstract methods (assume
                 // code in this class is correct)
                 // null is never a valid state
                 if (state == null) {
              
                     invalidTransition("null");
                     // Unreachable code - here to stop eclipse complaining about
                     // a possible NPE further down the method
                     return;
                 }
        
                 // Any method can transition to failed
                 // startInternal() permits STARTING_PREP to STARTING
                 // stopInternal() permits STOPPING_PREP to STOPPING and FAILED to
                 // STOPPING
                 if (!(state == LifecycleState.FAILED ||
                         (this.state == LifecycleState.STARTING_PREP &&
                                 state == LifecycleState.STARTING) ||
                         (this.state == LifecycleState.STOPPING_PREP &&
                                 state == LifecycleState.STOPPING) ||
                         (this.state == LifecycleState.FAILED &&
                                 state == LifecycleState.STOPPING))) {
              
                     // No other transition permitted
                     invalidTransition(state.name());
                 }
             }
        
             this.state = state;
             String lifecycleEvent = state.getLifecycleEvent();
             if (lifecycleEvent != null) {
              
                 fireLifecycleEvent(lifecycleEvent, data);
             }
         }
        
         protected void fireLifecycleEvent(String type, Object data) {
              
             LifecycleEvent event = new LifecycleEvent(this, type, data);
             for (LifecycleListener listener : lifecycleListeners) {
              
                 listener.lifecycleEvent(event);
             }
         }
6.  `HostConfig#lifecycleEvent()` 实现如下，显然对于 `Lifecycle.START_EVENT` 事件将触发 `HostConfig#start()` 方法
    
        public void lifecycleEvent(LifecycleEvent event) {
              
        
             // Identify the host we are associated with
             try {
              
                 host = (Host) event.getLifecycle();
                 if (host instanceof StandardHost) {
              
                     setCopyXML(((StandardHost) host).isCopyXML());
                     setDeployXML(((StandardHost) host).isDeployXML());
                     setUnpackWARs(((StandardHost) host).isUnpackWARs());
                     setContextClass(((StandardHost) host).getContextClass());
                 }
             } catch (ClassCastException e) {
              
                 log.error(sm.getString("hostConfig.cce", event.getLifecycle()), e);
                 return;
             }
        
             // Process the event that has occurred
             if (event.getType().equals(Lifecycle.PERIODIC_EVENT)) {
              
                 check();
             } else if (event.getType().equals(Lifecycle.BEFORE_START_EVENT)) {
              
                 beforeStart();
             } else if (event.getType().equals(Lifecycle.START_EVENT)) {
              
                 start();
             } else if (event.getType().equals(Lifecycle.STOP_EVENT)) {
              
                 stop();
             }
         }
7.  `HostConfig#start()` 方法实现如下，此处会判断 Host 的配置属性，如果是启动时部署应用则将调用 `HostConfig#deployApps()` 方法开始加载 web 应用，至此进入了 web 应用加载的流程
    
        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())
                 deployApps();
        
         }

#### 2.3 web 应用的加载 ####

1.  `HostConfig#deployApps()` 方法如下，可以看到主要操作是取得 web 应用相关目录再将其部署，本文关注 `HostConfig#deployDirectories()` 方法调用
    
        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
             deployWARs(appBase, filteredAppPaths);
             // Deploy expanded folders
             deployDirectories(appBase, filteredAppPaths);
        
         }
2.  `HostConfig#deployDirectories()` 方法的逻辑简单明了，就是扫描指定的目录下各个 web 应用的文件夹，将相关信息封装为 `DeployDirectory` 异步任务扔进线程池执行，最终将调用到 `HostConfig#deployDirectory()` 方法
    
        protected void deployDirectories(File appBase, String[] files) {
              
        
             if (files == null)
                 return;
        
             ExecutorService es = host.getStartStopExecutor();
             List<Future<?>> results = new ArrayList<>();
        
             for (int i = 0; i < files.length; i++) {
              
        
                 if (files[i].equalsIgnoreCase("META-INF"))
                     continue;
                 if (files[i].equalsIgnoreCase("WEB-INF"))
                     continue;
                 File dir = new File(appBase, files[i]);
                 if (dir.isDirectory()) {
              
                     ContextName cn = new ContextName(files[i], false);
        
                     if (isServiced(cn.getName()) || deploymentExists(cn.getName()))
                         continue;
        
                     results.add(es.submit(new DeployDirectory(this, cn, dir)));
                 }
             }
        
             for (Future<?> result : results) {
              
                 try {
              
                     result.get();
                 } catch (Exception e) {
              
                     log.error(sm.getString(
                             "hostConfig.deployDir.threaded.error"), e);
                 }
             }
         }
3.  `HostConfig#deployDirectory()` 方法实现比较长，不过关键步骤比较清晰：
    
    > 1.  首先创建 Context 容器对象，默认的 Context 实现类为 `StandardContext`
    > 2.  创建 ContextConfig 容器配置类，并将其作为容器的生命周期监听器添加到新建的 Context 容器对象中
    > 3.  `host.addChild(context)` 调用 Host 容器添加下一级容器的方法，把 Context 容器添加到 Host 容器中，此处将调用到 `StandardHost#addChild()` 方法
    
        protected void deployDirectory(ContextName cn, File dir) {
              
        
        
             long startTime = 0;
             // Deploy the application in this directory
             if( log.isInfoEnabled() ) {
              
                 startTime = System.currentTimeMillis();
                 log.info(sm.getString("hostConfig.deployDir",
                         dir.getAbsolutePath()));
             }
        
             Context context = null;
             File xml = new File(dir, Constants.ApplicationContextXml);
             File xmlCopy =
                     new File(host.getConfigBaseFile(), cn.getBaseName() + ".xml");
        
        
             DeployedApplication deployedApp;
             boolean copyThisXml = isCopyXML();
             boolean deployThisXML = isDeployThisXML(dir, cn);
        
             try {
              
                 if (deployThisXML && xml.exists()) {
              
                     synchronized (digesterLock) {
              
                         try {
              
                             context = (Context) digester.parse(xml);
                         } catch (Exception e) {
              
                             log.error(sm.getString(
                                     "hostConfig.deployDescriptor.error",
                                     xml), e);
                             context = new FailedContext();
                         } finally {
              
                             digester.reset();
                             if (context == null) {
              
                                 context = new FailedContext();
                             }
                         }
                     }
        
                     if (copyThisXml == false && context instanceof StandardContext) {
              
                         // Host is using default value. Context may override it.
                         copyThisXml = ((StandardContext) context).getCopyXML();
                     }
        
                     if (copyThisXml) {
              
                         Files.copy(xml.toPath(), xmlCopy.toPath());
                         context.setConfigFile(xmlCopy.toURI().toURL());
                     } else {
              
                         context.setConfigFile(xml.toURI().toURL());
                     }
                 } else if (!deployThisXML && xml.exists()) {
              
                     // Block deployment as META-INF/context.xml may contain security
                     // configuration necessary for a secure deployment.
                     log.error(sm.getString("hostConfig.deployDescriptor.blocked",
                             cn.getPath(), xml, xmlCopy));
                     context = new FailedContext();
                 } else {
              
                     context = (Context) Class.forName(contextClass).getConstructor().newInstance();
                 }
        
                 Class<?> clazz = Class.forName(host.getConfigClass());
                 LifecycleListener listener = (LifecycleListener) clazz.getConstructor().newInstance();
                 context.addLifecycleListener(listener);
        
                 context.setName(cn.getName());
                 context.setPath(cn.getPath());
                 context.setWebappVersion(cn.getVersion());
                 context.setDocBase(cn.getBaseName());
                 host.addChild(context);
             } catch (Throwable t) {
              
                 ExceptionUtils.handleThrowable(t);
                 log.error(sm.getString("hostConfig.deployDir.error",
                         dir.getAbsolutePath()), t);
             } finally {
              
                 
                 ......
         }
4.  `StandardHost#addChild()` 方法如下，比较关键的步骤还是 `super.addChild()` 调用父类方法，最终将触发执行 `ContainerBase#addChildInternal()` 方法
    
        public void addChild(Container child) {
              
        
             if (!(child instanceof Context))
                 throw new IllegalArgumentException
                     (sm.getString("standardHost.notContext"));
        
             child.addLifecycleListener(new MemoryLeakTrackingListener());
        
             // Avoid NPE for case where Context is defined in server.xml with only a
             // docBase
             Context context = (Context) child;
             if (context.getPath() == null) {
              
                 ContextName cn = new ContextName(context.getDocBase(), true);
                 context.setPath(cn.getPath());
             }
        
             super.addChild(child);
        
         }
5.  `ContainerBase#addChildInternal()` 方法的关键步骤是在将下一级容器添加到内部列表中后，会通过`child.start()`去调用下一级容器的启动方法，也就是说，此处会触发 `StandardContext#start()` 方法，最终调用到 `StandardContext#startInternal()` 方法
    
        private void addChildInternal(Container child) {
              
        
             if (log.isDebugEnabled()) {
              
                 log.debug("Add child " + child + " " + this);
             }
        
             synchronized(children) {
              
                 if (children.get(child.getName()) != null)
                     throw new IllegalArgumentException(
                             sm.getString("containerBase.child.notUnique", child.getName()));
                 child.setParent(this);  // May throw IAE
                 children.put(child.getName(), child);
             }
        
             fireContainerEvent(ADD_CHILD_EVENT, child);
        
             // Start child
             // Don't do this inside sync block - start can be a slow process and
             // locking the children object can cause problems elsewhere
             try {
              
                 if ((getState().isAvailable() ||
                         LifecycleState.STARTING_PREP.equals(getState())) &&
                         startChildren) {
              
                     child.start();
                 }
             } catch (LifecycleException e) {
              
                 throw new IllegalStateException(sm.getString("containerBase.child.start"), e);
             }
         }
6.  `StandardContext#startInternal()` 方法体非常长，主要是为 Context 容器配置各项属性，本文的关注点主要在最后的 `setState()` 方法调用
    
        protected synchronized void startInternal() throws LifecycleException {
              
        
             ......
        
             // Reinitializing if something went wrong
             if (!ok) {
              
                 setState(LifecycleState.FAILED);
             } else {
              
                 setState(LifecycleState.STARTING);
             }
         }
7.  此处与 本节步骤5 流程完全一致，最终将调用到 `ContextConfig#lifecycleEvent()`方法。可以看到对应于不同的事件有不同的处理方法，此处将触发 `ContextConfig#configureStart()`方法来配置容器
    
        public void lifecycleEvent(LifecycleEvent event) {
              
        
             // Identify the context we are associated with
             try {
              
                 context = (Context) event.getLifecycle();
             } catch (ClassCastException e) {
              
                 log.error(sm.getString("contextConfig.cce", event.getLifecycle()), e);
                 return;
             }
        
             // Process the event that has occurred
             if (event.getType().equals(Lifecycle.CONFIGURE_START_EVENT)) {
              
                 configureStart();
             } else if (event.getType().equals(Lifecycle.BEFORE_START_EVENT)) {
              
                 beforeStart();
             } else if (event.getType().equals(Lifecycle.AFTER_START_EVENT)) {
              
                 // Restore docBase for management tools
                 if (originalDocBase != null) {
              
                     context.setDocBase(originalDocBase);
                 }
             } else if (event.getType().equals(Lifecycle.CONFIGURE_STOP_EVENT)) {
              
                 configureStop();
             } else if (event.getType().equals(Lifecycle.AFTER_INIT_EVENT)) {
              
                 init();
             } else if (event.getType().equals(Lifecycle.AFTER_DESTROY_EVENT)) {
              
                 destroy();
             }
        
         }
8.  `ContextConfig#configureStart()`方法的核心是调用 `ContextConfig#webConfig()`方法进入 web 应用的配置
    
        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())));
             }
        
             webConfig();
        
             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 (int i = 0; i < valves.length; i++) {
              
                         log.debug("  " + valves[i].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);
             }
        
         }
9.  `ContextConfig#webConfig()`方法源码较长，比较重要的步骤如下：
    
    > 1.  解析当前 web 应用的 web.xml 文件，对配置的组件进行处理
    > 2.  调用 `ContextConfig#configureContext()` 方法完成 web 应用的配置，主要是 servlet 的创建等
    
        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));
        
             Set<WebXml> tomcatWebXml = new HashSet<>();
             tomcatWebXml.add(getTomcatWebXmlFragment(webXmlParser));
        
             WebXml webXml = createWebXml();
        
             // Parse context level 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 7a
                 // merge tomcat-web.xml
                 webXml.merge(tomcatWebXml);
        
                 // Step 7b. 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(tomcatWebXml);
                 webXml.merge(defaults);
                 convertJsps(webXml);
                 configureContext(webXml);
             }
        
             ......
        
         }
10. `ContextConfig#configureContext()` 方法是配置 web 应用的核心，其关键处理如下：
    
    > 1.  配置 Context 的各项重要属性
    > 2.  将 web.xml 文件配置的 servlet 封装到 Wrapper 容器中， Wrapper 容器默认实现类为 `StandardWrapper`
    > 3.  `context.addChild(wrapper)` 将 Wrapper 容器添加到 Context 容器中并启动，至此 web 应用加载主要流程基本结束
    
        private void configureContext(WebXml webxml) {
              
           // As far as possible, process in alphabetical order so it is easy to
           // check everything is present
           // Some validation depends on correct public ID
           context.setPublicId(webxml.getPublicId());
        
           // Everything else in order
           context.setEffectiveMajorVersion(webxml.getMajorVersion());
           context.setEffectiveMinorVersion(webxml.getMinorVersion());
        
           for (Entry<String, String> entry : webxml.getContextParams().entrySet()) {
              
               context.addParameter(entry.getKey(), entry.getValue());
           }
           context.setDenyUncoveredHttpMethods(
                   webxml.getDenyUncoveredHttpMethods());
           context.setDisplayName(webxml.getDisplayName());
           context.setDistributable(webxml.isDistributable());
           for (ContextLocalEjb ejbLocalRef : webxml.getEjbLocalRefs().values()) {
              
               context.getNamingResources().addLocalEjb(ejbLocalRef);
           }
           for (ContextEjb ejbRef : webxml.getEjbRefs().values()) {
              
               context.getNamingResources().addEjb(ejbRef);
           }
           for (ContextEnvironment environment : webxml.getEnvEntries().values()) {
              
               context.getNamingResources().addEnvironment(environment);
           }
           for (ErrorPage errorPage : webxml.getErrorPages().values()) {
              
               context.addErrorPage(errorPage);
           }
           for (FilterDef filter : webxml.getFilters().values()) {
              
               if (filter.getAsyncSupported() == null) {
              
                   filter.setAsyncSupported("false");
               }
               context.addFilterDef(filter);
           }
           for (FilterMap filterMap : webxml.getFilterMappings()) {
              
               context.addFilterMap(filterMap);
           }
           context.setJspConfigDescriptor(webxml.getJspConfigDescriptor());
           for (String listener : webxml.getListeners()) {
              
               context.addApplicationListener(listener);
           }
           for (Entry<String, String> entry :
                   webxml.getLocaleEncodingMappings().entrySet()) {
              
               context.addLocaleEncodingMappingParameter(entry.getKey(),
                       entry.getValue());
           }
           // Prevents IAE
           if (webxml.getLoginConfig() != null) {
              
               context.setLoginConfig(webxml.getLoginConfig());
           }
           for (MessageDestinationRef mdr :
                   webxml.getMessageDestinationRefs().values()) {
              
               context.getNamingResources().addMessageDestinationRef(mdr);
           }
        
           // messageDestinations were ignored in Tomcat 6, so ignore here
        
           context.setIgnoreAnnotations(webxml.isMetadataComplete());
           for (Entry<String, String> entry :
                   webxml.getMimeMappings().entrySet()) {
              
               context.addMimeMapping(entry.getKey(), entry.getValue());
           }
           context.setRequestCharacterEncoding(webxml.getRequestCharacterEncoding());
           // Name is just used for ordering
           for (ContextResourceEnvRef resource :
                   webxml.getResourceEnvRefs().values()) {
              
               context.getNamingResources().addResourceEnvRef(resource);
           }
           for (ContextResource resource : webxml.getResourceRefs().values()) {
              
               context.getNamingResources().addResource(resource);
           }
           context.setResponseCharacterEncoding(webxml.getResponseCharacterEncoding());
           boolean allAuthenticatedUsersIsAppRole =
                   webxml.getSecurityRoles().contains(
                           SecurityConstraint.ROLE_ALL_AUTHENTICATED_USERS);
           for (SecurityConstraint constraint : webxml.getSecurityConstraints()) {
              
               if (allAuthenticatedUsersIsAppRole) {
              
                   constraint.treatAllAuthenticatedUsersAsApplicationRole();
               }
               context.addConstraint(constraint);
           }
           for (String role : webxml.getSecurityRoles()) {
              
               context.addSecurityRole(role);
           }
           for (ContextService service : webxml.getServiceRefs().values()) {
              
               context.getNamingResources().addService(service);
           }
           for (ServletDef servlet : webxml.getServlets().values()) {
              
               Wrapper wrapper = context.createWrapper();
               // Description is ignored
               // Display name is ignored
               // Icons are ignored
        
               // jsp-file gets passed to the JSP Servlet as an init-param
        
               if (servlet.getLoadOnStartup() != null) {
              
                   wrapper.setLoadOnStartup(servlet.getLoadOnStartup().intValue());
               }
               if (servlet.getEnabled() != null) {
              
                   wrapper.setEnabled(servlet.getEnabled().booleanValue());
               }
               wrapper.setName(servlet.getServletName());
               Map<String,String> params = servlet.getParameterMap();
               for (Entry<String, String> entry : params.entrySet()) {
              
                   wrapper.addInitParameter(entry.getKey(), entry.getValue());
               }
               wrapper.setRunAs(servlet.getRunAs());
               Set<SecurityRoleRef> roleRefs = servlet.getSecurityRoleRefs();
               for (SecurityRoleRef roleRef : roleRefs) {
              
                   wrapper.addSecurityReference(
                           roleRef.getName(), roleRef.getLink());
               }
               wrapper.setServletClass(servlet.getServletClass());
               MultipartDef multipartdef = servlet.getMultipartDef();
               if (multipartdef != null) {
              
                   if (multipartdef.getMaxFileSize() != null &&
                           multipartdef.getMaxRequestSize()!= null &&
                           multipartdef.getFileSizeThreshold() != null) {
              
                       wrapper.setMultipartConfigElement(new MultipartConfigElement(
                               multipartdef.getLocation(),
                               Long.parseLong(multipartdef.getMaxFileSize()),
                               Long.parseLong(multipartdef.getMaxRequestSize()),
                               Integer.parseInt(
                                       multipartdef.getFileSizeThreshold())));
                   } else {
              
                       wrapper.setMultipartConfigElement(new MultipartConfigElement(
                               multipartdef.getLocation()));
                   }
               }
               if (servlet.getAsyncSupported() != null) {
              
                   wrapper.setAsyncSupported(
                           servlet.getAsyncSupported().booleanValue());
               }
               wrapper.setOverridable(servlet.isOverridable());
               context.addChild(wrapper);
           }
           for (Entry<String, String> entry :
                   webxml.getServletMappings().entrySet()) {
              
               context.addServletMappingDecoded(entry.getKey(), entry.getValue());
           }
           SessionConfig sessionConfig = webxml.getSessionConfig();
           if (sessionConfig != null) {
              
               if (sessionConfig.getSessionTimeout() != null) {
              
                   context.setSessionTimeout(
                           sessionConfig.getSessionTimeout().intValue());
               }
               SessionCookieConfig scc =
                   context.getServletContext().getSessionCookieConfig();
               scc.setName(sessionConfig.getCookieName());
               scc.setDomain(sessionConfig.getCookieDomain());
               scc.setPath(sessionConfig.getCookiePath());
               scc.setComment(sessionConfig.getCookieComment());
               if (sessionConfig.getCookieHttpOnly() != null) {
              
                   scc.setHttpOnly(sessionConfig.getCookieHttpOnly().booleanValue());
               }
               if (sessionConfig.getCookieSecure() != null) {
              
                   scc.setSecure(sessionConfig.getCookieSecure().booleanValue());
               }
               if (sessionConfig.getCookieMaxAge() != null) {
              
                   scc.setMaxAge(sessionConfig.getCookieMaxAge().intValue());
               }
               if (sessionConfig.getSessionTrackingModes().size() > 0) {
              
                   context.getServletContext().setSessionTrackingModes(
                           sessionConfig.getSessionTrackingModes());
               }
           }
        
           // Context doesn't use version directly
        
           for (String welcomeFile : webxml.getWelcomeFiles()) {
              
               /*
                * The following will result in a welcome file of "" so don't add
                * that to the context
                * <welcome-file-list>
                *   <welcome-file/>
                * </welcome-file-list>
                */
               if (welcomeFile != null && welcomeFile.length() > 0) {
              
                   context.addWelcomeFile(welcomeFile);
               }
           }
        
           // Do this last as it depends on servlets
           for (JspPropertyGroup jspPropertyGroup :
                   webxml.getJspPropertyGroups()) {
              
               String jspServletName = context.findServletMapping("*.jsp");
               if (jspServletName == null) {
              
                   jspServletName = "jsp";
               }
               if (context.findChild(jspServletName) != null) {
              
                   for (String urlPattern : jspPropertyGroup.getUrlPatterns()) {
              
                       context.addServletMappingDecoded(urlPattern, jspServletName, true);
                   }
               } else {
              
                   if(log.isDebugEnabled()) {
              
                       for (String urlPattern : jspPropertyGroup.getUrlPatterns()) {
              
                           log.debug("Skipping " + urlPattern + " , no servlet " +
                                   jspServletName);
                       }
                   }
               }
           }
        
           for (Entry<String, String> entry :
                   webxml.getPostConstructMethods().entrySet()) {
              
               context.addPostConstructMethod(entry.getKey(), entry.getValue());
           }
        
           for (Entry<String, String> entry :
               webxml.getPreDestroyMethods().entrySet()) {
              
               context.addPreDestroyMethod(entry.getKey(), entry.getValue());
           }
        }

[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/8012294f9038422692c38445ad434c2b.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUwNTMxMw==,size_16,color_FFFFFF,t_70#pic_center
[Connector]: https://blog.csdn.net/weixin_45505313/article/details/118855200#21_Connector__12
[Connector 1]: https://blog.csdn.net/weixin_45505313/article/details/118855200#t4
[Connector 2]: https://blog.csdn.net/weixin_45505313/article/details/118855200#t5