tomcat源码研读笔记—tomcat的接收请求之五 StandardWrapper接收请求

最新推荐文章于 2024-06-24 15:30:31 发布
最新推荐文章于 2024-06-24 15:30:31 发布
阅读量409 收藏
点赞数
分类专栏： tomcat源码研读笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/plkkoko/article/details/79643076
版权

StandardWrapper的继承关系：


从StandardWrapper的继承关系，我们根据之前的经验也可以推到出接收请求的过程了：

 

1，  调用了ContainerBase中的Invoke方法

2，  进而调用了实现valve接口的StandardWrapperValve的invoke方法

publicvoid invoke(Request request, Response response,

                       ValveContextvalveContext)

        throws IOException, ServletException {

        // Initialize local variables we mayneed

        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 instanceofHttpServletResponse)

            hres = (HttpServletResponse) sres;

 

        // Check for the application beingmarked unavailable

        if (!((Context)wrapper.getParent()).getAvailable()) {

           hres.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE,

                          sm.getString("standardContext.isUnavailable"));

            unavailable = true;

        }

 

        // Check for the servlet being markedunavailable

        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 toprocess this request

        try {

            if (!unavailable) {

                servlet = wrapper.allocate();

            }

        } catch (ServletException e) {

           log(sm.getString("standardWrapper.allocateException",

                            wrapper.getName()), e);

            throwable = e;

            exception(request, response, e);

            servlet = null;

        } catch (Throwable e) {

           log(sm.getString("standardWrapper.allocateException",

                            wrapper.getName()), e);

            throwable = e;

            exception(request, response, e);

            servlet = null;

        }

 

        // Acknowlege the request

        try {

            response.sendAcknowledgement();

        } catch (IOException e) {

            sreq.removeAttribute(Globals.JSP_FILE_ATTR);

           log(sm.getString("standardWrapper.acknowledgeException",

                            wrapper.getName()), e);

            throwable = e;

            exception(request, response, e);

        } catch (Throwable e) {

           log(sm.getString("standardWrapper.acknowledgeException",

                            wrapper.getName()), e);

            throwable = e;

            exception(request, response, e);

            servlet = null;

        }

 

        // Create the filter chain for thisrequest

        ApplicationFilterChain filterChain =

            createFilterChain(request,servlet);

 

        // Call the filter chain for thisrequest

        // NOTE: This also calls the servlet'sservice() 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)) {

                filterChain.doFilter(sreq,sres);

            }

           sreq.removeAttribute(Globals.JSP_FILE_ATTR);

        } catch (IOException e) {

            sreq.removeAttribute(Globals.JSP_FILE_ATTR);

           log(sm.getString("standardWrapper.serviceException",

                            wrapper.getName()), e);

            throwable = e;

            exception(request, response, e);

        } catch (UnavailableException e) {

           sreq.removeAttribute(Globals.JSP_FILE_ATTR);

           log(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))

               hres.setDateHeader("Retry-After", available);

            hres.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE,

                          sm.getString("standardWrapper.isUnavailable",

                                       wrapper.getName()));

            // Do not save exception in'throwable', because we

            // do not want to do exception(request,response, e) processing

        } catch (ServletException e) {

           sreq.removeAttribute(Globals.JSP_FILE_ATTR);

           log(sm.getString("standardWrapper.serviceException",

                             wrapper.getName()), e);

            throwable = e;

            exception(request, response, e);

        } catch (Throwable e) {

           sreq.removeAttribute(Globals.JSP_FILE_ATTR);

           log(sm.getString("standardWrapper.serviceException",

                             wrapper.getName()),e);

            throwable = e;

            exception(request, response, 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 servletinstance

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

            }

        }

 

}

这个方法比较长，但是目前我们只需要抓住如下2点即可：

1）  servlet = wrapper.allocate()

2）  ApplicationFilterChain filterChain = createFilterChain(request,servlet);

3）  filterChain.doFilter(sreq, sres);

 

我们根据这3点进一步分析：

第一，  我们从StandardWrapperValve的invoke方法可以早wrapper.allocate(),其实调用的就是standardWrapper中的allocate()

publicServlet allocate() throws ServletException {

 

        if (debug >= 1)

            log("Allocating aninstance");

 

        // If we are currently unloading thisservlet, throw an exception

        if (unloading)

            throw new ServletException

             (sm.getString("standardWrapper.unloading", getName()));

 

        // If not SingleThreadedModel, returnthe same instance every time

        if (!singleThreadModel) {

 

            // Load and initialize our instanceif necessary

            if (instance == null) {

                synchronized (this) {

                    if (instance == null) {

                        try {

                            instance =loadServlet();

                        } catch(ServletException e) {

                            throw e;

                        } catch (Throwable e) {

                            throw newServletException

                               (sm.getString("standardWrapper.allocate"), e);

                        }

                    }

                }

            }

 

            if (!singleThreadModel) {

                if (debug >= 2)

                    log("  Returning non-STM instance");

                countAllocated++;

                return (instance);

            }

 

        }

 

        synchronized (instancePool) {

 

            while (countAllocated >=nInstances) {

                // Allocate a new instance if possible, orelse wait

                if (nInstances <maxInstances) {

                    try {

                       instancePool.push(loadServlet());

                        nInstances++;

                    } catch (ServletExceptione) {

                        throw e;

                    } catch (Throwable e) {

                        throw newServletException

                           (sm.getString("standardWrapper.allocate"), e);

                    }

                } else {

                    try {

                        instancePool.wait();

                    } catch(InterruptedException e) {

                        ;

                    }

                }

            }

            if (debug >= 2)

                log("  Returning allocated STM instance");

            countAllocated++;

            return (Servlet)instancePool.pop();

 

        }

 

}

 

在这个方法里边，其实调用的就是loadServlet(),我们深入这个放放风的源码可以知道，其实这里就加载了一个servlet类到内存，并进行实例化，同时触发了一些事件方法，同时执行了servlet的init()方法

 

第二，  createFilterChain，这个方法其实就是根据配置文件里边的一些filter的配置，进行过滤链的配置

第三，  filterChain.doFilter(sreq,sres)，执行过滤方法，我们到ApplicationFilterChain类中查看doFilter方法的时候，发现它又通过线程的方式，将请求对象request和response传递给了internalDoFilter()方法中，在这个方法里边，循环执行了配置的filter，然后再执行servlet的service()方法

 

根据上述的分析，我们目前的主线流程就完成了！一个前端发起的请求，由tomcat接收的流程就完成了！！其他细节有待我们根据之前分析的主线，再深入分析了解即可。

StandardWrapper请求流程图：


StandardWrapper的请求关系类图：




plkkoko
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
tomcat源码分析五：Mapper（url到Wrapper的映射）
走进技术的世界
03-04 2300
tomcat中如何维护url到wrapper的对应关系的呢，又是如何初始化变更这些关系呢，对于用户的请求，是如何映射到具体的wrapper上的呢。
Tomcat从零开始（十七）——StandardWrapper
weixin_30911809的博客
07-07 137
第十七课：StandardWrapper 课前复习： 不知道大家是否还有印象，就是在6、7节课说的4种container,粗略的从大到小来说就是engine,host,context,和wrapper。当时写的时候很纠结，因为后面有详细介绍这4个的计划，所以前面写的可能不是很详尽。 让我们回忆一下，当一个请求到来的时候，发生了什么。比如什么创建Request这...
深入剖析Tomcat(十、十一) 详解StandardWrapper
最新发布
咖啡煮码
06-24 1089
详解Tomcat中Wrapper容器的标准实现：StandardWrapper
16,tomcat中StandardWrapper实现
老男人
11-14 196
Wrapper接口在Catalina中的标准实现StandardWrapper类的详细实现过程。一共有四种容器：engine（引擎）,host（主机）,context（上下文）和wrapper（包装器）一个上下文一般包括一个或者多个包装器，每一个包装器表示一个servlet方法调用序列Sequence of Methods Invocation对于每一个连接，连接器都会调用关联容器的invoke方...
浅析Tomcat之StandardWrapper
泛泛之辈
09-27 351
Wrapper是Context的子容器,它代表了在应用部署描述中的一个单独的servlet.它通过Servlet的init和destroy方法掌管了底层的Servlet的生命周期.并且其中的阀还负责调用Servlet响应用户请求的功能.Wrapper的默认实现是StandardWrapper. 首先,还是很老套地说StandardWrapper的构造函数还是跟StandardContext等...
Tomcat原理学习---StandardWrapper
zcm482的专栏
06-12 1506
在第五章中已经说过，一共有四种容器：engine（引擎）,host（主机）,context（上下文）和wrapper（包装器）。在前面的章节里也介绍了如何建立自己的context和wrapper。一个上下文一般包括一个或者多个包装器，每一个包装器表示一个servlet。本章将会看到Catalina 中Wrapper接口的标准实现。首先介绍了一个HTTP请求会唤醒的一系列方法，接下来介绍了javax
我的tomcat7源码手撕过程
01-11
### Tomcat7源码手撕过程详解 #### Tomcat初始化流程分析 Tomcat是一个流行的Java Servlet容器，用于部署和运行Web应用程序。理解Tomcat的工作原理对于优化应用性能、解决部署问题至关重要。以下是对Tomcat7启动...
apache-tomcat-9.0.1源码
10-17
Tomcat使用线程池来处理并发请求，`org.apache.tomcat.util.net`包中的`Executor`类提供了线程池的实现。 10. **错误处理**： `org.apache.catalina.valves`包下的`ErrorReportValve`类处理服务器错误报告，提供...
Tomcat8.0底层源码
08-20
《深入剖析Tomcat 8.0底层源码》 Tomcat作为一款广泛应用的开源Java Servlet容器，其8.0版本的源码对于开发者来说是一份宝贵的教育资源。通过深入学习Tomcat 8.0的源码，我们可以理解Web服务器的工作原理，提升对...
tomcat源码
10-19
Tomcat通过`CoyoteConnector`与外界通信，它负责接收和发送HTTP请求。Coyote连接器有基于Bio（Blocking I/O）和Nio（Non-blocking I/O）两种实现，Nio提供了更高的并发性能。 4. **容器（Container）**： 容器是...
Tomcat 10.0.12的源码
04-28
**Apache Tomcat 10.0.12 源码分析** Apache Tomcat 是一个开源的、基于Java Servlet和Java EE Web应用规范的应用服务器，主要用于处理和运行JSP和Servlet应用程序。源码分析对于理解其工作原理、优化性能以及进行...
Tomcat源码解析（一）：wrapper
进击吧！！
08-14 1427
读Tomcat源码：wrapperWrapper的作用StandardWrapper同StandardContext一样，继承自ContainerBase，Wrapper表示了一个servlet定义，一个servlet类对应一个wrapper。wrapper的parent container必须是context，而wrapper不能有child container。 定义如下：public fin
how tomcat works 读书笔记 十一 StandWrapper 上
程序员小董的专栏
11-18 1692
方法调用序列 下图展示了方法调用的协作图:  这个是前面第五章里,我画的图:  我们再回顾一下自从连接器里  connector.getContainer().invoke(request, response);  这句代码运行之后发生的事情;  这是第五章的时序图,放在这一章同样适用。。。  我们仔细分析一下:  1首先连接器创建请求与响应对象;  2调用这行代码
第11章——StandardWrapper
Programming is an art form.
03-11 427
第十一章 StandardWrapper11.1 方法调用序列1.调用和连接器关联的容器的invoke()方法。 2.调用该容器的管道的invoke方法，依次会调用所有管道阀，最后调用基础阀。 3.基础阀调用相应的Wrapper实例处理HTTP请求，调用Wrapper实例中的invoke方法。 4.Wrapper容器调用其管道的invoke方法的阀，最后调用基础阀。 5.基础阀调用alloc
tomcat源码阅读之StandardWrapper解析
weixin_30828379的博客
12-07 130
一、UML图： 1、Tomcat中Wrapper代表一个独立的servlet实例，StandardWrapper类是Wrapper接口的标准实现类，StandardWrapper类还实现了SelvletConfig接口，同时其从ContainerBase类继承过来，表示他是一个容器，只是他是最底层的容器，不能再含有任何的子容器了，且其父容器只能是context； 2、Valve接口代表阀门...
jxl导出EXCEL的java.lang.IllegalStateException异常
流氓猪的窝
07-10 2898
 http://blog.csdn.net/patriotlml/archive/2007/05/28/1628556.aspx我们在做文件上传或者下载，或者过滤等操作时，可能要用到页面的输出流.例如在JSP使用：　　　　response.reset();　　　　response.setContentType(”application/vnd.ms-excel”);　　　　OutputStre
Tomcat请求处理(五) -- 请求在容器间的流动
guo_yang的博客
10-23 197
请求在Tomcat中传到了CoyoteAdapter的#service()方法中后，就要准备进入Pipeline了，如#service()方法中的这句所示： connector.getContainer().getPipeline().getFirst().invoke(request, response); 这里的Container是Engine，然后得到它的Pipeline对象，然后得...
StandardWrapper
u012233580的博客
02-12 902
    Tomcat中一共有四种容器：engine（引擎）,host（主机）,context（上下文）和wrapper（包装器）。在前面的章节里也介绍了如何建立自己的context和wrapper。一个上下文一般包括一个或者多个包装器，每一个包装器表示一个servlet。本章将会看到Catalina中Wrapper接口的标准实现。首先介绍了一个HTTP请求会唤醒的一系列方法，接下来介绍了javax...
Tomcat源码：StandardEngine、StandardHost、StandardContext、StandardWrapper
CRUD工程师
04-16 708
在前文中，我们介绍了容器组件的公共接口Container接口，这个接口的抽象实现类ContainerBase实现了initInternal、startInternal这两个生命周期，规定了子容器中的大部分行为，本文我们就来继续深入到各个子容器中进行源码的分析。目录前言一、StandardEngine二、StandardHost三、HostConfig生命周期监听器的添加生命周期监听器的执行start与deployAppsdeployWARs四、StandardContext触发事件监听器。
Tomcat工作原理探索
11. **StandardWrapper**和**StandardContext类**：这两部分深入到Tomcat的内部实现，讲解了StandardWrapper如何包装servlet实例，以及StandardContext如何管理Web应用程序上下文。 通过这些章节的学习，读者可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值