How tomcat works （5）servlet容器阅读笔记
第四章阅读了tomcat默认连接器的实现，当时connector中的使用的容器是自定义的容器，也是非常之简单奥，一个人就干完了所有的活，完成了初始化类加载器，加载servlet，调用servlet的service方法等的活儿，秉承了专事专干的也就是模块化设计的理念，这样的设计肯定是不够灵活的，这一章就来看看tomcat中的容器是如何设计的
总体介绍
总的来说呢，tomcat将容器分为了四类：
- Engine：表示整个Catalina servlet引擎
- Host： 表示包含有一个或者多个Context容器的虚拟主机，一台tomcat还能用来部署多个web应用？非常的阿妹增啊！！
- Context：表示一个web应用程序，一个Context可以包含多个Wrapper
- Wrapper：（包装纸）表示一个独立的servlet
- 它们的具体实现在
org.apache.catalina.core包下面，对应到具体的类就是standardxxx
容器的分层有点像流水线，一个web应用可能有很多的servlet，那么context就负责随便干点活（调一下valve），然后把活交给打工人（basicvalve 把活交给wrapper），而wrapper也负责随便干点活（调一下valve），然后把活交给真正的劳动人民（basicvalve 调用servlet的service方法），这里提到的valve、basicvalve都是阀
所以container接口及其上述容器的UML如下：
高级容器可以包含0-多个低级子容器，但是wrapper就没法再向下了，有如下的接口用于子容器的管理
public void addChild(Container child);
public void removeChild(Container child);
public Container findChild(String name);
public Container[] findChildren();
//如果wrapper调用这些接口就会抛出异常，以下为standardWrapper的addChild实现
public void addChild(Container child) {
throw new IllegalStateException
(sm.getString("standardWrapper.notChild"));
}
Pipeline和valve
这两者可以说是目前所接触到的tomcat容器和普通自定义容器的最大区别了，其实说简单点也就是加了点过滤器，来看看tomcat中这个功能如何实现吧
管道：包含了该servlet容器将要执行的任务，一个容器对应了一条管道
//standardPipeline
protected Container container = null;
//constructor
public StandardPipeline(Container container) {
super();
setContainer(container);
}
public void setContainer(Container container) {
this.container = container;
}
阀：也就是该servlet容器具体执行的任务，一条管道上面有很多很多阀门，但是有一个basicvalve，也就是基础阀，它永远是最后执行的，pipeline和valve两者的关系就如下图所示
一种简单的方式就是，用一个for循环遍历valves数组，对于每个valve都执行invoke方法，但是tomcat采取了另一种执行方式，引入了一个新的接口org.apache.catalina.valveContext来实现阀的遍历执行，具体的过程代码如下
//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);
}
//StandardPipelineValveContext的invokeNext
//StandardPipelineValveContext是StandardPipeline的一个内部类
//也就是通过内部类的方式一个一个访问valve然后调用
public void invokeNext(Request request, Response response)
throws IOException, ServletException {
//成员变量stage初始值为0，protected int stage = 0;
int subscript = stage;
stage = stage + 1;
// Invoke the requested Valve for the current request thread
//valves数组
//protected Valve valves[] = new Valve[0];
if (subscript < valves.length) {
valves[subscript].invoke(request, response, this);
} else if ((subscript == valves.length) && (basic != null)) {
//最后调用basic阀门
basic.invoke(request, response, this);
} else {
throw new ServletException
(sm.getString("standardPipeline.noValve"));
}
}
//这一章提供了两个简单的阀，就是打印一些信息
//clientIPLoggervalve
//这里还需要传递valveContext实现进来，在invoke中回调invokeNext方法
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("------------------------------------");
}
//HeaderLoggervalve
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("------------------------------------");
}
Wrapper最低级的容器
wrapper接口中比较重要的方法
- allocate方法：分配一个已经初始化的实例
- load方法：加载并初始化实例
以Wrapper作为容器的应用程序的UML如下
主要类以及流程分析
SimpleLoader的构造方法
构造方法中初始化了classLoader，还是熟悉的味道，但是这里只初始化了ClassLoader
public SimpleLoader() {
try {
URL[] urls = new URL[1];
URLStreamHandler streamHandler = null;
//public static final String WEB_ROOT ="D:\tomcat\HowTomcatWorks\webroot";
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() );
}
}
SimpleWrapper
void load()
public void load() throws ServletException {
instance = loadServlet();
}
Servlet loadServlet()
将servlet加载并实例化赋值给成员变量servlet
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");
}
//过去上面的simpleLoader
Loader loader = getLoader();
// Acquire an instance of the class loader to be used
if (loader==null) {
throw new ServletException("No loader.");
}
ClassLoader classLoader = loader.getClassLoader();
//删除了try catch
// Load the specified servlet class from the appropriate class loader
Class classClass = null;
if (classLoader!=null) {
classClass = classLoader.loadClass(actualClass);
}
servlet = (Servlet) classClass.newInstance();
servlet.init(null);
return servlet;
}
至此位置，已经理清楚了classloader的加载过程，那么具体一个请求的调用过程呢？也就是basicvalve是如何来的
basicvalve的调用过程分析
在pipeline和valve中分析过了，最后一个调用basicvalve，那么这个basicvalve是谁呢？
StandardWrapper构造方法
//在构造时就指定了standardWrapper了奥，那么这个StandardWrapperValue又是何方神圣呢？
public StandardWrapper() {
super();
pipeline.setBasic(new StandardWrapperValve());
}
StandardWrapperValve的invoke方法干了啥？对basic的invoke干了啥
public void invoke(Request request, Response response,
ValveContext valveContext)
throws IOException, ServletException {
// Initialize local variables we may need
boolean unavailable = false;
Throwable throwable = null;
StandardWrapper wrapper = (StandardWrapper) 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;
// Check for the application being marked unavailable
if (!((Context) wrapper.getParent()).getAvailable()) {
hres.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE,
sm.getString("standardContext.isUnavailable"));
unavailable = true;
}
// Check for the servlet being marked unavailable
if (!unavailable && wrapper.isUnavailable()) {
log(sm.getString("standardWrapper.isUnavailable",
wrapper.getName()));
if (hres == null) {
; // NOTE - Not much we can do generically
} else {
long available = wrapper.getAvailable();
if ((available > 0L) && (available < Long.MAX_VALUE))
hres.setDateHeader("Retry-After", available);
hres.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE,
sm.getString("standardWrapper.isUnavailable",
wrapper.getName()));
}
unavailable = true;
}
// Allocate a servlet instance to process this request
//调用了allocate方法，有点像connector的分配processor方法
if (!unavailable) {
servlet = wrapper.allocate();
}
// Acknowlege the request
response.sendAcknowledgement();
// Create the filter chain for this request
//非常之容易迷失奥，我们的servlet已经到这里了
ApplicationFilterChain filterChain =
createFilterChain(request, servlet);
// Call the filter chain for this request
// NOTE: This also calls the servlet's service() method
try {
String jspFile = wrapper.getJspFile();
if (jspFile != null)
sreq.setAttribute(Globals.JSP_FILE_ATTR, jspFile);
else
sreq.removeAttribute(Globals.JSP_FILE_ATTR);
if ((servlet != null) && (filterChain != null)) {
//在doFilter里面，如果没有filter要执行，才会终于轮到我们的service服务
//往下的代码就不贴了
filterChain.doFilter(sreq, sres);
}
sreq.removeAttribute(Globals.JSP_FILE_ATTR);
} catch (IOException e) {
...
}
// Release the filter chain (if any) for this request
try {
if (filterChain != null)
filterChain.release();
} catch (Throwable e) {
log(sm.getString("standardWrapper.releaseFilters",
wrapper.getName()), e);
if (throwable == null) {
throwable = e;
exception(request, response, e);
}
}
// Deallocate the allocated servlet instance
try {
if (servlet != null) {
wrapper.deallocate(servlet);
}
} catch (Throwable e) {
log(sm.getString("standardWrapper.deallocateException",
wrapper.getName()), e);
if (throwable == null) {
throwable = e;
exception(request, response, e);
}
}
// If this servlet has been marked permanently unavailable,
// unload it and release this instance
try {
if ((servlet != null) &&
(wrapper.getAvailable() == Long.MAX_VALUE)) {
wrapper.unload();
}
} catch (Throwable e) {
log(sm.getString("standardWrapper.unloadException",
wrapper.getName()), e);
if (throwable == null) {
throwable = e;
exception(request, response, e);
}
}
}
至此，connector的一个简简单单的container.invoke()的具体流程就已经清晰了，先经过pipeline和valve的摧残，等到最后basicValve调用的时候，又要先经过filter的摧残，然后才调用servlet的service方法，非常之幸苦啊，期间还需要做一些准备工作，设置classLoader，加载并且实例化servlet
启动Bootstrap1，打印输出如下：
Client IP Logger Valve
127.0.0.1
------------------------------------
Header Logger Valve
host:localhost:8080
user-agent:Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:82.0) Gecko/20100101 Firefox/82.0
accept:text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
accept-language:en-US,en;q=0.5
accept-encoding:gzip, deflate
connection:keep-alive
upgrade-insecure-requests:1
cache-control:max-age=0
------------------------------------
这两个valve确实是干了活的，并且由于这两个valve的特点，先调用的valve后打印信息
Context
通过上面的学习，已经学会了部署一个仅包含一个servlet的wrapper应用，但是通常来说，应用怎么可能只包含一个servlet呢？肯定是要多个servlet协作的呀
其实context的大部分和wrapper基本一致，只不过这里的context的BasicVavle就不负责真正调用servlet的service方法了，它负责分发请求，根据servletName或者其他的东西将请求分发给context容器内包含的那些wrappers，然后在wrapper里面再执行上面的流程
这个时候就来了个新的组件Mapper映射器，顾名思义，就是负责将请求映射到对应的wrapper上面
mapper接口的定义如下：
package org.apache.catalina;
public interface Mapper{
public Container getContainer();
public void setContainer(Container container);
public String getProtocol();
public void setProtocol(String procotol);
public Container map(Request request,boolean update);
}
- map方法返回指定的container，也是它的核心方法，找到对应的wrapper
本应用程序的UML如下图所示：
主要类以及流程分析
这里主要分析以下Context是如何找到对应的mapper这条线
StandardContextValve的invoke
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();
if (relativeURI.equals("/META-INF") ||
relativeURI.equals("/WEB-INF") ||
relativeURI.startsWith("/META-INF/") ||
relativeURI.startsWith("/WEB-INF/")) {
notFound(requestURI, (HttpServletResponse) response.getResponse());
return;
}
Context context = (Context) getContainer();
// Select the Wrapper to be used for this Request
Wrapper wrapper = null;
try {
//调用map方法找到对应的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);
//调用wrapper的invoke方法
wrapper.invoke(request, response);
}
SimpleContext的map方法
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 = findMapper(request.getRequest().getProtocol());
if (mapper == null)
return (null);
// Use this Mapper to perform this mapping
//调用SimpleContextMapper的map方法
return (mapper.map(request, update));
}
SimpleContextMapper的map方法
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();
//从request中切割出来relativeURI
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;
//根据这个URI去寻找对应的wrapper name
String name = context.findServletMapping(relativeURI);
if (name != null)
//根据name找到对应的wrapper
wrapper = (Wrapper) context.findChild(name);
return (wrapper);
}
SimpleContext的findServletMapping方法
public String findServletMapping(String pattern) {
synchronized (servletMappings) {
//servletMappings就是一个HashMap
return ((String) servletMappings.get(pattern));
}
}
SimpleContext的findChild方法
public Container findChild(String name) {
if (name == null)
return (null);
synchronized (children) { // Required by post-start changes
return ((Container) children.get(name));
}
}
至此context是如何根据relativeURI找到对应的wrapper的流程分析结束
容器启动
可以看到，此时需要启动一个服务器需要事先做多少准备，准备classloader，准备wrapper，准备context，添加valve，添加mapper，然后就可以启动了
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();
}
}
访问localhost:8080/Modern或者localhost:8080/Primitive