要使用一个Web应用程序，必须要将表示该应用程序的Context实例部署到一个Host实例中，在Tomcat中，Context实例可以用WAR文件的形式来部署，也可以将整个WEB应用程序复制到Tomcat安装目录下的webapp下。对于部署的每个应用程序，可以在其中包含一个描述符文件，该文件包含Context实例的配置信息，描述符文件也采用XML文档格式。

　　下面会讨论如何使用部署器来部署一个web应用程序，在Tomcat 中，部署器 是org.apahce.catalina.Deployer接口的实例，部署器与一个Host实例相关联，用来安装Context实例，安装Context实例的意思是，创建一个StandardContext实例，并将该实例添加到Host实例中，创建的Context实例会随其父容器 ---Host实例一起启动，因此 除了Wrapper实例类，容器的实例总会是调用其子容器的start方法，但是 部署器也可以用来单独签订和关闭Context实例。

部署一个Web应用程序

　　在原来我们学习Host实例时，使用如下代码来实例化StandardHost实例，并将一个Context实例作为子容器添加到Host实例中。

  1. Context context = new StandardContext();
  2. context.setPath("/app1");
  3. conntext.setDocBase("app1");
  4. LifecycleListener listener = new ContextConfig();
  5. (Lifecycle(context)).addLifecycleListener(listener);
  6. Host host = new StandardHost();
  7. host.addChild(context);

这是之前部署应用程序的方法，但是在Tomcat中并没有这样部署应用程序，拿在实际部署环境中Context实例是如何被添加到Host容器中的呢？答案在于StandardHost实例中使用的org.apache.catalina.startup.HostConfig类型的声明周期监听器。

　　当调用StandardHost实例的start方法时，它会触发START事件，HostConfig实例会对该事件进行响应，并调用其自身的start方法，该方法会逐个部署并安装指定目录中的所有web应用程序，下面对其中的细节进行讲解。

　　回忆一下之前如何使用Digester对象来解析XML文档的内容，但是它并没有涉及Digester对象中的所有规则，其中被忽略掉的一个主题就是部署器。

　　在Tomcat中，org.apahce.catalina.startup.Catalina类时启动类，使用Digester对象来解析server.xml文件，将其中的XML元素转换为java对象，Catalina类定义了createStartDigester方法 来为Digester对象来添加规则，createStarDigester方法的器其中一行代码如下：

　　

  1. digester.addRuleSet(new HostRuleSet("Server/Service/Engine/"));

　　org.apahce.catalina.strtup.HostRuleSet类继承自org.apache.commons.digester.RuleSetBase类（该类在前面介绍过，）。作为RuleSetBase类的一个子类，HostRuleSet类必须提供addRuleInstances方法的实现，需要在该方法中定义RuleSet的规则，

  1.  digester.addObjectCreate(prefix + "Host",
  2.                                  "org.apache.catalina.core.StandardHost",
  3.                                  "className");
  4.         digester.addSetProperties(prefix + "Host");
  5.         digester.addRule(prefix + "Host",
  6.                          new CopyParentClassLoaderRule(digester));
  7.         digester.addRule(prefix + "Host",
  8.                          new LifecycleListenerRule
  9.                          (digester,
  10.                           "org.apache.catalina.startup.HostConfig",
  11.                           "hostConfigClass"));

当在Server.xml文件中遇到符合 Server/Service/Engine/Host 模式的标签时，会创建 org.apache.catalina.startup.HostConfig的一个实例。并将其添加到Host实例中，作为声明周期监听器，换句话说，HostConfig类会处理StandardHost实例的start方法和 stop方法触发的事件，

下面给出了HostConfig实例的 lifecycleEvent方法的实现，该方法是一个事件处理程序，因为HostConfig的实例是StandardHost对象的声明周期事件监听器，每当StandardHost实例启动或者关闭时，都会调用HostConfig的lifecycleEvent方法

  1.  /**
  2.       * 处理与该对象关联的Host对象的 声明周期监听事件
  3.       *
  4.       * @param event
  5.       *            发生的事件
  6.       */
  7.      public void lifecycleEvent(LifecycleEvent event) {
  8.  
  9.          // 确定与我们关联的Host
  10.          try {
  11.              host = (Host) event.getLifecycle();
  12.              if (host instanceof StandardHost) {
  13.                  int hostDebug = ((StandardHost) host).getDebug();
  14.                  if (hostDebug > this.debug) {
  15.                      this.debug = hostDebug;
  16.                  }
  17.                  // 设置 Host实例是否要部署一个Context实例的描述文件，默认情况 标志位true；
  18.                  setDeployXML(((StandardHost) host).isDeployXML());
  19.                  // 设置Host实例是否要周期性的检查一个新的部署的标志
  20.                  setLiveDeploy(((StandardHost) host).getLiveDeploy());
  21.                  // 设置 是否要将WAR文件形式的Web应用程序解压缩标志
  22.                  setUnpackWARs(((StandardHost) host).isUnpackWARs());
  23.              }
  24.          } catch (ClassCastException e) {
  25.              log(sm.getString("hostConfig.cce", event.getLifecycle()), e);
  26.              return;
  27.          }
  28.  
  29.          // 处理已经发生的事件
  30.          if (event.getType().equals(Lifecycle.START_EVENT))
  31.              start();
  32.          else if (event.getType().equals(Lifecycle.STOP_EVENT))
  33.              stop();
  34.  
  35.      }

如果变量host指向的对象是org.apahce.catalina.core.StandardHost类的实例，就会调用，setDeployXML、setLiveDeploye、setUnpackWARS方法，，

StandardHost类的 isDeployXML方法指明了host实例是否需要部署一个Context实例的描述符文件，默认情况下 deployXML属性的值为true，liveDeploy属性指明了Host实例是否要周期性的检查一个新的部署。unpackWARS属性指明是要将WAR文件形式的Web应用程序解压缩，

　　在收到START事件通知后，HostConfig对象的lifecycleEvent方法会调用start方法来部署web应用程序，

  1. /**
  2.      *
  3.      * 处理开始事件
  4.      */
  5.     protected void start() {
  6.  
  7.         if (debug >= 1)
  8.             log(sm.getString("hostConfig.start"));
  9.  
  10.         // 获取host的是否需要自动部署Web应用程序的标志，默认值为true
  11.         if (host.getAutoDeploy()) {
  12.             // 获取Host实例的 appBase属性的值，默认为“webapps”
  13.             // server.xml 中
  14.             /**
  15.              * <Host name="localhost" debug="0" appBase="webapps" unpackWARs=
  16.              * "true" autoDeploy="true">
  17.              *
  18.              */
  19.             // 部署进程会将%CATALINA_HOME%/webapps目录下的所有目录都看做web应用程序的目录来执行部署工作，该目录中的所有WAR文件和描述符文件也都会进行部署
  20.             deployApps();
  21.         }
  22.         /**
  23.          * HostConfig作为一个声明周期监听器。当StandardHost对象启动时，它的start方法会触发start事件。
  24.          * 为了响应start事件。HostConfig中的LifcycleEvent 方法 和 HostConfig 的start方法。
  25.          * 当LiveDeploye的值为true时，会调用threadStart方法
  26.          */
  27.         // 如果 需要周期性的检查部署 动态部署
  28.         if (isLiveDeploy()) {
  29.             threadStart();
  30.         }
  31.  
  32.     }

　　当autoDeploy的属性值是true时，默认情况下该值为true，start方法会调用deployApps方法，此外 如果 liveDeploy属性的值为true，它还会调用threadStart方法来派生一个新线程来动态部署web应用。

deployApps方法 会获取Host实例的appBase属性的值，默认为webapps的值（可以参考下Tomcat的server.xml文件），部署进程会将%CATALINA_HOME%/webapps目录下的所有目录都看作为Web应用程序的目录来执行部署工作，此外该目录中的所有的WAR文件和描述符文件也都会进行部署。

  1. /**
  2.      * 为在我们的“应用程序根目录”中找到的任何目录或war文件部署应用程序。
  3.      */
  4.     protected void deployApps() {
  5.  
  6.         if (!(host instanceof Deployer))
  7.             return;
  8.         if (debug >= 1)
  9.             log(sm.getString("hostConfig.deploying"));
  10.         // 返回了host 的根目录File引用
  11.         File appBase = appBase();
  12.         // 如果这个目录不存在 或者 这个目录 不是一个文件夹引用 直接返回
  13.         if (!appBase.exists() || !appBase.isDirectory())
  14.             return;
  15.         // 获取host根目录下的所有文件名
  16.         String files[] = appBase.list();
  17.         // 部署描述文件
  18.         deployDescriptors(appBase, files);
  19.         deployWARs(appBase, files);
  20.         deployDirectories(appBase, files);
  21.  
  22.     }

deployApps方法会调用其他三个方法，deployDescriptions、deployeWARs、deployDirectories方法，deployApps方法会将FIle类型的变量appBase和webApps目录下的所有的文件名数组形式传递给这3个方法，Context实例是通过它的路径来标识的，每个部署的Context是都必须有一条唯一的路径，已经部署的Context实例的文件名 也就是去掉 /的路径标识会添加到存储已经部署Context的文件名的ArrayList中，因此，在部署一个Context实例之前，deployDescriptions、deployWARs、deployDirectories方法必须保证已经部署的ArrayList中没有具有相同路径的Context实例，

HostConfig类使用deployDescriptions来部署XML文件

  1. /**
  2.      * Deploy XML context descriptors.
  3.      */
  4.     protected void deployDescriptors(File appBase, String[] files) {
  5.         // 如果部署描述器标志 为false 则直接返回
  6.         if (!deployXML)
  7.             return;
  8.         // 迭代 host根目录下的所有文件名
  9.         for (int i = 0; i < files.length; i++) {
  10.             // 如果文件名为 "META-INF" 则不作处理 继续迭代
  11.             if (files[i].equalsIgnoreCase("META-INF"))
  12.                 continue;
  13.             // 如果文件名为 "WEB-INF" 则不作处理 继续迭代
  14.             if (files[i].equalsIgnoreCase("WEB-INF"))
  15.                 continue;
  16.             // 如果 存储部署好的 Context 里已经包含这个这个文件名了 则 不继续做处理 继续迭代
  17.             if (deployed.contains(files[i]))
  18.                 continue;
  19.             // 拼接完整的 文件目录 并实例一个File对象
  20.             File dir = new File(appBase, files[i]);
  21.             // 如果文件末尾以xml结尾
  22.             if (files[i].toLowerCase().endsWith(".xml")) {
  23.                 // 将文件名 添加到已经部署好的集合中
  24.                 deployed.add(files[i]);
  25.  
  26.                 // 将文件名 .xml去掉 例如：admin.xml file = admin
  27.                 String file = files[i].substring(0, files[i].length() - 4);
  28.                 // Context的路径 = /admin
  29.                 String contextPath = "/" + file;
  30.                 // 如果 file 名为ROOT 则 context 的路径为host的appBase路径
  31.                 if (file.equals("ROOT")) {
  32.                     contextPath = "";
  33.                 }
  34.                 // 如果 host中 有这个路径Context 就不作任何处理 继续迭代
  35.                 if (host.findChild(contextPath) != null) {
  36.                     continue;
  37.                 }
  38.  
  39.                 // 假设这是一个配置描述符，然后部署它
  40.                 log(sm.getString("hostConfig.deployDescriptor", files[i]));
  41.                 try {
  42.                     URL config = new URL("file", null, dir.getCanonicalPath());
  43.                     ((Deployer) host).install(config, null);
  44.                 } catch (Throwable t) {
  45.                     log(sm.getString("hostConfig.deployDescriptor.error", files[i]), t);
  46.                 }
  47.  
  48.             }
  49.  
  50.         }
  51.  
  52.     }

第二：部署一个WAR文件

  1.  /**
  2.       * Deploy WAR files. 可以将Web应用程序以一个WAR形式的文件来部署，
  3.       */
  4.      protected void deployWARs(File appBase, String[] files) {
  5.          // 开始迭代 host根目录下的文件名
  6.          for (int i = 0; i < files.length; i++) {
  7.              // 如果文件名是 META-INF 则不作处理
  8.              if (files[i].equalsIgnoreCase("META-INF"))
  9.                  continue;
  10.              // 如果文件名是WEB-INF 则不做处理
  11.              if (files[i].equalsIgnoreCase("WEB-INF"))
  12.                  continue;
  13.              // 如果这个文件名 已经属于被被部署了 则不做处理 继续迭代
  14.              if (deployed.contains(files[i]))
  15.                  continue;
  16.              // 将这个文件全名 拼接完成 并实例一个FIle、引用
  17.              File dir = new File(appBase, files[i]);
  18.              // 如果这个文件是一个 war文件
  19.              if (files[i].toLowerCase().endsWith(".war")) {
  20.                  // 将其添加到已经部署集合中
  21.                  deployed.add(files[i]);
  22.  
  23.                  // 计算上下文路径并确保其唯一
  24.                  // 拼接一个context路径
  25.                  String contextPath = "/" + files[i];
  26.                  // 如果这个路径还有.
  27.                  int period = contextPath.lastIndexOf(".");
  28.                  if (period >= 0)
  29.                      // 截取.之前的路径字符串
  30.                      contextPath = contextPath.substring(0, period);
  31.                  // 如果context路径等于/ROOT
  32.                  if (contextPath.equals("/ROOT"))
  33.                      contextPath = "";
  34.                  // 如果这个host的子容器中已经存在这个路径的Context了 则不需要继续了
  35.                  if (host.findChild(contextPath) != null)
  36.                      continue;
  37.                  // 如果允许将WAR问价 解压缩的话
  38.                  if (isUnpackWARs()) {
  39.  
  40.                      // 将此应用程序扩展并部署为目录
  41.                      log(sm.getString("hostConfig.expand", files[i]));
  42.                      try {
  43.                          URL url = new URL("jar:file:" + dir.getCanonicalPath() + "!/");
  44.                          // 解压缩后的目录文件名
  45.                          String path = expand(url);
  46.  
  47.                          url = new URL("file:" + path);
  48.                          ((Deployer) host).install(contextPath, url);
  49.                      } catch (Throwable t) {
  50.                          log(sm.getString("hostConfig.expand.error", files[i]), t);
  51.                      }
  52.  
  53.                  } else {
  54.  
  55.                      // 如果不允许解压缩 则把WAR文件作为JAR文件部署
  56.                      log(sm.getString("hostConfig.deployJar", files[i]));
  57.                      try {
  58.                          URL url = new URL("file", null, dir.getCanonicalPath());
  59.                          url = new URL("jar:" + url.toString() + "!/");
  60.                          ((Deployer) host).install(contextPath, url);
  61.                      } catch (Throwable t) {
  62.                          log(sm.getString("hostConfig.deployJar.error", files[i]), t);
  63.                      }
  64.  
  65.                  }
  66.  
  67.              }
  68.  
  69.          }
  70.  
  71.      }

部署一个目录，可以直接将Web应用程序的整个目录复制到%CATALINA_HOME%/webapps目录下来完成web应用程序的部署

  1. /**
  2.      * 部署一个目录 可以直接将Web应用程序的整个目录复制到 %CATALINA_HOME%webapps目录下来完成web应用程序的部署，
  3.      */
  4.     protected void deployDirectories(File appBase, String[] files) {
  5.  
  6.         // 迭代host根目录下的所有文件名
  7.         for (int i = 0; i < files.length; i++) {
  8.             // 如果 文件名为 META-INF则 不做任何处理 继续跌倒
  9.             if (files[i].equalsIgnoreCase("META-INF"))
  10.                 continue;
  11.             // 如果文件名为 WEB-INF则不做任何处理继续迭代
  12.             if (files[i].equalsIgnoreCase("WEB-INF"))
  13.                 continue;
  14.             // 如果这个文件已经被部署了 则继续迭代 不做任何处理了
  15.             if (deployed.contains(files[i]))
  16.                 continue;
  17.             // 引用这个文件的FIle引用
  18.             File dir = new File(appBase, files[i]);
  19.             // 如果这个文件是一个 文件夹
  20.             if (dir.isDirectory()) {
  21.                 // 将文件添加到已经部署好的集合了
  22.                 deployed.add(files[i]);
  23.  
  24.                 // 确保存在应用程序配置目录。如果上下文AppBase与Web服务器文档根目录相同，则需要此目录，以确保仅部署Web应用程序，而不部署Web空间目录。.
  25.                 // 只部署其web-inf目录
  26.                 // 找到 dir目录下的 /WEB-INF文件夹
  27.                 File webInf = new File(dir, "/WEB-INF");
  28.                 // 如果不存在则 不做任何处理 继续迭代
  29.                 if (!webInf.exists() || !webInf.isDirectory() || !webInf.canRead())
  30.                     continue;
  31.  
  32.                 // 将文件名前加上一个/
  33.                 String contextPath = "/" + files[i];
  34.                 // 如果 文件名为ROOT 则host的appBase的目录为 context的目录
  35.                 if (files[i].equals("ROOT"))
  36.                     contextPath = "";
  37.                 // 如果 host的子容器中已经存在这个路径的Context 则继续迭代 不继续处理了
  38.                 if (host.findChild(contextPath) != null)
  39.                     continue;
  40.  
  41.                 // 在此目录中部署应用程序
  42.                 log(sm.getString("hostConfig.deployDir", files[i]));
  43.                 try {
  44.                     URL url = new URL("file", null, dir.getCanonicalPath());
  45.                     ((Deployer) host).install(contextPath, url);
  46.                 } catch (Throwable t) {
  47.                     log(sm.getString("hostConfig.deployDir.error", files[i]), t);
  48.                 }
  49.  
  50.             }
  51.  
  52.         }
  53.  
  54.     }

动态部署，正如前面提到的 StandardHost实例会使用HostConfig对象作为一个生命周期事件监听器，当StandardHost对象被启动时，它的start方法会触发一个START事件。为了响应START事件，HostConfig中lifecycleEvent方法和HostConfig中的事件处理程序会调用start方法，在start方法的最后一行，当liveDeploy属性为true时，start方法会调用threadStart方法，

threadStart方法会派生一个新线程并调用run方法，（本身HostConfig对象就继承了Runnable接口）所以会吧当前HostConfig对象传入，HostConfig对象的run方法会定期检查是否有新的应用要部署，或者已经部署的Web应用程序的web.xml文件是否已经被修改，

  1.  /**
  2.       *
  3.       * 派生一个新的线程并调用run方法，run方法会定期检查是否有新的应用要部署，或已经部署的Web应用程序的web.xml是否有修改。
  4.       *
  5.       * @exception IllegalStateException
  6.       *                如果我们不能启动这个线程
  7.       */
  8.      protected void threadStart() {
  9.  
  10.          // 这个后台线程是否已经被启动了
  11.          if (thread != null)
  12.              return;
  13.  
  14.          // 启动一个线程
  15.          if (debug >= 1)
  16.              log(" Starting background thread");
  17.          threadDone = false;
  18.          threadName = "HostConfig[" + host.getName() + "]";
  19.          thread = new Thread(this, threadName);
  20.          // 设置为守护线程
  21.          thread.setDaemon(true);
  22.          thread.start();
  23.  
  24.      }

这个守护线程被启动后 会调用HostConfig的run方法

  1.  /**
  2.       *
  3.       * 周期性检查Web应用程序自动部署和对web.xml配置的更改的后台线程。
  4.       */
  5.      public void run() {
  6.  
  7.          if (debug >= 1)
  8.              log("BACKGROUND THREAD Starting");
  9.  
  10.          // 循环直到终止变量被设置
  11.          while (!threadDone) {
  12.  
  13.              // 等待我们的检查间隔
  14.              threadSleep();
  15.  
  16.              // 如果主机允许自动部署，则部署应用程序
  17.              deployApps();
  18.  
  19.              // 检查web.xml文件的事假戳
  20.              checkWebXmlLastModified();
  21.  
  22.          }
  23.  
  24.          if (debug >= 1)
  25.              log("BACKGROUND THREAD Stopping");
  26.  
  27.      }

threadSleep方法会使该线程休眠一段时间，该时间的长短由属性checkInterval指定，该属性默认为15s，即每隔15秒检查一次，

看下检查web.xml文件的时间戳的方法

  1.     /**
  2.      * 检查部署描述符的上次修改日期。
  3.      */
  4.     protected void checkWebXmlLastModified() {
  5.  
  6.         if (!(host instanceof Deployer))
  7.             return;
  8.  
  9.         Deployer deployer = (Deployer) host;
  10.  
  11.         String[] contextNames = deployer.findDeployedApps();
  12.  
  13.         for (int i = 0; i < contextNames.length; i++) {
  14.  
  15.             String contextName = contextNames[i];
  16.             Context context = deployer.findDeployedApp(contextName);
  17.  
  18.             if (!(context instanceof Lifecycle))
  19.                 continue;
  20.  
  21.             try {
  22.                 DirContext resources = context.getResources();
  23.                 if (resources == null) {
  24.                     // This can happen if there was an error initializing
  25.                     // the context
  26.                     continue;
  27.                 }
  28.                 // 如果旧的时间戳 和新的 时间戳不一致
  29.                 ResourceAttributes webXmlAttributes = (ResourceAttributes) resources.getAttributes("/WEB-INF/web.xml");
  30.                 long newLastModified = webXmlAttributes.getLastModified();
  31.                 Long lastModified = (Long) webXmlLastModified.get(contextName);
  32.                 if (lastModified == null) {
  33.                     webXmlLastModified.put(contextName, new Long(newLastModified));
  34.                 } else {
  35.                     if (lastModified.longValue() != newLastModified) {
  36.                         webXmlLastModified.remove(contextName);
  37.                         // 先将cotext停止
  38.                         ((Lifecycle) context).stop();
  39.                         // Context 已停止，将引发生命周期异常，并且Context将不会重新启动。
  40.                         // 在重新启动 更细 现有的web.xml进行重新配置
  41.                         ((Lifecycle) context).start();
  42.                     }
  43.                 }
  44.             } catch (LifecycleException e) {
  45.                 ; // Ignore
  46.             } catch (NamingException e) {
  47.                 ; // Ignore
  48.             }
  49.  
  50.         }
  51.  
  52.     }

如果发现web.xml文件的时间戳已经发生改变则  将Context关闭 并重新启动，在重新启动时会重新读取web.xml的配置

下面来说一下 重中之重，部署器

Deployer接口

　　部署器是org.apache.catalina.Deployer接口的实例，StandardHost类实现了 Deployer接口，因此，StandardHost实例也是一个部署器，它是一个容器，web应用程序可以部署到其中，或者从中取消部署、

  1.  package org.apache.catalina;
  2.  
  3.  import java.io.IOException;
  4.  import java.net.URL;
  5.  
  6.  /**
  7.   *
  8.   * <p>
  9.   * <b>Title:Deployer.java</b>
  10.   * </p>
  11.   * <p>
  12.   * Copyright:ChenDong 2019
  13.   * </p>
  14.   * <p>
  15.   * Company:仅学习时使用
  16.   * </p>
  17.   * <p>
  18.   * 类功能描述: 部署程序是一个专门的容器，可以在其中部署和取消部署Web应用程序。这样的容器将为每个部署的应用程序创建和安装Context实例。
  19.   * 每个Web应用程序的唯一键是其附加到Context路径。
  20.   * </p>
  21.   *
  22.   * @author  * @date 2019年1月2日 下午10:03:45
  23.   * @version 1.0
  24.   */
  25.  /* public interface Deployer extends Container { */
  26.  public interface Deployer {
  27.  
  28.      // ----------------------------------------------------- Manifest Constants
  29.  
  30.      /**
  31.       * <code>install()</code>安装新应用程序时，在启动前发送的ContainerEvent事件类型。
  32.       */
  33.      public static final String PRE_INSTALL_EVENT = "pre-install";
  34.  
  35.      /**
  36.       * 启动新应用程序后，<code>install()</code>安装新应用程序时发送的ContainerEvent事件类型
  37.       */
  38.      public static final String INSTALL_EVENT = "install";
  39.  
  40.      /**
  41.       * <code>remove()</code>.移除现有应用程序时发送的ContainerEvent事件类型。
  42.       */
  43.      public static final String REMOVE_EVENT = "remove";
  44.  
  45.      // --------------------------------------------------------- Public Methods
  46.  
  47.      /**
  48.       * 返回与此部署程序关联的容器的名称
  49.       */
  50.      public String getName();
  51.  
  52.      /**
  53.       *
  54.       *
  55.       * <p>
  56.       * Title: install
  57.       * </p>
  58.       *
  59.       * @date 2019年1月2日 下午10:18:43
  60.       *
  61.       *       <p>
  62.       *       功能描述:使用指定的Context 路径将其标识的 Web应用程序部署到 指定URL位置上。此容器的根应用程序应使用“”（
  63.       *       空字符串）的Context路径。否则，Context路径必须以斜线开头。
  64.       *
  65.       *
  66.       *
  67.       *       如果成功安装此应用程序，将向所有注册的侦听器发送install_event类型的containerEvent，
  68.       *       并将新创建的Context作为参数。
  69.       *       </p>
  70.       *
  71.       * @param contextPath
  72.       * @param war
  73.       * @throws IOException
  74.       */
  75.      public void install(String contextPath, URL war) throws IOException;
  76.  
  77.      /**
  78.       *
  79.       *
  80.       * <p>
  81.       * Title: install
  82.       * </p>
  83.       *
  84.       * @date 2019年1月2日 下午10:27:36
  85.       *
  86.       *       <p>
  87.       *       功能描述:安装新的Web应用程序，Context 配置描述XML文件（由<context>元素组成） 部署到 指定URL。
  88.       *
  89.       *
  90.       *
  91.       *       如果成功安装此应用程序，将向所有注册的侦听器发送install_event类型的containerEvent，
  92.       *       并将新创建的Context作为参数
  93.       *       </p>
  94.       *
  95.       * @param config
  96.       * @param war
  97.       * @throws IOException
  98.       */
  99.      public void install(URL config, URL war) throws IOException;
  100.  
  101.      /**
  102.       *
  103.       *
  104.       * <p>
  105.       * Title: findDeployedApp
  106.       * </p>
  107.       *
  108.       * @date 2019年1月2日 下午10:30:03
  109.       *
  110.       *       <p>
  111.       *       功能描述:返回与指定Context路径关联的已部署应用程序的Context（如果有）；否则返回空值。
  112.       *       </p>
  113.       *
  114.       * @param contextPath
  115.       *            context路径
  116.       * @return
  117.       */
  118.      public Context findDeployedApp(String contextPath);
  119.  
  120.      /**
  121.       *
  122.       *
  123.       * <p>
  124.       * Title: findDeployedApps
  125.       * </p>
  126.       *
  127.       * @date 2019年1月2日 下午10:30:55
  128.       *
  129.       *       <p>
  130.       *       功能描述:返回此容器中所有已部署Web应用程序的Context 路径。如果没有部署的应用程序，则返回零长度数组。
  131.       *       </p>
  132.       *
  133.       * @return
  134.       */
  135.      public String[] findDeployedApps();
  136.  
  137.      /**
  138.       *
  139.       *
  140.       * <p>
  141.       * Title: remove
  142.       * </p>
  143.       *
  144.       * @date 2019年1月2日 下午10:31:41
  145.       *
  146.       *       <p>
  147.       *       功能描述:删除附加到指定Context 路径的现有Web应用程序。如果成功删除此应用程序，
  148.       *       将向所有注册的侦听器发送一个remove_event类型的containerEvent，并将删除的Context作为参数。
  149.       *       </p>
  150.       *
  151.       * @param contextPath
  152.       * @throws IOException
  153.       */
  154.      public void remove(String contextPath) throws IOException;
  155.  
  156.      /**
  157.       *
  158.       *
  159.       * <p>
  160.       * Title: start
  161.       * </p>
  162.       *
  163.       * @date 2019年1月2日 下午10:32:26
  164.       *
  165.       *       <p>
  166.       *       功能描述:启动附加到指定Context路径的现有Web应用程序。仅当Web应用程序不运行时才启动它。
  167.       *       </p>
  168.       *
  169.       * @param contextPath
  170.       * @throws IOException
  171.       */
  172.      public void start(String contextPath) throws IOException;
  173.  
  174.      /**
  175.       *
  176.       *
  177.       * <p>
  178.       * Title: stop
  179.       * </p>
  180.       *
  181.       * @date 2019年1月2日 下午10:32:53
  182.       *
  183.       *       <p>
  184.       *       功能描述:关闭附加到指定Context 路径的现有Web应用程序。仅在Web应用程序运行时才关闭。
  185.       *       </p>
  186.       *
  187.       * @param contextPath
  188.       * @throws IOException
  189.       */
  190.      public void stop(String contextPath) throws IOException;
  191.  
  192.  }

　　StandardHost类使用了一个辅助类(org.apahce.catalina.core.StandardHostDeployer)来完成部署与安装Web应用程序的相关任务，下面是StandardHost类的部分代码片段，展示了StandardHost对象是如何将部署任务委托给StandardHostDeployer实例来完成的，

  1. /**
  2.      * 我们将应用程序部署请求委托给的<code>Deployer</code>
  3.      */
  4.     private Deployer deployer = new StandardHostDeployer(this);
  1. public void install(String contextPath, URL war) throws IOException {
  2.  
  3.         deployer.install(contextPath, war);
  4.  
  5.     }
  1. public synchronized void install(URL config, URL war) throws IOException {
  2.  
  3.         deployer.install(config, war);
  4.  
  5.     }
  1. public Context findDeployedApp(String contextPath) {
  2.  
  3.         return (deployer.findDeployedApp(contextPath));
  4.  
  5.     }
  6.  
  7.     public String[] findDeployedApps() {
  8.  
  9.         return (deployer.findDeployedApps());
  10.  
  11.     }
  1. public void start(String contextPath) throws IOException {
  2.  
  3.         deployer.start(contextPath);
  4.  
  5.     }
  6.  
  7.     public void stop(String contextPath) throws IOException {
  8.  
  9.         deployer.stop(contextPath);
  10.  
  11.     }

下面介绍一下StandardHostDeployer

StandardHostDeployer类

　　org.apahce.catalina.core.StandardHostDeployer类是一个辅助类，帮助完成将Web应用程序部署到StandardHost实例的工作，StandardHostDeployer实例由StandardHost对象调用，在其构造函数中，会传入StandardHost的一个实例对象

  1. public StandardHostDeployer(StandardHost host) {
  2.  
  3.         super();
  4.         this.host = host;
  5.  
  6.     }

安装一个描述符

　　StandardHostDeployer类有两个install方法，下面介绍第一个install方法，它用来安装一个描述符，下面的代码给出的install方法用来安装描述符，当HostConfig对象的deployDescriptors方法调用了install方法后，StandardHost实例调用该install方法：

  1. public synchronized void install(URL config, URL war) throws IOException {
  2.  
  3.         // 验证参数的格式和状态
  4.         if (config == null)
  5.             throw new IllegalArgumentException(sm.getString("standardHost.configRequired"));
  6.  
  7.         if (!host.isDeployXML())
  8.             throw new IllegalArgumentException(sm.getString("standardHost.configNotAllowed"));
  9.  
  10.         // 计算新Web应用程序的文档库（如果需要）
  11.         String docBase = null; // 配置文件中值的可选重写
  12.         if (war != null) {
  13.             String url = war.toString();
  14.             host.log(sm.getString("standardHost.installingWAR", url));
  15.             // 计算war文件的绝对路径名
  16.             if (url.startsWith("jar:")) {
  17.                 url = url.substring(4, url.length() - 2);
  18.             }
  19.             if (url.startsWith("file://"))
  20.                 docBase = url.substring(7);
  21.             else if (url.startsWith("file:"))
  22.                 docBase = url.substring(5);
  23.             else
  24.                 throw new IllegalArgumentException(sm.getString("standardHost.warURL", url));
  25.  
  26.         }
  27.  
  28.         // 安装新的Web应用程序
  29.         this.context = null;
  30.         this.overrideDocBase = docBase;
  31.         InputStream stream = null;
  32.         try {
  33.             stream = config.openStream();
  34.             // 老话常谈了 这个就是自定义了一些Rule 有空自己在单独看吧
  35.             Digester digester = createDigester();
  36.             digester.setDebug(host.getDebug());
  37.             digester.clear();
  38.             // Digester将 StandardHostDeployer放到 栈中的第一个位置
  39.             digester.push(this);
  40.             digester.parse(stream);
  41.             stream.close();
  42.             stream = null;
  43.         } catch (Exception e) {
  44.             host.log(sm.getString("standardHost.installError", docBase), e);
  45.             throw new IOException(e.toString());
  46.         } finally {
  47.             if (stream != null) {
  48.                 try {
  49.                     stream.close();
  50.                 } catch (Throwable t) {
  51.                     ;
  52.                 }
  53.             }
  54.         }
  55.  
  56.     }

安装一个WAR文件或者目录

　　第二个 install方法接收一个表示 Context路径的字符串 和一个表示WAR文件的URL，代码清单如下：

  1. public synchronized void install(String contextPath, URL war) throws IOException {
  2.  
  3.         // 验证参数的格式和状态
  4.         if (contextPath == null)
  5.             throw new IllegalArgumentException(sm.getString("standardHost.pathRequired"));
  6.         if (!contextPath.equals("") && !contextPath.startsWith("/"))
  7.             throw new IllegalArgumentException(sm.getString("standardHost.pathFormat", contextPath));
  8.         // 先看看这个Context 是否已经被部署了
  9.         if (findDeployedApp(contextPath) != null)
  10.             throw new IllegalStateException(sm.getString("standardHost.pathUsed", contextPath));
  11.         if (war == null)
  12.             throw new IllegalArgumentException(sm.getString("standardHost.warRequired"));
  13.  
  14.         // 计算新Web应用程序的文档库
  15.         host.log(sm.getString("standardHost.installing", contextPath, war.toString()));
  16.         String url = war.toString();
  17.         String docBase = null;
  18.         if (url.startsWith("jar:")) {
  19.             url = url.substring(4, url.length() - 2);
  20.         }
  21.         if (url.startsWith("file://"))
  22.             docBase = url.substring(7);
  23.         else if (url.startsWith("file:"))
  24.             docBase = url.substring(5);
  25.         else
  26.             throw new IllegalArgumentException(sm.getString("standardHost.warURL", url));
  27.  
  28.         // 安装新的Web应用程序
  29.         try {
  30.             Class clazz = Class.forName(host.getContextClass());
  31.             Context context = (Context) clazz.newInstance();
  32.             context.setPath(contextPath);
  33.             // 重点在TM这里 就是将web库设置给新实例化的Context
  34.             context.setDocBase(docBase);
  35.             if (context instanceof Lifecycle) {
  36.                 clazz = Class.forName(host.getConfigClass());
  37.                 LifecycleListener listener = (LifecycleListener) clazz.newInstance();
  38.                 ((Lifecycle) context).addLifecycleListener(listener);
  39.             }
  40.             host.fireContainerEvent(PRE_INSTALL_EVENT, context);
  41.             //安装完这个Context之后 就会被添加到Host实例当中
    　　　　　　　host.addChild(context);
  42.             host.fireContainerEvent(INSTALL_EVENT, context);
  43.         } catch (Exception e) {
  44.             host.log(sm.getString("standardHost.installError", contextPath), e);
  45.             throw new IOException(e.toString());
  46.         }
  47.  
  48.     }

　　启动Context实例

StandardHostDeployer类中的start方法用于启动刚刚被安装的Context实例：

  1. public void start(String contextPath) throws IOException {
  2.         // 验证参数的有效性
  3.         if (contextPath == null)
  4.             throw new IllegalArgumentException(sm.getString("standardHost.pathRequired"));
  5.         if (!contextPath.equals("") && !contextPath.startsWith("/"))
  6.             throw new IllegalArgumentException(sm.getString("standardHost.pathFormat", contextPath));
  7.         // 根据 contextpath 找到 被安装的Context实例
  8.         Context context = findDeployedApp(contextPath);
  9.         if (context == null)
  10.             throw new IllegalArgumentException(sm.getString("standardHost.pathMissing", contextPath));
  11.         host.log("standardHost.start " + contextPath);
  12.         try {
  13.             // 启动Context
  14.             ((Lifecycle) context).start();
  15.         } catch (LifecycleException e) {
  16.             host.log("standardHost.start " + contextPath + ": ", e);
  17.             throw new IllegalStateException("standardHost.start " + contextPath + ": " + e);
  18.         }
  19.     }

那同样 有启动 就会有 停止

停止一个Context实例

　　StandardHostDeployer类的stop方法可以用来通知一个Context实例，代码清单如下:

  1. public void stop(String contextPath) throws IOException {
  2.  
  3.         // 验证参数的有效性
  4.         if (contextPath == null)
  5.             throw new IllegalArgumentException(sm.getString("standardHost.pathRequired"));
  6.         if (!contextPath.equals("") && !contextPath.startsWith("/"))
  7.             throw new IllegalArgumentException(sm.getString("standardHost.pathFormat", contextPath));
  8.         // 根据contextPath 来找到 被安装的Context实例
  9.         Context context = findDeployedApp(contextPath);
  10.         if (context == null)
  11.             throw new IllegalArgumentException(sm.getString("standardHost.pathMissing", contextPath));
  12.         host.log("standardHost.stop " + contextPath);
  13.         // 关闭这个Context
  14.         try {
  15.             ((Lifecycle) context).stop();
  16.         } catch (LifecycleException e) {
  17.             host.log("standardHost.stop " + contextPath + ": ", e);
  18.             throw new IllegalStateException("standardHost.stop " + contextPath + ": " + e);
  19.         }
  20.  
  21.     }

部署器是用来部署和安装Web应用程序的组件，是org.apache.catalina.core.Deployer接口的实例，StandHost类实现了Deployer接口，使其成为一个可以向其中部署web应用程序的特殊容器。StandardHost类会将部署和安装web应用程序的任务委托给StandardHostDeployer来完成，StandardHostDeployer类提供了部署和安装Web应用程序以及启动、关闭Context实例的具体实现。

Tomcat 的部署器的更多相关文章

  1. tomcat源码阅读之部署器

    我们知道web应用是用Context实例表示的,而Context是部署到Host实例中的,因此tomcat的部署器是关联的Host实例.Context实例可以用WAR文件部署,也可以把整个web应用的 ...

  2. tomcat源码解读（1）–tomcat热部署实现原理

    tomcat的热部署实现原理:tomcat启动的时候会有启动一个线程每隔一段时间会去判断应用中加载的类是否发生变法(类总数的变化,类的修改),如果发生了变化就会把应用的启动的线程停止掉,清除引用,并且 ...

  3. 【JVM】linux上tomcat中部署的web服务，时好时坏，莫名其妙宕机，报错：There is insufficient memory for the Java Runtime Environment to continue.

    =========================================================================================== 环境: linu ...

  4. Tomcat的类加载器

    看完了Java类装载器,我们再来看看应用服务器(Tomcat)对类加载器的使用,每个应用服务器都有一套自己的类加载器体系,从而与Java的类加载器区别开以达到自己与应用程序隔离的目的.Tomcat的类 ...

  5. Tomcat热部署的实现原理

    Tomcat热部署机制 对于Java应用程序来说,热部署就是在运行时更新Java类文件.在基于Java的应用服务器实现热部署的过程中,类装入器扮演着重要的角色.大多数基于Java的应用服务器,包括EJ ...

  6. JFinal 项目 在tomcat下部署

    原文:http://my.oschina.net/jfinal/blog/353062 首先明确一下 JFinal 项目是标准的 java web 项目,其部署方式与普通 java web 项目没有任 ...

  7. Intellij IDEA 创建Web项目并在Tomcat中部署运行（不使用maven）【转载】

    原文链接:http://www.thinksaas.cn/topics/0/350/350000.html 一.创建Web项目 1.File -> New Module,进入创建项目窗口 2.选 ...

  8. 在tomcat下部署工程

    xx系统第一期工程完成,今天老大要我去部署系统,从来就没有在tomcat下部署过,一直都是在myeclipse下部署.启动.运行即可,所以这次遇到了几个问题,记录下来. tomcat启动 在安装tom ...

  9. [Linux]Linux下安装和配置solr/tomcat/IK分词器 详细实例二.

    为了更好的排版, 所以将IK分词器的安装重启了一篇博文,  大家可以接上solr的安装一同查看.[Linux]Linux下安装和配置solr/tomcat/IK分词器 详细实例一: http://ww ...

随机推荐

  1. Leetcode题目96.不同的二叉搜索树（动态规划-中等）

    题目描述: 给定一个整数 n,求以 1 ... n 为节点组成的二叉搜索树有多少种? 示例: 输入: 3 输出: 5 解释: 给定 n = 3, 一共有 5 种不同结构的二叉搜索树: 1 3 3 2 ...

  2. mybatis用Map<Long,List<String>>作为参数

    mapper.xml文件里的<insert id="insertByMap" parameterType="java.util.Map"> inse ...

  3. IPv4 地址分类-for what

    怎么分的:IPV4 地址分类 A B C D E 分来做什么:IP地址为什要分类?就是a类,b类,c类...? - wuxinliulei的回答 - 知乎

  4. 第11组 Alpha冲刺（3/6）

    第11组 Alpha冲刺(3/6)   队名 不知道叫什么团队 组长博客 https://www.cnblogs.com/xxylac/p/11872098.html 作业博客 https://edu ...

  5. decimal模块 --数字的精度、保留小数位数、取整问题

    开始之前需要注意一点是:精度值为数字的总位数,如:1.23, 精度值为3: 0.123,精度值也为3 1.更改默认精度值后,直接进行计算即可保留对应精度值 from decimal import ge ...

  6. HearthBuddy遇奥秘解决方法

    https://tieba.baidu.com/g/5808796816 链接: https://pan.baidu.com/s/1NPQTOfxbN_4alP7J-XWuVw 密码: xfj1

  7. C# List中的ForEach

    ; List<string> aaa = new List<string>(){ "aaa", "bbb" }; aaa.ForEach ...

  8. 错误代码 2003不能连接到MySQL服务器在*.*.*.*（10061）

    错误代码 2003不能连接到MySQL服务器在*.*.*.*(10061) 错误代码 2003不能连接到MySQL服务器在*.*.*.*(10061)哪位大侠知道怎么解决啊? 在线等!!! [[i] ...

  9. JAVA 基础编程练习题3 【程序 3 水仙花数】

    3 [程序 3 水仙花数] 题目:打印出所有的"水仙花数",所谓"水仙花数"是指一个三位数,其各位数字立方和等于该数本身.例 如:153 是一个"水仙 ...

  10. elk报错解决

    .elasticsearch启动失败如下: [root@bogon home]# /home/elasticsearch-/bin/elasticsearch [--11T07::,][WARN ][ ...