Coder 爱翻译 How Tomcat Works 第五章 第三部分

[size=large]The Context Application[/size]

这章的第一个应用，你了解了怎么部署一个只有一个wrapper组成的简单的web应用程序。这个应用中只有一个servlet。在一个应用中，只要一个单独的servlet是可能的，但大多数情况下需要更多。在这种情况下，你需要和wrapper相比不同的容器类型。你就需要一个context。

第二个应用程序演示了怎么使用一个有两个wrapper的context，context包装了两个servlet类。当有多于一个wrapper的时候，你就需要用到一个映射器(mapper)。mapper它是一个帮助容器(本例中是context)选择一个子容器来处理特定的请求的组件。

注意一个mapper只能在Tomcat 4中找到，在Tomcat 5中使用另外一种方式找到一个子容器。

mapper是ex05.pyrmont.core.SimpleContextMapper类的实例，它实现org.apache.catalina.Mapper接口。
一个容器也使用多个mapper来支持多协议。这种情况下，一个mapper支持一种请求协议。例如：一个容器可能有一个为HTTP协议的mapper，另外一个是HTTPS协议的mapper。

Listing 5.13: The Mapper interface   

package org.apache.catalina; 
public interface Mapper { 

   public Container getContainer(); 
   public void setContainer(Container container); 
   public String getProtocol(); 
   public void setProtocol(String protocol); 
   public Container map(Request request, boolean update);
}

getContainer方法返回与mapper相关联的容器，setContainer方法是用来把一个mapper和一个容器相关联。getProtocal方法返回这个mapper负责处理的协议，setProtocol方法用来指配这个mapper负责处理的协议的名字。map方法返回一个用来处理特定的请求的子容器。
类图：
[img]http://dl.iteye.com/upload/attachment/359728/3ecc0335-fb8d-34df-965a-cff5c093ba37.jpg[/img]

SimpleContext类代表一个context。它使用SimpleContextMapper作为它的mapper，SimpleContextValve作为basic valve。两个valve：ClientIPLoggerValve 和HeaderLoggerValve
被添加到context。两个wrapper，用SimpleWrapper代表，被作为子容器添加到context。
wrapper使用SimpleWrapperValve作为它们的basic valve，但是没有其他的valve。

Context应用程序使用相同的loader和两个valve。但是loader和valve是和context相关联的，而不是和wrapper相关联。这样，loader可以被所有的wrapper使用。context被指配为一个连接器的容器。此外，连接器在收到一个HTTP请求时将调用context的invoke方法。

 1：一个容器有一个pipeline。容器的invoke方法调用pipeline的invoke方法。
 2：pipeline的invoke方法调用所有的添加在容器里的valve。然后调用它的basic valve的invoke方法。
 3：在一个wrapper中，basic valve负责加载相关联的servlet和相关request。
 4：在一个有子容器的context中，basic valve使用mapper来找到一个负责处理请求的子容器。如果一个子容器被找到，它调用子容器的invoke方法，然后返回第一步。

现在看看在实现中的处理：
SimpleContext类的invoke方法调用pipeline的invoke方法：

The SimpleContext class's invoke method calls the pipeline's invoke method. 
   public void invoke(Request request, Response response) 
     throws IOException, ServletException { 
     pipeline.invoke(request, response); 
   }

pipeline是由SimplePipeline类代表。它的invoke方法：

public void invoke(Request request, Response response) 
     throws IOException, ServletException { 
     // Invoke the first Valve in this pipeline for this request 
     (new SimplePipelineValveContext()).invokeNext(request, response); 
   }

SimpleContextValve使用context的mapper找到wrapper：

// Select the Wrapper to be used for this Request 
Wrapper wrapper = null; 
  try { 
    wrapper = (Wrapper) context.map(request, true); 
  }

如果找到一个wrapper，它的invoke方法将被调用。

wrapper.invoke(request, response);

一个应用程序中的wrapper是SimpleWrapper类代表的。这里invoke方法：

public void invoke(Request request, Response response) 
    throws IOException, ServletException { 
    pipeline.invoke(request, response); 
  }

这个pipeline是一个SimplePipeline的实例。这个wrapper除了basic valve(SimpleArapperValve的实例)就没有其他valve。wrapper的pipeline调用SimpleWrapperValve类的invoke方法来分配servlet，调用它的service方法。

注意wrapper和一个loader是不相关联的，但是和context是相关联的。SimpleWrapper类的getLoader方法返回父类的loader。

SimpleContext, SimpleContextValve, SimpleContextMapper和Bootstrap2

[size=large]ex05.pyrmont.core.SimpleContextValve[/size]

这个类代表SimpleContext的basic valve。它的重要方法：invoke：

public void invoke(Request request, Response response,ValveContext valveContext) 
   throws IOException, ServletException { 
   // Validate the request and response object types 
   if (!(request.getRequest() instanceof HttpServletRequest) || 
     !(response.getResponse() instanceof HttpServletResponse)) { 
     return; 
   }
   // Disallow any direct access to resources under WEB-INF or META-INF 
   HttpServletRequest hreq = (HttpServletRequest) request.getRequest(); 
   String contextPath = hreq.getContextPath(); 
   String requestURI = ((HttpRequest) request).getDecodedRequestURI(); 
   String relativeURI = requestURI.substring(contextPath.length()).toUpperCase();
   Context context = (Context) getContainer(); 
   // Select the Wrapper to be used for this Request 
   Wrapper wrapper = null; 
   try { 
     wrapper = (Wrapper) context.map(request, true); 
   }catch (IllegalArgumentException e) { 
     badRequest(requestURI, (HttpServletResponse) 
       response.getResponse()); 
       return; 
   }
   if (wrapper == null) { 
     notFound(requestURI, (HttpServletResponse) response.getResponse()); 
     return; 
   } 
   // Ask this Wrapper to process this Request 
   response.setContext(context); 
   wrapper.invoke(request, response); 
} 

[size=large]ex05.pyrmont.core.SimpleContextMapper[/size]

SimpleContextMapper类，实现了org.apache.catalina.Mapper接口。

Listing 5.15: The SimpleContextMapper class   

package ex05.pyrmont.core; 

import javax.servlet.http.HttpServletRequest; 
import org.apache.catalina.Container; 
import org.apache.catalina.HttpRequest; 
import org.apache.catalina.Mapper; 
import org.apache.catalina.Request; 
import org.apache.catalina.Wrapper; 

public class SimpleContextMapper implements Mapper { 

   private SimpleContext context = null; 
   public Container getContainer() { 
     return (context); 
   }
  public void setContainer(Container container) { 
     if (!(container instanceof SimpleContext)) 
       throw new IllegalArgumentException ("Illegal type of container"); 
       context = (SimpleContext) container; 
   } 
  public String getProtocol() { 
     return null; 
   } 
   public void setProtocol(String protocol) {  }
   public Container map(Request request, boolean update) { 
     // Identify the context-relative URI to be mapped 
     String contextPath = ((HttpServletRequest) request.getRequest()).getContextPath(); 
     String requestURI = ((HttpRequest) request).getDecodedRequestURI(); 
     String relativeURI = requestURI.substring(contextPath.length()); 
     // Apply the standard request URI mapping rules from 
     // the specification 
     Wrapper wrapper = null; 
     String servletPath = relativeURI; 
     String pathInfo = null; 
     String name = context.findServletMapping(relativeURI); 
     if (name != null) 
       wrapper = (Wrapper) context.findChild(name);
  	   return (wrapper);
}
}

SetContainer方法当在你如果传递的一个容器不是SimpleContext的实例，它将抛出一个IllegalArgumentException异常。map方法返回一个子容器(wrapper)负责来处理请求。map方法有两个参数，一个request对象和一个boolean值。实现将忽略第二个参数。这个方法是从请求对象中获取context路径和使用context的findServletMapping方法获取相关的路径名。如果一个路径名被找到，它使用context的findChild方法获取一个Wrapper的实例。

[size=large]ex05.pyrmont.core.SimpleContext[/size]

SimpleContext类是context的实现。它是与连接器相关联的主容器。但是处理每一个单独的servlet是wraper完成的。这个应用有两个servlet：PrimitiveServlet 和ModernServlet。每一个wrapper有一个名字。PrimitiveServlet 的wrapper名字是Primitive，ModernServlet的wrapper的名字是Morden。SimpleContext决定哪一个wrapper将被调用来处理每一个请求。你必须映射请求URL和wrapper的名字。这个应用中，我们有两个URL可以用来调用两个wrapper。第一个是/Primitive，是用来映射到wrapper Primitive。第二个是/Modern,是映射到wrapper Modern。

这里有很多Container和Context接口的方法在SimpleContext中必须实现。大多方法是空方法。

addServletMapping：增加一个URL/wrapper名字对。你每增加一个URL就可以用给出的相应的名字来调用这个wrapper。
findServletMapping：获取给出的URL对应的wrapper的名字。这个方法用来找到哪个wrapper应该被某个特定的URL调用。如果给出的URL没有使用addServletMapping方法来注册，这个方法就返回null。
addMapper：给context增加一个mapper。SimpleContext类声明了mapper变量和mappers变量。mapper是指默认mapper，而mappers包含所有SimpleContext实例的mapper。第一个增加到context的mapper就是默认的mapper。
findMapper：找到正确的mapper。在SimpleContext，它返回默认mapper。
Map：返回负责处理这个请求的wrapper。

此外，SimpleContext也提供addChild、findChild和findChildren方法的实现。addChild方法用来把一个wrapper添加到context中，findChild方法通过名字来找到一个wrapper，findChildren方法返回SimpleContext中的所有wrapper实例。

[size=large]ex05.pyrmont.startup.Bootstrap2[/size]

Listing 5.16: The Bootstrap2 class   

package ex05.pyrmont.startup; 
import ex05.pyrmont.core.SimpleContext; 
import ex05.pyrmont.core.SimpleContextMapper; 
import ex05.pyrmont.core.SimpleLoader; 
import ex05.pyrmont.core.SimpleWrapper; 
import ex05.pyrmont.valves.ClientIPLoggerValve; 
import exO5.pyrmont.valves.HeaderLoggerValve; 
import org.apache.catalina.Connector; 
import org.apache.catalina.Context; 
import org.apache.catalina.Loader; 
import org.apache.catalina.Mapper; 
import org.apache.catalina.Pipeline; 
import org.apache.catalina.Valve; 
import org.apache.catalina Wrapper; 
import org.apache.catalina.connector.http.HttpConnector; 

public final class Bootstrap2 { 
   public static void main(String[] args) { 
    HttpConnector connector = new HttpConnector(); 
    Wrapper wrapper1 = new SimpleWrapper(); 
    Wrapper1.setName("Primitive"); 
    wrapper1.setServletClass("PrimitiveServlet"); 
    Wrapper wrapper2 = new SimpleWrapper(); 
    wrapper2.setName("Modern"); 
    wrapper2.setServletClass("ModernServlet");
    Context context = new SimpleContext(); 
    context.addChild(wrapper1); 
    context.addChild(wrapper2);
    Valve valve1 = new HeaderLoggerValve(); 
    Valve valve2 = new ClientIPLoggerValve(); 
    ((Pipeline) context).addValve(valve1); 
    ((Pipeline) context).addValve(valve2); 
    Mapper mapper = new SimpleContextMapper(); 
    mapper.setProtocol("http"); 
    context.addMapper(mapper); 
    Loader loader = new SimpleLoader(); 
    context.setLoader(loader); 
    // context.addServletMapping(pattern, name); 
    context.addServletMapping("/Primitive", "Primitive"); 
    context.addServletMapping("/Modern", "Modern"); 
    connector.setContainer(context);
    try { 
       connector.initialize(); 
       connector.start(); 
       // make the application wait until we press a key. 
       System.in.read(); 
     } catch (Exception e) { 
       e.printStackTrace(); 
     } 
   } 
} 

主方法开始实例化Tomcat默认连接器和两个wrapper：wrapper1和wrapper2。

HttpConnector connector = new HttpConnector(); 
Wrapper wrapper1 = new SimpleWrapper(); 
wrapper1.setName("Primitive");  
wrapper1.setServletClass("PrimitiveServlet"); 

Wrapper wrapper2 = new SimpleWrapper(); 
wrapper2.setName("Modern"); 
wrapper2.setServletClass("ModernServlet");

然后，主方法创建一个SimpleContext的实例，添加wrapper1和wrapper2作为SimpleContext的容器的子容器，实例化两个valveClientIPLoggerValve和 HeaderLoggerValve,
并把他们两个valve添加到SimpleContext。

Context context = new SimpleContext(); 
context.addChild(wrapper1); 
context.addChild(wrapper2); 

Valve valve1 = new HeaderLoggerValve(); 
Valve valve2 = new ClientIPLoggerValve(); 

((Pipeline) context).addValve(valve1); 
((Pipeline) context).addValve(valve2);

接下来它构建一个mapper对象，并把mapper添加到SimpleContext。mapper负责找到在context里的子容器，让其来处理HTTP请求。

Mapper mapper = new SimpleContextMapper(); 
mapper.setProtocol("http"); 
context.addMapper(mapper);

加载servlet类，你需要一个loader。这里你使用SimpleLoader类，就像第一个应用程序一样。但是，不同时是增加两个wrapper，loader被添加到context里。wrapper将使用getLoader方法找到loader，因为context是他们的父容器。

Loader loader = new SimpleLoader(); 
context.setLoader(loader);

现在，该添加servlet映射了。为你添加的两个wrapper作映射。

    // context.addServletMapping(pattern, name); 
    context.addServletMapping("/Primitive", "Primitive"); 
    context.addServletMapping("/Modern", "Modern");

最后，把context作为容器指配给连接器，初始化并启动连接器。

connector.setContainer(context); 
    try { 
      connector.initialize(); 
      connector.start();

第五章 完