1、类图

image.png

2、处理过程（以Wrapper为例）

在连接器部分了解到，对于客户端的处理，连接器是在解析相关的协议后，最终调用了Container的invoke方法来处理的，这里看一下Wrapper的处理过程，Wrapper的标准实现为StandardWrapper：

public StandardWrapper() {
        super();
        // 设置基本的 Value
        pipeline.setBasic(new StandardWrapperValve());
    }

根据类图可知，invoke方法在ContainerBase中实现：

protected Pipeline pipeline = new StandardPipeline(this);

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

其调用了Pipeline的invoke方法：

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

protected class StandardPipelineValveContext implements ValveContext {

        protected int stage = 0;

        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"));
            }
        }
}

以ClientIPLoggerValve为例：

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方法
    valveContext.invokeNext(request, response);
// 然后才是处理自己的逻辑
    System.out.println("Client IP Logger Valve");
    ServletRequest sreq = request.getRequest();
    System.out.println(sreq.getRemoteAddr());
    System.out.println("------------------------------------");
  }

每一个Pipeline维持着一个基本的Valve和一个Valve[]，Valve通过addValve()方法加入到pipeline中，当Container的invoke被Connector调用的时候，Container内部调用了pipeline的invoke方法，而pipeline内部则是通过ValveContext的invokeNext方法来实现Valve的依次执行，根据每个Valve的内部实现，这里的执行顺序为basic valve会被优先执行，然后其他的Valve是按照后进先出的顺序执行，这个从Valve中的invoke方法实现也可以验证，每个Valve在执行前都是先执行了ValveContext的invokeNext方法。

// 构建一个包装容器，一个包装容器代表一个具体的servlet
    Wrapper wrapper = new SimpleWrapper();
    wrapper.setServletClass("ModernServlet");
    // 构建两个Valve
    Valve valve1 = new HeaderLoggerValve();
    Valve valve2 = new ClientIPLoggerValve();
    // 添加阀门（任务）
    ((Pipeline) wrapper).addValve(valve1);
    ((Pipeline) wrapper).addValve(valve2);

Basic Valve:

public void invoke(Request request, Response response, ValveContext valveContext)
    throws IOException, ServletException {
    System.out.println("00000000000 SimpleWrapperValve Basic Valve ");
    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);
      }
    }
    catch (ServletException e) {
    }
  }

#######Basic Valve被优先执行
00000000000 SimpleWrapperValve Basic Valve 
ModernServlet -- init
#######Client IP Logger Valve被执行
00000000000 Client IP Logger Valve
0:0:0:0:0:0:0:1
------------------------------------
#######Header Logger Valve被执行
00000000000 Header Logger Valve
host:localhost:8080
connection:keep-alive
upgrade-insecure-requests:1
user-agent:Mozilla/5.0 (Windows NT 10.0; WOW64) ...
accept:text/html,application/xhtml+xml,application/xml;...
accept-encoding:gzip, deflate, br
accept-language:zh-CN,zh;q=0.9,en;q=0.8
------------------------------------

3、多Wrapper容器处理

在tomcat4中，如果包含多个wrapper容器，这时需要一个mapper来处理这些wrapper

HttpConnector connector = new HttpConnector();
    // wrapper 1
    Wrapper wrapper1 = new SimpleWrapper();
    wrapper1.setName("Primitive");
    wrapper1.setServletClass("PrimitiveServlet");
    // wrapper 2
    Wrapper wrapper2 = new SimpleWrapper();
    wrapper2.setName("Modern");
    wrapper2.setServletClass("ModernServlet");
    // context
    Context context = new SimpleContext();
    // wrapper add to context
    context.addChild(wrapper1);
    context.addChild(wrapper2);
    // create 2 Valve
    Valve valve1 = new HeaderLoggerValve();
    Valve valve2 = new ClientIPLoggerValve();
    // 阀门加入到了Context容器中
    ((Pipeline) context).addValve(valve1);
    ((Pipeline) context).addValve(valve2);
    // create a mapper
    Mapper mapper = new SimpleContextMapper();
    // set protocol
    mapper.setProtocol("http");
    // add mapper to context
    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);

Basic Valve:

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;     // NOTE - Not much else we can do generically
    }

    // 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 {
// ##############1、从context中获取一个wrapper
      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);
//  ##############2、调用wrapper的invoke方法
    wrapper.invoke(request, response);
  }

看一下Context是如何找wrapper的：

public Container map(Request request, boolean update) {
    //this method is taken from the map method in org.apache.cataline.core.ContainerBase
    //the findMapper method always returns the default mapper, if any, regardless the
    //request's protocol
// 根据协议来找到对应的Mapper
    Mapper mapper = findMapper(request.getRequest().getProtocol());
    if (mapper == null)
      return (null);
    // Use this Mapper to perform this mapping
// 然后从Mapper中来找到wrapper
    return (mapper.map(request, update));
  }

Mapper查找wrapper过程

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;
// 找到servlet的名称
    String name = context.findServletMapping(relativeURI);
    if (name != null)
// 根据名称来找wrapper，在tomcat中，一个wrapper对应一个servlet
      wrapper = (Wrapper) context.findChild(name);
    return (wrapper);
  }

总的过程就是根据协议先找到Mapper，然后再根据servlet name找到wrapper。