tomcat源码分析1 —— 整体架构

tomcat的整体结构大概可以分成两块，一个是Connector，另一个是Container。Connector负责接收请求，建立socket连接，根据请求中的信息创建Request和Response对象，具体的处理逻辑交给Container。

server.xml配置文件描述了tomcat服务器的整体结构。

Server：表示整个Tomcat服务器，包含一个或多个Service。

Service：包含一个或多个connector + 一个Engine。

Engine：包含一个或多个Host。

Host：就是虚拟主机。包含一个或多个Context，每个webapp目录下的文件夹就可以表示一个Context。

Context：包含一个或多个Wrapper，一个Context一般就表示一个应用，web.xml配置文件就对应一个Context，里面的东西解析后都会装在Context里面。

Wrapper：对应一个servlet，负责创建servlet，创建过滤器链，然后执行。

Container：Engine、Host、Context、Wrapper都属于Container。

Connector完成自己的工作后，会调用下面这行代码。

connector.getService().getContainer().getPipeline().getFirst().invoke(request, response);

就像整体架构中描述的那样，connector首先找到和自己属于同一Service的engine。然后通过engine的pipeline去处理请求。

Container的请求处理逻辑都是基于Pipeline的，所以只要搞清楚Pipeline是怎么工作的就可以了。

每个pipeline里面包含了一个valve链表，pipeline中存储头节点，valve存储next节点。这个valve链中的最后一个就是basic valve，也是必不可少的那一个。

public class StandardPipeline extends Lifecyclebase
        implements Pipeline, Contained {
    
    protected Valve basic = null;

    protected Container container = null;
	// Pipeline中的第一个valve
    protected Valve first = null;
}

public abstract class Valvebase extends LifecycleMBeanbase
    implements Contained, Valve {

    protected Container container = null;
	// 该valve的下一个valve
    protected Valve next = null;
    
    public abstract void invoke(Request request, Response response)
        throws IOException, ServletException;
}

tomcat实现了四个basic valve，它们是必不可少的。只需要这四个basic valve就可以完成整个请求处理过程。

StandardEnginevalve、StandardHostValve、StandardContextValve、StandardWrapperValve。

StandardEnginevalve

// StandardEnginevalve
public final void invoke(Request request, Response response)
    throws IOException, ServletException {

    // Select the Host to be used for this Request
    Host host = request.getHost();

    // 调用host的pipeline
    host.getPipeline().getFirst().invoke(request, response);
}

StandardHostValve

public final void invoke(Request request, Response response)
    throws IOException, ServletException {

    // Select the Context to be used for this Request
    Context context = request.getContext();
    context.getPipeline().getFirst().invoke(request, response);
           
}

StandardContextValve

public final void invoke(Request request, Response response)
    throws IOException, ServletException {

    Wrapper wrapper = request.getWrapper();
    wrapper.getPipeline().getFirst().invoke(request, response);
}

StandardWrapperValve

public final void invoke(Request request, Response response)
    throws IOException, ServletException {
    
	StandardWrapper wrapper = (StandardWrapper) getContainer();
    Servlet servlet = null;
    Context context = (Context) wrapper.getParent();
    // 创建一个servlet，首次创建执行init
	servlet = wrapper.allocate();
    // 找对应的filter，和servlet合在一起创建过滤器链。
    ApplicationFilterFactory factory = ApplicationFilterFactory.getInstance();
    ApplicationFilterChain filterChain = 
        factory.createFilterChain(request, wrapper, servlet);
    // 执行过滤器链，里面就会执行自己实现的filter和servlet。
    filterChain.doFilter(request.getRequest(), response.getResponse());
}

filterChain的执行逻辑和spring aop的执行逻辑是差不多的，核心就是下面这行代码

filter.doFilter(request, response, this);
// 位置如下
// org/apache/catalina/core/ApplicationFilterChain.java
public void doFilter(ServletRequest request, ServletResponse response){
    internalDoFilter(request,response);
}
private void internalDoFilter(ServletRequest request, ServletResponse response){
    filter.doFilter(request, response, this);
}