How tomcat works（深入剖析tomcat）servlet容器

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

巴特西

How tomcat works（深入剖析tomcat）servlet容器

How tomcat works （5）servlet容器阅读笔记

总体介绍

Pipeline和valve

Wrapper最低级的容器

主要类以及流程分析

SimpleLoader的构造方法

SimpleWrapper

basicvalve的调用过程分析

Context

主要类以及流程分析

StandardContextValve的invoke

SimpleContext的map方法

SimpleContextMapper的map方法

容器启动

最新文章

热门文章