程序博客网 > 好看的网络自制剧古装

Tomcat请求处理(七) - Servlet实例的调用

来源：互联网 发布：好看的网络自制剧古装 编辑：程序博客网 时间：2024/06/05 07:07
Tomcat请求处理中Servlet实例的调用是和Filter的调用联系在一起的，是在StandardWrapperValve类的#invoke()方法中调用的，前面的文章中提到过，就是下面的这句： 
filterChain.doFilter(request.getRequest(), response.getResponse()); 

它的源代码如下： 

Java代码  收藏代码
  1. public void doFilter(ServletRequest request, ServletResponse response) throws IOException,  
  2.         ServletException {  
  3.   
  4.     if (Globals.IS_SECURITY_ENABLED) {  
  5.         final ServletRequest req = request;  
  6.         final ServletResponse res = response;  
  7.         try {  
  8.             java.security.AccessController  
  9.                     .doPrivileged(new java.security.PrivilegedExceptionAction() {  
  10.                         public Object run() throws ServletException, IOException {  
  11.                             internalDoFilter(req, res);  
  12.                             return null;  
  13.                         }  
  14.                     });  
  15.         } catch (PrivilegedActionException pe) {  
  16.             Exception e = pe.getException();  
  17.             if (e instanceof ServletException)  
  18.                 throw (ServletException) e;  
  19.             else if (e instanceof IOException)  
  20.                 throw (IOException) e;  
  21.             else if (e instanceof RuntimeException)  
  22.                 throw (RuntimeException) e;  
  23.             else  
  24.                 throw new ServletException(e.getMessage(), e);  
  25.         }  
  26.     } else {  
  27.         internalDoFilter(request, response);  
  28.     }  
  29. }  


这个方法只是调用了#internalDoFilter()，这个才是Filter调用的核心，源代码如下所示： 

Java代码  收藏代码
  1. private void internalDoFilter(ServletRequest request, ServletResponse response)  
  2.         throws IOException, ServletException {  
  3.   
  4.     if (pos < n) {  
  5.         ApplicationFilterConfig filterConfig = filters[pos++];  
  6.         Filter filter = null;  
  7.         try {  
  8.             // 得到当前Filter  
  9.             filter = filterConfig.getFilter();  
  10.             support.fireInstanceEvent(InstanceEvent.BEFORE_FILTER_EVENT, filter, request,  
  11.                     response);  
  12.             // 调用Filter的#doFilter()方法。  
  13.             // 在Filter内部，如果Filter调用成功，会调用chain.doFilter(request,response); 这个语句。  
  14.             // 这里传递给忒Filter的chain实例就是ApplicationFilterChain类的对象。  
  15.             // 于是程序又回到了#doFilter()，然后再次调用本方法。也应该是一种变相的递归了。  
  16.             if (Globals.IS_SECURITY_ENABLED) {  
  17.                 final ServletRequest req = request;  
  18.                 final ServletResponse res = response;  
  19.                 Principal principal = ((HttpServletRequest) req).getUserPrincipal();  
  20.   
  21.                 Object[] args = new Object[] { req, res, this };  
  22.                 SecurityUtil.doAsPrivilege("doFilter", filter, classType, args);  
  23.   
  24.                 args = null;  
  25.             } else {  
  26.                 filter.doFilter(request, response, this);  
  27.             }  
  28.   
  29.             support.fireInstanceEvent(InstanceEvent.AFTER_FILTER_EVENT, filter, request,  
  30.                     response);  
  31.         } catch (IOException e) {  
  32.             if (filter != null)  
  33.                 support.fireInstanceEvent(InstanceEvent.AFTER_FILTER_EVENT, filter, request,  
  34.                         response, e);  
  35.             throw e;  
  36.         } catch (ServletException e) {  
  37.             if (filter != null)  
  38.                 support.fireInstanceEvent(InstanceEvent.AFTER_FILTER_EVENT, filter, request,  
  39.                         response, e);  
  40.             throw e;  
  41.         } catch (RuntimeException e) {  
  42.             if (filter != null)  
  43.                 support.fireInstanceEvent(InstanceEvent.AFTER_FILTER_EVENT, filter, request,  
  44.                         response, e);  
  45.             throw e;  
  46.         } catch (Throwable e) {  
  47.             if (filter != null)  
  48.                 support.fireInstanceEvent(InstanceEvent.AFTER_FILTER_EVENT, filter, request,  
  49.                         response, e);  
  50.             throw new ServletException(sm.getString("filterChain.filter"), e);  
  51.         }  
  52.         return;  
  53.     }  
  54.   
  55.     try {  
  56.         if (Globals.STRICT_SERVLET_COMPLIANCE) {  
  57.             lastServicedRequest.set(request);  
  58.             lastServicedResponse.set(response);  
  59.         }  
  60.         // Filter全部调用完毕后，就会把请求真正的传递给Servlet了，调用它的#service()方法。  
  61.         support.fireInstanceEvent(InstanceEvent.BEFORE_SERVICE_EVENT, servlet, request,  
  62.                 response);  
  63.         if ((request instanceof HttpServletRequest)  
  64.                 && (response instanceof HttpServletResponse)) {  
  65.   
  66.             if (Globals.IS_SECURITY_ENABLED) {  
  67.                 final ServletRequest req = request;  
  68.                 final ServletResponse res = response;  
  69.                 Principal principal = ((HttpServletRequest) req).getUserPrincipal();  
  70.                 Object[] args = new Object[] { req, res };  
  71.                 SecurityUtil.doAsPrivilege("service", servlet, classTypeUsedInService, args,  
  72.                         principal);  
  73.                 args = null;  
  74.             } else {  
  75.                 servlet.service((HttpServletRequest) request, (HttpServletResponse) response);  
  76.             }  
  77.         } else {  
  78.             servlet.service(request, response);  
  79.         }  
  80.         support  
  81.                 .fireInstanceEvent(InstanceEvent.AFTER_SERVICE_EVENT, servlet, request,  
  82.                         response);  
  83.     } catch (IOException e) {  
  84.         support.fireInstanceEvent(InstanceEvent.AFTER_SERVICE_EVENT, servlet, request,  
  85.                 response, e);  
  86.         throw e;  
  87.     } catch (ServletException e) {  
  88.         support.fireInstanceEvent(InstanceEvent.AFTER_SERVICE_EVENT, servlet, request,  
  89.                 response, e);  
  90.         throw e;  
  91.     } catch (RuntimeException e) {  
  92.         support.fireInstanceEvent(InstanceEvent.AFTER_SERVICE_EVENT, servlet, request,  
  93.                 response, e);  
  94.         throw e;  
  95.     } catch (Throwable e) {  
  96.         support.fireInstanceEvent(InstanceEvent.AFTER_SERVICE_EVENT, servlet, request,  
  97.                 response, e);  
  98.         throw new ServletException(sm.getString("filterChain.servlet"), e);  
  99.     } finally {  
  100.         if (Globals.STRICT_SERVLET_COMPLIANCE) {  
  101.             lastServicedRequest.set(null);  
  102.             lastServicedResponse.set(null);  
  103.         }  
  104.     }  
  105.   
  106. }  


程序到了这里，就出现了分水岭，分别对应着对Servlet，JSP，和静态资源的处理。 
Servlet比较简单，因为这里的"servlet"就是真实的Servlet实例了，直接调用开发人员自己编写的#service()方法了(#service()内部是会调用#doGet()，#doPost()等方法的)。 

对于静态资源，是调用org.apache.catalina.servlets.DefaultServlet的#service()方法，由于DefaultServlet并没有重写这个方法，所以直接使用HttpServlet的#service()方法。但是DefaultServlet重写了#doGet()，#doPost()等方法(#doPost()内部又调用了#doGet())，所以请求就又到了#doGet()这个方法中，DefaultServlet的#doGet()只调用了#serveResource()这个方法来提取资源，代码太长，就不再仔细的看了。 
对于JSP资源，就比较复杂了，还有编译等操作，下面来重点看一下。 

首先，要调用org.apache.jasper.servlet.JspServlet的#service()方法，源代码如下： 

Java代码  收藏代码
  1. public void service(HttpServletRequest request, HttpServletResponse response)  
  2.         throws ServletException, IOException {  
  3.   
  4.     // 获得请求的JSP文件的路径  
  5.     String jspUri = null;  
  6.   
  7.     String jspFile = (String) request.getAttribute(Constants.JSP_FILE);  
  8.     if (jspFile != null) {  
  9.         // 通过web.xml中的<jsp-file>标签定义  
  10.         jspUri = jspFile;  
  11.     } else {  
  12.         jspUri = (String) request.getAttribute(Constants.INC_SERVLET_PATH);  
  13.         if (jspUri != null) {  
  14.             String pathInfo = (String) request.getAttribute("javax.servlet.include.path_info");  
  15.             if (pathInfo != null) {  
  16.                 jspUri += pathInfo;  
  17.             }  
  18.         } else {  
  19.             jspUri = request.getServletPath();  
  20.             String pathInfo = request.getPathInfo();  
  21.             if (pathInfo != null) {  
  22.                 jspUri += pathInfo;  
  23.             }  
  24.         }  
  25.     }  
  26.   
  27.     if (log.isDebugEnabled()) {  
  28.         log.debug("JspEngine --> " + jspUri);  
  29.         log.debug("\t     ServletPath: " + request.getServletPath());  
  30.         log.debug("\t        PathInfo: " + request.getPathInfo());  
  31.         log.debug("\t        RealPath: " + context.getRealPath(jspUri));  
  32.         log.debug("\t      RequestURI: " + request.getRequestURI());  
  33.         log.debug("\t     QueryString: " + request.getQueryString());  
  34.         log.debug("\t  Request Params: ");  
  35.         Enumeration e = request.getParameterNames();  
  36.         while (e.hasMoreElements()) {  
  37.             String name = (String) e.nextElement();  
  38.             log.debug("\t\t " + name + " = " + request.getParameter(name));  
  39.         }  
  40.     }  
  41.   
  42.     try {  
  43.         // 预编译模式，如果是预编译模式，只是对JSP进行编译，不会返回页面执行结果  
  44.         boolean precompile = preCompile(request);  
  45.         // 继续JSP请求  
  46.         serviceJspFile(request, response, jspUri, null, precompile);  
  47.     } catch (RuntimeException e) {  
  48.         throw e;  
  49.     } catch (ServletException e) {  
  50.         throw e;  
  51.     } catch (IOException e) {  
  52.         throw e;  
  53.     } catch (Throwable e) {  
  54.         throw new ServletException(e);  
  55.     }  
  56.   
  57. }  

这里，有两个方法需要看一下，一个是预编译方法#preCompile()，另外一个是调用JSP的#serviceJspFile()方法。

首先来看一下#preCompile()： 

Java代码  收藏代码
  1. boolean preCompile(HttpServletRequest request) throws ServletException {  
  2.     // 获得查询字符串  
  3.     String queryString = request.getQueryString();  
  4.     if (queryString == null) {  
  5.         return (false);  
  6.     }  
  7.     // 看是否有预编译参数，默认是jsp_precompile  
  8.     int start = queryString.indexOf(Constants.PRECOMPILE);  
  9.     if (start < 0) {  
  10.         return (false);  
  11.     }  
  12.     queryString = queryString.substring(start + Constants.PRECOMPILE.length());  
  13.     if (queryString.length() == 0) {  
  14.         return (true);  
  15.     }  
  16.     if (queryString.startsWith("&")) {  
  17.         return (true);  
  18.     }  
  19.     if (!queryString.startsWith("=")) {  
  20.         return (false);  
  21.     }  
  22.     int limit = queryString.length();  
  23.     int ampersand = queryString.indexOf("&");  
  24.     if (ampersand > 0) {  
  25.         limit = ampersand;  
  26.     }  
  27.     String value = queryString.substring(1, limit);  
  28.     // 如果jsp_precompile的值为true，代表此次请求为预编译JSP的请求。  
  29.     if (value.equals("true")) {  
  30.         return (true);  
  31.     } else if (value.equals("false")) {  
  32.         // 这里要注意下，如果是false，同样是返回true的。  
  33.         // 因为规范中说如果这个参数是false，那么请求不应该被提交到JSP页面的，那么此次请求就变得毫无意义了，所以索性都预编译好了。  
  34.         return (true);  
  35.     } else {// 如果是true和false之外的值就要抛出异常了。  
  36.         throw new ServletException("Cannot have request parameter " + Constants.PRECOMPILE  
  37.                 + " set to " + value);  
  38.     }  
  39. }  

从这个方法中看出，要想预编译一个页面，只要在页面名字后加上查询字符串jsp_precompile=true就可以了。 

下面是#serviceJspFile()方法，这个方法提供对请求进行了进一步的处理。 

Java代码  收藏代码
  1. private void serviceJspFile(HttpServletRequest request, HttpServletResponse response,  
  2.         String jspUri, Throwable exception, boolean precompile) throws ServletException,  
  3.         IOException {  
  4.     // 获取JspServletWrapper实例  
  5.     JspServletWrapper wrapper = (JspServletWrapper) rctxt.getWrapper(jspUri);  
  6.     if (wrapper == null) {  
  7.         synchronized (this) {  
  8.             wrapper = (JspServletWrapper) rctxt.getWrapper(jspUri);  
  9.             if (wrapper == null) {  
  10.                 if (null == context.getResource(jspUri)) {  
  11.                     String includeRequestUri = (String) request  
  12.                             .getAttribute("javax.servlet.include.request_uri");  
  13.                     if (includeRequestUri != null) {  
  14.                         String msg = Localizer.getMessage("jsp.error.file.not.found", jspUri);  
  15.                         throw new ServletException(SecurityUtil.filter(msg));  
  16.                     } else {  
  17.                         try {  
  18.                             response.sendError(HttpServletResponse.SC_NOT_FOUND, request  
  19.                                     .getRequestURI());  
  20.                         } catch (IllegalStateException ise) {  
  21.                             log.error(Localizer.getMessage("jsp.error.file.not.found", jspUri));  
  22.                         }  
  23.                     }  
  24.                     return;  
  25.                 }  
  26.                 boolean isErrorPage = exception != null;  
  27.                 wrapper = new JspServletWrapper(config, options, jspUri, isErrorPage, rctxt);  
  28.                 rctxt.addWrapper(jspUri, wrapper);  
  29.             }  
  30.         }  
  31.     }  
  32.       
  33.     // 调用它的#service()方法。  
  34.     wrapper.service(request, response, precompile);  
  35.   
  36. }  

org.apache.jasper.servlet.JspServletWrapper的service()方法包括了编译，载入和执行Servlet几个步骤，如下所示： 

Java代码  收藏代码
  1. public void service(HttpServletRequest request, HttpServletResponse response, boolean precompile)  
  2.         throws ServletException, IOException, FileNotFoundException {  
  3.   
  4.     try {  
  5.         if (ctxt.isRemoved()) {  
  6.             throw new FileNotFoundException(jspUri);  
  7.         }  
  8.   
  9.         if ((available > 0L) && (available < Long.MAX_VALUE)) {  
  10.             if (available > System.currentTimeMillis()) {  
  11.                 response.setDateHeader("Retry-After", available);  
  12.                 response.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE, Localizer  
  13.                         .getMessage("jsp.error.unavailable"));  
  14.                 return;  
  15.             } else {  
  16.                 // Wait period has expired. Reset.  
  17.                 available = 0;  
  18.             }  
  19.         }  
  20.   
  21.         // (1) 编译  
  22.         if (options.getDevelopment() || firstTime) {  
  23.             synchronized (this) {  
  24.                 firstTime = false;  
  25.   
  26.                 // The following sets reload to true, if necessary  
  27.                 ctxt.compile();  
  28.             }  
  29.         } else {  
  30.             if (compileException != null) {  
  31.                 // Throw cached compilation exception  
  32.                 throw compileException;  
  33.             }  
  34.         }  
  35.   
  36.         // (2) 载入Servlet类文件  
  37.         getServlet();  
  38.   
  39.         // 如果是预编译，那么直接返回  
  40.         if (precompile) {  
  41.             return;  
  42.         }  
  43.   
  44.     } catch (ServletException ex) {  
  45.         if (options.getDevelopment()) {  
  46.             throw handleJspException(ex);  
  47.         } else {  
  48.             throw ex;  
  49.         }  
  50.     } catch (IOException ex) {  
  51.         if (options.getDevelopment()) {  
  52.             throw handleJspException(ex);  
  53.         } else {  
  54.             throw ex;  
  55.         }  
  56.     } catch (IllegalStateException ex) {  
  57.         if (options.getDevelopment()) {  
  58.             throw handleJspException(ex);  
  59.         } else {  
  60.             throw ex;  
  61.         }  
  62.     } catch (Exception ex) {  
  63.         if (options.getDevelopment()) {  
  64.             throw handleJspException(ex);  
  65.         } else {  
  66.             throw new JasperException(ex);  
  67.         }  
  68.     }  
  69.   
  70.     try {  
  71.   
  72.         // (3) 调用Servlet处理请求  
  73.         if (theServlet instanceof SingleThreadModel) {  
  74.             synchronized (this) {  
  75.                 theServlet.service(request, response);  
  76.             }  
  77.         } else {  
  78.             theServlet.service(request, response);  
  79.         }  
  80.   
  81.     } catch (UnavailableException ex) {  
  82.         String includeRequestUri = (String) request  
  83.                 .getAttribute("javax.servlet.include.request_uri");  
  84.         if (includeRequestUri != null) {  
  85.             throw ex;  
  86.         } else {  
  87.             int unavailableSeconds = ex.getUnavailableSeconds();  
  88.             if (unavailableSeconds <= 0) {  
  89.                 unavailableSeconds = 60; // Arbitrary default  
  90.             }  
  91.             available = System.currentTimeMillis() + (unavailableSeconds * 1000L);  
  92.             response.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE, ex.getMessage());  
  93.         }  
  94.     } catch (ServletException ex) {  
  95.         if (options.getDevelopment()) {  
  96.             throw handleJspException(ex);  
  97.         } else {  
  98.             throw ex;  
  99.         }  
  100.     } catch (IOException ex) {  
  101.         if (options.getDevelopment()) {  
  102.             throw handleJspException(ex);  
  103.         } else {  
  104.             throw ex;  
  105.         }  
  106.     } catch (IllegalStateException ex) {  
  107.         if (options.getDevelopment()) {  
  108.             throw handleJspException(ex);  
  109.         } else {  
  110.             throw ex;  
  111.         }  
  112.     } catch (Exception ex) {  
  113.         if (options.getDevelopment()) {  
  114.             throw handleJspException(ex);  
  115.         } else {  
  116.             throw new JasperException(ex);  
  117.         }  
  118.     }  
  119. }  

#compile()方法实现了对JSP文件向java类(Servlet)的编译，源代码如下所示： 

Java代码  收藏代码
  1. public void compile() throws JasperException, FileNotFoundException {  
  2.     // 创建"jspCompiler"的实例  
  3.     createCompiler();  
  4.     // 判断是否过期，即是否需要重新编译，这个方法中主要用源代码和编译后的文件的修改时间等因素进行判断  
  5.     if (jspCompiler.isOutDated()) {  
  6.         try {  
  7.             jspCompiler.removeGeneratedFiles();  
  8.             jspLoader = null;  
  9.             // 执行编译  
  10.             jspCompiler.compile();  
  11.             // 设定reload标志为true，让#getServlet()方法载入新的类  
  12.             jsw.setReload(true);  
  13.             jsw.setCompilationException(null);  
  14.         } catch (JasperException ex) {  
  15.             // Cache compilation exception  
  16.             jsw.setCompilationException(ex);  
  17.             throw ex;  
  18.         } catch (Exception ex) {  
  19.             JasperException je = new JasperException(  
  20.                         Localizer.getMessage("jsp.error.unable.compile"),  
  21.                         ex);  
  22.             // Cache compilation exception  
  23.             jsw.setCompilationException(je);  
  24.             throw je;  
  25.         }  
  26.     }  
  27. }  

可以看出，JSP页面没有修改的前提下Tomcat是不会对JSP进行多次编译的，只在第一次调用它的时候编译。 

看完#compile()后，再来看一下#getServlet()，它载入了前面编译生成的Servlet类。 

Java代码  收藏代码
  1. public Servlet getServlet() throws ServletException, IOException, FileNotFoundException {  
  2.     if (reload) {  
  3.         synchronized (this) {  
  4.             if (reload) {  
  5.                 // 销毁旧的Servlet  
  6.                 destroy();  
  7.   
  8.                 Servlet servlet = null;  
  9.   
  10.                 try {  
  11.                     // 载入Servlet  
  12.                     servletClass = ctxt.load();  
  13.                     servlet = (Servlet) servletClass.newInstance();  
  14.                     AnnotationProcessor annotationProcessor = (AnnotationProcessor) config  
  15.                             .getServletContext().getAttribute(  
  16.                                     AnnotationProcessor.class.getName());  
  17.                     if (annotationProcessor != null) {  
  18.                         annotationProcessor.processAnnotations(servlet);  
  19.                         annotationProcessor.postConstruct(servlet);  
  20.                     }  
  21.                 } catch (IllegalAccessException e) {  
  22.                     throw new JasperException(e);  
  23.                 } catch (InstantiationException e) {  
  24.                     throw new JasperException(e);  
  25.                 } catch (Exception e) {  
  26.                     throw new JasperException(e);  
  27.                 }  
  28.                 // Servlet初始化  
  29.                 servlet.init(config);  
  30.   
  31.                 if (!firstTime) {  
  32.                     ctxt.getRuntimeContext().incrementJspReloadCount();  
  33.                 }  
  34.   
  35.                 theServlet = servlet;  
  36.                 // reload值复原  
  37.                 reload = false;  
  38.             }  
  39.         }  
  40.     }  
  41.     return theServlet;  
  42. }  

通过这个类，获得了一个"theServlet"实例作为JSP编译之后的Servlet引用，并且在JSP没有改动前，这个实例是不需要重新生成的。 

通过这两个步骤后，最后调用了JSP编译后的Servlet类的#service()方法去处理请求。至此，Tomcat的请求处理结束了。
0 0
好看的网络自制剧古装 好看的网络自制剧古装
原创粉丝点击
热门IT博客
2015双十一淘宝交易量2015双十一淘宝交易量
eclipse java模板修改eclipse java模板修改
社交网络用户影响力
淘宝评价图片怎么上传
网络协议原理实验报告
als矩阵
大闹骑兵进阶数据
android抓取网页数据
适合大学生的淘宝店铺
一台电脑双网络
淘宝买大麻暗语2016
linux中cat
千牛官网mac版
linux vim 保存文件
赵薇同款背带裤淘宝网
鹊桥和淘宝客的区别
淘宝产品授权书模板
淘宝客赚钱流程
什么是网络流行文化
淘宝买知网账号靠谱吗
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 电视机品牌排行榜 油烟机品牌排行榜 手表品牌欧米茄 鱼竿品牌排行榜 整体衣柜品牌 奢侈品牌logo大全 自行车品牌排行 大众旗下品牌 床垫品牌排行 男士手表品牌欧米茄 洗发水品牌排行榜 音响品牌排行榜 奢侈手表品牌欧米茄 高端手表品牌欧米茄 皮鞋品牌排行 尿不湿品牌排行榜 少儿英语品牌玛玛洛可 中国知名品牌 运动品牌大全 国产运动品牌排行 运动衣服品牌 运动品牌排行 运动品牌logo大全 鞋子品牌排行 运动品牌标志 运动品牌排名 鞋品牌排行榜 国外运动品牌 中国运动品牌 运动休闲品牌 韩国运动品牌 国外运动品牌logo大全 运动装备品牌 世界运动鞋品牌排行 中国运动品牌排行榜 运动服装品牌 体育品牌排行榜 运动女装品牌 国际运动品牌 全球运动品牌排行 运动鞋品牌排行

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里