How Tomcat works 翻译(2) 之 Wrapper容器

ddddddf

第五章、容器

　　一个容器就是处理一个servlet请求和封装web客户端的相应响应的一个模块。一个容器由org.apache.catalina.Container接口所具有，Tomcat有四种类型容器如：Engine、Host、Context、Wrapper。这章是讲解Context和Wrapper，剩下的两个容器在第13章讲解。这章以讨论Container接口作为开始，紧跟着就是讨论在容器中的管道机制。接下来就要谈论Wrapper和Context接口。两个应用程序总结这章，通过运用一个简单的wrapper和一个简单的context.
　　一、容器接口
　　一个容器一定要实现org.apache.catalina.Container。这如你在第四章看到的，你把Container实例传给Conector对象的setContainer()方法，目的是connector能够调用container的invoke()方法.让我们回想在第四章的Bootstrap类中的代码：
　　HttpConnector connector=new HttpConnector();
　　SimpleContainer container=new SimpleContainer();
　　connector.setContainer(container);
　　第一件事要注意的就是在Catalina容器中有四个不同概念层次的容器：
　　1）Engine   代表整个Catalina servlet engine
　　2)  Host     代表一个含有一个或者多个的Context的虚拟host
　　3）Context   代表一个Web应用。一个Context包含一个或者更多的wrapper
　　4) Wrapper  代表单个servlet
　　每个上面的容器在org.apache.catalina包中用接口来进行描述，这些接口的名字是：Engine、Host、Context、Wrapper。上面四个接口继承了Container接口。下面四个类StandardEngine、StandardHost、StandardContext、StandardWrapper标准的实现了这四个容器的接口，这四个类在org.apache.catalina.core包中
　　下面的类图说明了Container接口、以及子接口还有他们的实现。注意整个接口在org.apache.catalina包中，其实现是在org.apache.catalina.core包中。
　　

　　注意在上面的类图中，整个实现的类派生了一个抽象的类ContainerBase.
　　一个可以运行的Cataline不需要完完全全的四种类型的容器。比如，在这章第一个应用程序的container模块仅仅是有一个wrapper组成。第二个应用的container模块是由一个Contect和一个Wrapper组成。这章是既没有Engine也没有host容器。
　　一个容器有零个或者更多个孩子容器(要比这个容器的层次低)。例如，正常的一个Context有一个或者多个wrapper,一个Host有零个或者多个Context。然而，四个容器中层次最低的Wrapper容器不能包含有孩子容器。为了添加一个孩子容器给一个容器你要用Container接口的方法addChild，下面是是它的方法签名：
　　public void addChild(Container child);
　　如果要从一个容器中移除孩子容器，就需要调用Container接口的removeChild方法，下面是此方法的签名：
　　public void removeChild(Container child);
　　除此之外Container接口也有寻找一个孩子和找出容器的所有孩子，下面是两个方法的签名：
　　public Container findChild(String name);
　　public Cotainer[] findChildren();
　　一个容器也可以包含许多组件如：Loader、Logger、Manager、Realm、Resources。我们将会在下面的章节谈论这些组件。有一件值得注意的地方就是Container接口提供了get和set方法，目的是Container和这些组件进行关联。这些方法包括：getLoader、setLoader、getLogger、setLogger、getManager、setManager、getRealm、setRealm、getResources、setResources.
　　更有趣的是，Container接口被设计成一种可以用xml文件配置的方式，如：Tomcat管理员想要容器需要什么样的功能只需要在server.xml文件下进行配置就可以了。这种实现是引用了管道技术和一系列的阀门，这些技术将会在“管道任务”这段就行讲解。
　　注意在Tomcat4中的Container接口与Tomcat5有一点点小的区别。比如：在Tomcat4中Container接口有一个map方法，但是在Tomcat5中此方法就没有。
　　二、管道任务
　　这段主要说明：当connector调用了一个Container中的invoke方法将会发生什么事情。这段的又分为四个小部分，主要是讨论在org.apache.catalina包中的四个接口，Pipeline、Valve、ValveContext和Contained.
　　一个Pipeline包含的任务就是容器的调用机制。一个Valve代表着一个具体的任务。在Container的pipeline中有一个基本的valve，而且你也可以添加你所需要的Valve(这个不包含基本的Valve).更令人惊奇的就是这些Valve能够在server.xml文件进行动态编辑。下面是pipeline和他的Valves:
　　如果你想了解servlet过滤器，你就需要想象一下pipeline和他的valves是怎么工作的。一个Pipeline就像一个过滤链，每个valve就是过滤门。想一个过滤器，一个valve能过处理request和response对象。valve完成处理之后，又可以调用pipeline中的一下一个Valve中去。注意这个基本的Valve一直是最后被调用。
　　一个Container可以有一个Pipeline。当Container的Invoke方法被调用，Container就会传递给pipeline中的invoke方法进行处理，pipeline调用了第一个valve然后紧跟着调用下一个，如此类推，直到在pipeline中没有了Valve。因此你可以想象一下在pipeline中的invoke方式调用的伪代码，伪代码请看下面：
　　//调用添加到pipeline中的valve
　　for(int n=0;n<valves.length;i++){
　　valve[n].invoke(...);
　　}
　　//然后就调用the basic valve
　　basicValve.invoke(...);
　　然而，Tomcat设计者选择了一个与众不同的方法就是在org.apache.catalina包中引用了ValveContext接口。在这里会详细说明他的工作原理。
　　当connector调用了invoke()方法，然后调用pipeline中的valves，里面的代码不是十分的复杂。instead，the container 调用了pipeline中的invoke方法。the pipeline接口中的invoke方法的前面在下面，需要注意的就是此方法与the Container接口中的invoke方法是一模一样。
　　public void invoke(Request request,Response response)
　　throws IOException,ServletException;
　　下面的代码是org.apache.catalina.core.ContainerBase类实现了Container接口，并实现了invoke方法，代码如下：
　　public void invoke(Request request,Response response)
　　throws IOException,ServletException{
　　pipeline.invoke(request,response);
　　}
　　Pipeline实例在ContainerBase类中的实例变量中
　　现在，the pipeline必须确保添加在pipeline中的valves和the basic valve一定要别调用。the pipeline创建了一个Valve接口实例。the ValveContext被Pipeline中的内部类所实现，以至于the ValveContext 能够访问the pipeline中的所有成员变量。the ValveContext接口中的invokeNext方法是十分重要的，方法签名如下：
　　public void invokeNext(Request request,Response response)
　　throws IOException,ServletException;
　　创建一个ValveContext实例后，the pipeline就要调用the ValveContext中invokeNext方法。the ValveContext将首先调用the pipeline中的第一个valve,在处理第一个valve任务之前，第一个valve将会调用下一个valve.the ValveContext会传给this给每个valve，这样就可以调用ValveContext中的invokeNext方法，下面的方法签名是Valve接口的invoke方法。
　　public void invoke(Request request,Response response,ValveContext valveContext)
　　throws IOException,ServletException;
　　实现了Valve中的invoke方法就是像下面的代码一样做这些事：
　　public void invoke(Request request,Response response,ValveContext valveContext)

　　throws IOException,ServletException{
　　//通过传给request和response给pipeline中的下一个valve
　　valveContext.invokeNext(request,response);
　　//现在就执行valve应该做的任务
　　....
　　}
　　the org.apache.cataline.core.StandardPipeline类在整个Container实现了Pipeline接口。在Tomcat4.这个类有一个内部类叫做StandardPipelineValveContext(实现了ValveContext接口)，下面的代码就是StandardPipelineValveContext的标准实现：

protected class StandardPipelineValveContext

implements ValveContext {

protected int stage = 0;

public String getInfo() {

return info;

}

public void invokeNext(Request request, Response response)

throws IOException, ServletException {


int subscript = stage;

stage = stage + 1;


// Invoke the requested Valve for the current request thread

if (subscript < valves.length) {

valves[subscript].invoke(request, response, this);

} else if ((subscript == valves.length) && (basic != null)) {

basic.invoke(request, response, this);

} else {

throw new ServletException

(sm.getString("standardPipeline.noValve"));

}


}

}
 　　注解：这种管道方式的调用方式非常值得借鉴，他的调用相当于堆栈形式那样，读者要用心的去调式跟踪一下他们的调用方式。以后在项目可以运用这种方法。强烈推荐。。。。

　　The invokeNext方法使用了subscript和stage变量，这两个变量时控制valve调用的。当首次从pipeline中的invkoe方法中调用时，subscript的值是0，stage的值变成1.因此第一个valve（array index 0）被调用.第一个valve在Pipeline中接收到ValveContext实例，然后就在实现valve接口类中的invokeNext方法被调用(这样如此有回调回来了)。然而，the subscript的值变成1以至于第二个valve被调用，以此类推。
　　当the invokeNext方法被调用到最后一个valve时，subscript的值与valves的值是相等的。结果，the basic valve被调用。
　　Tomcat5从StandadrPipeline中移除了内部类StandardPipelineValve，而是依赖于org.apache.core包中的StandardValveContext类。下面会呈现出其代码：
　　


 


 

　　你能看到在Tomcat4中的StandardPipelineValveContext类与在Tomcat5中的StandardPipelineValveContext有什么类似的吗？
　　我们将会更详细的解释the Pipeline、Valve、ValveContext接口。同时也会讨论在org.apache.catalina.Contained接口(这个接口有一个Valve类实现)。
　　三、The Pipeline接口
　　The Pipeline接口的第一个方法，我们已经提到了就是invoke方法，一个Container在Pipeline调用Valves的invoke方法和basic valve。the Pipeline接口允许你添加一个Valve（通过调用addValve方法），允许移除一个Valve(通过调用removeValve方法)。最后，你需要用setBasic方法分配一个basic valve给pipeline,而getBasic方法是获得basic valve.最后被调用的Invoke方法的basic valve主要负责处理the request和相应的response。下面的代码是The Pipeline接口：

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接口
　　The Valve接口代表了一个阀值，主要是处理request请求。这个接口有两个方法：invoke和getInfo方法。The invoke方法已经在上面讨论了。The getInfo方法就是返回实现Valve的相关信息。下面是关于Valve接口的代码：

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接口
　　这个接口有两个方法：The invokeNext方法，此方法已经在上面讨论了，the getInfo方法是返回实现ValveContext接口类的相关信息。下面代码是The ValveContext接口：

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接口
　　一个Valve类能够任意实现the org.apache.catalina.Contained接口。实现这个接口的类主要的目的就是想和一个Container实例相关(至多一个)，下面是The Contained接口的代码：

package org.apache.catalina;
public interface Contained {
public Container getContainer();
public void setContainer(Container container);
}
　　七、The Wrapper接口
　　The org.apache.catalina.Wrapper接口代表了一个封装。A Wrapper是代表了一个单个的Servlet定义的信息的容器。The Wrapper接口继承了Container接口还添加许多新的方法。实现Wrapper接口主要的责任就是管理Servlet的生命周期，比如：调用init、service、destory方法。由于一个Wrapper是容器中层次最低的一个，所有它是不允许添加孩子。如果用户调用了addChild方法，那么就会抛出IllegalArgumentException异常。
　　在Wrapper接口中最为重要的方法还是allocate和load方法。
　　The allocate方法为the servlet初始化实例。The allocate方法也在考虑是否the servlet实现了javax.servlet.SingleThreadModel接口，但是我们将会在下面的章节讨论(11章)。The load 方法就是加载和初始化servlet实例。下面是allocate和load方法标签：
　　public javax.servlet.Servlet allocate() throws javax.servlet.ServletException;
　　public void load() throws javax.servlet.ServletException;
　　当我们在讨论org.apache.catalina.core.StandardWrapper类(这个是在第11章讨论)，我们才会谈论Wrapper接口的其他方法。
　　八、The Context 接口
　　一个Context代表了一个Web应用的容器。一个Context通常有一个或者更多的Wrappers作为它的孩子容器。
　　此接口有重要的方法就是addWrapper、createWrapper等，这个接口将会在第12章会详细的讲到。
　　九、The Wrapper应用程序
　　这个应用程序为了证明怎样写一个微型的container模块。这个应用的核心类是ex05.pyrmont.core.SimpleWrapper(实现了Wrapper接口)。一个Pipeline(这个接口被ex05.pyront.core.SimplePipeline类实现)和一个Loader接口（被ex05.pyront.core.SimpleLoader实现）是The SimpleWrapper类的成员变量。The Pipeline包含了一个basic valve(ex05.pyrmont.core.SimpleWrapperValve)和两个valves(ex05.pyrmont.core.ClientIPLogger和ex05.pyrmont.core.HeaderLoggerValve)。下面是这个应用程序的类图：
　　


   注意The container 使用了Tomocat4的默认连接器
　　The wrapper封装了ModernServlet(这个你应该在前面的章节使用过)这个应用程序证明：你有一个由仅仅一个Wrapper组成的servlet容器。整个类没有完完全全的实现整个功能，但是实现的一些方法将会在这些类中呈现出来。现在让我们来详细了解这些类的运行。
　　十、ex05.pyrmont.core.SimpleLoader
　　在容器中加载servlet类的任务被指定给实现Loader接口类的身上。在这个应用中SimpleLoader类就充当这个责任。SimpleLoader要知道servlet类的位置，并要有一个getClassLoader方法，目的就是返回一个java.lang.ClassLoader实例（搜索servlet类的位置）。The 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;
　　The SimpleLoader类的构造函数初始化the class loader,目的是为了准备返回一个the SimpleWrapper实例。

  public SimpleClassLoader() {
try {
URL[] urls = new URL[1];
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() );
}
}
　　这个构造函数的代码在前面的章节出现过，这里就不在详细的解释。
　　The Container成员变量代表的是The Container与这个Loader相关联。
　　注意的是Loaders将会在第八章会详细的讨论。
　　十一、ex05.pyrmont.core.SimplePipeline
　　The SimplePipeline类实现了org.apache.catalina.Pipeline接口。十分重要的方法就是the invoke方法，它同时也包含了一个内部类SimplePipelineValveContext.SimplePipelineValveContext实现了org.apache.catalina.ValveContext接口
　　这个实现的细节在"Pipelining Task"中已经讨论了。
　　十二、ex05.pyrmont.core.SimpleWrapper
　　这个类实现了org.apache.catalina.Wrapper接口，并且实现了allocate和load方法。其他的就是，这个类定义了以下
　　成员变量：

private Loader loader;
private Container parent;
　　The loader成员变量是一个常常用到的类加载器接口。The parent成员变量代表了这个Wrapper的父类容器，这样就意味着这个wrapper能够成为别的容器(Conetx)的孩子容器。
　　特别注意的就是SimpleWrapper类中的getLoader方法，下面就是其代码：

public Loader getLoader() {
if(loader!=null)
return loader;
else if(parent!=null)
return parent.getLoader();
return null;
}
　　The getLoader方法返回一个Loader(经常加载一个sevlet类)，如果the Wrapper与一个Loader相关联，这个Loader就会返回。如果没有，就会返回父类容器的Loader。如果父类容器也没有，那么就只能返回null.
　　The SimpleWrapper类有一个pipeline和设置一个basic valve给pipeline.你会在the SimpleWrapper构造函数中会做这样的事，下面的代码进行说明：

public SimpleWrapper() {
pipeline.setBasic(new CallServletValve());
}
　　这儿pipeline作为SimplePipeline类的成员变量，代码如图所示：

/***
* 只要new SimpleWrapper()就把Container容器传过来，
* 因为SimpleWrapper实现了Wrapper接口而Wrapper继承了
* Container接口,注意的是为什么要new SimpleWrapper()
* 呢？   
* 这是因为SimpleWrapper这个类代理调用了SimplePipeLine
* 的方法，这样做的好处就是客户写程序时不再去面对SimplePipeLine类，
* 而只需要关注SimpleWrapper这个类的方法就行，
*/
private SimplePipeline pipeline = new SimplePipeline(this);
 　　十三、ex05.pyrmont.core.SimpleWrapperValve
　　The SimpleWrapperValve类是一个the basic valve(专门处理the SimpleWrapper类中的request请求)。SimpleWrapperValve实现了the org.apache.catalina.Valve接口，同时还实现了the org.apache.catalina.Contained接口。在SimpleWrapperValve十分重要的方法就是the invoke方法，下面是其方法的代码：

public void invoke(Request request, Response response,
ValveContext context)
throws IOException, ServletException {
//System.out.println("这个是CallServletValve中的容器："+getContainer());
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;
// 分配一个servlet实例，调用servlet中service()方法
try {
servlet = wrapper.allocate();
if (hres!=null && hreq!=null) {
servlet.service(hreq, hres);
}
else {
servlet.service(sreq, sres);
}
}
catch (ServletException e) {
}
}
　　因为SimpleWrapperValve被作为basic valve，所以The invoke方法不需要调用the ValveContext中的invokeNext方法。The invoke方法调用了the SimpleWrapper类中的the allocate方法，目的是获得一个servlet实例，然而该实例就会调用本身方法service。注意the Wrapper的pipeline中的the basic valve调用了servlet的service方法，而不是the wrapper本身调用的。
　　十四、ex05.pyrmont.valves.ClientIPLoggerValve
　　The ClientIPLoggerValve类主要职责就是把客户的IP地址打印在控制台上，下面是其代码：

package org.hewen.jerry.conatiner;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import org.apache.catalina.Request;
import org.apache.catalina.Response;
import org.hewen.jerry.inter.Contained;
import org.hewen.jerry.inter.Container;
import org.hewen.jerry.inter.Valve;
import org.hewen.jerry.inter.ValveContext;
public class ClientLoggerValve implements Contained, Valve {
protected Container container;
public Container getContainer() {
return this.container;
}
public void setContainer(Container container) {
this.container=container;
}
public void invoke(Request request, Response response, ValveContext context)
throws IOException, ServletException {
context.invokeNext(request, response);
System.out.println("该阀门的职责就是获取客户端的IP");
// System.out.println("这是ClientLoggerValve容器："+getContainer());
ServletRequest sreq = request.getRequest();
System.out.println(sreq.getRemoteAddr());
System.out.println("------------------------------------");
}
}
　　注意the invoke方法。the invoke第一件事就是调用了The ValveContext的invokeNext方法，这样调用的目的就是为了在pipeline中调用下一个valve的invoke方法。这个类也打印了一些字符串包括输出了the request对象的远程地址方法。
　　十五、ex05.pyrmont.valves.HeaderLoggerValve
　　这个类与the ClientIPLoggerValve类十分相似，The HeaderLoggerValve类主要职责就是在控制台上打印the request的相关信息。下面的代码所示：

package org.hewen.jerry.conatiner;
import java.io.IOException;
import java.util.Enumeration;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.http.HttpServletRequest;
import org.apache.catalina.Request;
import org.apache.catalina.Response;
import org.hewen.jerry.inter.Contained;
import org.hewen.jerry.inter.Container;
import org.hewen.jerry.inter.Valve;
import org.hewen.jerry.inter.ValveContext;
public class HeaderLoggerValve implements Contained, Valve {
protected Container container;
public Container getContainer() {
return this.container;
}
public void setContainer(Container container) {
this.container=container;
}

public void invoke(Request request, Response response, ValveContext context)
throws IOException, ServletException {
context.invokeNext(request, response);
System.out.println("这个阀门所做的事就是获取请求头的信息");
//System.out.println("这个是HeaderLoggerValve容器："+getContainer());
ServletRequest serRequest=request.getRequest();
if(serRequest instanceof HttpServletRequest){
HttpServletRequest hsr=(HttpServletRequest)serRequest;
Enumeration names=hsr.getHeaderNames();
while(names.hasMoreElements()){
String name=names.nextElement().toString();
String value=hsr.getHeader(name);
System.out.println(name+" :"+value);
}
}else{
System.out.println("没有相应Http请求");
}
System.out.println("----------------------------------");
}
}

　　现在反复强调特别注意the invoke 方法。the invoke第一件事就是调用了The ValveContext的invokeNext方法，这样调用的目的就是为了在pipeline中调用下一个valve的invoke方法。这个类也打印了一些头部信息。
　　十六、ex05.pyrmont.startup.Bootstrap1
　　The Bootstrap1类是用来启动这个应用程序，下面给出其代码：

package ex04.pyrmont.startup;
import org.apache.catalina.connector.http.HttpConnector;
import org.hewen.jerry.conatiner.ClientLoggerValve;
import org.hewen.jerry.conatiner.HeaderLoggerValve;
import org.hewen.jerry.conatiner.SimpleClassLoader;
import org.hewen.jerry.conatiner.SimpleWrapper;
import org.hewen.jerry.inter.Loader;
import org.hewen.jerry.inter.Pipeline;
import org.hewen.jerry.inter.Wrapper;
public final class Bootstartup {
public static void main(String[] args){
HttpConnector connector=new HttpConnector();
Wrapper wrapper=new SimpleWrapper();
wrapper.setServletClass("ModernServlet");
Loader loader=new SimpleClassLoader();
ClientLoggerValve clientValve=new ClientLoggerValve();
HeaderLoggerValve headerValve=new HeaderLoggerValve();
((Pipeline)wrapper).addValve(clientValve);
((Pipeline)wrapper).addValve(headerValve);
wrapper.setLoader(loader);
connector.setMyDefContainer(wrapper);
try {
connector.initialize();
connector.start();
System.in.read();
} catch (Exception e) {
e.printStackTrace();
}

}
}

　　创建了HttpConnector和SimpleWrapper实例后，The Bootstrap类的main方法把ModernServlet传给SimpleWrapper的setServletClass方法（即作为参数传递），目的就是为了告知the wrapper要加载以该名称的class。
　　wrapper.setServletClass("ModernServlet");
　　接下来就是创建一个Loader和两个Valves并且把loader传给wrapper,下面代码：
　　Loader loader=new SimpleLoader();
　　Valve valve1=new HeaderLoggerValve();
　　Valve valve2=new ClientIPLoggerValve();
　　wrapper.setLoader(loader);
　　两个valves就会被添加到the wrapper中的pipeline上。
　　((Pipeline)wrapper).addValve(valve1);

        ((Pipeline)wrapper).addValve(valve2);
　　最后，The wrapper被the Connector类的setContainer方法当做参数传递，接着就是the connector 的初始化和启动，下面代码：
　　connector.setContainer(wrapper);
　　try{
　　connector.initialize();
　　connector.start();
　　}
　　下面的代码就是允许用户停止应用
　　System.in.read();
　　十七、运行这个应用程序
　　这里我就不翻译了，我当时做的就是直接在myEclipse中新建一个项目，再把源代码加上去就可以了，运行浏览器url地址就OK。。。。这里就不详细分析。。。。