上一章介绍了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在构造时就创建了一个类加载器负责加载servletpublic 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 pipelinevalveContext.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 pipelinevalveContext.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);}} elseSystem.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作为映射的keyString contextPath = ((HttpServletRequest) request.getRequest()).getContextPath();String requestURI = ((HttpRequest) request).getDecodedRequestURI();String relativeURI = requestURI.substring(contextPath.length());// 调用Context中相关方法拿到特定WrapperWrapper 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 IAEif (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实例的name1.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 IAEif (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中生命周期相关的内容，敬请期待！

源码分享

https://gitee.com/huo-ming-lu/HowTomcatWorks

本章代码基于原书中代码做了些许美化，添加了注释，代码没有重大bug就不再另起一个包去做实现了，本章代码在这个包下