1、类图
image.png
2、处理过程（以Wrapper为例）
在连接器部分了解到，对于客户端的处理，连接器是在解析相关的协议后，最终调用了Container的invoke方法来处理的，这里看一下Wrapper的处理过程，Wrapper的标准实现为StandardWrapper：
public StandardWrapper() {
super();
// 设置基本的 Value
pipeline.setBasic(new StandardWrapperValve());
}
根据类图可知，invoke方法在ContainerBase中实现：
protected Pipeline pipeline = new StandardPipeline(this);
public void invoke(Request request, Response response)
throws IOException, ServletException {
pipeline.invoke(request, response);
}
其调用了Pipeline的invoke方法：
public void invoke(Request request, Response response)
throws IOException, ServletException {
// Invoke the first Valve in this pipeline for this request
(new StandardPipelineValveContext()).invokeNext(request, response);
}
protected class StandardPipelineValveContext implements ValveContext {
protected int stage = 0;
public void invokeNext(Request request, Response response)
throws IOException, ServletException {
int subscript = stage;// 下标
stage = stage + 1;// 级别
// Invoke the requested Valve for the current request thread
if (subscript < valves.length) {
valves[subscript].invoke(request, response, this);
} else if ((subscript == valves.length) && (basic != null)) {
basic.invoke(request, response, this);
} else {
throw new ServletException
(sm.getString("standardPipeline.noValve"));
}
}
}
以ClientIPLoggerValve为例：
public void invoke(Request request, Response response, ValveContext valveContext)
throws IOException, ServletException {
// Pass this request on to the next valve in our pipeline
// 这里先调用了ValveContext的invokeNext方法
valveContext.invokeNext(request, response);
// 然后才是处理自己的逻辑
System.out.println("Client IP Logger Valve");
ServletRequest sreq = request.getRequest();
System.out.println(sreq.getRemoteAddr());
System.out.println("------------------------------------");
}
每一个Pipeline维持着一个基本的Valve和一个Valve[]，Valve通过addValve()方法加入到pipeline中，当Container的invoke被Connector调用的时候，Container内部调用了pipeline的invoke方法，而pipeline内部则是通过ValveContext的invokeNext方法来实现Valve的依次执行，根据每个Valve的内部实现，这里的执行顺序为basic valve会被优先执行，然后其他的Valve是按照后进先出的顺序执行，这个从Valve中的invoke方法实现也可以验证，每个Valve在执行前都是先执行了ValveContext的invokeNext方法。
// 构建一个包装容器，一个包装容器代表一个具体的servlet
Wrapper wrapper = new SimpleWrapper();
wrapper.setServletClass("ModernServlet");
// 构建两个Valve
Valve valve1 = new HeaderLoggerValve();
Valve valve2 = new ClientIPLoggerValve();
// 添加阀门（任务）
((Pipeline) wrapper).addValve(valve1);
((Pipeline) wrapper).addValve(valve2);
Basic Valve:
public void invoke(Request request, Response response, ValveContext valveContext)
throws IOException, ServletException {
System.out.println("00000000000 SimpleWrapperValve Basic Valve ");
SimpleWrapper wrapper = (SimpleWrapper) getContainer();
ServletRequest sreq = request.getRequest();
ServletResponse sres = response.getResponse();
Servlet servlet = null;
HttpServletRequest hreq = null;
if (sreq instanceof HttpServletRequest)
hreq = (HttpServletRequest) sreq;
HttpServletResponse hres = null;
if (sres instanceof HttpServletResponse)
hres = (HttpServletResponse) sres;
// Allocate a servlet instance to process this request
try {
servlet = wrapper.allocate();
if (hres!=null && hreq!=null) {
servlet.service(hreq, hres);
}
else {
servlet.service(sreq, sres);
}
}
catch (ServletException e) {
}
}
#######Basic Valve被优先执行
00000000000 SimpleWrapperValve Basic Valve
ModernServlet -- init
#######Client IP Logger Valve被执行
00000000000 Client IP Logger Valve
0:0:0:0:0:0:0:1
------------------------------------
#######Header Logger Valve被执行
00000000000 Header Logger Valve
host:localhost:8080
connection:keep-alive
upgrade-insecure-requests:1
user-agent:Mozilla/5.0 (Windows NT 10.0; WOW64) ...
accept:text/html,application/xhtml+xml,application/xml;...
accept-encoding:gzip, deflate, br
accept-language:zh-CN,zh;q=0.9,en;q=0.8
------------------------------------
3、多Wrapper容器处理
在tomcat4中，如果包含多个wrapper容器，这时需要一个mapper来处理这些wrapper
HttpConnector connector = new HttpConnector();
// wrapper 1
Wrapper wrapper1 = new SimpleWrapper();
wrapper1.setName("Primitive");
wrapper1.setServletClass("PrimitiveServlet");
// wrapper 2
Wrapper wrapper2 = new SimpleWrapper();
wrapper2.setName("Modern");
wrapper2.setServletClass("ModernServlet");
// context
Context context = new SimpleContext();
// wrapper add to context
context.addChild(wrapper1);
context.addChild(wrapper2);
// create 2 Valve
Valve valve1 = new HeaderLoggerValve();
Valve valve2 = new ClientIPLoggerValve();
// 阀门加入到了Context容器中
((Pipeline) context).addValve(valve1);
((Pipeline) context).addValve(valve2);
// create a mapper
Mapper mapper = new SimpleContextMapper();
// set protocol
mapper.setProtocol("http");
// add mapper to context
context.addMapper(mapper);
Loader loader = new SimpleLoader();
context.setLoader(loader);
// context.addServletMapping(pattern, name);
context.addServletMapping("/Primitive", "Primitive");
context.addServletMapping("/Modern", "Modern");
connector.setContainer(context);
Basic Valve:
public void invoke(Request request, Response response, ValveContext valveContext)
throws IOException, ServletException {
// Validate the request and response object types
if (!(request.getRequest() instanceof HttpServletRequest) ||
!(response.getResponse() instanceof HttpServletResponse)) {
return; // NOTE - Not much else we can do generically
}
// Disallow any direct access to resources under WEB-INF or META-INF
HttpServletRequest hreq = (HttpServletRequest) request.getRequest();
String contextPath = hreq.getContextPath();
String requestURI = ((HttpRequest) request).getDecodedRequestURI();
String relativeURI =
requestURI.substring(contextPath.length()).toUpperCase();
Context context = (Context) getContainer();
// Select the Wrapper to be used for this Request
Wrapper wrapper = null;
try {
// ##############1、从context中获取一个wrapper
wrapper = (Wrapper) context.map(request, true);
}
catch (IllegalArgumentException e) {
badRequest(requestURI, (HttpServletResponse) response.getResponse());
return;
}
if (wrapper == null) {
notFound(requestURI, (HttpServletResponse) response.getResponse());
return;
}
// Ask this Wrapper to process this Request
response.setContext(context);
// ##############2、调用wrapper的invoke方法
wrapper.invoke(request, response);
}
看一下Context是如何找wrapper的：
public Container map(Request request, boolean update) {
//this method is taken from the map method in org.apache.cataline.core.ContainerBase
//the findMapper method always returns the default mapper, if any, regardless the
//request's protocol
// 根据协议来找到对应的Mapper
Mapper mapper = findMapper(request.getRequest().getProtocol());
if (mapper == null)
return (null);
// Use this Mapper to perform this mapping
// 然后从Mapper中来找到wrapper
return (mapper.map(request, update));
}
Mapper查找wrapper过程
public Container map(Request request, boolean update) {
// Identify the context-relative URI to be mapped
String contextPath =
((HttpServletRequest) request.getRequest()).getContextPath();
String requestURI = ((HttpRequest) request).getDecodedRequestURI();
String relativeURI = requestURI.substring(contextPath.length());
// Apply the standard request URI mapping rules from the specification
Wrapper wrapper = null;
String servletPath = relativeURI;
String pathInfo = null;
// 找到servlet的名称
String name = context.findServletMapping(relativeURI);
if (name != null)
// 根据名称来找wrapper，在tomcat中，一个wrapper对应一个servlet
wrapper = (Wrapper) context.findChild(name);
return (wrapper);
}
总的过程就是根据协议先找到Mapper，然后再根据servlet name找到wrapper。