碼上快樂

相關內容    簡體    繁體

response重定向底層原理

本文轉載自   查看原文   2017-11-16 17:36   2077 

 來自：

http://jiayanjujyj.iteye.com/blog/1028914

 

網上已經有很多關於redirect和forward區別的文章，更多的都是只是一些概念上的描述，雖然在大多情況下，知道這些就已經足夠了。但也有例外：forward not working for struts2，why？我也是在工作中碰到了這個問題，才特意看了下tomcat有關這部分的源代碼。深刻的了解下也無妨。 
redirect和forward都是屬於servlet規范的，不同的servlet容器的實現可能會有一些區別，但原理都是類似的。 

redirect和forward的定義： 
1. redirect（重定向）：服務端發送給客戶端一個重定向的臨時響應頭，這個響應頭包含重定向之后的URL，客戶端用新的URL重新向服務器發送一個請求。 
2. forward（請求轉向）：服務器程序內部請求轉向，這個特性允許前一個程序用於處理請求，而后一個程序用來返回響應。 

Redirect的原理比較簡單，它的定義也已經描述的很清楚了，我也不想多講什么，就貼一段簡單的代碼吧！ 

org.apache.catalina.connector.Response#sendRedirect(String)： 
  

Java代碼   收藏代碼
  1.  public void sendRedirect(String location)   
  2.         throws IOException {  
  3.   
  4.         if (isCommitted())  
  5.             throw new IllegalStateException  
  6.                 (sm.getString("coyoteResponse.sendRedirect.ise"));  
  7.   
  8.         // Ignore any call from an included servlet  
  9.         if (included)  
  10.             return;   
  11.   
  12.         // Clear any data content that has been buffered  
  13.         resetBuffer();  
  14.   
  15.         // Generate a temporary redirect to the specified location  
  16.         try {  
  17.             String absolute = toAbsolute(location);  
  18.             setStatus(SC_FOUND);  
  19.             setHeader("Location", absolute);  
  20.         } catch (IllegalArgumentException e) {  
  21.             setStatus(SC_NOT_FOUND);  
  22.         }  
  23.   
  24.         // Cause the response to be finished (from the application perspective)  
  25.         setSuspended(true);  
  26. }  


方法行為：先把相對路徑轉換成絕對路徑，再包裝一個包含有新的URL的臨時響應頭，“SC_FOUND”的值是302，就是重定向臨時響應頭的狀態碼。如果傳入的“location”值不合法，就包裝一個404的響應頭。 

下面就來看看tomcat是如何實現forward的，forward為什么在struts2下會無效(注解：其實是可以設置的)。 

先看下程序是如何調用forward的： 

Java代碼   收藏代碼
  1. req.getRequestDispatcher("testForward").forward(req, resp);  


整個過程分兩個步驟來執行 
1. 得到一個請求調度器 
2. 通過調度器把請求轉發過去。 


第一步驟，獲取請求調度器。 
org.apache.catalina.connector.Request#getRequestDispatcher(String) 

Java代碼   收藏代碼
  1.       
  2. public RequestDispatcher getRequestDispatcher(String path) {  
  3.   
  4.         if (request == null) {  
  5.             throw new IllegalStateException(  
  6.                             sm.getString("requestFacade.nullRequest"));  
  7.         }  
  8.   
  9.         if (Globals.IS_SECURITY_ENABLED){  
  10.             return (RequestDispatcher)AccessController.doPrivileged(  
  11.                 new GetRequestDispatcherPrivilegedAction(path));  
  12.         } else {  
  13.              return request.getRequestDispatcher(path);    
  14.         }  


方法行為：把獲取RequestDispatcher的任務交個內部的request。它們之間的關系如下所示 

 


org.apache.catalina.connector.RequestFacade和類org.apache.catalina.connector.Request都是實現了javax.servlet.http.HttpServletRequest接口，而RequestFacade內部有包裝了個Request，對Request的訪問做了些控制，應該是代理模式 

org.apache.catalina.connector.Request#getRequestDispatcher(String) 

Java代碼   收藏代碼
  1. public RequestDispatcher getRequestDispatcher(String path) {  
  2.          if (path.startsWith("/"))  
  3.            return (context.getServletContext().getRequestDispatcher(path));  
  4.   
  5.        //省略了部分代碼  
  6.        return (context.getServletContext().getRequestDispatcher(relative));   
  7.   
  8.    }  


方法行為：把絕對路徑轉換成相對路徑，最終的格式如“/testForward”。若已經是這種格式的相對路徑，就無需再轉換了。 
接下來就轉交給ServletContext來處理，ServletContext是web項目的一個上下文，包含所有的Servlet集合，還定義了一些Servlet與容器之間交互的接口。 
org.apache.catalina.core.ApplicationContext#getRequestDispatcher(String) 

Java代碼   收藏代碼
  1. public RequestDispatcher getRequestDispatcher(String path) {  
  2.           //省去部分代碼  
  3.           context.getMapper().map(uriMB, mappingData);  
  4.           //省去部分代碼  
  5.       Wrapper wrapper = (Wrapper) mappingData.wrapper;  
  6.       String wrapperPath = mappingData.wrapperPath.toString();  
  7.       String pathInfo = mappingData.pathInfo.toString();  
  8.   
  9.       mappingData.recycle();  
  10.         
  11.       // Construct a RequestDispatcher to process this request  
  12.       return new ApplicationDispatcher  
  13.           (wrapper, uriCC.toString(), wrapperPath, pathInfo,   
  14.            queryString, null);   
  15.   }  


方法行為：根據路徑名“path”找到一個包含有Servlet的Wrapper，最后實例化一個ApplicationDispatcher，並且返回該ApplicationDispatcher。 

該方法里非常關鍵的一行：context.getMapper().map(uriMB, mappingData)。 
Mapper的類定義我不知道如何描述，就貼上原文吧：Mapper, which implements the servlet API mapping rules (which are derived from the HTTP rules)。 
不過只想了解forward的原理，熟悉map函數就夠了。 

org.apache.tomcat.util.http.mapper.Mapper#map(org.apache.tomcat.util.buf.MessageBytes, org.apache.tomcat.util.http.mapper.MappingData)： 

Java代碼   收藏代碼
  1. public void map(MessageBytes uri, MappingData mappingData)  
  2.     throws Exception {  
  3.   
  4.     uri.toChars();  
  5.     CharChunk uricc = uri.getCharChunk();  
  6.     uricc.setLimit(-1);  
  7.     internalMapWrapper(context, uricc, mappingData);  
  8.   
  9. }  


方法行為：。。。。。。。就介紹下參數吧，uri可以理解是path(“/testforward”)的一個變形,而mappingData用於存儲當前線程用到的部分數據。該函數是沒有返回值的，處理之后的結果就是存放到mappingData里的。 

org.apache.tomcat.util.http.mapper.Mapper#internalMapWrapper(Mapper$Context,org.apache.tomcat.util.buf.CharChunk, org.apache.tomcat.util.http.mapper.MappingData)： 

Java代碼   收藏代碼
  1. private final void internalMapWrapper(Context context, CharChunk path,  
  2.                                          MappingData mappingData)  
  3.        throws Exception {  
  4.   
  5.        int pathOffset = path.getOffset();  
  6.        int pathEnd = path.getEnd();  
  7.        int servletPath = pathOffset;  
  8.        boolean noServletPath = false;  
  9.   
  10.        int length = context.name.length();  
  11.        if (length != (pathEnd - pathOffset)) {  
  12.            servletPath = pathOffset + length;  
  13.        } else {  
  14.            noServletPath = true;  
  15.            path.append('/');  
  16.            pathOffset = path.getOffset();  
  17.            pathEnd = path.getEnd();  
  18.            servletPath = pathOffset+length;  
  19.        }  
  20.   
  21.        path.setOffset(servletPath);  
  22.   
  23.        // Rule 1 -- Exact Match  
  24.        Wrapper[] exactWrappers = context.exactWrappers;  
  25.        internalMapExactWrapper(exactWrappers, path, mappingData);  
  26.   
  27.        // Rule 2 -- Prefix Match  
  28.        boolean checkJspWelcomeFiles = false;  
  29.        Wrapper[] wildcardWrappers = context.wildcardWrappers;  
  30.        if (mappingData.wrapper == null) {  
  31.            internalMapWildcardWrapper(wildcardWrappers, context.nesting,   
  32.                                       path, mappingData);  
  33.            if (mappingData.wrapper != null && mappingData.jspWildCard) {  
  34.                char[] buf = path.getBuffer();  
  35.                if (buf[pathEnd - 1] == '/') {  
  36.                    /* 
  37.                     * Path ending in '/' was mapped to JSP servlet based on 
  38.                     * wildcard match (e.g., as specified in url-pattern of a 
  39.                     * jsp-property-group. 
  40.                     * Force the context's welcome files, which are interpreted 
  41.                     * as JSP files (since they match the url-pattern), to be 
  42.                     * considered. See Bugzilla 27664. 
  43.                     */   
  44.                    mappingData.wrapper = null;  
  45.                    checkJspWelcomeFiles = true;  
  46.                } else {  
  47.                    // See Bugzilla 27704  
  48.                    mappingData.wrapperPath.setChars(buf, path.getStart(),  
  49.                                                     path.getLength());  
  50.                    mappingData.pathInfo.recycle();  
  51.                }  
  52.            }  
  53.        }  
  54.   
  55.        if(mappingData.wrapper == null && noServletPath) {  
  56.            // The path is empty, redirect to "/"  
  57.            mappingData.redirectPath.setChars  
  58.                (path.getBuffer(), pathOffset, pathEnd);  
  59.            path.setEnd(pathEnd - 1);  
  60.            return;  
  61.        }  
  62.   
  63.        // Rule 3 -- Extension Match  
  64.        Wrapper[] extensionWrappers = context.extensionWrappers;  
  65.        if (mappingData.wrapper == null && !checkJspWelcomeFiles) {  
  66.            internalMapExtensionWrapper(extensionWrappers, path, mappingData);  
  67.        }  
  68.   
  69.        // Rule 4 -- Welcome resources processing for servlets  
  70.        if (mappingData.wrapper == null) {  
  71.            boolean checkWelcomeFiles = checkJspWelcomeFiles;  
  72.            if (!checkWelcomeFiles) {  
  73.                char[] buf = path.getBuffer();  
  74.                checkWelcomeFiles = (buf[pathEnd - 1] == '/');  
  75.            }  
  76.            if (checkWelcomeFiles) {  
  77.                for (int i = 0; (i < context.welcomeResources.length)  
  78.                         && (mappingData.wrapper == null); i++) {  
  79.                    path.setOffset(pathOffset);  
  80.                    path.setEnd(pathEnd);  
  81.                    path.append(context.welcomeResources[i], 0,  
  82.                                context.welcomeResources[i].length());  
  83.                    path.setOffset(servletPath);  
  84.   
  85.                    // Rule 4a -- Welcome resources processing for exact macth  
  86.                    internalMapExactWrapper(exactWrappers, path, mappingData);  
  87.   
  88.                    // Rule 4b -- Welcome resources processing for prefix match  
  89.                    if (mappingData.wrapper == null) {  
  90.                        internalMapWildcardWrapper  
  91.                            (wildcardWrappers, context.nesting,   
  92.                             path, mappingData);  
  93.                    }  
  94.   
  95.                    // Rule 4c -- Welcome resources processing  
  96.                    //            for physical folder  
  97.                    if (mappingData.wrapper == null  
  98.                        && context.resources != null) {  
  99.                        Object file = null;  
  100.                        String pathStr = path.toString();  
  101.                        try {  
  102.                            file = context.resources.lookup(pathStr);  
  103.                        } catch(NamingException nex) {  
  104.                            // Swallow not found, since this is normal  
  105.                        }  
  106.                        if (file != null && !(file instanceof DirContext) ) {  
  107.                            internalMapExtensionWrapper(extensionWrappers,  
  108.                                                        path, mappingData);  
  109.                            if (mappingData.wrapper == null  
  110.                                && context.defaultWrapper != null) {  
  111.                                mappingData.wrapper =  
  112.                                    context.defaultWrapper.object;  
  113.                                mappingData.requestPath.setChars  
  114.                                    (path.getBuffer(), path.getStart(),   
  115.                                     path.getLength());  
  116.                                mappingData.wrapperPath.setChars  
  117.                                    (path.getBuffer(), path.getStart(),   
  118.                                     path.getLength());  
  119.                                mappingData.requestPath.setString(pathStr);  
  120.                                mappingData.wrapperPath.setString(pathStr);  
  121.                            }  
  122.                        }  
  123.                    }  
  124.                }  
  125.   
  126.                path.setOffset(servletPath);  
  127.                path.setEnd(pathEnd);  
  128.            }  
  129.                                          
  130.        }  


方法行為：通過“path”從“context”里找到對應的Servlet，存放到“mappingData”里。 
可以看到這里有7個匹配Servlet規則： 
1. Rule 1 -- Exact Match:精確匹配，匹配web.xml配置的格式如“<url-pattern>/testQiu</url-pattern>”的Servlet 
2. Rule 2 -- Prefix Matcha:前綴匹配，匹配的Servlet格式如“<url-pattern>/testQiu/*</url-pattern>” 
3. Rule 3 -- Extension Match:擴展匹配，匹配jsp或者jspx 
4. ---Rule 4a -- Welcome resources processing for exact macth: 
5. ---Rule 4b -- Welcome resources processing for prefix match: 
6. ---Rule 4c -- Welcome resources processing for physical folder: 
7. Rule 7 --如果前面6條都沒匹配到，那就返回org.apache.catalina.servlets.DefaultServlet。 

其實這里真正的匹配的是Wapper，而不是Servlet，因為Wapper最重要的一個屬性就是Servlet，說成“匹配Servlet”是為了更容易的表達。 

至此返回RequestDispatcher就結束了。 



接下來就是講解RequestDispatcher.forward了。Forward的就不貼出全部的源代碼，只貼一些重要的片段，絕大部分的邏輯都在org.apache.catalina.core.ApplicationDispatcher類里。 
先描述下過程： 
1. 設置request里的部分屬性值，如：請求的路徑、參數等。 
2. 組裝一個FilterChain鏈，調用doFilter方法。 
3. 最后根據實際情況調用Filter的doFilter函數或者Servlet的service函數。 

注：FilterChain和Filter是兩個不同的接口，兩個接口的UML 

 

org.apache.catalina.core.ApplicationDispatcher#doForward(ServletRequest,ServletResponse)： 

Java代碼   收藏代碼
  1. private void doForward(ServletRequest request, ServletResponse response)  
  2.         throws ServletException, IOException  
  3.          //省略了部分代碼  
  4.         // Handle an HTTP named dispatcher forward  
  5.         if ((servletPath == null) && (pathInfo == null)) {  
  6. //省略了部分代碼  
  7.         } else {// Handle an HTTP path-based forward  
  8.             ApplicationHttpRequest wrequest =  
  9.                 (ApplicationHttpRequest) wrapRequest(state);  
  10.             String contextPath = context.getPath();  
  11.             HttpServletRequest hrequest = state.hrequest;  
  12.             if (hrequest.getAttribute(Globals.FORWARD_REQUEST_URI_ATTR) == null) {  
  13.                 wrequest.setAttribute(Globals.FORWARD_REQUEST_URI_ATTR,  
  14.                                       hrequest.getRequestURI());  
  15.                 wrequest.setAttribute(Globals.FORWARD_CONTEXT_PATH_ATTR,  
  16.                                       hrequest.getContextPath());  
  17.                 wrequest.setAttribute(Globals.FORWARD_SERVLET_PATH_ATTR,  
  18.                                       hrequest.getServletPath());  
  19.                 wrequest.setAttribute(Globals.FORWARD_PATH_INFO_ATTR,  
  20.                                       hrequest.getPathInfo());  
  21.                 wrequest.setAttribute(Globals.FORWARD_QUERY_STRING_ATTR,  
  22.                                       hrequest.getQueryString());  
  23.             }  
  24.    
  25.             wrequest.setContextPath(contextPath);  
  26.             wrequest.setRequestURI(requestURI);  
  27.             wrequest.setServletPath(servletPath);  
  28.             wrequest.setPathInfo(pathInfo);  
  29.             if (queryString != null) {  
  30.                 wrequest.setQueryString(queryString);  
  31.                 wrequest.setQueryParams(queryString);  
  32.             }  
  33.   
  34.             processRequest(request,response,state);  
  35.         }  
  36.         }  
  37. //省略了部分代碼  
  38.     }  


第1步：設置新的request的屬性： 
         

Java代碼   收藏代碼
  1. wrequest.setContextPath(contextPath);  
  2.           wrequest.setRequestURI(requestURI);  
  3.           wrequest.setServletPath(servletPath);  
  4.           wrequest.setPathInfo(pathInfo);  
  5.           if (queryString != null) {  
  6.               wrequest.setQueryString(queryString);  
  7.               wrequest.setQueryParams(queryString);  
  8.           }  




第2步：組裝FitlerChain鏈，根據web.xml配置信息，是否決定添加Filter---- 
<filter-mapping> 
<filter-name>struts2</filter-name> 
<url-pattern>/*</url-pattern> 
<dispatcher>REQUEST</dispatcher> 
</filter-mapping> 


org.apache.catalina.core.ApplicationFilterFactory#createFilterChain(ServletRequest, Wrapper, Servlet)： 

Java代碼   收藏代碼
  1. public ApplicationFilterChain createFilterChain(ServletRequest request, Wrapper wrapper, Servlet servlet) {  
  2.         //省略部分代碼  
  3.             filterChain = new ApplicationFilterChain();  
  4.         }  
  5.   
  6.         filterChain.setServlet(servlet);  
  7.   
  8.         filterChain.setSupport  
  9.             (((StandardWrapper)wrapper).getInstanceSupport());  
  10.   
  11.         // Acquire the filter mappings for this Context  
  12.         StandardContext context = (StandardContext) wrapper.getParent();  
  13.         FilterMap filterMaps[] = context.findFilterMaps();  
  14.   
  15.         // If there are no filter mappings, we are done  
  16.         if ((filterMaps == null) || (filterMaps.length == 0))  
  17.             return (filterChain);  
  18.   
  19.         // Acquire the information we will need to match filter mappings  
  20.         String servletName = wrapper.getName();  
  21.   
  22.         // Add the relevant path-mapped filters to this filter chain  
  23.         for (int i = 0; i < filterMaps.length; i++) {  
  24.             if (!matchDispatcher(filterMaps[i] ,dispatcher)) {  
  25.                 continue;  
  26.             }  
  27.             if (!matchFiltersURL(filterMaps[i], requestPath))  
  28.                 continue;  
  29.             ApplicationFilterConfig filterConfig = (ApplicationFilterConfig)  
  30.                 context.findFilterConfig(filterMaps[i].getFilterName());  
  31.             if (filterConfig == null) {  
  32.                 ;       // FIXME - log configuration problem  
  33.                 continue;  
  34.             }  
  35.             boolean isCometFilter = false;  
  36.             if (comet) {  
  37.                 try {  
  38.                     isCometFilter = filterConfig.getFilter() instanceof CometFilter;  
  39.                 } catch (Exception e) {  
  40.                     // Note: The try catch is there because getFilter has a lot of   
  41.                     // declared exceptions. However, the filter is allocated much  
  42.                     // earlier  
  43.                 }  
  44.                 if (isCometFilter) {  
  45.                     filterChain.addFilter(filterConfig);  
  46.                 }  
  47.             } else {  
  48.                 filterChain.addFilter(filterConfig);  
  49.             }  
  50.         }  
  51.   
  52.        //省略部分代碼  
  53.   
  54.         // Return the completed filter chain  
  55.         return (filterChain);  
  56.   
  57. }  




如果是<dispatcher>REQUEST</dispatcher>，那就不添加Filter，默認設置是REQUEST 
如果是<dispatcher>FORWARD</dispatcher>，添加Filter到FilterChain。 

第3步：調用doFilter或者service,代碼刪減了很多。 

org.apache.catalina.core.ApplicationFilterChain#doFilter(ServletRequest, ServletResponse)： 

Java代碼   收藏代碼
  1.   public void doFilter(ServletRequest request, ServletResponse response)throws IOException, ServletException {  
  2.             internalDoFilter(request,response);  
  3.   }  
  4.   
  5.   
  6. org.apache.catalina.core.ApplicationFilterChain#internalDoFilter(ServletRequest, ServletResponse)  
  7. private void internalDoFilter(ServletRequest request,   
  8.                                   ServletResponse response)  
  9.         throws IOException, ServletException {  
  10.   
  11.         // Call the next filter if there is one  
  12.         if (pos < n) {  
  13.                     filter.doFilter(request, response, this);  
  14.             return;  
  15.         }  
  16.        servlet.service((HttpServletRequest) request,(HttpServletResponse) response);              
  17. }  






如果我對Filter非常了解的，根本就不需要花那么多時間去查看tomcat源代碼。只要在web.xml增加一點配置就OK了。 

Java代碼   收藏代碼
    1. <filter-mapping>  
    2.         <filter-name>struts2</filter-name>  
    3.         <url-pattern>/*</url-pattern>  
    4.         <dispatcher>REQUEST</dispatcher>  
    5.         <dispatcher>FORWARD</dispatcher>  
    6. </filter-mapping>  


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 重定向底層實現原理 httpclient response 重定向 response重定向與request轉發 response對象、轉發、重定向 Response重定向實現參數隱藏 response請求轉發和重定向，cookie Java Response URL 重定向的 Cookie 問題 JavaWeb案例：使用response實現重定向 關於request、response轉發與重定向的簡述 Response——下載文件、重定向
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM