【Tomcat】《How Tomcat Works》英文版GPT翻译（第十八章）

Context context = new StandardContext();
context.setPath("/app1");
context.setDocBase("app1");
LifecycleListener listener = new ContextConfig();
((Lifecycle) context).addLifecycleListener(listener);
Host host = new StandardHost();
host.addChild(context);

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

public void addRuleInstances(Digester digester) {
 digester.addObjectCreate(prefix + "Host",
 "org.apache.catalina.core.StandardHost", "className");
 digester.addSetProperties(prefix + "Host");
 digester.addRule(prefix + "Host",
 new CopyParentClassLoaderRule(digester));
 digester.addRule(prefix + "Host",
 new LifecycleListenerRule (digester,
 "org.apache.catalina.startup.HostConfig", "hostConfigClass"));

public void lifecycleEvent(LifecycleEvent event) {
 // Identify the host we are associated with
 try {
  host = (Host) event.getLifecycle();
  if (host instanceof StandardHost) {
   int hostDebug = ((StandardHost) host).getDebug();
   if (hostDebug > this.debug) {
    this.debug = hostDebug;
   }
   setDeployXML(((StandardHost) host).isDeployXML());
   setLiveDeploy(((StandardHost) host).getLiveDeploy());
   setUnpackWARs(((StandardHost) host).isUnpackWARs());
  }
 }
 catch (ClassCastException e) {
  log(sm.getString("hostConfig.cce", event.getLifecycle()), e);
  return;
 }
 // Process the event that has occurred
 if (event.getType().equals(Lifecycle.START_EVENT))
  start ();
 else if (event.getType().equals(Lifecycle.STOP_EVENT))
  stop();
}

setDeployXML(((StandardHost) host).isDeployXML());
 setLiveDeploy(((StandardHost) host).getLiveDeploy());
 setUnpackWARs(((StandardHost) host).isUnpackWARs());

  
protected void start() {  
    if (debug >= 1)  
        log(sm.getString("hostConfig.start"));  
    if (host.getAutoDeploy()) {  
        deployApps();  
    }  
    if (isLiveDeploy ()) {  
        threadStart();  
    }  
}

  
protected void deployApps() {  
 if (!(host instanceof Deployer))  
  return;  
 if (debug >= 1)  
  log(sm.getString("hostConfig.deploying"));  
 File appBase = appBase();  
 if (!appBase.exists() || !appBase.isDirectory())  
  return;  
 String files[] = appBase.list();  
 deployDescriptors(appBase, files);  
 deployWARs(appBase, files);  
 deployDirectories(appBase, files);  
}

<Context path="/admin" docBase="../server/webapps/admin"
 debug="0" privileged="true">
 <!-- Uncomment this Valve to limit access to the Admin app to
 localhost for obvious security reasons. Allow may be a comma-
 separated list of hosts (or even regular expressions).
 <Valve className="org.apache.catalina.valves.RemoteAddrValve"
 allow="127.0.0.1"/>
 -->
 <Logger className="org.apache.catalina.logger.FileLogger"
 prefix="localhost_admin_log." suffix=".txt"
 timestamp="true"/>
</Context>

<Context path="/manager" docBase="../server/webapps/manager"
 debug="0" privileged="true">
 <!-- Link to the user database we will get roles from -->
 <ResourceLink name="users" global="UserDatabase"
 type="org.apache.catalina.UserDatabase"/>
</Context>

    protected void deployDescriptors(File appBase, String[] files) {
        if (!deployXML)
            return;
        for (int i = 0; i < files.length; i++) {
            if (files[i].equalsIgnoreCase("META-INF"))
                continue;
            if (files[i].equalsIgnoreCase("WEB-INF"))
                continue;
            if (deployed.contains(files[i]))
                continue;
            File dir = new File(appBase, files[i]);
            if (files[i].toLowerCase().endsWith(".xml")) {
                deployed.add(files[i]);
                // Calculate the context path and make sure it is unique
                String file = files[i].substring(0, files[i].length() - 4);
                String contextPath = "/" + file;
                if (file.equals("ROOT")) {
                    contextPath = "";
                }
                if (host.findChild(contextPath) != null) {
                    continue;
                }
                // Assume this is a configuration descriptor and deploy it
                log(sm.getString("hostConfig.deployDescriptor", files[i]));
                try {
                    URL config =
                            new URL("file", null, dir.getCanonicalPath());
                    ((Deployer) host).install(config, null);
                }
                catch (Throwable t) {
                    log(sm.getString("hostConfig.deployDescriptor.error",
                            files[i]), t);
                }
            }
        }
    }

protected void deployWARs(File appBase, String[] files) {
 for (int i = 0; i < files.length; i++) {
  if (files[i].equalsIgnoreCase("META-INF"))
   continue;
  if (files[i].equalsIgnoreCase("WEB-INF"))
   continue;
  if (deployed.contains(files [i]))
   continue;
  File dir = new File(appBase, files [i]);
  if (files[i].toLowerCase().endsWith(".war")) {
   deployed.add(files [i]);
   // Calculate the context path and make sure it is unique
   String contextPath = "/" + files[i];
   int period = contextPath.lastIndexOf(".");
   if (period >= 0)
    contextPath = contextPath.substring(0, period);
   if (contextPath.equals("/ROOT"))
    contextPath = "";
   if (host.findChild(contextPath) != null)
    continue;
   if (isUnpackWARs()) {
    // Expand and deploy this application as a directory
    log(sm.getString("hostConfig.expand", files[i]));
    try {
     URL url = new URL("jar:file:" +
       dir.getCanonicalPath() + "!/");
     String path = expand(url);
     url = new URL("file:" + path);
     ((Deployer) host).install(contextPath, url);
    }
    catch (Throwable t) {
     log(sm.getString("hostConfig.expand.error", files[i]), t);
    }
   }
   else {
    // Deploy the application in this WAR file
    log(sm.getString("hostConfig.deployJar", files[i]));
    try {
     URL url = new URL("file", null,
       dir.getCanonicalPath());
     url = new URL("jar:" + url.toString() + "!/");
     ((Deployer) host).install(contextPath, url);
    }
    catch (Throwable t) {
     log(sm.getString("hostConfig.deployJar.error",
       files[i]), t);
    }
   }
  }
 }
}

protected void deployDirectories (File appBase, string[] files){
 for (int i = 0; i < files.length; i++) {
  if (files[i].equalsIgnoreCase("META-INF"))
   continue;
  if (files[i].equalsIgnoreCase("WEB-INF"))
   continue;
  if (deployed.contains(files[i]))
   continue;
  File dir = new File(appBase, files[i]);
  if (dir.isDirectory()) {
   deployed.add(files[i]);
   // Make sure there is an application configuration directory
   // This is needed if the Context appBase is the same as the
   // web server document root to make sure only web applications
   // are deployed and not directories for web space.
   File webInf = new File(dir, "/WEB-INF");
   if (!webInf.exists() || !webInf.isDirectory() ||
     !webInf.canRead())
    continue;
   // Calculate the context path and make sure it is unique
   String contextPath = "/" + files[i];
   if (files[i].equals("ROOT"))
    contextPath = "";
   if (host.findChild(contextPath) != null)
    continue;
   // Deploy the application in this directory
   log(sm.getString("hostConfig.deployDir", files[i]));
   try {
    URL url = new URL("file", null, dir.getCanonicalPath());
    ((Deployer) host).install(contextPath, url);
   }
   catch (Throwable t) {
    log(sm.getString("hostConfig.deployDir.error", files[i]), t);
   }
  }
 }
}

if (isLiveDeploy()) {
 threadStart();
 }

  
/**  
 * The background thread that checks for web application autoDeploy     * and changes to the web.xml config.     */    
public void run() {  
 if (debug >= 1)  
  log("BACKGROUND THREAD Starting");  
 // Loop until the termination semaphore is set  
 while (!threadDone) {  
  // Wait for our check interval  
  threadSleep();  
  // Deploy apps if the Host allows auto deploying  
  deployApps();  
  // Check for web.xml modification  
  checkWebXmlLastModified();  
 }  
 if (debug >= 1)  
  log("BACKGROUND THREAD Stopping");  
}

public void backgroundProcess() {
 lifecycle.fireLifecycleEvent("check", null);
}

public void lifecycleEvent(LifecycleEvent event) {
  if (event.getType().equals("check"))
  check();
  ...

protected void check() {
 if (host.getAutoDeploy()) {
 // Deploy apps if the Host allows auto deploying
 deployApps();
 // Check for web.xml modification
 checkContextLastModified();
 }
}

package org.apache.catalina;
        import java.io.IOException;
        import java.net.URL;
/**
 * A <b>Deployer</b> is a specialized Container into which web
 * applications can be deployed and undeployed. Such a Container
 * will create and install child Context instances for each deployed
 * application. The unique key for each web application will be the
 * context path to which it is attached.
 *
 * @author Craig R. McClanahan
 * @version $Revision: 1.6 $ $Date: 2002/04/09 23:48:21 $
 */
public interface Deployer {
    /**
     * The ContainerEvent event type sent when a new application is
     * being installed by <code>install()</code>, before it has been
     * started.
     */
    public static final String PRE_INSTALL_EVENT = "pre-install";
    /**
     * The ContainerEvent event type sent when a new application is
     * installed by <code>install()</code>, after it has been started.
     */
    public static final String INSTALL_EVENT = "install";
    /**
     * The ContainerEvent event type sent when an existing application is
     * removed by <code>remove()</code>.
     */
    public static final String REMOVE_EVENT = "remove";
    /**
     * Return the name of the Container with which this Deployer is
     * associated.
     */
    public String getName();
    /**
     * Install a new web application, whose web application archive is at
     * the specified URL, into this container with the specified context.
     * path. A context path of "" (the empty string) should be used for
     * the root application for this container. Otherwise, the context
     * path must start with a slash.
     * <p>
     * If this application is successfully installed, a ContainerEvent of
     * type <code>INSTALL_EVENT</code> will be sent to all registered
     * listeners,
     * with the newly created <code>Context</code> as an argument.
     *
     * @param contextPath The context path to which this application
     * should be installed (must be unique)
     * @param war A URL of type "jar:" that points to a WAR file, or type
     * "file:" that points to an unpacked directory structure containing
     * the web application to be installed
     *
     * @exception IllegalArgumentException if the specified context path
     * is malformed (it must be "" or start with a slash)
     * @exception IllegalStateException if the specified context path
     * is already attached to an existing web application
     * @exception IOException if an input/output error was encountered
     * during installation
     */
    public void install(String contextPath, URL war) throws IOException;
    /**
     * <p>Install a new web application, whose context configuration file
     * (consisting of a <code>&lt;Context&gt;</code> element) and web
     * application archive are at the specified URLs.</p>
     *
     * <p>If this application is successfully installed, a ContainerEvent
     * of type <code>INSTALL_EVENT</code> will be sent to all registered
     * listeners, with the newly created <code>Context</code> as an
     * argument.
     * </p>
     *
     * @param config A URL that points to the context configuration file
     * to be used for configuring the new Context
     * @param war A URL of type "jar:" that points to a WAR file, or type
     * "file:" that points to an unpacked directory structure containing
     * the web application to be installed
     *
     * @exception IllegalArgumentException if one of the specified URLs
     * is null
     * @exception IllegalStateException if the context path specified in
     * the context configuration file is already attached to an existing
     * web application
     * @exception IOException if an input/output error was encountered
     * during installation
     */
    public void install(URL config, URL war) throws IOException;
    /**
     * Return the Context for the deployed application that is associated
     * with the specified context path (if any); otherwise return
     * <code>null</code>.
     *
     * @param contextPath The context path of the requested web
     * application
     */
    public Context findDeployedApp(String contextPath);
    /**
     * Return the context paths of all deployed web applications in this
     * Container. If there are no deployed applications, a zero-length
     * array is returned.
     */
    public String[] findDeployedApps();
    /**
     * Remove an existing web application, attached to the specified
     * context path. If this application is successfully removed, a
     * ContainerEvent of type <code>REMOVE_EVENT</code> will be sent to
     * all registered listeners, with the removed <code>Context</code> as
     * an argument.
     *
     * @param contextPath The context path of the application to be
     * removed
     *
     * @exception IllegalArgumentException if the specified context path
     * is malformed (it must be "" or start with a slash)
     * @exception IllegalArgumentException if the specified context path
     * does not identify a currently installed web application
     * @exception IOException if an input/output error occurs during
     * removal
     */
    public void remove(String contextPath) throws IOException;
    /**
     * Start an existing web application, attached to the specified
     * context path. Only starts a web application if it is not running.
     *
     * @param contextPath The context path of the application to be
     * started
     * @exception IllegalArgumentException if the specified context path
     * is malformed (it must be "" or start with a slash)
     * @exception IllegalArgumentException if the specified context path
     * does not identify a currently installed web application
     * @exception IOException if an input/output error occurs during
     * startup
     */
    public void start(String contextPath) throws IOException;
    /**
     * Stop an existing web application, attached to the specified
     * context path. Only stops a web application if it is running.
     *
     * @param contextPath The context path of the application to be
     * stopped
     * @exception IllegalArgumentException if the specified context path
     * is malformed (it must be "" or start with a slash)
     * @exception IllegalArgumentException if the specified context path
     * does not identify a currently installed web application
     * @exception IOException if an input/output error occurs while
     * stopping the web application
     */
    public void stop(String contextPath) throws IOException;
}

/**
     * The <code>Deployer</code> to whom we delegate application
     * deployment requests.
     */
    private Deployer deployer = new StandardHostDeployer(this);
    public void install(String contextPath, URL war) throws IOException {
        deployer.install(contextPath, war);
    }
    public synchronized void install(URL config, URL war) throws
            IOException {
        deployer.install(config, war);
    }
    public Context findDeployedApp(String contextPath) {
        return (deployer.findDeployedApp(contextPath));
    }
    public String[] findDeployedApps() {
        return (deployer.findDeployedApps());
    }
    public void remove(String contextPath) throws IOException {
        deployer.remove(contextPath);
    }
    public void start(String contextPath) throws IOException {
        deployer.start(contextPath);
    }
    public void stop(String contextPath) throws IOException {
        deployer.stop(contextPath);
    }

public StandardHostDeployer(StandardHost host) {
 super();
 this.host = host;
}

    public synchronized void install(URL config, URL war)
            throws IOException {
        // Validate the format and state of our arguments
        if (config == null)
            throw new IllegalArgumentException
                    (sm.getString("StandardHost.configRequired"));
        if (!host.isDeployXML())
            throw new IllegalArgumentException
                    (sm.getString("StandardHost.configNotAllowed"));
        // Calculate the document base for the new web application (if
        // needed)
        String docBase = null; // Optional override for value in config file
        if (war != null) {
            String url = war.toString();
            host.log(sm.getString("StandardHost.installingWAR", url));
            // Calculate the WAR file absolute pathname
            if (url.startsWith("jar:")) {
                url = url.substring(4, url.length() - 2);
            }
            if (url.startsWith("file://"))
                docBase = url.substring(7);
            else if (url.startsWith("file:"))
                docBase = url.substring(5);
            else
                throw new IllegalArgumentException
                        (sm.getString("standardHost.warURL", url));
        }
        // Install the new web application
        this.context = null;
        this.overrideDocBase = docBase;
        InputStream stream = null;
        try {
            stream = config.openStream();
            Digester digester = createDigester();
            digester.setDebug(host.getDebug());
            digester.clear();
            digester.push(this);
            digester.parse(stream);
            stream.close();
            stream = null;
        }
        catch (Exception e) {
            host.log
                    (sm.getString("standardHost.installError", docBase), e);
            throw new IOException(e.toString());
        }
        finally {
            if (stream != null) {
                try {
                    stream.close();
                }
                catch (Throwable t) {
                    ;
                }
            }
        }
    }

    public synchronized void install(String contextPath, URL war)
            throws IOException {
        // Validate the format and state of our arguments
        if (contextPath == null)
            throw new IllegalArgumentException
                    (sm.getString("standardHost.pathRequired"));
        if (!contextPath.equals("") && !contextPath.startsWith("/"))
            throw new IllegalArgumentException
                    (sm.getString("standardHost.pathFormat", contextPath));
        if (findDeployedApp(contextPath) != null)
            throw new IllegalStateException
                    (sm.getString("standardHost.pathUsed", contextPath));
        if (war == null)
            throw new IllegalArgumentException
                    (sm.getString("standardHost.warRequired"));
        // Calculate the document base for the new web application
        host.log(sm.getString("standardHost.installing",
                contextPath, war.toString()));
        String url = war.toString();
        String docBase = null;
        if (url.startsWith("jar:")) {
            url = url.substring(4, url.length() - 2);
        }
        if (url.startsWith("file://"))
            docBase = url.substring(7);
        else if (url.startsWith("file:"))
            docBase = url.substring(5);
        else
            throw new IllegalArgumentException
                    (sm.getString("standardHost.warURL", url));
        // Install the new web application
        try {
            Class clazz = Class.forName(host.getContextClass());
            Context context = (Context) clazz.newInstance();
            context.setPath(contextPath);
            context.setDocBase(docBase);
            if (context instanceof Lifecycle) {
                clazz = Class.forName(host.getConfigClass());
                LifecycleListener listener =
                        (LifecycleListener) clazz.newInstance();
                ((Lifecycle) context).addLifecycleListener(listener);
            }
            host.fireContainerEvent(PRE_INSTALL_EVENT, context);
            host.addChild(context);
            host.fireContainerEvent(INSTALL_EVENT, context);
        }
        catch (Exception e) {
            host.log(sm.getString("standardHost.installError", contextPath),
                    e);
            throw new IOException(e.toString());
        }
    }

    public void start(String contextPath) throws IOException {
        // Validate the format and state of our arguments
        if (contextPath == null)
            throw new IllegalArgumentException
                    (sm.getString("standardHost.pathRequired"));
        if (!contextPath.equals("") && !contextPath.startsWith("/"))
            throw new IllegalArgumentException
                    (sm.getString("standardHost.pathFormat", contextPath));
        Context context = findDeployedApp(contextPath);
        if (context == null)
            throw new IllegalArgumentException
                    (sm.getstring("standardHost.pathMissing", contextPath));
        host.log("standardHost.start " + contextPath);
        try {
            ((Lifecycle) context).start();
        }
        catch (LifecycleException e) {
            host.log("standardHost.start " + contextPath + ": ", e);
            throw new IllegalStateException
                    ("standardHost.start " + contextPath + ": " + e);
        }
    }

public void stop(String contextPath) throws IOException {
 // Validate the format and state of our arguments
 if (contextPath == null)
  throw new IllegalArgumentException
    (sm.getstring("standardHost.pathRequired"));
 if (!contextPath.equals("") && !contextPath.startsWith("/"))
  throw new IllegalArgumentException
    (sm.getstring("standardHost.pathFormat", contextPath));
 Context context = findDeployedApp(contextPath);
 if (context == null)
  throw new IllegalArgumentException
    (sm.getstring("standardHost.pathMissing", contextPath));
 host.log("standardHost.stop " + contextPath);
 try {
  ((Lifecycle) context).stop();
 }
 catch (LifecycleException e) {
  host.log("standardHost.stop " + contextPath + ": ", e);
  throw new IllegalStateException
    ("standardHost.stop " + contextPath + ": " + e);
 }
}