程序博客网 > java时间轴

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

来源：互联网 发布：java时间轴 编辑：程序博客网 时间：2024/06/05 21:55

一个容器就是处理一个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的标准实现：

 

Java代码  收藏代码
  1. protected class StandardPipelineValveContext  
  2.   
  3.   
  4.         implements ValveContext {  
  5.   
  6.   
  7.   protected int stage = 0;  
  8.   
  9.   
  10.   public String getInfo() {  
  11.   
  12.   
  13.             return info;  
  14.   
  15.   
  16.         }  
  17.   
  18.   
  19.       public void invokeNext(Request request, Response response)  
  20.   
  21.   
  22.             throws IOException, ServletException {  
  23.   
  24.   
  25.   
  26.   
  27.   
  28.             int subscript = stage;  
  29.   
  30.   
  31.             stage = stage + 1;  
  32.   
  33.   
  34.   
  35.   
  36.   
  37.             // Invoke the requested Valve for the current request thread  
  38.   
  39.   
  40.             if (subscript < valves.length) {  
  41.   
  42.   
  43.                 valves[subscript].invoke(request, response, this);  
  44.   
  45.   
  46.             } else if ((subscript == valves.length) && (basic != null)) {  
  47.   
  48.   
  49.                 basic.invoke(request, response, this);  
  50.   
  51.   
  52.             } else {  
  53.   
  54.   
  55.                 throw new ServletException  
  56.   
  57.   
  58.                     (sm.getString("standardPipeline.noValve"));  
  59.   
  60.   
  61.             }  
  62.   
  63.   
  64.   
  65.   
  66.   
  67.         }  
  68.   
  69.   
  70. }  
 

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

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接口：

 

Java代码  收藏代码
  1. package org.apache.catalina;  
  2.   
  3.   
  4. import java.io.IOException;  
  5. import javax.servlet.ServletException;  
  6. public interface Pipeline {  
  7.     public Valve getBasic();  
  8.     public void setBasic(Valve valve);  
  9.     public void addValve(Valve valve);  
  10.     public Valve[] getValves();  
  11.     public void invoke(Request request, Response response)  
  12.         throws IOException, ServletException;  
  13.      public void removeValve(Valve valve);  
  14.   
  15. }  

 四、The Valve接口

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

 

Java代码  收藏代码
  1. package org.apache.catalina;  
  2.   
  3.   
  4. import java.io.IOException;  
  5. import javax.servlet.ServletException;  
  6. public interface Valve {  
  7.       public String getInfo();  
  8.       public void invoke(Request request, Response response,  
  9.                        ValveContext context)  
  10.         throws IOException, ServletException;  
  11.   
  12. }  

 五、The ValveContext接口

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

Java代码  收藏代码
  1. package org.apache.catalina;  
  2.   
  3.   
  4. import java.io.IOException;  
  5. import javax.servlet.ServletException;  
  6. public interface ValveContext {  
  7.       public String getInfo();  
  8.       public void invokeNext(Request request, Response response)  
  9.         throws IOException, ServletException;  
  10.   
  11. }  

 六、The Contained接口

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

Java代码  收藏代码
  1. package org.apache.catalina;  
  2. public interface Contained {  
  3.     public Container getContainer();  
  4.     public void setContainer(Container container);  
  5.   
  6. }  

 七、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类的目录）。代码如下：

Java代码  收藏代码
  1. public static final String WEB_ROOT =  
  2.         System.getProperty("user.dir") + File.separator  + "webroot";  

 其他的两个变量是ClassLoader和Container应用变量:

Java代码  收藏代码
  1. ClassLoader classLoader = null;  
  2.   Container container = null;  

 The SimpleLoader类的构造函数初始化the class loader,目的是为了准备返回一个the SimpleWrapper实例。

Java代码  收藏代码
  1. public SimpleClassLoader() {  
  2.    try {  
  3.      URL[] urls = new URL[1];  
  4.      URLStreamHandler streamHandler = null;  
  5.      File classPath = new File(WEB_ROOT);  
  6.      String repository = (new URL("file", null, classPath.getCanonicalPath() + File.separator)).toString() ;  
  7.      urls[0] = new URL(null, repository, streamHandler);  
  8.      classLoader = new URLClassLoader(urls);  
  9.    }  
  10.    catch (IOException e) {  
  11.      System.out.println(e.toString() );  
  12.    }  
  13.   
  14.  }  

 这个构造函数的代码在前面的章节出现过，这里就不在详细的解释。

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方法。其他的就是，这个类定义了以下

成员变量：

 

Java代码  收藏代码
  1. private Loader loader;  
  2.   
  3. private Container parent;  

 The loader成员变量是一个常常用到的类加载器接口。The parent成员变量代表了这个Wrapper的父类容器，这样就意味着这个wrapper能够成为别的容器(Conetx)的孩子容器。

 

特别注意的就是SimpleWrapper类中的getLoader方法，下面就是其代码：

 

Java代码  收藏代码
  1. public Loader getLoader() {  
  2.         if(loader!=null)  
  3.             return loader;  
  4.         else if(parent!=null)  
  5.             return parent.getLoader();  
  6.               
  7.         return null;  
  8.     }  

 The getLoader方法返回一个Loader(经常加载一个sevlet类)，如果the Wrapper与一个Loader相关联，这个Loader就会返回。如果没有，就会返回父类容器的Loader。如果父类容器也没有，那么就只能返回null.

 

   The SimpleWrapper类有一个pipeline和设置一个basic valve给pipeline.你会在the SimpleWrapper构造函数中会做这样的事，下面的代码进行说明：

Java代码  收藏代码
  1. public SimpleWrapper() {  
  2.         pipeline.setBasic(new CallServletValve());  
  3.     }  

 这儿pipeline作为SimplePipeline类的成员变量，代码如图所示：

Java代码  收藏代码
  1. /*** 
  2.      * 只要new SimpleWrapper()就把Container容器传过来， 
  3.      * 因为SimpleWrapper实现了Wrapper接口而Wrapper继承了 
  4.      * Container接口,注意的是为什么要new SimpleWrapper() 
  5.      * 呢？     
  6.      * 这是因为SimpleWrapper这个类代理调用了SimplePipeLine 
  7.      * 的方法，这样做的好处就是客户写程序时不再去面对SimplePipeLine类， 
  8.      * 而只需要关注SimpleWrapper这个类的方法就行， 
  9.      */  
  10.     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方法，下面是其方法的代码：

Java代码  收藏代码
  1. public void invoke(Request request, Response response,  
  2.         ValveContext context)  
  3.         throws IOException, ServletException {  
  4. /       System.out.println("这个是CallServletValve中的容器："+getContainer());  
  5.     SimpleWrapper wrapper = (SimpleWrapper) getContainer();  
  6.     ServletRequest sreq = request.getRequest();  
  7.     ServletResponse sres = response.getResponse();  
  8.     Servlet servlet = null;  
  9.     HttpServletRequest hreq = null;  
  10.     if (sreq instanceof HttpServletRequest)  
  11.       hreq = (HttpServletRequest) sreq;  
  12.     HttpServletResponse hres = null;  
  13.     if (sres instanceof HttpServletResponse)  
  14.       hres = (HttpServletResponse) sres;  
  15.   
  16.     // 分配一个servlet实例，调用servlet中service()方法  
  17.     try {  
  18.       servlet = wrapper.allocate();  
  19.       if (hres!=null && hreq!=null) {  
  20.         servlet.service(hreq, hres);  
  21.       }  
  22.       else {  
  23.         servlet.service(sreq, sres);  
  24.       }  
  25.     }  
  26.     catch (ServletException e) {  
  27.     }  
  28. }  

 因为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地址打印在控制台上，下面是其代码：

Java代码  收藏代码
  1. package org.hewen.jerry.conatiner;  
  2.   
  3. import java.io.IOException;  
  4.   
  5. import javax.servlet.ServletException;  
  6. import javax.servlet.ServletRequest;  
  7.   
  8. import org.apache.catalina.Request;  
  9. import org.apache.catalina.Response;  
  10. import org.hewen.jerry.inter.Contained;  
  11. import org.hewen.jerry.inter.Container;  
  12. import org.hewen.jerry.inter.Valve;  
  13. import org.hewen.jerry.inter.ValveContext;  
  14.   
  15. public class ClientLoggerValve implements Contained, Valve {  
  16.     protected Container container;  
  17.     public Container getContainer() {  
  18.         return this.container;  
  19.     }  
  20.   
  21.     public void setContainer(Container container) {  
  22.         this.container=container;  
  23.     }  
  24.   
  25.     public void invoke(Request request, Response response, ValveContext context)  
  26.             throws IOException, ServletException {  
  27.           
  28.          context.invokeNext(request, response);  
  29.          System.out.println("该阀门的职责就是获取客户端的IP");  
  30. //       System.out.println("这是ClientLoggerValve容器："+getContainer());  
  31.            
  32.          ServletRequest sreq = request.getRequest();  
  33.          System.out.println(sreq.getRemoteAddr());  
  34.          System.out.println("------------------------------------");  
  35.     }  
  36.   
  37. }  

 注意the invoke方法。the invoke第一件事就是调用了The ValveContext的invokeNext方法，这样调用的目的就是为了在pipeline中调用下一个valve的invoke方法。这个类也打印了一些字符串包括输出了the request对象的远程地址方法。

 

十五、ex05.pyrmont.valves.HeaderLoggerValve

这个类与the ClientIPLoggerValve类十分相似，The HeaderLoggerValve类主要职责就是在控制台上打印the request的相关信息。下面的代码所示：

Java代码  收藏代码
  1. package org.hewen.jerry.conatiner;  
  2.   
  3. import java.io.IOException;  
  4. import java.util.Enumeration;  
  5.   
  6. import javax.servlet.ServletException;  
  7. import javax.servlet.ServletRequest;  
  8. import javax.servlet.http.HttpServletRequest;  
  9.   
  10. import org.apache.catalina.Request;  
  11. import org.apache.catalina.Response;  
  12. import org.hewen.jerry.inter.Contained;  
  13. import org.hewen.jerry.inter.Container;  
  14. import org.hewen.jerry.inter.Valve;  
  15. import org.hewen.jerry.inter.ValveContext;  
  16.   
  17. public class HeaderLoggerValve implements Contained, Valve {  
  18.       
  19.     protected Container container;  
  20.     public Container getContainer() {  
  21.         return this.container;  
  22.     }  
  23.   
  24.     public void setContainer(Container container) {  
  25.         this.container=container;  
  26.     }  
  27.   
  28.   
  29.     public void invoke(Request request, Response response, ValveContext context)  
  30.             throws IOException, ServletException {  
  31.         context.invokeNext(request, response);  
  32.           
  33.         System.out.println("这个阀门所做的事就是获取请求头的信息");  
  34. //      System.out.println("这个是HeaderLoggerValve容器："+getContainer());  
  35.         ServletRequest serRequest=request.getRequest();  
  36.         if(serRequest instanceof HttpServletRequest){  
  37.             HttpServletRequest hsr=(HttpServletRequest)serRequest;  
  38.             Enumeration names=hsr.getHeaderNames();  
  39.             while(names.hasMoreElements()){  
  40.                 String name=names.nextElement().toString();  
  41.                 String value=hsr.getHeader(name);  
  42.                 System.out.println(name+" :"+value);  
  43.             }  
  44.         }else{  
  45.             System.out.println("没有相应Http请求");  
  46.         }  
  47.         System.out.println("----------------------------------");  
  48.           
  49.     }  
  50.   
  51. }  

 现在反复强调特别注意the invoke 方法。the invoke第一件事就是调用了The ValveContext的invokeNext方法，这样调用的目的就是为了在pipeline中调用下一个valve的invoke方法。这个类也打印了一些头部信息。

 

十六、ex05.pyrmont.startup.Bootstrap1

The Bootstrap1类是用来启动这个应用程序，下面给出其代码：

Java代码  收藏代码
  1. package ex04.pyrmont.startup;  
  2.   
  3. import org.apache.catalina.connector.http.HttpConnector;  
  4. import org.hewen.jerry.conatiner.ClientLoggerValve;  
  5. import org.hewen.jerry.conatiner.HeaderLoggerValve;  
  6. import org.hewen.jerry.conatiner.SimpleClassLoader;  
  7. import org.hewen.jerry.conatiner.SimpleWrapper;  
  8. import org.hewen.jerry.inter.Loader;  
  9. import org.hewen.jerry.inter.Pipeline;  
  10. import org.hewen.jerry.inter.Wrapper;  
  11.   
  12. public final class Bootstartup {  
  13.     public static void main(String[] args){  
  14.         HttpConnector connector=new HttpConnector();  
  15.         Wrapper wrapper=new SimpleWrapper();  
  16.         wrapper.setServletClass("ModernServlet");  
  17.         Loader loader=new SimpleClassLoader();  
  18.         ClientLoggerValve clientValve=new ClientLoggerValve();  
  19.         HeaderLoggerValve headerValve=new HeaderLoggerValve();  
  20.         ((Pipeline)wrapper).addValve(clientValve);  
  21.         ((Pipeline)wrapper).addValve(headerValve);  
  22.           
  23.         wrapper.setLoader(loader);  
  24.           
  25.         connector.setMyDefContainer(wrapper);  
  26.           
  27.         try {  
  28.             connector.initialize();  
  29.             connector.start();  
  30.             System.in.read();  
  31.         } catch (Exception e) {  
  32.             e.printStackTrace();  
  33.         }  
  34.           
  35.           
  36.     }  
  37. }  

 创建了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。。。。这里就不详细分析。。。。

0 0
java时间轴 java时间轴
原创粉丝点击
热门IT博客
哪里招淘宝异地客服哪里招淘宝异地客服
淘宝女装幽默宣传语淘宝女装幽默宣传语
skype ubuntu 14.04
华为机顶盒破解软件
颜值高的女生特征 知乎
淘宝食品类目专项
黑河学院网络管理系统
淘宝新店铺描述怎么写
java 策略模式运用场景
java 随机 加密
基因数据库
近几年石油开采量数据
mysql存储引擎
linux 路由表
mac打谱软件
浙师大行知学院2017
c语言取u盘文件
java重载加法
linux 快照备份
无甲醛油漆 知乎
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 窗花的图片 窗花的剪法 窗花教程 窗花图样 圣诞窗花 儿童300种窗花剪法步骤图解 儿童窗花剪法 儿童简单窗花剪法 小学生学剪窗花简易大全 剪窗花课文朗读 儿童剪窗花大全图解 窗花剪纸教程 儿童简易窗花剪法步骤图 窗花剪纸步骤 轴对称窗花怎么剪一步一步 手工剪纸窗花 剪纸窗花批发 幼儿园简单窗花的剪法 铝合金窗花价格 窗花图案大全 简单窗花剪纸 手工窗花剪纸步骤 窗花剪纸步骤图解 简易窗花的剪法步骤图 简单的窗花剪纸步骤图 窗花剪纸图片 动物窗花的剪法步骤图 剪窗花的详细步骤图 简单窗花的剪法步骤图 小学生剪纸大全及方法 静电窗贴 魔术贴纱窗 窗贴画 贴玻璃窗纸 贴窗纸 窗贴图片 三轨推拉窗 窗轨 创饰阳台窗 窘态 窘态百出

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里