Tomcat源码---请求处理四(1)

最新推荐文章于 2020-08-03 17:11:41 发布
最新推荐文章于 2020-08-03 17:11:41 发布
阅读量124 收藏
点赞数
分类专栏： Tomcat6 文章标签： Tomcat Comet Servlet JSP Apache

 

 一,现在到了StandardWrapperValve#invoke下,现在才算是真正的调用,主要实现了对servlet,filter执行

 

/**
     * Invoke the servlet we are managing, respecting the rules regarding
     * servlet lifecycle and SingleThreadModel support.
     *
     * @param request Request to be processed
     * @param response Response to be produced
     * @param valveContext Valve context used to forward to the next Valve
     *
     * @exception IOException if an input/output error occurred
     * @exception ServletException if a servlet error occurred
     */
    public final void invoke(Request request, Response response)
        throws IOException, ServletException {

        // Initialize local variables we may need
        boolean unavailable = false;
        Throwable throwable = null;
        // This should be a Request attribute...
        long t1=System.currentTimeMillis();
        requestCount++;
        StandardWrapper wrapper = (StandardWrapper) getContainer();
        Servlet servlet = null;
        Context context = (Context) wrapper.getParent();
        
        // Check for the application being marked unavailable
        if (!context.getAvailable()) {
        	response.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE,
                           sm.getString("standardContext.isUnavailable"));
            unavailable = true;
        }

        // Check for the servlet being marked unavailable
        if (!unavailable && wrapper.isUnavailable()) {
            container.getLogger().info(sm.getString("standardWrapper.isUnavailable",
                    wrapper.getName()));
            long available = wrapper.getAvailable();
            if ((available > 0L) && (available < Long.MAX_VALUE)) {
                response.setDateHeader("Retry-After", available);
                response.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE,
                        sm.getString("standardWrapper.isUnavailable",
                                wrapper.getName()));
            } else if (available == Long.MAX_VALUE) {
                response.sendError(HttpServletResponse.SC_NOT_FOUND,
                        sm.getString("standardWrapper.notFound",
                                wrapper.getName()));
            }
            unavailable = true;
        }

        // Allocate a servlet instance to process this request
        try {
            if (!unavailable) {
                //servlet行行在这一步
                servlet = wrapper.allocate();
            }
        } catch (UnavailableException e) {
            container.getLogger().error(
                    sm.getString("standardWrapper.allocateException",
                            wrapper.getName()), e);
            long available = wrapper.getAvailable();
            if ((available > 0L) && (available < Long.MAX_VALUE)) {
            	response.setDateHeader("Retry-After", available);
            	response.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE,
                           sm.getString("standardWrapper.isUnavailable",
                                        wrapper.getName()));
            } else if (available == Long.MAX_VALUE) {
            	response.sendError(HttpServletResponse.SC_NOT_FOUND,
                           sm.getString("standardWrapper.notFound",
                                        wrapper.getName()));
            }
        } catch (ServletException e) {
            container.getLogger().error(sm.getString("standardWrapper.allocateException",
                             wrapper.getName()), StandardWrapper.getRootCause(e));
            throwable = e;
            exception(request, response, e);
            servlet = null;
        } catch (Throwable e) {
            container.getLogger().error(sm.getString("standardWrapper.allocateException",
                             wrapper.getName()), e);
            throwable = e;
            exception(request, response, e);
            servlet = null;
        }

        // Identify if the request is Comet related now that the servlet has been allocated
        boolean comet = false;
        if (servlet instanceof CometProcessor 
                && request.getAttribute("org.apache.tomcat.comet.support") == Boolean.TRUE) {
            comet = true;
            request.setComet(true);
        }
        
        // Acknowledge the request
        try {
             //通知request已经调用
            response.sendAcknowledgement();
        } catch (IOException e) {
        	request.removeAttribute(Globals.JSP_FILE_ATTR);
            container.getLogger().warn(sm.getString("standardWrapper.acknowledgeException",
                             wrapper.getName()), e);
            throwable = e;
            exception(request, response, e);
        } catch (Throwable e) {
            container.getLogger().error(sm.getString("standardWrapper.acknowledgeException",
                             wrapper.getName()), e);
            throwable = e;
            exception(request, response, e);
            servlet = null;
        }
        MessageBytes requestPathMB = null;
        if (request != null) {
            requestPathMB = request.getRequestPathMB();
        }
        request.setAttribute
            (ApplicationFilterFactory.DISPATCHER_TYPE_ATTR,
             ApplicationFilterFactory.REQUEST_INTEGER);
        request.setAttribute
            (ApplicationFilterFactory.DISPATCHER_REQUEST_PATH_ATTR,
             requestPathMB);
        // Create the filter chain for this request
        ApplicationFilterFactory factory =
            ApplicationFilterFactory.getInstance();
        //过滤链的创建
        ApplicationFilterChain filterChain =
            factory.createFilterChain(request, wrapper, servlet);
        // Reset comet flag value after creating the filter chain
        request.setComet(false);

        // Call the filter chain for this request
        // NOTE: This also calls the servlet's service() method
        try {
            String jspFile = wrapper.getJspFile();
            if (jspFile != null)
            	request.setAttribute(Globals.JSP_FILE_ATTR, jspFile);
            else
            	request.removeAttribute(Globals.JSP_FILE_ATTR);
            if ((servlet != null) && (filterChain != null)) {
                // Swallow output if needed
                if (context.getSwallowOutput()) {
                    try {
                        SystemLogHandler.startCapture();
                        if (comet) {
                            filterChain.doFilterEvent(request.getEvent());
                            request.setComet(true);
                        } else {
                            //这里面开始对过滤器进行处理
                            filterChain.doFilter(request.getRequest(), 
                                    response.getResponse());
                        }
                    } finally {
                        String log = SystemLogHandler.stopCapture();
                        if (log != null && log.length() > 0) {
                            context.getLogger().info(log);
                        }
                    }
                } else {
                    if (comet) {
                        request.setComet(true);
                        filterChain.doFilterEvent(request.getEvent());
                    } else {
                        filterChain.doFilter
                            (request.getRequest(), response.getResponse());
                    }
                }

            }
            request.removeAttribute(Globals.JSP_FILE_ATTR);
        } catch (ClientAbortException e) {
        	request.removeAttribute(Globals.JSP_FILE_ATTR);
            throwable = e;
            exception(request, response, e);
        } catch (IOException e) {
        	request.removeAttribute(Globals.JSP_FILE_ATTR);
            container.getLogger().error(sm.getString("standardWrapper.serviceException",
                             wrapper.getName()), e);
            throwable = e;
            exception(request, response, e);
        } catch (UnavailableException e) {
        	request.removeAttribute(Globals.JSP_FILE_ATTR);
            container.getLogger().error(sm.getString("standardWrapper.serviceException",
                             wrapper.getName()), e);
            //            throwable = e;
            //            exception(request, response, e);
            wrapper.unavailable(e);
            long available = wrapper.getAvailable();
            if ((available > 0L) && (available < Long.MAX_VALUE)) {
                response.setDateHeader("Retry-After", available);
                response.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE,
                           sm.getString("standardWrapper.isUnavailable",
                                        wrapper.getName()));
            } else if (available == Long.MAX_VALUE) {
            	response.sendError(HttpServletResponse.SC_NOT_FOUND,
                            sm.getString("standardWrapper.notFound",
                                        wrapper.getName()));
            }
            // Do not save exception in 'throwable', because we
            // do not want to do exception(request, response, e) processing
        } catch (ServletException e) {
        	request.removeAttribute(Globals.JSP_FILE_ATTR);
            Throwable rootCause = StandardWrapper.getRootCause(e);
            if (!(rootCause instanceof ClientAbortException)) {
                container.getLogger().error(sm.getString("standardWrapper.serviceException",
                                 wrapper.getName()), rootCause);
            }
            throwable = e;
            exception(request, response, e);
        } catch (Throwable e) {
            request.removeAttribute(Globals.JSP_FILE_ATTR);
            container.getLogger().error(sm.getString("standardWrapper.serviceException",
                             wrapper.getName()), e);
            throwable = e;
            exception(request, response, e);
        }

        // Release the filter chain (if any) for this request
        if (filterChain != null) {
            if (request.isComet()) {
                // If this is a Comet request, then the same chain will be used for the
                // processing of all subsequent events.
                filterChain.reuse();
            } else {
                filterChain.release();
            }
        }

        // Deallocate the allocated servlet instance
        try {
            if (servlet != null) {
               //servlet释放
                wrapper.deallocate(servlet);
            }
        } catch (Throwable e) {
            container.getLogger().error(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) {
            container.getLogger().error(sm.getString("standardWrapper.unloadException",
                             wrapper.getName()), e);
            if (throwable == null) {
                throwable = e;
                exception(request, response, e);
            }
        }
        long t2=System.currentTimeMillis();

        long time=t2-t1;
        processingTime += time;
        if( time > maxTime) maxTime=time;
        if( time < minTime) minTime=time;

    }
 

dxsksk
关注
专栏目录
Tomcat一次http请求处理，filter、servlet调用流程
探索java技术、web技术
12-13 2997
Tomcat一次http请求处理，filter、servlet调用流程
Tomcat对HTTP请求的处理(三)
weixin_30511107的博客
02-04 324
摘要：本文主要介绍了tomcat内部处理HTTP请求的Container部分,即剩余的部分 上一篇文章讲到CoyoteAdapter对HTTP请求的处理,主要查看了postParseRequest()方法对request的处理填充。我们继续往下看： //代码清单1 // Parse and set Catalina and configuration specific // request par...
Tomcat请求处理(五) -- 请求在容器间的流动
臭美
12-28 119
请求在Tomcat中传到了CoyoteAdapter的#service()方法中后，就要准备进入Pipeline了，如#service()方法中的这句所示： connector.getContainer().getPipeline().getFirst().invoke(request, response); 这里的Container是Engine，然后得到它的Pipeline对象，然后...
【Tomcat】容器 之 Wrapper（Servlet）
u010900754的专栏
05-01 1686
tomcat4.0版本。wrapper是四大容器最底层的容器，是请求处理的真正容器。与servlet的区别是：wrapper本质并未处理请求，而是加载对应的servlet来处理，在这之前也会调用filter。首先来看一个context和wrapper容器的调用时序图：与之前容器一样，也是在构造方法里设置自己pipeline的basic 的valve： /** * Create a ...
tomcat-cluster-redis-session-manager:Tomcat集群Redis会话管理器Java客户端
05-11
在这里，会话被实现为非粘性的（意味着，每个请求都可以转到集群中的任何服务器，这与Apache提供的Tomcat集群设置不同。） 请求会话将立即存储到Redis中（会话属性必须是可序列化的），以供其他服务器使用。 当...
apache-tomcat-7.0.81-src 源码免费下载
08-28
1. **Servlet容器**：Tomcat作为Servlet容器，其核心是Catalina组件，负责处理HTTP请求并调用相应的Servlet。源码中的`catalina`目录包含了这部分内容，你可以看到如何解析请求、创建响应以及管理Servlet实例。 2. ...
3-5Tomcat响应请求源码与nio处理请求源码实现.mp4
12-07
3-5Tomcat响应请求源码与nio处理请求源码实现.mp4
Tomcat源码apache-tomcat-8.5.47-src.zip
05-07
在开始学习Tomcat源码之前，首先需要了解一些基本概念。Java Servlet是Java平台上的一个标准接口，用于处理HTTP请求。而JSP则是用于创建动态网页的Java技术，它将业务逻辑和页面展示分离。Tomcat作为Servlet容器，...
apache-tomcat-9.0.8-src源码资源
06-12
通过对`apache-tomcat-9.0.8-src`源码的深入研究，我们可以了解到Tomcat如何处理网络请求，怎样管理Web应用，以及如何实现各种高级特性。这对于开发者来说是一份宝贵的学习资料，可以帮助他们更好地优化应用程序，...
tomcat 内存溢出总结（转）
yuanlanjun
05-13 130
在生产环境中tomcat内存设置不好很容易出现内存溢出。造成内存原因是不一样的，当然处理方式也不一样。 这里根据平时遇到的情况和相关 资料进行一个总结。常见的一般会有下面三种情况： 1.OutOfMemoryError: Java heap space 2.OutOfMemoryError: PermGen space 3.OutOfMemoryError: unable ...
tomcat解析(十九)对客户请求的处理3
holly2k的专栏
02-09 1090
下面是StandardContextValve的invoke方法内容     对于路径中直接访问META-INF或WEB-INF目录下资源的,直接返回404错误      MessageBytes requestPathMB = request.getRequestPathMB(); if ((requestPathMB.startsWithIgnoreCase("/META-INF
tomcat源码分析系列之请求处理---关门打狗
yayagepei的专栏
08-13 284
    上回我们把请求放进来了，这回我们关上门，好好修理修理它，不折腾它一番，休想轻易出去。 要关门打狗，先得知道房子在哪才行啊，上回我们说到proces的处理被委托到Http11Processor类，它就是这套房子！Http11Processor的process方法，就是这间屋子： /** * Process pipelined HTTP requests on the spec...
Tomcat源码分析——请求原理分析（下）
weixin_30455023的博客
10-23 195
前言 　　本文继续讲解TOMCAT的请求原理分析，建议朋友们阅读本文时首先阅读过《TOMCAT源码分析——请求原理分析（上）》和《TOMCAT源码分析——请求原理分析（中）》。在《TOMCAT源码分析——请求原理分析（中）》一文我简单讲到了Pipeline，但并未完全展开，本文将从Pipeline开始讲解请求原理的剩余内容。 管道 　　在Tomcat中管道Pipeline是一个接口...
Tomcat学习笔记（9）- 管道（Pipeline）、tomcat启动
littlewhitevg的博客
08-03 733
文章目录1. 管道模式2. Valve接口3. Pipeline4. 流程4.1 StandardEngineValve4.2 StandardHostValve4.3 StandardContextValve4.4 StandardWrapperValve4.5 debug一次 1. 管道模式 管道模式把多个对象连接起来，整体看起来就像若干个阀门嵌套在管道中，而处理逻辑就放在阀门上。 在tomcat中，Valve接口定义了阀门的调用方法，由于阀门与阀门使用单链表结构连接，因此需提供对下一个阀门的操作；Pi
[转帖]从HTTP/0.9到HTTP/2：一文读懂HTTP协议的历史演变和设计思路
weixin_30827565的博客
09-24 190
从HTTP/0.9到HTTP/2：一文读懂HTTP协议的历史演变和设计思路 http://www.52im.net/thread-1709-1-2.html 本文原作者阮一峰，作者博客：ruanyifeng.com。 1、引言 HTTP 协议是最重要的互联网基础协议之一，它从最初的仅为浏览网页的目的进化到现在，已经是短连接通信的事实...
Tomcat中Context元素详解（转）
shiyangxt的专栏
07-31 283
Context元素代表一个web应用，运行在某个特定的虚拟主机上。   如Servlet Specification 2.2或以后版本中描述的那样，每个web应用基于一个Web Application Archive(WAR)文件，或者是一个目录，包含WAR文件解压后的内容。有关Web Application Archive的更多信息，可以参考Servlet Specification和Tomc...
Tomcat连接器：Coyote框架
热门推荐
王程斯的专栏
09-24 2万+
不论Tomcat的容器设计得如何精妙，本质上Tomcat就是个http服务器，需要从socket中获得HTTP数据流；另一方面，容器只能处理封装好的org.apache.coyote.Request （这个类的具体用途下面会讲到），从socket到Request之间需要有个转换过程。因此，连接socket和容器之间的重任就交给了CoyoteCoyote简介coyote(北美的一种狼、山狗)
Tomcat源码深度剖析：启动与请求处理
"深入解析Tomcat源码，探索其启动与请求处理机制" Tomcat作为一款广泛应用的开源Java Servlet容器，其高效稳定的特点深受开发者喜爱。本文将深入剖析Tomcat的源码，帮助读者理解其核心架构和工作流程。 首先，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值