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

The Pipeline Interface

我们提到的Pipeline接口的第一个方法invoke方法，这个方法是容器用来调用在pipeline中的valve和basic valve的。Pipeline接口允许你使用它的addValve方法来添加一个新的valve和使用removeValve方法来移除一个valve。最后，你使用它的setBasic方法给pipeline来指定一个basic valve和它的getBasic方法获取basic valve。basic valve是在最后被调用的，它负责处理request和相应的response。下面是Pipeline接口：

Listing 5.3: The Pipeline interface   
 
package org.apache.catalina; 
import java.io.IOException; 
 
import javax.servlet.ServletException;
public interface Pipeline { 
   public Valve getBasic(); 
   public void setBasic(Valve valve); 
   public void addValve(Valve valve); 
   public Valve[] getValves(); 
   public void invoke(Request request, Response response) 
     throws IOException, ServletException; 
   public void removeValve(Valve valve); 
} 

The Valve Interface

Valve接口代表了一个valve，这个组件负责处理一个request。这个接口有两个方法：invoke和getInfo。invoke方法在前面已经讨论了。getInfo方法返回关于valve实现的信息。

Listing 5.4: The Valve interface   
package org.apache.catalina; 
import java.io.IOException; 
import javax.servlet.ServletException; 
 
public interface Valve { 
   public String getInfo(); 
   public void invoke(Request request, Response response, 
     ValveContext context) throws IOException, ServletException;
}

The ValveContext Interface

这个接口有两个方法：invokeNext方法在前面讨论了，getInfo方法返回ValveContext实现的信息。

Listing 5.5: The ValveContext interface   
 
package org.apache.catalina;
import java.io.IOException; 
import javax.servlet.ServletException; 
 
public interface ValveContext { 
   public String getInfo(); 
   public void invokeNext(Request request, Response response) 
     throws IOException, ServletException; 
 } 

The Contained Interface

一个valve类可以选择性地实现org.apache.catalina.Contained接口。这个接口表明实现了该接口的类是最多和一个容器实例相关联的。

Listing 5.6: The Contained interface   
 
package org.apache.catalina; 
public interface Contained { 
   public Container getContainer(); 
   public void setContainer(Container container);
}

The Wrapper Interface

org.apache.catalina.Wrapper接口代表了一个wrapper。一个wrapper代表了一个独立的servlet定义的容器。Wrapper接口继承自Container，再添加了一些其他方法。Wrapper的实现负责管理它们底层的servlet类的servlet生命周期。例如：调用servlet的init，service和destroy方法。一个wrapper是容器的最底层，你就不能向它里面添加子容器。如果你向它里面调用addChild方法添加子容器，这时Wrapper会抛出一个IllegalArgumantException异常。

Wrapper接口的重要方法包括:allocate和load。allocate方法分配一个这wrapper所代表的servlet初始化实例。allocate方法必须考虑到这个servlet是否是实现了javax.servlet.SingleThreadModel接口，我们在后面十一章讨论。load方法加载和实例化一个wrapper所代表的servlet。

public javax.servlet.Servlet allocate() throws
javax.servlet.ServletException; 

public void load() throws javax.servlet.ServletException;

The Context Interface

一个context是代表了一个web应用的容器。一个context通常有一个或多个子容器。
重要的方法包括addWrapper，createWrapper等。这接口将在十二章详细讨论。

The Wrapper Application

这个应用程序演示怎么编写一个小的容器模块。核心类是ex05.pyrmont.core.SimpleWrapper,一个Wrapper接口的实现。SimpleWrapper类包含了一个Pipeline(实现了ex05.pyrmont.core.SimplePipeline类)和使用Loader(实现了ex05.pyrmont.core.SimpeLoader)来加载servlet。Pipeline包含了一个basic valve(ex05.pyrmont.core.SimpleWrapperValve)和两个valve(ex05.pyrmont.core.ClientIPLoggerValve 和ex05.pyrmont.core.HeaderLoggerValve)

类图：


wrapper包装了在前几章使用过的ModernServlet。这个应用程序证实了你可以使用一个只有一个wrapper组成的servlet容器。

ex05.pyrmont.core.SimpleLoader

在容器中加载servlet类的任务分配给Loader来完成这个功能。在这个应用中，SimpleLoader类就是Loader实现。它知道servlet类的路径，它的getClassLoader方法返回一个java.lang.ClassLoader实例来搜索servlet类的路径。SimpleLoader类声明了三个变量。第一个是WEB_ROOT，它指向能找到servlet类所在的目录。

public static final String WEB_ROOT = 
   System.getProperty("user.dir") + File.separator  + "webroot";

其他两个变量时ClassLoader和Container的对象引用。

ClassLoader classLoader = null; 
Container container = null;

SimpleLoader类的构造函数初始化类加载器，并返回给SimpleWrapper实例。

public SimpleLoader() { 
     try { 
       URL[] urls = new URL[l]; 
       URLStreamHandler streamHandler = null; 
       File classPath = new File(WEB_ROOT); 
       String repository = (new URL("file", null, 
classPath.getCanonicalPath() + File.separator)).toString() ; 
       urls[0] = new URL(null, repository, streamHandler); 
       classLoader = new URLClassLoader(urls); 
     }catch (IOException e) { 
       System.out.println(e.toString() ); 
     } 
}

构造函数里面的代码用来初始化应用程序中的类加载器。
容器的变量代表了与这个加载器相关联的容器。Loader会在第八章讨论。

ex05.pyrmont.core.SimplePipeline

SimplePipeline类实现了org.apache.catalina.Pipeline接口。最重要的方法是invoke方法，里面包含一个内部类SimplePipelineValveContext。SimplePipelineValveContext实现了org.apache.catalina.ValveContext接口。

ex05.pyrmont.core.SimpleWrapper

这个类实现了org.apache.catalina.Wrapper接口和提供了allocate和load方法的实现。它还声明了下面的变量：

private Loader loader; 
protected Container parent = null;

loader变量是一个Loader，它用来加载servlet类。parent变量代表一个这个wrapper的父容器。这意味着wrapper可以是另一个容器的子容器(就像是Context的子容器)。注意一下getLoader方法：

public Loader getLoader() { 
   if (loader != null) 
     return (loader); 
   if (parent != null) 
     return (parent.getLoader()); 
   return (null); 
}

getLoader方法返回一个用来加载servlet类的Loader。如果wrapper和一个Loader相关联，这个Loader将被返回。如果没有相关的，就返回Loader的父容器。如果没有preant变量，getLoader就返回null。

SimpleWrapper类有一个pipeline并在pipeline中设置了一个basic valve。

public SimpleWrapper() { 
 	pipeline.setBasic(new SimpleWrapperValve()); 
} 

这里，pipeline是一个在类中声明的SimplePipeline实例：

private SimplePipeline pipeline = new SimplePipeline(this);

ex05.pyrmont.core.SimpleWrapperValve

SimpleWrapperValve类是basic valve用来为SimpleWrapper类处理请求。它实现了org.apache.catalina.Valve接口和org.apache.catalina.Contained接口。在SimpleWrapperValve中最重要的方法invoke方法。

Listing 5.9: The SimpleWrapperValve class's invoke method   
 
public void invoke(Request request, Response response, 
   ValveContext valveContext) 
   throws IOException, ServletException { 
 
   SimpleWrapper wrapper = (SimpleWrapper) getContainer(); 
   ServletRequest sreq = request.getRequest(); 
   ServletResponse sres = response.getResponse(); 
   Servlet servlet = null; 
   HttpServletRequest hreq = null; 
   if (sreq instanceof HttpServletRequest)
     hreq = (HttpServletRequest) sreq; 
   HttpServletResponse hres = null; 
   if (sres instanceof HttpServletResponse) 
     hres = (HttpServletResponse) sres; 
   // Allocate a servlet instance to process this request 
   try { 
     servlet = wrapper.allocate(); 
     if (hres!=null && hreq!=null) { 
       servlet.service(hreq, hres); 
     } 
     else { 
       servlet.service(sreq, sres)
     hreq = (HttpServletRequest) sreq; 
   HttpServletResponse hres = null; 
   if (sres instanceof HttpServletResponse) 
     hres = (HttpServletResponse) sres; 
   // Allocate a servlet instance to process this request 
   try { 
     servlet = wrapper.allocate(); 
     if (hres!=null && hreq!=null) { 
       servlet.service(hreq, hres); 
     } 
     else { 
       servlet.service(sreq, sres)
     } 
   } catch (ServletException e) { 
   } 
}

因为SimpleWrapperValve是作为一个basic valve，所以它的invoke方法不需要调用传递给它的ValveContext的invokeNext方法。invoke方法调用SimpleWrapper类的allocate方法获取一个代表wrapper的servlet实例。注意wrapper中pipeline的basic valve调用servlet的service方法。而不是调用wrapper它自己。

ex05.pyrmont.valves.ClientIPLoggerValve

ClientIPLoggerValve类是一个valve，它是打印客户端的IP地址到控制台。

Listing 5.10: The ClientIPLoggerValve class   
package ex05.pyrmont.valves; 
 
import java.io.IOException; 
import javax.servlet.ServletRequest; 
import javax.servlet.ServletException; 
import org.apache.catalina.Request; 
import org.apache.catalina.Response;
import org.apache.catalina.Valve; 
import org.apache.catalina.ValveContext; 
import org.apache.catalina.Contained; 
import org.apache.catalina.Container; 
 
public class ClientIPLoggerValve implements Valve, Contained { 
    protected Container container; 
    public void invoke(Request request, Response response, 
    ValveContext valveContext) throws IOException, ServletException { 
    // Pass this request on to the next valve in our pipeline 
    valveContext.invokeNext(request, response); 
    System.out.println("Client IP Logger Valve"); 
    ServletRequest sreq = request.getRequest(); 
    System.out.println(sreq.getRemoteAddr());
    System, out.println("-----------------------------------"); 
   } 
 	 public String getInfo() { 
     	return null; 
  	} 
  	 public Container getContainer() { 
     return container; 
   }
   public void setContainer(Container container) { 
     this.container = container; 
   } 
}

注意invoke方法。第一件要做的事是invoke方法调用valve context 的invokeNext方法来调用pipeline中的下一个valve。然后打印几行字符串,包括请求对象的getRemoteAddress方法的输出。

ex05.pyrmont.valves.HeaderLoggerValve

这个类和ClientIPLoggerValve类相似。HeaderLoggerValve类是打印请求头部信息到控制台。

Listing 5.11: The HeaderLoggerValve class   
 
package ex05.pyrmont.valves; 
 
import java.io.IOException; 
import java.util.Enumeration; 
import javax.servlet.ServletRequest; 
import javax.servlet.ServletException; 
import javax.servlet.http.HttpServletRequest; 
import org.apache.catalina.Request;
import org.apache.catalina.Response; 
import org.apache.catalina.Valve; 
import org.apache.catalina.ValveContext; 
import org.apache.catalina.Contained; 
import org.apache.catalina.Container; 
 
public class HeaderLoggerValve implements Valve, Contained {
protected Container container; 
public void invoke(Request request, Response response, 
    ValveContext valveContext) throws IOException, ServletException { 
    // Pass this request on to the next valve in our pipeline 
    valveContext.invokeNext(request, response); 
    System.out.println("Header Logger Valve"); 
    ServletRequest sreq = request.getRequest(); 
    if (sreq instanceof HttpServletRequest) { 
      HttpServletRequest hreq = (HttpServletRequest) sreq; 
      Enumeration headerNames = hreq.getHeaderNames();
   while (headerNames.hasMoreElements()) { 
         String headerName = headerNames.nextElement().toString(); 
         String headerValue = hreq.getHeader(headerName); 
         System.out.println(headerName + ":" + headerValue); 
       } 
 
     } 
     else 
       System.out.println("Not an HTTP Request"); 
 
     System.out.println ("-----------------------------------");
   } 
 
   public String getInfo() { 
     return null; 
   } 
   public Container getContainer() { 
     return container; 
   } 
   public void setContainer(Container container) {
     this.container = container; 
   } 
} 

再一次，注意invoke方法。第一件事是invoke方法调用valve context 的invokeNext方法调用pipeline的下一个valve。然后打印头部信息值。

ex05.pyrmont.startup.Bootstrap1

Bootstrap1类用来启动这个应用程序。

Listing 5.12: The Bootstrap1 class   
 
package ex05.pyrmont.startup; 
import ex05.pyrmont.core.SimpleLoader; 
import ex05.pyrmont.core.SimpleWrapper; 
import ex05.pyrmont.valves.ClientlPLoggerValve; 
import ex05.pyrmont.valves.HeaderLoggerValve; 
import org.apache.catalina.Loader; 
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 Bootstrap1 { 
   public static void main(String[] args) { 
     HttpConnector connector = new HttpConnector(); 
    Wrapper wrapper = new SimpleWrapper(); 
     wrapper.setServletClass("ModernServlet"); 
     Loader loader = new SimpleLoader(); 
     Valve valve1 = new HeaderLoggerValve();
     Valve valve1 = new HeaderLoggerValve(); 
     Valve valve2 = new ClientIPLoggerValve(); 
     wrapper.setLoader(loader); 
     ((Pipeline) wrapper).addValve(valve1); 
     ((Pipeline) wrapper).addValve(valve2); 
     connector.setContainer(wrapper);
  try { 
       connector.initialize(); 
       connector.start(); 
       // make the application wait until we press a key. 
       System.in.read(); 
     } catch (Exception e) { 
       e.printStackTrace(); 
     } 
   }
}

创建一个HttpConnector和SimpleWrapper实例后，Bootstrap类的主方法把ModernServlet指配给SimpleWrapper的setServlet方法，通知wrapper，类的名字被加载。

wrapper.setServletClass("ModernServlet");

然后创建一个loader和两个valve，把loader设置给wrapper：

Loader loader = new SimpleLoader(); 
Valve valve1 = new HeaderLoggerValve(); 
Valve valve2 = new ClientIPLoggerValve(); 
wrapper.setLoader(loader);

两个valve被加入到wrapper的pipeline中：

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

最后，wrapper被设置为连接器的容器，然后连接器初始化并启动。

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

下面一行允许用户通过在控制台按Enter键停止应用程序。

// make the application wait until we press Enter. 
System.in.read();

Running the Application