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

tomcat的整体结构大概可以分成两块,一个是Connector,另一个是Container。Connector负责接收请求,建立socket连接,根据请求中的信息创建Request和Response对象,具体的处理逻辑交给Container。
tomcat源码分析1 —— 整体架构_第1张图片

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

你可能感兴趣的:(tomcat,tomcat,架构,java)