0.0）本文部分文字描述转自：“深入剖析tomcat”，旨在学习 tomcat(5)servlet容器 的基础知识；

0.1）intro to servlet容器：servlet容器是用来处理请求servlet资源，并为web客户端填充response 对象的模块；

0.2）补充：吃个饭过来，真心没想到这么多人围观，再次对文章重新排版（并不是博主我不给力，是CSDN编辑器时不时吊链子啊，oh），并添加了测试用例的程序流程图（共3张）[1604111947]；

0.3）for complete source code, please visit  https://github.com/pacosonTang/HowTomcatWorks/tree/master/chapter5

0.4） 温馨建议：建议阅读本文之前，已阅读过 tomcat(1~4)的系列文章，因为它们是环环相扣的；

t1）Engine：表示整个Catalina servlet 引擎；

t2）Host：表示包含有一个或多个 Context容器的虚拟主机；

t3）Context：表示一个web 应用程序，一个Context 可以有多个 Wrapper；

t4）Wrapper：表示一个独立的servlet；

2）以上4种容器都是 org.apache.catalina包下的接口：分别为Engine，Host， Context， Wrapper，他们都继承自Container接口。这4个接口的标准实现是 StandardEngine类，StandardHost类，StandardContext类，StandardWrapper类，他们都在 org.apache.catalina.core 包内；

Attention）

A1）所有的实现类都继承自抽象类 ContainerBase ；

A2）Container接口的设计满足以下条件：在部署应用时，Tomcat管理员可以通过编辑配置文件(server.xml)来决定使用哪种容器。这是通过引入容器中的管道（pipeline）和阀（valve）的集合实现的；（干货——引入了容器中的管道和阀）

【2】管道任务

1）本节旨在说明： 当连接器调用了servlet容器的invoke方法后会发生什么事情，并讨论org.apache.catalina 包中的4个相关接口，Pipeline， Valve， ValveContext 和 Contained；

2）管道和阀：（干货——注意管道和阀的定义）

2.1）管道：包含该servlet容器将要调用的任务；

2.2）一个阀：表示一个具体的任务。

2.3）在servlet容器的管道中，有一个基础阀，但是，可以添加任意数量的阀。阀的数量指的是额外添加的阀数量，即，不包括基础阀。有意思的是， 可以通过编辑tomcat 的 配置文件(server.xml)来动态地添加阀；

2.4）一条管道和阀的示意图如下：

Attention）

A1）管道就想过滤器链条一样，而阀则好似过滤器；

A2）当一个阀执行完成后，会调用下一个阀继续执行。基础阀总是最后一个执行；（干货——当一个阀执行完成后，会调用下一个阀继续执行。基础阀总是最后一个执行）

3）管道的invoke方法：一个servlet容器可以有一条管道，当调用了容器的invoke方法后，容器会将处理工作交由管道完成，而管道会调用其中的第一个阀开始处理。当第一个阀处理完后，它会调用后续的阀继续执行任务，直到管道中所有的阀都处理完成。

 public void invoke(Request request, Response response) //SimplePipeline.invoke()方法throws IOException, ServletException {// Invoke the first Valve in this pipeline for this request(new SimplePipelineValveContext()).invokeNext(request, response);}public void removeValve(Valve valve) {}// this class is copied from org.apache.catalina.core.StandardPipeline class's// StandardPipelineValveContext inner class.protected class SimplePipelineValveContext implements ValveContext {protected int stage = 0;public String getInfo() {return null;}public void invokeNext(Request request, Response response)throws IOException, ServletException {int subscript = stage; // init stage == 0.stage = stage + 1;// Invoke the requested Valve for the current request threadif (subscript < valves.length) {valves[subscript].invoke(request, response, this); // 若非基础阀是 ClientIPLoggerValve}else if ((subscript == valves.length) && (basic != null)) {basic.invoke(request, response, this); // this line, 直到基础阀才停止遍历非基础阀}else {throw new ServletException("No valve");}}} // end of inner class

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); // 继续回调 SimplePipeline.invokeNext()，直到基础阀System.out.println("Client IP Logger Valve");ServletRequest sreq = request.getRequest();System.out.println(sreq.getRemoteAddr()); // this line outputs ip addr to the console.System.out.println("------------------------------------");}

4）实现阀的遍历：Tomcat引入接口 org.apache.catalina.ValveContext 来实现阀的遍历执行；

4.1）管道必须保证添加到其中的所有阀和基础阀都被调用一次：这是通过调用一个 ValveContext接口实例来实现的。

4.2）ValveContext接口中最重要的方法是 invokeNext方法：在创建了ValveContext实例后，管道会调用ValveContext实例的 invokeNext方法。ValveContext实例会首先调用管道中的 第一个阀，第一个阀执行完后，会调用后面的阀继续执行。ValveContext实例会将自身传给每个阀，因此，每个阀都可以调用 ValveContext实例的 invokeNext方法；

5）org.apache.catalina.core.StandardPipeline类： 是所有servlet容器中的Pipeline接口的实现，Tomcat4中有一个实现了ValveContext接口的内部类，名为StandardPipelineValveContext；

6）Tomcat5 从 StandardPipeline类中移除了 StandardPipelineValveContext类：却使用 org.apache.catalina.core.StandardValveContext类来调用阀；

【2.1】Pipeline接口

1）对于Pipeline接口：首先要提到的一个方法是 invoke方法，servlet容器调用invoke方法来开始调用管道中的阀和基础阀；

2）getBasic和setBasic：setBasic方法将基础阀设置到管道中，getBasic获取基础阀；（干货——管道中可以指定基础阀）

3）addValve和removeValve：新增阀和删除阀；（干货——在管道中可以新增和删除非基础阀）（请注意：SimplePipe.addValve()下面的 System.arraycopy 方法）

public final class Bootstrap1 {public static void main(String[] args) {/* call by using http://localhost:8080/ModernServlet,but could be invoked by any name */HttpConnector connector = new HttpConnector();Wrapper wrapper = new SimpleWrapper();wrapper.setServletClass("servlet.ModernServlet"); // 设置servlet的相对路径Loader loader = new SimpleLoader(); // 类加载器Valve valve1 = new HeaderLoggerValve(); // 把请求头信息output到 consoleValve valve2 = new ClientIPLoggerValve();// 用来将client的IP 地址输出到控制台上wrapper.setLoader(loader);((Pipeline) wrapper).addValve(valve1); // 新增阀 ，key line((Pipeline) wrapper).addValve(valve2); // 新增阀, key lineconnector.setContainer(wrapper);try {connector.initialize(); // 创建服务器套接字connector.start(); // // make the application wait until we press a key.System.in.read();}catch (Exception e) {e.printStackTrace();}}
}

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

public void addValve(Valve valve) { // SimplePipeline.addValve()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;}}

【2.2】Valve接口

1）阀是Valve接口的实例，用来处理接收到的请求，有两个方法：invoke方法和getinfo方法；

public interface Valve {
public String getInfo();
public void invoke(Request request, Response response,ValveContext context)throws IOException, ServletException;
}

【2.3.】ValveContext接口

1）有两个方法：invokeNext方法和 getInfo方法；

public interface ValveContext {
public String getInfo();
public void invokeNext(Request request, Response response)throws IOException, ServletException;
}

【2.4】Contained接口

public interface Contained {
public Container getContainer();
public void setContainer(Container container);
}

【3】Wrapper接口

1）intro to Wrapper：Wrapper级的servlet容器是一个 org.apache.catalina.Wrapper接口的实例，表示一个独立的servlet定义。Wrapper接口继承自 Container接口，又添加了一些额外的方法。

2）Wrapper接口的实现类：要负责管理继承servlet类的servlet生命周期，即，调用 servlet的 init(), service(), destroy()方法；

3）由于Wrapper已经是最低级的容器了，不能再向其中添加子容器；（干货——Wrapper已经是最低级的servlet容器）

4）Wrapper接口有两个方法：load方法 和 allocate方法；

4.1）load方法：载入并初始化servlet类；

4.2）allocate方法：会分配一个已经初始化的servlet实例；

 public Servlet allocate() throws ServletException { // SimpleWrapper.allocate() method.// Load and initialize our instance if necessaryif (instance==null) {try {instance = loadServlet(); // this line}catch (ServletException e) {throw e;}catch (Throwable e) {throw new ServletException("Cannot allocate a servlet instance", e);}}return instance;}private Servlet loadServlet() throws ServletException { // this line 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(); // this line// Acquire an instance of the class loader to be usedif (loader==null) {throw new ServletException("No loader.");}ClassLoader classLoader = loader.getClassLoader(); // this line// Load the specified servlet class from the appropriate class loaderClass classClass = null;try {if (classLoader!=null) {classClass = classLoader.loadClass(actualClass);}}catch (ClassNotFoundException e) {throw new ServletException("Servlet class not found");}// Instantiate and initialize an instance of the servlet class itselftry {servlet = (Servlet) classClass.newInstance();}catch (Throwable e) {throw new ServletException("Failed to instantiate servlet");}// Call the initialization method of this servlettry {servlet.init(null);}catch (Throwable f) {throw new ServletException("Failed initialize servlet.");}return servlet;}public Loader getLoader() { // this  lineif (loader != null)return (loader);if (parent != null)return (parent.getLoader());return (null);}

【4】Context接口

1）intro to Context：Context接口是一个web 应用程序，一个Context实例可以有一个或多个Wrapper实例作为其子容器；

2）比较重要的方法： addWrapper() and createWrapper()；

【5】Wrapper 应用程序（demonstrate how to build a smallest servlet container）

1）SimpleWrapper类：该类实现了Wrapper接口，包含一个Pipeline实例，并使用Loader实例载入servlet类。Pipeline实例包含一个基础阀和两个额外的阀。

【5.1】SimpleLoader类

1）SimpleLoader：负责完成类的载入工作，它知道servlet类的位置，通过调用其getClassLoader可以返回一个 java.lang.ClassLoader实例，可以用来搜索servlet类的位置；

2）SimpleLoader的构造函数：会初始化类加载器，供 SimpleWrapper实例使用；

public class SimpleLoader implements Loader { // return class loaderpublic static final String WEB_ROOT =System.getProperty("user.dir") + File.separator  + "webroot";ClassLoader classLoader = null;Container container = null;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;}

【5.2】SimplePipeline类

1）该类最重要的方法是 invoke方法；

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 void invoke(Request request, Response response)throws IOException, ServletException {// Invoke the first Valve in this pipeline for this request(new SimplePipelineValveContext()).invokeNext(request, response);} protected class SimplePipelineValveContext implements ValveContext {protected int stage = 0;public String getInfo() {return null;}public void invokeNext(Request request, Response response)throws IOException, ServletException {int subscript = stage; // init stage == 0.stage = stage + 1;// Invoke the requested Valve for the current request threadif (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

【5.3】SimpleWrapper类

1）该类实现了Wrapper接口：并提供了 allocate 和 load 方法的实现；

2）getLoader()方法：该方法返回一个用于载入servlet 类的载入器。若Wrapper实例已经关联了一个载入器，则直接将其返回；否则，它将返回父容器的载入器。若没有父容器，getLoader方法会返回null；

public Servlet allocate() throws ServletException {// Load and initialize our instance if necessaryif (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();// Acquire an instance of the class loader to be usedif (loader==null) {throw new ServletException("No loader.");}ClassLoader classLoader = loader.getClassLoader();// Load the specified servlet class from the appropriate class loaderClass classClass = null;try {if (classLoader!=null) {classClass = classLoader.loadClass(actualClass);}}catch (ClassNotFoundException e) {throw new ServletException("Servlet class not found");}// Instantiate and initialize an instance of the servlet class itselftry {servlet = (Servlet) classClass.newInstance();}catch (Throwable e) {throw new ServletException("Failed to instantiate servlet");}// Call the initialization method of this servlettry {servlet.init(null);}catch (Throwable f) {throw new ServletException("Failed initialize servlet.");}return servlet;}

3）SimpleWrapper类有一个Pipeline实例：并该为Pipeline实例设置基础阀；

【5.4】SimpleWrapperValve类

1）SimpleWrapperValve是一个基础阀：用于处理对SimpleWrapper类的请求，其最主要的方法是 invoke方法；

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;// Allocate a servlet instance to process this requesttry {servlet = wrapper.allocate();if (hres!=null && hreq!=null) {servlet.service(hreq, hres);}else {servlet.service(sreq, sres);}}catch (ServletException e) {}  }

【5.5】ClientIPLoggerValve类

1）ClientIPLoggerValve类所表示的阀：用来将client的IP 地址输出到控制台上；

2）注意其invoke方法：它先调用方法参数 valveContext的 invokeNext方法来调用管道中的下一个阀。然后，它会把几行字符串output到 console；

【5.6】HeaderLoggerValve类

1）HeaderLoggerValve类作用：会把请求头信息output到 console；

2）注意其invoke方法：它先调用方法参数 valveContext的 invokeNext方法来调用管道中的下一个阀。

【5.7】Bootstrap1

step1）创建 HttpConnector 和 SimpleWrapper实例，并将需要加载的 servlet name 赋值给 Wrapper实例；

step2）创建一个载入器和两个阀，将载入器设置到Wrapper实例中 ；

step3）将上述创建的两个阀添加到 Wrapper的管道中；

step4）将Wrapper 实例设置为 连接器的servlet容器，并初始化并启动连接器

public final class Bootstrap1 {public static void main(String[] args) {/* call by using http://localhost:8080/ModernServlet,but could be invoked by any name */HttpConnector connector = new HttpConnector();Wrapper wrapper = new SimpleWrapper();wrapper.setServletClass("servlet.ModernServlet"); // 设置servlet的相对路径Loader loader = new SimpleLoader(); // 类加载器Valve valve1 = new HeaderLoggerValve(); // 把请求头信息output到 consoleValve valve2 = new ClientIPLoggerValve();// 用来将client的IP 地址输出到控制台上wrapper.setLoader(loader);((Pipeline) wrapper).addValve(valve1); // 新增阀((Pipeline) wrapper).addValve(valve2); // 新增阀connector.setContainer(wrapper);try {connector.initialize(); // 创建服务器套接字connector.start(); // // make the application wait until we press a key.System.in.read();}catch (Exception e) {e.printStackTrace();}  }}

Attention）我这里总结了该测试用例的调用流程图（共3张）

【5.8】运行应用程序

1）运行参数

E:\bench-cluster\cloud-data-preprocess\HowTomcatWorks\src>java -cp .;lib/servlet.jar;lib/catalina_4_1_24.jar;E:\bench-cluster\cloud-data-preprocess\HowTomcatWorks\webroot com.tomcat.chapter5.startup/B ootstrap1
HttpConnector Opening server socket on all host IP addresses
HttpConnector[8080] Starting background thread
ModernServlet -- init
Client IP Logger Valve
127.0.0.1
------------------------------------
Header Logger Valve
host:localhost:8080
connection:keep-alive
accept:text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
user-agent:Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/39.0.2171.71 Safari/537.36
accept-encoding:gzip, deflate, sdch
accept-language:zh-CN,zh;q=0.8,en;q=0.6
------------------------------------
Client IP Logger Valve
127.0.0.1
------------------------------------
Header Logger Valve
host:localhost:8080
connection:keep-alive
accept:text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
user-agent:Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/39.0.2171.71 Safari/537.36
accept-encoding:gzip, deflate, sdch
accept-language:zh-CN,zh;q=0.8,en;q=0.6
------------------------------------

2）运行结果

step1）HttpConnector类的大致工作：

step1.1）initialize方法：调用该类的open方法创建服务器套接字；

step1.2）start方法：开启一个线程，该线程中有一个while循环，不断接收client发送的HTTP连接请求，接着调用其类的createProcessor方法；

step1.3）createProcessor方法：调用其类的 newProcessor方法；

step1.4）newProcessor方法：创建HttpProcessor（HTTP连接器的支持类，HTTP请求处理器），利用HttpProcessor实例开启一个线程，调用 HttpProcessor.run()方法；（转向HttpProcessor类的run方法）（干货中的干货——也即当clients 发出http 连接请求后，HttpConnector 在while循环中创建HttpConnector的支持类 HttpProcessor，Http处理器类，并调用该类的start方法，开启线程，即while循环为每一个client 请求 开启一个线程进行处理，多么巧妙）

step2）HttpProcessor类的大致工作：

step2.1）run方法：传入套接字参数，并调用process方法；

step2.2）process方法：依次调用 parseConnection()方法， parseRequest()方法， parseHeader() 方法；调用上述三个方法后，会调用连接器HttpConnector实例的关联容器的invoke方法；（转向container的invoke方法）注意：本程序的container是SimpleContext类，下面转向SimpleContext.invoke() 方法；