Tomcat请求处理(五) -- 请求在容器间的流动

最新推荐文章于 2023-01-29 08:28:11 发布
最新推荐文章于 2023-01-29 08:28:11 发布
阅读量855 收藏
点赞数
分类专栏： java web 文章标签： java tomcat
本文深入探讨了在Tomcat中请求从CoyoteAdapter的#service()方法开始，经过Container、Host、Context等组件，最终到达Wrapper的过程，详细解释了各组件的作用及Valve的调用逻辑。
请求在Tomcat中传到了CoyoteAdapter的#service()方法中后，就要准备进入Pipeline了，如#service()方法中的这句所示： 
connector.getContainer().getPipeline().getFirst().invoke(request, response); 

这里的Container是Engine，然后得到它的Pipeline对象，然后得到他的第一个Valve，如果没有配置的话第一个Valve就是Basic的了，这里就是org.apache.catalina.core.StandardEngineValve，最后调用了它的#invoke()方法，源代码如下所示： 

Java代码   收藏代码
  1. public final void invoke(Request request, Response response) throws IOException,  
  2.         ServletException {  
  3.   
  4.     // 获得Host对象  
  5.     Host host = request.getHost();  
  6.     if (host == null) {  
  7.         response.sendError(HttpServletResponse.SC_BAD_REQUEST, sm.getString(  
  8.                 "standardEngine.noHost", request.getServerName()));  
  9.         return;  
  10.     }  
  11.   
  12.     // 将请求传递给Host  
  13.     host.getPipeline().getFirst().invoke(request, response);  
  14.   
  15. }  


这个Valve并没做什么实质性的东西，只是将请求继续传递，当然可以定义自己的Valve实现一些特殊的行为。 
还是来继续请求的处理过程，和上边Engine的情况类似，请求这次到了org.apache.catalina.core.StandardHostValve的#invoke()方法，源代码如下所示： 

Java代码   收藏代码
  1. public final void invoke(Request request, Response response) throws IOException,  
  2.         ServletException {  
  3.   
  4.     // 获得Context对象  
  5.     Context context = request.getContext();  
  6.     if (context == null) {  
  7.         response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, sm  
  8.                 .getString("standardHost.noContext"));  
  9.         return;  
  10.     }  
  11.   
  12.     // 如果没有设置Loader，那么设置为context自己的ClassLoader  
  13.     if (context.getLoader() != null) {  
  14.         Thread.currentThread().setContextClassLoader(context.getLoader().getClassLoader());  
  15.     }  
  16.   
  17.     // 将请求通过Pipeline给Context  
  18.     context.getPipeline().getFirst().invoke(request, response);  
  19.   
  20.     if (Globals.STRICT_SERVLET_COMPLIANCE) {  
  21.         request.getSession(false);  
  22.     }  
  23.   
  24.     // 处理错误页  
  25.     response.setSuspended(false);  
  26.   
  27.     Throwable t = (Throwable) request.getAttribute(Globals.EXCEPTION_ATTR);  
  28.   
  29.     if (t != null) {  
  30.         throwable(request, response, t);  
  31.     } else {  
  32.         status(request, response);  
  33.     }  
  34.   
  35.     // 恢复ClassLoader  
  36.     Thread.currentThread().setContextClassLoader(StandardHostValve.class.getClassLoader());  
  37.   
  38. }  

不出意外的，请求下边就到了org.apache.catalina.core.StandardContextValve，源代码如下： 

Java代码   收藏代码
  1. public final void invoke(Request request, Response response) throws IOException,  
  2.         ServletException {  
  3.   
  4.     // 不允许请求访问META-INF和WEB-INF文件夹下的内容。  
  5.     MessageBytes requestPathMB = request.getRequestPathMB();  
  6.     if ((requestPathMB.startsWithIgnoreCase("/META-INF/", 0))  
  7.             || (requestPathMB.equalsIgnoreCase("/META-INF"))  
  8.             || (requestPathMB.startsWithIgnoreCase("/WEB-INF/", 0))  
  9.             || (requestPathMB.equalsIgnoreCase("/WEB-INF"))) {  
  10.         notFound(response);  
  11.         return;  
  12.     }  
  13.   
  14.     // 如果系统正在重新载入中，那么暂停请求。  
  15.     boolean reloaded = false;  
  16.     while (context.getPaused()) {  
  17.         reloaded = true;  
  18.         try {  
  19.             Thread.sleep(1000);  
  20.         } catch (InterruptedException e) {  
  21.             ;  
  22.         }  
  23.     }  
  24.   
  25.     // 如果正在重载，停止老的WebappClassLoader并创建一个新的  
  26.     if (reloaded && context.getLoader() != null && context.getLoader().getClassLoader() != null) {  
  27.         Thread.currentThread().setContextClassLoader(context.getLoader().getClassLoader());  
  28.     }  
  29.   
  30.     // 获得Wrapper对象  
  31.     Wrapper wrapper = request.getWrapper();  
  32.     if (wrapper == null) {  
  33.         notFound(response);  
  34.         return;  
  35.     } else if (wrapper.isUnavailable()) {  
  36.         wrapper = (Wrapper) container.findChild(wrapper.getName());  
  37.         if (wrapper == null) {  
  38.             notFound(response);  
  39.             return;  
  40.         }  
  41.     }  
  42.   
  43.     // 获得Listener列表  
  44.     Object instances[] = context.getApplicationEventListeners();  
  45.   
  46.     ServletRequestEvent event = null;  
  47.   
  48.     if ((instances != null) && (instances.length > 0)) {  
  49.         event = new ServletRequestEvent(((StandardContext) container).getServletContext(),  
  50.                 request.getRequest());  
  51.   
  52.         for (int i = 0; i < instances.length; i++) {  
  53.             if (instances[i] == null)  
  54.                 continue;  
  55.             if (!(instances[i] instanceof ServletRequestListener))  
  56.                 continue;  
  57.             ServletRequestListener listener = (ServletRequestListener) instances[i];  
  58.             try {  
  59.                 // 调用请求初始化事件  
  60.                 listener.requestInitialized(event);  
  61.             } catch (Throwable t) {  
  62.                 container.getLogger().error(  
  63.                         sm.getString("standardContext.requestListener.requestInit",  
  64.                                 instances[i].getClass().getName()), t);  
  65.                 ServletRequest sreq = request.getRequest();  
  66.                 sreq.setAttribute(Globals.EXCEPTION_ATTR, t);  
  67.                 return;  
  68.             }  
  69.         }  
  70.     }  
  71.   
  72.     // 调用Wrapper的Valve  
  73.     wrapper.getPipeline().getFirst().invoke(request, response);  
  74.   
  75.     if ((instances != null) && (instances.length > 0)) {  
  76.         for (int i = 0; i < instances.length; i++) {  
  77.             if (instances[i] == null)  
  78.                 continue;  
  79.             if (!(instances[i] instanceof ServletRequestListener))  
  80.                 continue;  
  81.             ServletRequestListener listener = (ServletRequestListener) instances[i];  
  82.             try {  
  83.                 // 调用请求结束事件  
  84.                 listener.requestDestroyed(event);  
  85.             } catch (Throwable t) {  
  86.                 container.getLogger().error(  
  87.                         sm.getString("standardContext.requestListener.requestDestroy",  
  88.                                 instances[i].getClass().getName()), t);  
  89.                 ServletRequest sreq = request.getRequest();  
  90.                 sreq.setAttribute(Globals.EXCEPTION_ATTR, t);  
  91.             }  
  92.         }  
  93.     }  
  94.   
  95. }  

这个Valve重要的是包括了对Listener的调用，最后来看一下Wrapper的Valve调用(org.apache.catalina.core.StandardWrapperValve)。 

Java代码   收藏代码
  1. public final void invoke(Request request, Response response) throws IOException,  
  2.             ServletException {  
  3.   
  4.         boolean unavailable = false;  
  5.         Throwable throwable = null;  
  6.   
  7.         long t1 = System.currentTimeMillis();  
  8.         requestCount++;  
  9.         // 获得Wrapper所关联的对象  
  10.         StandardWrapper wrapper = (StandardWrapper) getContainer();  
  11.         // Servlet对象  
  12.         Servlet servlet = null;  
  13.         // 获得Context对象  
  14.         Context context = (Context) wrapper.getParent();  
  15.   
  16.         if (!context.getAvailable()) {  
  17.             response.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE, sm  
  18.                     .getString("standardContext.isUnavailable"));  
  19.             unavailable = true;  
  20.         }  
  21.   
  22.         if (!unavailable && wrapper.isUnavailable()) {  
  23.             container.getLogger().info(  
  24.                     sm.getString("standardWrapper.isUnavailable", wrapper.getName()));  
  25.             long available = wrapper.getAvailable();  
  26.             if ((available > 0L) && (available < Long.MAX_VALUE)) {  
  27.                 response.setDateHeader("Retry-After", available);  
  28.                 response.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE, sm.getString(  
  29.                         "standardWrapper.isUnavailable", wrapper.getName()));  
  30.             } else if (available == Long.MAX_VALUE) {  
  31.                 response.sendError(HttpServletResponse.SC_NOT_FOUND, sm.getString(  
  32.                         "standardWrapper.notFound", wrapper.getName()));  
  33.             }  
  34.             unavailable = true;  
  35.         }  
  36.   
  37.         try {  
  38.             if (!unavailable) {  
  39.                 // 分配一个Servelt实例  
  40.                 servlet = wrapper.allocate();  
  41.             }  
  42.         } catch (UnavailableException e) {  
  43.             container.getLogger().error(  
  44.                     sm.getString("standardWrapper.allocateException", wrapper.getName()), e);  
  45.             long available = wrapper.getAvailable();  
  46.             if ((available > 0L) && (available < Long.MAX_VALUE)) {  
  47.                 response.setDateHeader("Retry-After", available);  
  48.                 response.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE, sm.getString(  
  49.                         "standardWrapper.isUnavailable", wrapper.getName()));  
  50.             } else if (available == Long.MAX_VALUE) {  
  51.                 response.sendError(HttpServletResponse.SC_NOT_FOUND, sm.getString(  
  52.                         "standardWrapper.notFound", wrapper.getName()));  
  53.             }  
  54.         } catch (ServletException e) {  
  55.             container.getLogger().error(  
  56.                     sm.getString("standardWrapper.allocateException", wrapper.getName()),  
  57.                     StandardWrapper.getRootCause(e));  
  58.             throwable = e;  
  59.             exception(request, response, e);  
  60.             servlet = null;  
  61.         } catch (Throwable e) {  
  62.             container.getLogger().error(  
  63.                     sm.getString("standardWrapper.allocateException", wrapper.getName()), e);  
  64.             throwable = e;  
  65.             exception(request, response, e);  
  66.             servlet = null;  
  67.         }  
  68.   
  69.         boolean comet = false;  
  70.         if (servlet instanceof CometProcessor  
  71.                 && request.getAttribute("org.apache.tomcat.comet.support") == Boolean.TRUE) {  
  72.             comet = true;  
  73.             request.setComet(true);  
  74.         }  
  75.   
  76.         // 告知Request已经收到  
  77.         try {  
  78.             response.sendAcknowledgement();  
  79.         } catch (IOException e) {  
  80.             request.removeAttribute(Globals.JSP_FILE_ATTR);  
  81.             container.getLogger().warn(  
  82.                     sm.getString("standardWrapper.acknowledgeException", wrapper.getName()), e);  
  83.             throwable = e;  
  84.             exception(request, response, e);  
  85.         } catch (Throwable e) {  
  86.             container.getLogger().error(  
  87.                     sm.getString("standardWrapper.acknowledgeException", wrapper.getName()), e);  
  88.             throwable = e;  
  89.             exception(request, response, e);  
  90.             servlet = null;  
  91.         }  
  92.         MessageBytes requestPathMB = null;  
  93.         if (request != null) {  
  94.             requestPathMB = request.getRequestPathMB();  
  95.         }  
  96.           
  97.         request.setAttribute(ApplicationFilterFactory.DISPATCHER_TYPE_ATTR,  
  98.                 ApplicationFilterFactory.REQUEST_INTEGER);  
  99.         request.setAttribute(ApplicationFilterFactory.DISPATCHER_REQUEST_PATH_ATTR, requestPathMB);  
  100.         // 创建FilterChain  
  101.         ApplicationFilterFactory factory = ApplicationFilterFactory.getInstance();  
  102.         ApplicationFilterChain filterChain = factory.createFilterChain(request, wrapper, servlet);  
  103.   
  104.         request.setComet(false);  
  105.   
  106.         try {  
  107.             // web.xml中的<jsp-file>标签  
  108.             String jspFile = wrapper.getJspFile();  
  109.             if (jspFile != null)  
  110.                 request.setAttribute(Globals.JSP_FILE_ATTR, jspFile);  
  111.             else  
  112.                 request.removeAttribute(Globals.JSP_FILE_ATTR);  
  113.               
  114.             // 调用Filter  
  115.             if ((servlet != null) && (filterChain != null)) {  
  116.                 if (context.getSwallowOutput()) {  
  117.                     try {  
  118.                         SystemLogHandler.startCapture();  
  119.                         if (comet) {  
  120.                             filterChain.doFilterEvent(request.getEvent());  
  121.                             request.setComet(true);  
  122.                         } else {  
  123.                             filterChain.doFilter(request.getRequest(), response.getResponse());  
  124.                         }  
  125.                     } finally {  
  126.                         String log = SystemLogHandler.stopCapture();  
  127.                         if (log != null && log.length() > 0) {  
  128.                             context.getLogger().info(log);  
  129.                         }  
  130.                     }  
  131.                 } else {  
  132.                     if (comet) {  
  133.                         request.setComet(true);  
  134.                         filterChain.doFilterEvent(request.getEvent());  
  135.                     } else {  
  136.                         filterChain.doFilter(request.getRequest(), response.getResponse());  
  137.                     }  
  138.                 }  
  139.   
  140.             }  
  141.             request.removeAttribute(Globals.JSP_FILE_ATTR);  
  142.         } catch (ClientAbortException e) {  
  143.             request.removeAttribute(Globals.JSP_FILE_ATTR);  
  144.             throwable = e;  
  145.             exception(request, response, e);  
  146.         } catch (IOException e) {  
  147.             request.removeAttribute(Globals.JSP_FILE_ATTR);  
  148.             container.getLogger().error(  
  149.                     sm.getString("standardWrapper.serviceException", wrapper.getName()), e);  
  150.             throwable = e;  
  151.             exception(request, response, e);  
  152.         } catch (UnavailableException e) {  
  153.             request.removeAttribute(Globals.JSP_FILE_ATTR);  
  154.             container.getLogger().error(  
  155.                     sm.getString("standardWrapper.serviceException", wrapper.getName()), e);  
  156.   
  157.             wrapper.unavailable(e);  
  158.             long available = wrapper.getAvailable();  
  159.             if ((available > 0L) && (available < Long.MAX_VALUE)) {  
  160.                 response.setDateHeader("Retry-After", available);  
  161.                 response.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE, sm.getString(  
  162.                         "standardWrapper.isUnavailable", wrapper.getName()));  
  163.             } else if (available == Long.MAX_VALUE) {  
  164.                 response.sendError(HttpServletResponse.SC_NOT_FOUND, sm.getString(  
  165.                         "standardWrapper.notFound", wrapper.getName()));  
  166.             }  
  167.   
  168.         } catch (ServletException e) {  
  169.             request.removeAttribute(Globals.JSP_FILE_ATTR);  
  170.             Throwable rootCause = StandardWrapper.getRootCause(e);  
  171.             if (!(rootCause instanceof ClientAbortException)) {  
  172.                 container.getLogger().error(  
  173.                         sm.getString("standardWrapper.serviceException", wrapper.getName()),  
  174.                         rootCause);  
  175.             }  
  176.             throwable = e;  
  177.             exception(request, response, e);  
  178.         } catch (Throwable e) {  
  179.             request.removeAttribute(Globals.JSP_FILE_ATTR);  
  180.             container.getLogger().error(  
  181.                     sm.getString("standardWrapper.serviceException", wrapper.getName()), e);  
  182.             throwable = e;  
  183.             exception(request, response, e);  
  184.         }  
  185.   
  186.         if (filterChain != null) {  
  187.             if (request.isComet()) {  
  188.                 filterChain.reuse();  
  189.             } else {  
  190.                 filterChain.release();  
  191.             }  
  192.         }  
  193.   
  194.         // 释放Servlet对象  
  195.         try {  
  196.             if (servlet != null) {  
  197.                 wrapper.deallocate(servlet);  
  198.             }  
  199.         } catch (Throwable e) {  
  200.             container.getLogger().error(  
  201.                     sm.getString("standardWrapper.deallocateException", wrapper.getName()), e);  
  202.             if (throwable == null) {  
  203.                 throwable = e;  
  204.                 exception(request, response, e);  
  205.             }  
  206.         }  
  207.   
  208.         try {  
  209.             if ((servlet != null) && (wrapper.getAvailable() == Long.MAX_VALUE)) {  
  210.                 wrapper.unload();  
  211.             }  
  212.         } catch (Throwable e) {  
  213.             container.getLogger().error(  
  214.                     sm.getString("standardWrapper.unloadException", wrapper.getName()), e);  
  215.             if (throwable == null) {  
  216.                 throwable = e;  
  217.                 exception(request, response, e);  
  218.             }  
  219.         }  
  220.         long t2 = System.currentTimeMillis();  
  221.   
  222.         long time = t2 - t1;  
  223.         processingTime += time;  
  224.         if (time > maxTime)  
  225.             maxTime = time;  
  226.         if (time < minTime)  
  227.             minTime = time;  
  228.   
  229.     }  

这段代码的关键点是Servlet实例的构建(servlet = wrapper.allocate();)和Filter Chain的调用(filterChain.doFilter(request.getRequest(), response.getResponse());)，具体的还要进入方法内部去仔细看一下。comet方式以后再详细看。
SpringBoot最多能处理多少请求
qq_65779957的博客
09-01 690
现在，我们把整个流程串起来，模拟一个请求的“一生”：一个新请求（客户）到来。检查：保安看整个大厅人数是否已满。如果满了，直接拒绝入内（连接被拒绝）。否则，允许进入。线程池检查：请求进入后，经理看是否有空闲的柜员窗口（线程）。有空闲线程：立即分配一个窗口处理请求。无空闲线程：经理会尝试开设新窗口（创建新线程），但前提是当前总窗口数不能超过max。队列检查：如果线程池已满（窗口数达到max），且无法立即处理，就把请求请到等候区 (排队。超时检查如果请求在队列中等待的时间过长，客户端可能会主动超时。
Tomcat源码阅读之StandarWrapper源码分析
fjs的专栏
03-24 1692
StandarWrapper，嗯，其实可以将其理解为对servlet对象的包装。。。先来看看简单的继承结构吧： 这里的继承体系还算是比较简单吧，首先是继承了ContainerBase，让StandarWrapper有了基本的对Container的管理能力，其实是先了ServletConfig接口，这个接口应该比较熟悉吧，在servlet的初始化的时候，传进去的就是这个参数，另外就是还有实现了Wrapper接口和NotificationEmitter。。。 从前面可以知道，Wrapper对象是在Context
Tomcat 处理请求的流程
qq_20004115的博客
07-21 281
1、NioEndPoint接收到请求开启线程执行其内部类SocketProcessor的run(),然后执行doRun方法 2、采用责任链模式调用invoke方法 调用类如下图所示： StandardEngineValve AccessLogValve ErrorReportValve StandardHostValve NonLoginAuthenticator StandardContextValve ...
tomcat学习（备忘）
cp1002327672的博客
01-29 111
tomcat
新手入门：介绍JSP中request属性的用法
liangquan的专栏
07-27 2605
新手入门：介绍JSP中request属性的用法   一、request.getParameter() 和request.getAttribute() 区别 （1）request.getParameter()取得是通过容器的实现来取得通过类似post，get等方式传入的数据，request.setAttribute()和getAttribute()只是在web容器内部流转，仅仅是请求处理阶段
今日头条Java三面：GC+堆排+Tomcat+算法题
weixin_47067712的博客
10-12 623
字节跳动一面： 自我介绍,主要讲讲做了什么和擅长什么 看你项目做Spring比较多, 问一下Spring相关的东西, IoC是什么概念? Bean的默认作用范围是什么?其他的作用范围? 索引是什么概念有什么作用? MySQL里主要有哪些索弓|结构?哈希索弓和B+树索引比较? 平常用线程主要是怎么写的，会用一一些线程框架吗? (没有用框架) Java线程池的概念?线程池有哪 些?线程池工厂有哪些线程池类型,及其线程池参数是什么? ConcurrentHashMap讲一讲? Java GC机制? GC Ro.
Tomcat的处理请求流程详解
fffffccc1的博客
04-10 4418
Tomcat启动后，在接收到某个请求后，就可以根据请求路径和url-pattern进行匹配，如果匹配成功，则会把这个请求交给对应的servlet进行处理。 大致的处理流程中的问题： 1、tomcat如何解析字节流 2、tomcat把解析出来的httpServletRequests对象，是如何到servlet的，调用了哪些方法，如何调用的。 处理流程简述： 浏览器在请求一个Servlet时，会按照HTTP协议构造一个HTTP请求，通过Socket连接发送给Tomcat Tomcat通过不同的IO模型都可以接
Tomcat中容器的pipeline机制 - coldridgeValley - 博客园1
08-03
在Tomcat的架构中，Pipeline（管道）机制扮演着至关重要的角色，它使得请求在不同层次的Container（容器）间高效流动。本文将深入探讨Pipeline机制以及与其密切相关的Valve（阀门）组件。 首先，Tomcat中的...
Tomcat容器pipeline与Valve详解：构建请求流转桥梁
在Tomcat中，容器的pipeline机制是其核心组件之一，它负责请求的路由和处理流程。文章《Tomcat中容器的pipeline机制》深入解析了这种机制，主要围绕以下几个方面展开： 1. **背景与容器结构**: 文章首先回顾了...
容器网页终端（websocket-webshell）
09-23
在WebSocket-WebShell的场景中，Tomcat8可能作为WebSocket服务器运行，处理来自客户端的WebSocket连接，并将这些连接转发到Docker容器中的SSH服务。 在项目"websocket-tail-demo-master"中，我们可以预见到一些关键...
java-websocket聊天室代码+Tomcat8_x64地址+JDK7_x64地址
12-22
它创建了一条持久连接，允许数据在服务器和客户端之间自由流动，而无需为每个消息发送单独的HTTP请求。这极大地提高了性能，尤其适用于需要频繁交互的应用，如在线游戏、聊天室或股票报价。 在这个项目中，主要涉及...
Tomcat对HTTP请求的处理(三)
weixin_30511107的博客
02-04 355
摘要：本文主要介绍了tomcat内部处理HTTP请求的Container部分,即剩余的部分 上一篇文章讲到CoyoteAdapter对HTTP请求的处理,主要查看了postParseRequest()方法对request的处理填充。我们继续往下看： //代码清单1 // Parse and set Catalina and configuration specific // request par...
Tomcat源码分析（四）------ Request和Response处理的全过程
热门推荐
走向架构师之路
12-28 1万+
从Tomcat源码分析（二）可知，用户的一个请求会经过n个环节的处理，最后到达开发人员写的Servlet，传给Servlet也就是HttpServletRequest和HttpServletResponse，因此可以认为这一路走下来无非就是把最原始的Socket包装成Servlet里用到的HttpServletRequest和HttpServletResponse，只不过每个环节完成的包装功能和部
tomcat启动(Ⅷ)--请求最终目的地 getContainer().getPipeline().getFirst().invoke(request, response)...
weixin_30251587的博客
11-14 301
当tomcat的Conector保存着StandardService实例，而StandardService保存着Container的实例 当Http11NioProcessor.process()方法内调用getAdapter.service(request,response)时会调用CoyoteAdapter.service() 上面会调用请求对应的container的方法。 在这之前有...
浅读Tomcat源码（三）---请求处理
qq_28241149的博客
11-03 479
在上一篇中，我们讲述了Tomcat在启动之初所做的事情，我们简单罗列回顾一下 1）依次开启组件，其中较为核心的是开启Connector的serverSocket，并等待请求 2）开新线程初始化容器，补充一点，之所以要开启新线程而不在主线程完成，个人理解核心原因是为了在Tomcat运行过程中可以直接添加新的应用 3）开启等待关闭线程，等待Tomcat的关闭指令 这一篇我们将着重讲解T
Tomcat源码---请求处理三
dxsksk的专栏
03-25 176
一,这一章节主要讲request与response通过管道,阀门在各个容器间运行  1,connector.getContainer().getPipeline().getFirst().invoke(request, response); 这一步是StandardEngine获取StandardPipeline被StandardEngineValve进行过滤后执行到StandardHost ...
Tomcat处理HTTP请求过程分析
雷小涛的专栏
12-14 7149
Tomcat处理HTTP请求过程分析 一、Tomcat是什么？ Tomcat是一个web应用服务器，是一个Servlet/Jsp容器，主要负责将客户端请求传递给对应的Servlet，并且将Servlet的响应数据返回给客户端。 Tomcat是基于组件的服务器。 二、Tomcat体系结构 Tomcat是一个基于组件的服务器，它的构成组件都是可配置的。其各个组件都在Tomcat安装目录下的....
tomcat源码分析系列之请求处理---关门打狗
yayagepei的专栏
08-13 316
    上回我们把请求放进来了，这回我们关上门，好好修理修理它，不折腾它一番，休想轻易出去。 要关门打狗，先得知道房子在哪才行啊，上回我们说到proces的处理被委托到Http11Processor类，它就是这套房子！Http11Processor的process方法，就是这间屋子： /** * Process pipelined HTTP requests on the spec...
Tomcat7中一次请求处理的前世今生（四）Tomcat7阀机制原理
预流
08-31 253
通过前面的三篇文章看到了一次客户端连接在Tomcat内部被转换成了请求对象（org.apache.catalina.connector.Request类的实例），并在该请求对象内部将与本次请求相关的Host、Context、Wrapper对象的引用。本文主要分析该请求对象在容器内部流转的经过。 再来看一下Tomcat7内部的组件结构图： 其实这张图已经给出了答案，在Connector接收到...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值