深入剖析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在构造时就创建了一个类加载器负责加载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就不再另起一个包去做实现了,本章代码在这个包下

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.rhkb.cn/news/318479.html

如若内容造成侵权/违法违规/事实不符,请联系长河编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

实现优先队列——C++

目录 1.优先队列的类模板 2.仿函数的讲解 3.成员变量 4.构造函数 5。判空&#xff0c;返回size&#xff0c;返回队头 6.插入 7.删除 1.优先队列的类模板 我们先通过模板来进行初步了解 由上图可知&#xff0c;我们的模板里有三个参数&#xff0c;第一个参数自然就是你要存储的数…

读天才与算法:人脑与AI的数学思维笔记16_音乐图灵测试

1. 艾米 1.1. 人工智能作曲家 1.1.1. 分析机可能会生成任意复杂程度、精细程度的科学的音乐作品 1.1.1.1. 阿达洛夫莱斯 1.1.2. 巴赫的作品是大多数作曲家开始学习创作的起点&#xff0c;也是大多数计算机开始学习作曲的起点…

uniapp 短视频浏览组件(仿抖音、上滑下滑)组件 Ba-VideoSView

简介&#xff08;下载地址&#xff09; Ba-VideoSView 是一款uniapp短视频上划浏览组件&#xff0c;支持无限滑动加载&#xff0c;支持自定义界面&#xff08;功能遮罩&#xff09;,支持点播、直播。 支持无限滑动加载支持自定义界面&#xff08;遮罩&#xff09;支持监听上滑…

第 8 章 机器人平台设计(自学二刷笔记)

重要参考&#xff1a; 课程链接:https://www.bilibili.com/video/BV1Ci4y1L7ZZ 讲义链接:Introduction Autolabor-ROS机器人入门课程《ROS理论与实践》零基础教程 学习到当前阶段大家对ROS已经有一定的认知了&#xff0c;但是之前的内容更偏理论&#xff0c;尤其是介绍完第6…

KKView远程控制2.0版本发布,TeamViewer面临巨大挑战

KKView远程控制2.0版本发布&#xff0c;TeamViewer面临巨大挑战 近日&#xff0c;备受瞩目的远程控制软件KKView发布了其全新2.0版本&#xff0c;KKView以其独特的创新性和用户友好的设计&#xff0c;为远程办公、远程培训等领域提供了更加高效、便捷的解决方案。 KKView远程…

K8S 哲学 - deployment -- kubectl【create 、 rollout 、edit、scale、set】

kubectl create kubectl rollout kubectl edit kubectl set kubectl scale 1、创建与配置文件解析 2、deploy 滚动更新 &#xff1a;template 里面的内容改变触发滚动更新 编辑该 deploy 的 配置文件 &#xff0c;加入一个 label 不会触发滚动更新 改变 nginx镜…

分布式与一致性协议之Raft算法(一)

Raft算法 概述 Raft算法属于Multi-Paxos算法&#xff0c;它在兰伯特Multi-Paxos思想的基础上做了一些简化和限制&#xff0c;比如日志必须是连续的&#xff0c;只支持领导者(Leader)、跟随者(Follwer)和候选人(Candidate)3种状态。在理解和算法实现上&#xff0c;Raft算法相对…

Python语言零基础入门——文件

目录 一、文件的基本概念 1.文件 2.绝对路径与相对路径 3.打开文件的模式 二、文件的读取 三、文件的追加 四、文件的写入 五、with语句 六、csv文件 1.csv文件的读取 2.csv文件的写入 七、练习题&#xff1a;实现日记本 一、文件的基本概念 1.文件 文件是以计算…

浏览器安装路径位置的查看、指定网址快捷方式的创建

浏览器安装路径位置的查看、指定网址快捷方式的创建 浏览器安装路径位置的查看 法一、属性查看法 右键点击浏览器的桌面图标&#xff0c;选择“属性”&#xff0c;“快捷方式”页中的“目标”框中可见. 以Microsoft Edge浏览器为例&#xff0c;参见下图&#xff1a; 法二、地…

免费开源语音克隆-GPT-SoVITS-WebUI只需 5 秒的声音样本

语音克隆-GPT-SoVITS-WebUI 强大的少样本语音转换与语音合成Web用户界面。 功能&#xff1a; 零样本文本到语音&#xff08;TTS&#xff09;&#xff1a; 输入 5 秒的声音样本&#xff0c;即刻体验文本到语音转换。 少样本 TTS&#xff1a; 仅需 1 分钟的训练数据即可微调模型…

LabVIEW换智能仿真三相电能表研制

LabVIEW换智能仿真三相电能表研制 在当前电力工业飞速发展的背景下&#xff0c;确保电能计量的准确性与公正性变得尤为重要。本文提出了一种基于LabVIEW和单片机技术&#xff0c;具有灵活状态切换功能的智能仿真三相电能表&#xff0c;旨在通过技术创新提高电能计量人员的培训…

基于SpringBoot+Vue的旅游网站系统

初衷 在后台收到很多私信是咨询毕业设计怎么做的&#xff1f;有没有好的毕业设计参考?能感觉到现在的毕业生和当时的我有着同样的问题&#xff0c;但是当时的我没有被骗&#xff0c;因为现在很多人是被骗的&#xff0c;还没有出学校还是社会经验少&#xff0c;容易相信别人。…

项目管理-项目进度管理2/3

项目管理&#xff1a;每天进步一点点~ 活到老&#xff0c;学到老 ヾ(◍∇◍)&#xff89;&#xff9e; 何时学习都不晚&#xff0c;加油 项目进度管理&#xff1a;需掌握 ITTO, 搞懂计算图&#xff0c;问题和解决方案。 项目进度管理6个过程&#xff0c;包括&#xff08;口…

机器学习:深入解析SVM的核心概念【二、对偶问题】

对偶问题 **问题一&#xff1a;什么叫做凸二次优化问题&#xff1f;而且为什么符合凸二次优化问题&#xff1f;**为什么约束条件也是凸的半空间&#xff08;Half-Space&#xff09;凸集&#xff08;Convex Set&#xff09;半空间是凸集的例子SVM 约束定义的半空间总结 **问题二…

nginx的前世今生(二)

书接上回&#xff1a; 上回书说到&#xff0c;nginx的前世今生&#xff0c;这回我们继续说 3.缓冲秘籍&#xff0c;洪流控水 Nginx的缓冲区是其处理数据传输和提高性能的关键设计之一&#xff0c;主要用于暂存和管理进出的数据流&#xff0c;以应对不同组件间速度不匹配的问题…

Dokcer容器分布式搭建LNMP+wordpress论坛

目录 引言 一、架构环境 二、搭建容器 &#xff08;一&#xff09;自定义网络 &#xff08;二&#xff09;搭建nginx容器 1.文件准备 2.查看与编辑文件 3.生成镜像 4.创建容器 &#xff08;三&#xff09;搭建MySQL容器 1.文件准备 2.查看与编辑文件 3.生成镜像 …

基于Unity+Vue通信交互的WebGL项目实践

unity-webgl 是无法直接向vue项目进行通信的&#xff0c;需要一个中间者 jslib 文件 jslib当作中间者&#xff0c;unity与它通信&#xff0c;前端也与它通信&#xff0c;在此基础上三者之间进行了通信对接 看过很多例子&#xff1a;介绍的都不是很详细&#xff0c;不如自己写&…

【银角大王——Django课程——用户表的基本操作】

Django课程——用户表的基本操作 模板的继承用户管理用户列表展示新建用户Django组件原始方法【麻烦&#xff0c;太原始】form组件modelform组件 使用modelsform组件编写添加页面 模板的继承 &#xff08;1&#xff09;先写一个页面模板————这个案例中的模板基本上就是一个…

分布式与一致性协议之CAP和Paxos算法(一)

CAP 理论 如何使用BASE理论 以InfluxDB系统中DATA节点的集群实现为例。DATA节点的核心功能是读和写&#xff0c;所以基本可用是指读和写的基本可用。我们可以通过分片和多副本实现读和写的基本可用。也就是说&#xff0c;将同一业务的数据先分片&#xff0c;再以多份副本的形…

嫦娥六号发射任务圆满成功,开启月球背面采样返回之旅 | 最新快讯

央视新闻5月3日消息&#xff0c;据国家航天局&#xff0c;5月3日17时27分&#xff0c;嫦娥六号探测器由长征五号遥八运载火箭在中国文昌航天发射场成功发射&#xff0c;准确进入地月转移轨道&#xff0c;发射任务取得圆满成功。嫦娥六号探测器开启世界首次月球背面采样返回之旅…