tomcat原理解析(七)：执行servlet

最新推荐文章于 2023-02-25 14:37:20 发布
最新推荐文章于 2023-02-25 14:37:20 发布
阅读量2.6k 收藏 5
点赞数
分类专栏： tomcat实现 文章标签： tomcat
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qiangcai/article/details/72901115
版权

一  概述

       前面章节已经说到http的请求到达了管道处理。最后的一个管道是StandardWrapper中的管道，它最后的阀门是StandardWrapperValve，阀门中的invoke代码主要做了两件事情：1.执行过滤器链，2调用http请求servlet的service方法。

二 调用过滤器并执行servlet

这里再次贴下invoke中的代码，部分省略掉： 

@Override
    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();//取当前阀门对应的wrapper容器
        Servlet servlet = null;
        Context context = (Context) wrapper.getParent();//取wrapper容器对应的父context容器
        
        // 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
        //检查servlet被标记不可用
        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) {
                //加载wrapper对应的servlet实例来处理此请求
                //通过java反射机制来加载对象
                servlet = wrapper.allocate();
            }
        } catch (UnavailableException e) {
            
        } catch (ServletException e) {
            
        } catch (Throwable e) {
            
        }

        // 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 {
            response.sendAcknowledgement();
        } catch (IOException e) {
        	
        } catch (Throwable e) {
            
        }
        MessageBytes requestPathMB = request.getRequestPathMB();
        DispatcherType dispatcherType = DispatcherType.REQUEST;
        if (request.getDispatcherType()==DispatcherType.ASYNC) dispatcherType = DispatcherType.ASYNC; 
        request.setAttribute
            (ApplicationFilterFactory.DISPATCHER_TYPE_ATTR,
             dispatcherType);
        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 (request.isAsyncDispatching()) {
                            //TODO SERVLET3 - async
                            ((AsyncContextImpl)request.getAsyncContext()).doInternalDispatch(); 
                        } else 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 (request.isAsyncDispatching()) {
                        //TODO SERVLET3 - async
                        ((AsyncContextImpl)request.getAsyncContext()).doInternalDispatch();
                    } 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) {
        	
        } catch (IOException e) {
        	
        } catch (UnavailableException e) {
        	
        } catch (ServletException e) {
        	
        } catch (Throwable 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) {
                wrapper.deallocate(servlet);
            }
        } catch (Throwable 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) {
            
        }
        long t2=System.currentTimeMillis();

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

    }
上面的代码主要做了两件事
1.取当前阀门对应的wrapper容器，我们知道wrapper容器是对一个servlet信息的封装
2.创建单例的ApplicationFilterFactory对象
3.创建过滤器链ApplicationFilterChain对象
4.调用ApplicationFilterChain的doFilter方法，以递归的方式循环执行过滤器链中的过滤器


跟进到ApplicationFilterChain类的doFilter方法，代码如下： 

   public void doFilter(ServletRequest request, ServletResponse response)
        throws IOException, ServletException {

        if( Globals.IS_SECURITY_ENABLED ) {
            final ServletRequest req = request;
            final ServletResponse res = response;
            try {
                java.security.AccessController.doPrivileged(
                    new java.security.PrivilegedExceptionAction<Void>() {
                        public Void run() 
                            throws ServletException, IOException {
                            internalDoFilter(req,res);
                            return null;
                        }
                    }
                );
            } catch( PrivilegedActionException pe) {
                Exception e = pe.getException();
                if (e instanceof ServletException)
                    throw (ServletException) e;
                else if (e instanceof IOException)
                    throw (IOException) e;
                else if (e instanceof RuntimeException)
                    throw (RuntimeException) e;
                else
                    throw new ServletException(e.getMessage(), e);
            }
        } else {
            internalDoFilter(request,response);
        }
    }

doFilter方法中主要调用了internalDoFilter方法，代码如下： 

 private void internalDoFilter(ServletRequest request, 
                                  ServletResponse response)
        throws IOException, ServletException {

        // Call the next filter if there is one
        if (pos < n) {
            ApplicationFilterConfig filterConfig = filters[pos++];//控制过滤器链中过滤器对象获取
            Filter filter = null;
            try {
                filter = filterConfig.getFilter();
                support.fireInstanceEvent(InstanceEvent.BEFORE_FILTER_EVENT,
                                          filter, request, response);
                
                if (request.isAsyncSupported() && "false".equalsIgnoreCase(
                        filterConfig.getFilterDef().getAsyncSupported())) {
                    request.setAttribute(Globals.ASYNC_SUPPORTED_ATTR,
                            Boolean.FALSE);
                }
                if( Globals.IS_SECURITY_ENABLED ) {
                    final ServletRequest req = request;
                    final ServletResponse res = response;
                    Principal principal = 
                        ((HttpServletRequest) req).getUserPrincipal();

                    Object[] args = new Object[]{req, res, this};
                    SecurityUtil.doAsPrivilege
                        ("doFilter", filter, classType, args, principal);
                    
                    args = null;
                } else {  
                    filter.doFilter(request, response, this);//递归调用过滤器链中的Filter
                }

                support.fireInstanceEvent(InstanceEvent.AFTER_FILTER_EVENT,
                                          filter, request, response);
            } catch (IOException e) {
                if (filter != null)
                    support.fireInstanceEvent(InstanceEvent.AFTER_FILTER_EVENT,
                                              filter, request, response, e);
                throw e;
            } catch (ServletException e) {
                if (filter != null)
                    support.fireInstanceEvent(InstanceEvent.AFTER_FILTER_EVENT,
                                              filter, request, response, e);
                throw e;
            } catch (RuntimeException e) {
                if (filter != null)
                    support.fireInstanceEvent(InstanceEvent.AFTER_FILTER_EVENT,
                                              filter, request, response, e);
                throw e;
            } catch (Throwable e) {
                if (filter != null)
                    support.fireInstanceEvent(InstanceEvent.AFTER_FILTER_EVENT,
                                              filter, request, response, e);
                throw new ServletException
                  (sm.getString("filterChain.filter"), e);
            }
            return;
        }

        // We fell off the end of the chain -- call the servlet instance
        try {
            if (ApplicationDispatcher.WRAP_SAME_OBJECT) {
                lastServicedRequest.set(request);
                lastServicedResponse.set(response);
            }

            support.fireInstanceEvent(InstanceEvent.BEFORE_SERVICE_EVENT,servlet, request, response);
            if (request.isAsyncSupported()
                    && !support.getWrapper().isAsyncSupported()) {
                request.setAttribute(Globals.ASYNC_SUPPORTED_ATTR,
                        Boolean.FALSE);
            }
            // Use potentially wrapped request from this point
            if ((request instanceof HttpServletRequest) &&
                (response instanceof HttpServletResponse)) {
                    
                if( Globals.IS_SECURITY_ENABLED ) {
                    final ServletRequest req = request;
                    final ServletResponse res = response;
                    Principal principal = 
                        ((HttpServletRequest) req).getUserPrincipal();
                    Object[] args = new Object[]{req, res};
                    SecurityUtil.doAsPrivilege("service",
                                               servlet,
                                               classTypeUsedInService, 
                                               args,
                                               principal);   
                    args = null;
                } else {  
                    servlet.service(request, response);//执行http请求对应的servlet的servie方法
                }
            } else {
                servlet.service(request, response);//执行http请求对应的servlet的servie方法
            }
            support.fireInstanceEvent(InstanceEvent.AFTER_SERVICE_EVENT,
                                      servlet, request, response);
        } catch (IOException e) {
            
        } catch (ServletException e) {
            
        } catch (RuntimeException e) {
           
        } catch (Throwable e) {
            
        } finally {
            if (ApplicationDispatcher.WRAP_SAME_OBJECT) {
                lastServicedRequest.set(null);
                lastServicedResponse.set(null);
            }
        }

    }

internalDoFilter方法中主要干了两件事情
1.递归执行过滤器链中的过滤器
2.执行完过滤器以后，执行servlet的service方法

因为所有的servlet对象都继承HttpServlet类，跟到HttpServlet类的service方法代码如下： 
    @Override
    public void service(ServletRequest req, ServletResponse res)
        throws ServletException, IOException {

        HttpServletRequest  request;
        HttpServletResponse response;
        
        try {
            request = (HttpServletRequest) req;
            response = (HttpServletResponse) res;
        } catch (ClassCastException e) {
            throw new ServletException("non-HTTP request or response");
        }
        service(request, response);
    }
}
查看最后一行service(request, response);调用了当前HttpServlet类的另外一个service方法在参数类型上存在差别。 

 protected void service(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException {

        String method = req.getMethod();//取当前请求的方法名如get post

        //根据http请求的方法名判断是小于post方法还是get方法
        if (method.equals(METHOD_GET)) {
            long lastModified = getLastModified(req);
            if (lastModified == -1) {
                // servlet doesn't support if-modified-since, no reason
                // to go through further expensive logic
                doGet(req, resp);
            } else {
                long ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);
                if (ifModifiedSince < (lastModified / 1000 * 1000)) {
                    // If the servlet mod time is later, call doGet()
                    // Round down to the nearest second for a proper compare
                    // A ifModifiedSince of -1 will always be less
                    maybeSetLastModified(resp, lastModified);
                    doGet(req, resp);
                } else {
                    resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
                }
            }

        } else if (method.equals(METHOD_HEAD)) {
            long lastModified = getLastModified(req);
            maybeSetLastModified(resp, lastModified);
            doHead(req, resp);

        } else if (method.equals(METHOD_POST)) {
            doPost(req, resp);
            
        } else if (method.equals(METHOD_PUT)) {
            doPut(req, resp);
            
        } else if (method.equals(METHOD_DELETE)) {
            doDelete(req, resp);
            
        } else if (method.equals(METHOD_OPTIONS)) {
            doOptions(req,resp);

        } else if (method.equals(METHOD_TRACE)) {
            doTrace(req,resp);
            
        } else {
            //
            // Note that this means NO servlet supports whatever
            // method was requested, anywhere on this server.
            //

            String errMsg = lStrings.getString("http.method_not_implemented");
            Object[] errArgs = new Object[1];
            errArgs[0] = method;
            errMsg = MessageFormat.format(errMsg, errArgs);
            
            resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);
        }
    }

service方法中主要是根据请求对象（HttpServletRequest）拿到是调用的get方法和post方法。我们跟进到get方法中的代码如下： 
    protected void doGet(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException
    {
        String protocol = req.getProtocol();
        String msg = lStrings.getString("http.method_get_not_supported");
        if (protocol.endsWith("1.1")) {
            resp.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, msg);
        } else {
            resp.sendError(HttpServletResponse.SC_BAD_REQUEST, msg);
        }
    }
doGet方法中只有返回405,400异常处理的代码，这是为什么呢？
因为我们自己开发写的servlet类都会继承HttpServlet对象，同时会重写doGet和doPost方法。所以在HttpServlet的service方法中调用的doGet方法其实执行的是HttpServlet子类中的doGe方法。


三 总结

         在web开发中我们定义的servlet最终都是实现了servlet接口，servlet接口是连接tomcat容器和web应用的规范。   试着扩展想想struts，springmvc应该也是实现servlet接口才会正常在tomcat中部署使用。   到这里从浏览器发起http请求到如何定位并执行对应的servlet主流程已经结束，个人感觉只是知道了tomat的主体流程，很多细节的代码没有完全理解，不知道这样的阅读理解层次算不算掌握了tomcat的实现原理。


逆水行舟不进则退
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
12-Servlet执行原理.pdf
10-28
1. 当服务器接受到客户端浏览器的请求后，会解析请求URL路径，获取访问的Servlet的资源路径。在上图 的URL中，获取的资源路径就是/demo01 2. 查找web.xml文件，是否有对应的标签体内容。 3. 如果有，则在找到对应的...
Lisp入门
Dragon.G
03-22 1万+
本教程以图文 搭配的形式向您简要介绍Racket编程。这些例子很有趣，也很有启发作用，即使你不打算深入下去也值得一看。毕竟，一图胜千言，至少是五百句“hello world”。 我们假设你用DrRacket来运行这些例子，这是了解这门语言的概貌和环境的最好途径，虽然你也可以时不时地用用macs，vi，或是别的编辑器。1、准备下载Racket，安装，启动DrRacket。2、设置我们先要加载一些能
Lisp入门教程
xyjikl
05-30 9153
Common LISP Hints                          Geoffrey J. Gordon                         [email protected]>                       Friday, February 5, 1993                            Modified by  
使用Tomcat搭建一个Servlet项目
weixin_46429649的博客
08-25 1925
Tomcat maven 使用 创建maven项目 管理依赖 实践 使用总结 GET,POST请求应用场景 Servlet运行原理 Tomcat伪代码 Tomcat初始化 Tomcat处理请求 Servlet的关键API HTTPServlet HttpServletRequest和HttpServletResponse 例子1： 例子2： body格式 请求body格式 响应body格式 Cookie和Session HttpServletRequest类中的相关方法 HttpServletRespons
Lisp语言入门
nameofcsdn的博客
02-20 4623
目录 一，在线运行环境 二，输入输出 1，输出 2，输入 三，变量 1，格式化输出 2，变量赋值 setf 四，函数 五，列表 1，表list、nth 2，解引用 3，属性表plist 一，在线运行环境 https://www.nhooo.com/tool/lisp/ http://lisp.jsrun.net/ 二，输入输出 1，输出 （1）format format有2个必须的参数，一个是输出位置，如 t 是标准输出，一个是输出内容 代码： (for...
Apache+Tomcat负载平衡设置方法详细解析
03-04
每个Tomcat worker是一个服务于web server、等待执行servlet的Tomcat实例。例如我们经常使用像Apache之类的web server转发sevlet请求给位于其后面的一个Tomcat进程（也就是前面所说的worker）。本文详细介绍了如何...
Servlet
12-20
Servlet server applet 运行在服务器端的小程序 Servlet就是一个接口，定义了...执行原理 当服务器接收到客户端浏览器请求后，会解析请求URL路径，获取访问的Servlet的资源路径 查找web.xml文件，是否有对应的标签体
rr:RR-铁路图生成器
05-05
可以将.war文件部署在Tomcat或Jetty之类的servlet容器中，以为GUI提供服务。 这构成了在原始网站上运行的webapp。 .war文件是Java的“可执行战争”，即也可以从命令行独立启动。 在独立模式下可以执行两个不同的...
Java Servlet的注解配置与生命周期详解.docx
07-02
执行原理加图解 1.当服务器接受到服务器请求的时候，会先解析浏览器的UPL地址，获取访问服务的路径 2.然后查找WEB.xml文件，查看是否有对应的标签体的内容 3.如果有，则找到对应的全类名 4.tomcat会将字节码文件加载...
Web第一个Servlet程序(生命周期、执行流程、tomcat)
09-29
web项目：第一个Servlet程序 Servlet的生命周期：init--service--destroy、执行流程：构造器--init方法--循环[ service方法 ]--destory方法(正常关闭Tomcat)、启动tomcat测试
AutoLISP从入门到精通初级教程(新手必备）
08-31
《AutoLISP从入门到精通初级教程》新手学习AutoCAD二次开发必备材料
lisp教程
03-23
Visual_LISP程序设计(AutoCAD-2006)
IntelliJ IDEA 2017 建立简单的servlet
11-02
IntelliJ IDEA 2017.2.2 建立简单的servle是我自己写的pdf有兴趣的可以下载
AutoLiSP入门教程
12-06
AutoLISP 是强化AutoCAD 最好、最直接的『程序语言』! AutoLISP 易学、易用,即使不会程序设计的AutoCAD 使用者,都能在最 短的时间内,写出令人惊讶、赞叹的功能! 学习AutoLISP 是非常容易的,对初学者而言,即使没有学习过任何的程序语言, 都能很快的上手,写出精彩漂亮的AutoLISP 程序!
tomcat源码分析(第四篇 tomcat请求处理原理解析--Container源码分析)
weixin_33743703的博客
06-27 190
Container容器是所用servlet容器的父接口，也就是说作为一个servlet容器，首先必须要实现Container接口，每个tomcat服务器只能有唯一的根Container，Connector组件通过setContainer方法将Container容器和Connector关联起来。共有四种类型Container容器，分别对应不同概念的层次，每一层之间是父子的关系。 1、Engine：整...
【一天一门编程语言】Lisp 语言程序设计极简教程
热门推荐
禅与计算机程序设计艺术
02-25 2万+
Lisp（LISt Processing）是一种古老的程序设计语言，它最初由 John McCarthy 于 1956 年发明，起初是一种交互式程序设计的工具，可以用来实现简单的算法和计算，随着时间的推移，它被广泛应用于各种领域，如人工智能、自然语言处理、机器学习等。由于其灵活性、易用性和高效性，Lisp 被许多公司用于应用开发，例如 Google、Facebook 等。Lisp 是一种动态类型的语言，拥有非常高的表示能力，可以用来实现复杂的软件系统。
java invoke servlet
runthu
11-14 294
package com.iyunti.core; import java.io.IOException; import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.uti...
Visual LISP教程
10-02
autocad Visual LISP教程 简体中文版的
AUTOLISP基础教程
03-22
会CAD的很多不会编程，会编程的很多不会CAD，这本书会教我们学习如何CAD编程，让编程来提高CAD画图的效率
【tomcat】servlet 工作原理解析
最新发布
12-05
Tomcat是一个开源的Java Servlet容器，它的工作原理是基于...总的来说，Tomcat作为Servlet容器，其工作原理就是根据Servlet规范来管理和处理Servlet，为开发人员提供一个可靠的环境来开发和部署基于Java的Web应用程序。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值