深入理解Tomcat——Servlet容器

Servlet容器处理客户端的请求并填充response对象。Servlet容器实现了Container接口。在Tomcat中有4种级别的容器：Engine，Host，Context和Wrapper。

Engine：整个Catalina Servlet引擎；

Host:包含一个或多个Context容器的虚拟主机；

Context：表示一个Web应用程序，可以包含多个Wrapper；

Wrapper：表示一个独立的Servlet；

4个层级接口的标准实现分别是：StandardEngine类，StandardHost类，StandardContext类和StandardWrapper类。它们在org.apache.catalina.core包下。

管道任务

Tomcat中，当连接器调用servlet容器的invoke()方法后，也即connector.getContainer().invoke()方法中执行servlet容器需要调用的任务。管道包含了这些任务，一个阀表示一个具体的任务。在servlet容器中有一个基础阀，可以添加任意数量的阀，不包括基础阀。也可以通过编辑Tomcat的配置文件(server.xml)来动态地添加阀。

管道任务.jpg

​ 图1 管道和阀

管道和阀类似servlet中地过滤器，和Netty中的Pipeline，使用责任链模式。管道是多个阀的组成，每次调用invoke()方法，从第一个阀开始处理，依次向后传播，直到所有阀处理完成。

Tomcat中使用了ValveContext接口来实现管道任务的传播。

public interface ValveContext {

    public String getInfo();

    public void invokeNext(Request request, Response response)
        throws IOException, ServletException;
}

创建了ValveContext实例后，管道会调用ValveContext实例的invokeNext()方法，首先调用管道中的第一个阀，第一个阀执行完成后，调用后面的阀继续执行。具体实现类本文相关代码使用了StandardPipelineValveContext类，代码分析见后文。

本文代码在https://github.com/fanfte/HowTomcatWorks 中，具体工程路径为/src/ex05/pyrmont。本文主要分析Container的实现，具体的请求接收，解析等工作，在深入理解Tomcat——Connector中有具体的解释，可以返回先去看前一篇文章。

源码分析

我们从BootStrap1来分析源码，该类为本应用的启动类。

public final class Bootstrap1 {
  public static void main(String[] args) {
    HttpConnector connector = new HttpConnector();
    // servlet容器的核心wrapper，SimpleWrapper实现wrapper接口
    Wrapper wrapper = new SimpleWrapper();
    // 设置servlet类名，通过名称加载类
    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);

    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();
    }
  }
}

在main方法中初始化时，将创建一个HttpConnector，即在上一篇文章中详细描述的类，这里就不再过多描述了。

初始化时，simpleWrapper的构造方法：

public SimpleWrapper() {
    pipeline.setBasic(new SimpleWrapperValve());
}

public void setBasic(Valve valve) {
  this.basic = valve;
  ((Contained) valve).setContainer(container);
}

设置了一个basic的阀为SimpleWrapperValve。

之后在wrapper中绑定一个加载器，并且SimpleLoader实现了Pipeline接口，调用它的addValve()方法添加两个阀

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

调用pipeline的addValve()方法

public void addValve(Valve valve) {
  // 是Contained类型实例，则绑定一个container
  if (valve instanceof Contained)
    ((Contained) valve).setContainer(this.container);

  synchronized (valves) {
    // valves是一个存放Valve对象的数组，拷贝该数组，在数组最后添加一个valve对象
    Valve results[] = new Valve[valves.length +1];
    System.arraycopy(valves, 0, results, 0, valves.length);
    results[valves.length] = valve;
    valves = results;
  }
}

最后执行到初始化：

// wrapper和connector绑定
connector.setContainer(wrapper);

try {
  // 启动connector
  connector.initialize();
  connector.start();
  // 终止应用的条件
  System.in.read();
}
catch (Exception e) {
  e.printStackTrace();
}

start()方法在前一篇文章说过，开启了Connector线程和Processor线程，我们直接看到HttpProcessor类中的run方法，即Processor线程内部的process()方法的：

connector.getContainer().invoke(request, response);

开始完成pipeline的处理，在这里设置一个断点并且debug一下,在浏览器中输入http://localhost:8080/程序会进入这一段逻辑。可以看到getContainer()得到的是前面注册进去的simpleWrapper，调用关系如下：

simpleWrapper.invoke() --> pipeline.invoke() --> (new SimplePipelineValveContext()).invokeNext() --> valves[subscript].invoke(request, response, this) --> valveContext.invokeNext(request, response) --> valves[subscript].invoke(request, response, this)

可以查看IDEA的调用栈，也是符合上述逻辑的。

调用栈.png

                                                         图2 IDEA调用栈

SimplePipelineValveContext实现自ValveContext接口，是SimplePipeline的内部类，

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;
    stage = stage + 1;
    // 在当前请求的线程调用valve的invoke方法
    // 初始subscript = 0，按照调用注册顺序调用headerLoggerValve，
    // clientIpLoggerValve的invoke()方法，向下传播请求
    if (subscript < valves.length) {
      valves[subscript].invoke(request, response, this);
    } //传播到最后一个任务，先执行basic任务
    else if ((subscript == valves.length) && (basic != null)) {
      basic.invoke(request, response, this);
    }
    else {
      throw new ServletException("No valve");
    }
  }
} 

初始stage为0则invoke执行valves中第一个元素的任务，将请求向下传递，最后传递到basic的valve，为之前初始化SimpleWrapper时添加到basic成员的SimpleWrapperValve实例。SimpleWrapperValve的invoke()方法如下：

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)
        // 抓换为HttpServletRequest实例 
        hreq = (HttpServletRequest) sreq;
    HttpServletResponse hres = null;
    if (sres instanceof HttpServletResponse)
        // 转换为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) {
    }
}

allocate()中通过反射机制进行servlet的加载，加载名称为ModernServlet的Servlet，该名称在初始化时设置。接着，调用service方法执行servlet中的方法，由于浏览器中访问是GET方式，则最终会执行ModernServlet中的doGet，具体doGet代码为输出一些HTML信息，可以自己跟读源码了解。

上述过程则为Wrapper作为Container的执行机制。

Context的运行机制类似，代码在BootStrap2中，可以自行Debug查看。

😀