深入剖析Tomcat(五) 剖析Servlet容器并实现一个简易Context与Wrapper容器

上一章介绍了Tomcat的默认连接器，后续程序都会使用默认连接器。前面有讲过Catalina容器的两大块内容就是连接器与Servlet容器。不同于第二章的自定义丐版Servlet容器，这一章就来探讨下Catalina中的真正的Servlet容器究竟长啥样。

四种容器

在Catalina中Servlet容器共有四种：Engine、Host、Context、Wrapper，分别对应不同的概念层次

Engine：表示整个Catalina servlet引擎；
Host：表示包含一个或多个Context的虚拟主机；
Context：表示一个Web应用程序，一个Context一般包含多个Wrapper;
Wrapper：表示一个独立的servlet。

上述四种容器分别对应org.apache.catalina包内一个接口，分别是

org.apache.catalina.Engine
org.apache.catalina.Host
org.apache.catalina.Context
org.apache.catalina.Wrapper

这四个接口都继承自org.apache.catalina.Container接口，代表它们是一种容器。

能看懂上面四个容器都是干啥的吗？什么，看不懂？没关系，我们一步一步来了解它们，本章内容只讨论 Context与Wrapper两种容器，Engine与Host在第十三章会详细讲解。

第四章的Bootstrap启动类中有这么段代码，连接器需要关联一个容器，这个容器只要实现了org.apache.catalina.Container就行，而Tomcat中的四种容器都实现了这个接口，所以这里放哪种容器都可以。

HttpConnector connector = new HttpConnector();
SimpleContainer container = new SimpleContainer();
connector.setContainer(container);

部署功能性的Catalina并不是必须将所有四种容器都包含在内，本章将会提供两个例子，第一个例子只包含Wrapper容器，第二个例子包含Context与Wrapper两种容器。

org.apache.catalina.core包中有一个基础容器抽象类：ContainerBase，该包下还提供了四种容器的标准实现StandardEngine、StandardHost、StandardContext、StandardWrapper，这四个类都继承了ContainerBase，证明四种容器之间是存在共性的，接下来看看ContainerBase这个类，看看容器们有哪些共性。

容器的共性

ContainerBase的定义如下

public abstract class ContainerBase implements Container, Lifecycle, Pipeline

它实现了三个接口，Container接口我们已经比较熟悉了，Lifecycle生命周期接口下章详细讲解，Pipeline接口是什么呢？下面会讲

我梳理了一下ContainerBase这个类，排除了本章还没接触到的内容后，剩下有这么几项针对四种容器的共性内容

持有一个Pipeline（管道）对象，该对象使用“责任链”设计模式，针对容器类invoke方法接收到的请求做具体处理。
持有一个父容器对象的引用 Container parent;
持有一个子容器对象的map集合，HashMap<String,Container> children = new HashMap<>(); key为子容器名字，value为子容器对象。
持有一个载入器，Loader loader; 载入器的主要功能是给容器提供一个类加载器，用于加载servlet。
持有一个映射器，Mapper mapper；映射器的主要功能是提供一种方式，可以让容器知晓要把请求内容交给哪个子容器实例进行下一步处理。

这个Pipeline单独讲一下

Pipeline可以翻译为管道，管道中按顺序排着一排叫做“阀”的东西，英文名叫Valve,阀的数量可多可少，但是至少得有一个坐镇管道尾部的阀，叫做“基础阀”。

在代码中，Pipeline与Valve都以接口的形式定义

在上一章中我们就已经知道，连接器将http请求封装为request与response对象后，就会调用Servlet容器的invoke方法来进行下一步处理。ContainerBase中定义了Servlet容器的invoke方法的默认逻辑为：

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

Servlet容器接到request与response信息后，直接扔给pipeline去处理了，pipeline中的这个处理方法也叫 invoke。

那pipeline拿到request与response后又是怎么做的呢？它又会交给这些排好队的valve们去处理，valve中的处理方法也是叫做invoke，pipeline中invoke方法的伪代码逻辑如下

public void invoke(Request request, Response response) {
    // 先按顺序将普通阀的逻辑执行一遍
    for (int i = 0; i < valves.length; i++) {
        valves[i].invoke(request,response);
    }
    // 最后执行基础阀的逻辑
    basicValue.invoke(request,response);
}

基础阀是必须的，它负责实现该容器的主要任务。例如Wrapper容器代表一个servlet，它的基础阀的任务就是调用该Wrapper容器对应的servlet的service方法；Context容器代表一个Web应用程序，该容器包含多个Wrapper容器，它的基础阀的任务就是根据请求找到具体对应的Wrapper容器，去调用该Wrapper容器的invoke方法。

基础阀干了主要的事，那普通阀干的就是一些附加的功能了，比如打印下客户端的ip,打印下请求头等。

上面pipeline中的invoke代码示例，只是个伪代码，方便你理解执行逻辑。实际上Tomcat采用另一种方式来实现“责任链”的逻辑。这用到了另一个接口 org.apache.catalina.ValveContext

顾明思议，ValveContext：阀的上下文。这个接口的主要方法为invokeNext，要干的事就是调用“责任链”中下一个“阀”的invoke方法。这个接口怎么用的呢？来看下StandardPipeline中的部分逻辑

public class StandardPipeline implements Pipeline, Contained, Lifecycle {

    // 基础阀
    protected Valve basic = null;

    // 关联的容器对象
    protected Container container = null;

    // 此管道拥有的所有阀
    protected Valve[] valves = new Valve[0];

    /**
     * 接手容器收到的Request与Response请求，由与此管道关联的阀挨个处理，直到基础阀处理完成。 
     * 此方法要保证在被并发调用（同时被不同线程调用）情况下不会出现问题。
     */
    public void invoke(Request request, Response response) throws IOException, ServletException {

        // 交给ValveContext来保证阀的调用顺序
        (new StandardPipelineValveContext()).invokeNext(request, response);

    }

    /**
    * 内部类，可以使用外部类的valves属性
    */
    protected class StandardPipelineValveContext implements ValveContext {

        protected int stage = 0;

        /**
         * 调用下一个阀的invoke方法，阀的invoke方法参数之一为当前ValveContext对象
         */
        public void invokeNext(Request request, Response response) throws IOException, ServletException {

            int subscript = stage;
            stage = stage + 1;

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

    }

}

普通阀的伪代码

public class MyValve implements Valve, Contained {

    protected Container container;

    public void invoke(Request request, Response response, ValveContext valveContext)
            throws IOException, ServletException {
        // 处理逻辑…

        // 利用valveContext来调用下一个阀的invoke方法
        valveContext.invokeNext(request, response);
        
        // 处理逻辑…
    }

}

StandardPipeline中拥有一个已经排好顺序的阀的数组 valves ，StandardPipeline的invoke方法的实现为：实例化一个StandardPipelineValveContext对象，并调用其invokeNext方法。StandardPipelineValveContext是StandardPipeline的一个非静态内部类，它可以使用StandardPipeline中的属性，主要是为了使用 valves 属性，StandardPipelineValveContext中有一个属性stage，代表当前“责任链”已经执行到哪个阀了，invokeNext方法的作用则为调用“责任链”中下一个阀的invoke方法。总的来说，StandardPipelineValveContext的作用就是根据管道中已经排好的阀们，使用invokeNext方法调用下一个阀的invoke方法，直到基础阀执行完。

阀的invoke方法中的第三个参数则为StandardPipelineValveContext对象，每个非基础阀的invoke方法中都需要有这段代码 valveContext.invokeNext(request, response); 以确保责任链能继续执行下去，而基础阀中是不应该有这段代码的，“责任链”到基础阀就该结束了。

另外StandardPipeline和MyValve还实现了org.apache.catalina.Contained接口。谁实现了这个接口，就代表谁要持有一个容器对象的引用，容器的处理逻辑相关类一般会实现这个接口。

Pipeline的介绍到此为止，我们继续回到四种容器的共性研究上。上面说了，每种容器都有管道、父容器、子容器、加载器、映射器等等其他一些本章没描述的东西。长的都还有点像，这种结构像什么呢？

没错，俄罗斯套娃，哈哈！稍微不同的是，在Tomcat中，父容器一下子可以套多个子容器。

Tomcat中的容器相似点就介绍到这里，Engine与Host容器会编排到第十三章来讲，中间还需要做些铺垫。本章主要介绍Context与Wrapper两种容器。

Wrapper容器

Wrapper容器是最底层的容器，它没有子容器了。Wrapper容器是对一个具体Servlet的封装，负责Servlet整个生命周期，在合适的时机会调用Servlet的 init、service、destroy 方法。

Wrapper接口中比较重要的方法为load()和allocate()方法。Wrapper容器中拥有一个指定servlet的全限定名servletClass，load方法负责加载并初始化一个servlet实例，allocate方法负责提供一个可用的servlet实例(即可以执行service方法的servlet实例)。

接下来，我们来编写一个只有Wrapper容器的Servlet容器，本次设计相关的UML图如下

SimpleWrapper代表一个Wrapper容器，负责维护一个servlet。

SimplePipeline代表一个容器管道，可以被SimpleWrapper持有。

ClientIPLoggerValve、HeaderLoggerValve是普通阀，他们可被编排在SimplePipeline中。

SimpleWrapperVave是针对Wrapper容器的基础阀，负责加载servlet并调用其service方法。

SimpleLoader代表一个加载器，在本章代码中主要负责提供一个类加载器。

这些个类共同组成一个最小的servlet容器

SimpleLoader类

该类负责向外提供一个类加载器，负责加载serlvet。

由于Loader接口的很多方法暂时没实现，所以留空的方法不在展示出来，下面是精简后的代码

public class SimpleLoader implements Loader {

    // servlet类所在目录
    public static final String WEB_ROOT = System.getProperty("user.dir") + File.separator + "webroot";

    // 类加载器
    ClassLoader classLoader = null;

    // 容器
    Container container = null;

    // SimpleLoader在构造时就创建了一个类加载器负责加载servlet
    public SimpleLoader() {
        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());
        }
    }

    public ClassLoader getClassLoader() {
        return classLoader;
    }

}

SimplePipeline类

该类是一个简易通道类，含有一个内部类SimplePipelineValveContext来负责阀们“责任链”的编排。

package ex05.pyrmont.core;

import org.apache.catalina.*;

import javax.servlet.ServletException;
import java.io.IOException;

public class SimplePipeline implements Pipeline {

    public SimplePipeline(Container container) {
        setContainer(container);
    }

    // 基础阀
    protected Valve basic = null;
    // 关联的容器
    protected Container container = null;
    // 普通阀数组
    protected Valve valves[] = new Valve[0];

    public void setContainer(Container container) {
        this.container = container;
    }

    public Valve getBasic() {
        return basic;
    }

    public void setBasic(Valve valve) {
        this.basic = valve;
        ((Contained) valve).setContainer(container);
    }

    public void addValve(Valve valve) {
        if (valve instanceof Contained) {
            ((Contained) valve).setContainer(this.container);
        }

        synchronized (valves) {
            Valve results[] = new Valve[valves.length + 1];
            System.arraycopy(valves, 0, results, 0, valves.length);
            results[valves.length] = valve;
            valves = results;
        }
    }

    public Valve[] getValves() {
        return valves;
    }

    public void invoke(Request request, Response response) throws IOException, ServletException {
        // 调用该管道中第一个阀的invoke方法
        (new SimplePipelineValveContext()).invokeNext(request, response);
    }

    public void removeValve(Valve valve) {
    }

    // 内部类，负责阀的"责任链"的执行编排
    protected class SimplePipelineValveContext implements ValveContext {

        // 记录当前执行到哪一个阀了
        protected int stage = 0;

        public String getInfo() {
            return null;
        }
        
        // 执行下一个阀的invoke方法
        public void invokeNext(Request request, Response response)
                throws IOException, ServletException {
            int subscript = stage;
            stage = stage + 1;
            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("No valve");
            }
        }
    } // end of inner class

}

SimpleWrapper类

该类代表一个Wrapper容器，实现了org.apache.catalina.Wrapper接口，并提供了load()和allocate()方法的实现。

SimpleWrapper拥有一个servletClass属性，代表其对应的servlet的全限定名；还设置了一个instance属性，代表serlvet的实例化对象；拥有一个载入器对象loader，负责提供类加载器；拥有一个pipeline管道；拥有一个parent属性，代表父容器，SimpleWrapper可以作为Context容器的子容器。

SimpleWrapper在构造方法中就指定了SimpleWrapperValve作为其管道中的基础阀。

Wrapper接口的很多方法都没实现，所以不再展示留空的方法，下面是精简后的代码

public class SimpleWrapper implements Wrapper, Pipeline {

    // servlet的实例
    private Servlet instance = null;

    // 关联的servlet类的全限定名
    private String servletClass;

    // 载入器
    private Loader loader;
    private String name;
    private SimplePipeline pipeline = new SimplePipeline(this);
    protected Container parent = null;

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

    public synchronized void addValve(Valve valve) {
        pipeline.addValve(valve);
    }

    public Servlet allocate() throws ServletException {
        // 如果需要的话，加载并实例化一个servlet对象
        if (instance == null) {
            try {
                instance = loadServlet();
            } catch (ServletException e) {
                throw e;
            } catch (Throwable e) {
                throw new ServletException("Cannot allocate a servlet instance", e);
            }
        }
        return instance;
    }

    private Servlet loadServlet() throws ServletException {
        if (instance != null)
            return instance;

        Servlet servlet = null;
        String actualClass = servletClass;
        if (actualClass == null) {
            throw new ServletException("servlet class has not been specified");
        }

        Loader loader = getLoader();
        if (loader == null) {
            throw new ServletException("No loader.");
        }
        ClassLoader classLoader = loader.getClassLoader();

        // 使用载入器提供的类加载器，加载特定的servlet类
        Class classClass = null;
        try {
            if (classLoader != null) {
                classClass = classLoader.loadClass(actualClass);
            }
        } catch (ClassNotFoundException e) {
            throw new ServletException("Servlet class not found");
        }
        // 创建一个servlet对象
        try {
            servlet = (Servlet) classClass.newInstance();
        } catch (Throwable e) {
            throw new ServletException("Failed to instantiate servlet");
        }

        // 调用servlet的init方法
        try {
            servlet.init(null);
        } catch (Throwable f) {
            throw new ServletException("Failed initialize servlet.");
        }
        return servlet;
    }

    /**
     * 获取加载器，如果此容器加载器为空的话则去获取父容器的
     */
    public Loader getLoader() {
        if (loader != null)
            return (loader);
        if (parent != null)
            return (parent.getLoader());
        return (null);
    }

    public void setLoader(Loader loader) {
        this.loader = loader;
    }

    public void setServletClass(String servletClass) {
        this.servletClass = servletClass;
    }

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

    public void load() throws ServletException {
        instance = loadServlet();
    }

}

SimpleWrapperValve类

该类是SimpleWrapper对应的基础阀，专门用于处理对SimpleWrapper类的请求，加载、实例化servlet并执行其service方法。

基础阀的invoke方法中不需要也不应该调用传递给它的ValveContext示例的invokeNext方法。

package ex05.pyrmont.core;

import org.apache.catalina.*;

import javax.servlet.Servlet;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;


public class SimpleWrapperValve implements Valve, Contained {

    protected Container container;

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

        // 获取一个servlet实例用以处理请求
        try {
            servlet = wrapper.allocate();
            if (hres != null && hreq != null) {
                servlet.service(hreq, hres);
            } else {
                servlet.service(sreq, sres);
            }
        } catch (ServletException e) {
        }
    }

    public String getInfo() {
        return null;
    }

    public Container getContainer() {
        return container;
    }

    public void setContainer(Container container) {
        this.container = container;
    }
}

ClientIPLoggerValve与HeaderLoggerValve

这是两个普通阀，都实现了org.apache.catalina.valve接口，ClientIPLoggerValve用于将客户端的IP地址输出到控制台上，HeaderLoggerValve会把请求头信息输出到控制台上。

Valve的invoke方法定义为

void invoke(Request request, Response response,ValveContext context)

普通阀的invoke方法中，需要调用ValveContext参数对象的invokeNext方法，来执行管道中下一个阀的invoke方法。

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

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

Bootstrap1类

这是一个启动类，负责利用上面的容器相关类，组织成一个容器，连接器的话还是使用Tomcat的默认连接器，main方法运行起来后就可以接收请求了。

由于这个容器中仅有一个Wrapper容器，关联了ModernServlet，所以无论客户端什么请求都会打到ModernServlet中。本章的下个程序将会包含多个Wrapper，届时会根据不同uri请求不同srevlet。

package ex05.pyrmont.startup;

import ex05.pyrmont.core.SimpleLoader;
import ex05.pyrmont.core.SimpleWrapper;
import ex05.pyrmont.valves.ClientIPLoggerValve;
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) {

        // 使用Tomcat的默认连接器
        HttpConnector connector = new HttpConnector();
        
        // 构建Wrapper容器
        Wrapper wrapper = new SimpleWrapper();
        wrapper.setServletClass("ModernServlet");
        Loader loader = new SimpleLoader();
        Valve valve1 = new HeaderLoggerValve();
        Valve valve2 = new ClientIPLoggerValve();

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

        // 将wrapper容器与连接器做个关联
        connector.setContainer(wrapper);

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

            // 保活main线程，直到键盘输入了任何字符
            System.in.read();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

执行结果展示

Bootstrap1启动后，浏览器调用结果

Context容器

一个Context容器其实就可以代表一个完整的应用了。一个Context实例可以包含一个或多个Wrapper实例作为子容器。

通常情况下一个Web应用的serlvet是有多个的，也就是存在多个Wrapper实例，Context容器接收到连接器给的请求对象后，如何知道该将这个请求交给哪个Wrapper来处理呢？这就需要一个映射器了。

开篇介绍容器的共性时就提到了，容器会有一个映射器，他会提供一种方式，让容器知晓它该把请求交给哪个子容器实例来进行下一步的处理。在Catalina中映射器的定义是一个接口：org.apache.catalina.Mapper

getContainner()、setContainer() 两个方法说明映射器得持有一个容器实例的引用。

getProtocol()、setProtocol() 两个方法说明映射器是针对协议进行区分的，一个映射器实例仅处理一种协议的请求，比如http协议或者https协议等。

map()方法是实现映射器主要逻辑的方法，它负责根据Request映射出一个子容器实例，然后父容器就将请求信息给到该实例，由该实例进行进一步处理。

接下来看下本章第二个程序（Context应用程序）的设计UML图

相比于第一个程序，该程序添加了如下几个类

SimpleContext：一个简易的Context容器，持有Mapper映射器和多个Wrapper实例

SimpleContextMapper：Context的映射器

SimpleContextValve：Context容器的基础阀，主要逻辑为将特定请求给到特定的Wapper实例。

这几个类加第一个程序的类，就组成了一个以Context为顶层容器的servlet容器。

Context应用程序使用了与第一个应用程序相同的载入器和两个阀，但是，载入器与阀都是与Context容器（而非Wapper）相关联的。这样，两个Wrapper就都可以使用这个载入器。Context实例作为servlet容器被设置到连接器中。这样，当连接器收到http请求后，就可以调用Context的invoke方法了。

Context应用程序中Wrapper容器管道中就只放了一个基础阀SimpleWrapperValve，没有其他阀了。

Context与Wrapper的两个管道要区分好了，连接器会先将请求给到Context，Context将请求给到Context管道，请求经过几个普通阀的处理后来到了Context基础阀，Context基础阀挑出来一个Wrapper实例，将请求交给该Wrapper，Wrapper又将请求给到Wrapper管道，Wrapper基础阀负责调用具体servlet的service方法。

来看看具体的代码

SimpleContextValve类

Context容器的基础阀，负责将请求交给特定的Wrapper，主要逻辑在invoke方法中，其中获取特定Wrapper的逻辑其实是通过调用SimpleContext类中的map方法来实现的。

package ex05.pyrmont.core;

import org.apache.catalina.*;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;


public class SimpleContextValve implements Valve, Contained {

    protected Container container;

    public void invoke(Request request, Response response, ValveContext valveContext) throws IOException, ServletException {
        // 验证request和response对象的类型
        if (!(request.getRequest() instanceof HttpServletRequest) || !(response.getResponse() instanceof HttpServletResponse)) {
            return;
        }

        String requestURI = ((HttpRequest) request).getDecodedRequestURI();

        Context context = (Context) getContainer();
        // 挑选一个 Wrapper 处理该请求
        Wrapper wrapper;
        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;
        }
        // 调用 Wrapper 的invoke方法处理请求
        response.setContext(context);
        wrapper.invoke(request, response);
    }

    public String getInfo() {
        return null;
    }

    public Container getContainer() {
        return container;
    }

    public void setContainer(Container container) {
        this.container = container;
    }

    private void badRequest(String requestURI, HttpServletResponse response) {
        try {
            response.sendError(HttpServletResponse.SC_BAD_REQUEST, requestURI);
        } catch (Exception e) {
            ;
        }
    }

    private void notFound(String requestURI, HttpServletResponse response) {
        try {
            response.sendError(HttpServletResponse.SC_NOT_FOUND, requestURI);
        } catch (Exception e) {
            ;
        }
    }

}

SimpleContextMapper类

该类实现了org.apache.catalina.Mapper接口，代表它是一个映射器。它持有一个SimpleContext对象的引用，它的主要逻辑在map方法中，负责根据特定请求找到一个特定的Wrapper。map方法有两个参数，一个Request对象和一个布尔变量。本应用程序中忽略第二个参数。

package ex05.pyrmont.core;

import org.apache.catalina.*;

import javax.servlet.http.HttpServletRequest;

public class SimpleContextMapper implements Mapper {

    // 映射器关联的Context容器对象
    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;
    }
    
    /**
     * 根据请求的特征返回子容器，该子容器用于处理此请求。
     * 如果没有这样的子容器可以被识别，则返回null
     */
    public Container map(Request request, boolean update) {
        // 获取相对路径的uri作为映射的key
        String contextPath = ((HttpServletRequest) request.getRequest()).getContextPath();
        String requestURI = ((HttpRequest) request).getDecodedRequestURI();
        String relativeURI = requestURI.substring(contextPath.length());
        // 调用Context中相关方法拿到特定Wrapper
        Wrapper wrapper = null;
        String servletPath = relativeURI;
        String name = context.findServletMapping(servletPath);
        if (name != null) {
            wrapper = (Wrapper) context.findChild(name);
        }
        return (wrapper);
    }

    public String getProtocol() {
        return null;
    }

    public void setProtocol(String protocol) {
    }
    
}

SimpleContext类

Context应用程序的Context容器就是SimpleContext类的实例。SimpleContext类实现了Context与Pipeline接口，但是接口的大部分方法都暂未实现，但与映射相关的方法都给出了具体的实现。这些方法包括以下几个

addMapper()：在Context容器中添加一个映射器。SimpleContext类有声明两个变量：mapper与mappers。mappers代表Context容器拥有的所有映射器，针对不同协议用不同映射器。如果mappers中只有一个映射器的话，则将该映射器赋给mapper对象，代表默认映射器；反之，如果mappers中有多个映射器的话，则mapper属性置为null。这个设定在findMapper方法中会用到。

protected Mapper mapper = null;
protected HashMap<String,Mapper> mappers = new HashMap<>();


public void addMapper(Mapper mapper) {
    synchronized (mappers) {
        // 如果相同协议的映射器已经被添加过了，则抛出异常
        if (mappers.get(mapper.getProtocol()) != null) {
            throw new IllegalArgumentException("addMapper:  Protocol '" + mapper.getProtocol() + "' is not unique");
        }
        mappers.put(mapper.getProtocol(), mapper);
        mapper.setContainer(this);      // May throw IAE
        if (mappers.size() == 1) {
            this.mapper = mapper;
        } else {
            this.mapper = null;
        }
    }
}

fiindMapper()：从Context容器中获取映射器，如果默认映射器有值的话则返回默认映射器，否则根据指定协议返回指定的映射器。

public Mapper findMapper(String protocol) {
    if (mapper != null) {
        return mapper;
    } else synchronized (mappers) {
        return mappers.get(protocol);
    }
}

addServletMapping()：这方法有两个参数，（String pattern, String name）。pattern代表请求uri的一个路径，name代表Wrapper容器的名字。要知道SimpleContext中对于子容器的定义是这样的

HashMap<String, Container> children = new HashMap<>();

children的key就是Wrapper实例的名字，value就是Wrapper实例。而addServletMapping方法的name参数也是Wrapper实例的名字,所以，通过name就可以找到Wrapper实例。

protected HashMap<String, Container> children = new HashMap<>();
protected final HashMap<String,String> servletMappings = new HashMap<>();

public void addServletMapping(String pattern, String name) {
    synchronized (servletMappings) {
        servletMappings.put(pattern, name);
    }
}

findServletMapping()：通过uri路径找到对应的Wrapper容器的name

public String findServletMapping(String pattern) {
    synchronized (servletMappings) {
        return servletMappings.get(pattern);
    }
}

map()：通过request请求，找到一个能处理该请求的特定Wrapper

public Container map(Request request, boolean update) {
    // 本次代码中，findMapper方法永远只会返回默认映射器
    Mapper mapper = findMapper(request.getRequest().getProtocol());
    if (mapper == null) {
        return null;
    }

    // 调用映射器的map方法，找到特定的Wrapper容器
    return mapper.map(request, update);
}

通过上面几个方法，可以了解到SimpleContext容器：

持有一个子容器实例的Map ( key: Wrapper实例name， value:Wrapper实例对象)。
持有一个uri与Wrapper实例name的映射关系Map (key:uri处理后的路径， value:Wrapper实例name)。
持有一个映射器集合 HashMap<String,Mapper> mappers;

基于以上几点，再看Context容器基础阀SimpleContextValve#invoke方法的流程

1. 根据请求对象request，调用SimpleContext的map方法去获取Wrapper对象         
  1.1 SimpleContext#map方法通过request请求的对应协议，找到一个匹配的映射器
  1.2 调用映射器Mapper#map方法通过request请求，去获取Wrapper对象
    1.2.1 Mapper#map方法根据request请求的uri，调用SimpleContext#findServletMapping方法找到该请求对应的Wrapper实例的name
    1.2.2 调用SimpleContext#findChild方法，通过Wrapper实例的name,找到对应的Wrapper实例对象
2. Wrapper实例对象调用其invoke方法执行接下来的逻辑，接下来的逻辑就与第一个应用程序的逻辑一样了

SimpleContext类的代码如下，我精简了一下代码，去掉了一些没有实现的接口方法

public class SimpleContext implements Context, Pipeline {

    public SimpleContext() {
        pipeline.setBasic(new SimpleContextValve());
    }

    private Container parent = null;
    protected HashMap<String, Container> children = new HashMap<>();
    protected Loader loader = null;
    protected SimplePipeline pipeline = new SimplePipeline(this);
    protected final HashMap<String,String> servletMappings = new HashMap<>();
    protected Mapper mapper = null;
    protected HashMap<String,Mapper> mappers = new HashMap<>();


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

    public void addServletMapping(String pattern, String name) {
        synchronized (servletMappings) {
            servletMappings.put(pattern, name);
        }
    }

    public String findServletMapping(String pattern) {
        synchronized (servletMappings) {
            return servletMappings.get(pattern);
        }
    }

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

    public void addChild(Container child) {
        child.setParent((Container) this);
        children.put(child.getName(), child);
    }

    /**
     * 向Context容器中添加映射器，第一个被加进来的映射器将作为默认映射器
     */
    public void addMapper(Mapper mapper) {
        synchronized (mappers) {
            // 如果相同协议的映射器已经被添加过了，则抛出异常
            if (mappers.get(mapper.getProtocol()) != null) {
                throw new IllegalArgumentException("addMapper:  Protocol '" + mapper.getProtocol() + "' is not unique");
            }
            mappers.put(mapper.getProtocol(), mapper);
            mapper.setContainer(this);      // May throw IAE
            if (mappers.size() == 1) {
                this.mapper = mapper;
            } else {
                this.mapper = null;
            }
        }
    }

    public Container findChild(String name) {
        if (name == null) {
            return null;
        }
        synchronized (children) {
            return children.get(name);
        }
    }

    /**
     * 如果默认映射器有值的话，则该方法使用返回默认映射器，无论是什么协议（protocol）
     */
    public Mapper findMapper(String protocol) {
        if (mapper != null) {
            return mapper;
        } else synchronized (mappers) {
            return mappers.get(protocol);
        }
    }

    /**
     * 通过request请求找到特定的Wrapper实例
     */
    public Container map(Request request, boolean update) {
        // 本次代码中，findMapper方法永远只会返回默认映射器
        Mapper mapper = findMapper(request.getRequest().getProtocol());
        if (mapper == null) {
            return null;
        }

        // 调用映射器的map方法，找到特定的Wrapper容器
        return mapper.map(request, update);
    }

}

Bootstrap2类

该类是Context应用程序的启动类。

本次应用程序包含两个servlet：PrimitiveServlet与ModernServlet，两个servlet对应两个Wrapper实例，对应的名字为Primitive与Modern，它们作为子容器被包含在Context容器中。

本次应用程序只有一个映射器可以使用，所以这个映射器也作为Context容器的默认映射器。映射器指定了uri与Wrapper容器name的映射关系为：

/Primitive → Primitive
/Modern → Modern

连接器仍然使用Tomcat的默认连接器

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 ex05.pyrmont.valves.HeaderLoggerValve;
import org.apache.catalina.*;
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();
        }
    }
}

执行结果展示

Bootstrap2启动后，浏览器访问结果展示

/Primitive

/Modern

后台日志

HttpConnector Opening server socket on all host IP addresses
HttpConnector[8080] Starting background thread
PrimitiveServlet -- init
Client IP Logger Valve
127.0.0.1
------------------------------------
Header Logger Valve
host:127.0.0.1:8080
connection:keep-alive
sec-ch-ua:"Google Chrome";v="123", "Not:A-Brand";v="8", "Chromium";v="123"
sec-ch-ua-mobile:?0
sec-ch-ua-platform:"macOS"
upgrade-insecure-requests:1
user-agent:Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36
accept:text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7
sec-fetch-site:none
sec-fetch-mode:navigate
sec-fetch-user:?1
sec-fetch-dest:document
accept-encoding:gzip, deflate, br, zstd
accept-language:zh-CN,zh;q=0.9
------------------------------------
ModernServlet -- init
Client IP Logger Valve
127.0.0.1
------------------------------------
Header Logger Valve
host:127.0.0.1:8080
connection:keep-alive
sec-ch-ua:"Google Chrome";v="123", "Not:A-Brand";v="8", "Chromium";v="123"
sec-ch-ua-mobile:?0
sec-ch-ua-platform:"macOS"
upgrade-insecure-requests:1
user-agent:Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36
accept:text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7
sec-fetch-site:none
sec-fetch-mode:navigate
sec-fetch-user:?1
sec-fetch-dest:document
accept-encoding:gzip, deflate, br, zstd
accept-language:zh-CN,zh;q=0.9
------------------------------------

好，本章内容就到这里，在这一章里，我们动手实现了一个仅有Wrapper的servlet容器，又实现了一个既有Context又有Wrapper的servlet容器；Pipeline的原理使我们对责任链机制又储备了一个实际参考案例；由于容器实例的单例性，要保证并发请求时不会出现问题，主要是保证对象的实例属性不轻易变化；Engine与Host容器在做足铺垫后将在第13章详细介绍。下一章我们一起来看看Tomcat中生命周期相关的内容，敬请期待！