`

tomcat源码—redirect和forward的实现

TomcatServletJSPApacheSecurity 
阅读更多

网上已经有很多关于redirect和forward区别的文章，更多的都是只是一些概念上的描述，虽然在大多情况下，知道这些就已经足够了。但也有例外：forward not working for struts2，why？我也是在工作中碰到了这个问题，才特意看了下tomcat有关这部分的源代码。深刻的了解下也无妨。
redirect和forward都是属于servlet规范的，不同的servlet容器的实现可能会有一些区别，但原理都是类似的。

redirect和forward的定义：
1. redirect（重定向）：服务端发送给客户端一个重定向的临时响应头，这个响应头包含重定向之后的URL，客户端用新的URL重新向服务器发送一个请求。
2. forward（请求转向）：服务器程序内部请求转向，这个特性允许前一个程序用于处理请求，而后一个程序用来返回响应。

Redirect的原理比较简单，它的定义也已经描述的很清楚了，我也不想多讲什么，就贴一段简单的代码吧！

  

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. }  
 public void sendRedirect(String location) 
        throws IOException {

        if (isCommitted())
            throw new IllegalStateException
                (sm.getString("coyoteResponse.sendRedirect.ise"));

        // Ignore any call from an included servlet
        if (included)
            return; 

        // Clear any data content that has been buffered
        resetBuffer();

        // Generate a temporary redirect to the specified location
        try {
            String absolute = toAbsolute(location);
            setStatus(SC_FOUND);
            setHeader("Location", absolute);
        } catch (IllegalArgumentException e) {
            setStatus(SC_NOT_FOUND);
        }

        // Cause the response to be finished (from the application perspective)
        setSuspended(true);
}


方法行为：先把相对路径转换成绝对路径，再包装一个包含有新的URL的临时响应头，“SC_FOUND”的值是302，就是重定向临时响应头的状态码。如果传入的“location”值不合法，就包装一个404的响应头。

下面就来看看tomcat是如何实现forward的，forward为什么在struts2下会无效(注解：其实是可以设置的)。

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

Java代码 复制代码
  1. req.getRequestDispatcher("testForward").forward(req, resp);  
req.getRequestDispatcher("testForward").forward(req, resp);


整个过程分两个步骤来执行
1. 得到一个请求调度器
2. 通过调度器把请求转发过去。


第一步骤，获取请求调度器。

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.         }  
    
public RequestDispatcher getRequestDispatcher(String path) {

        if (request == null) {
            throw new IllegalStateException(
                            sm.getString("requestFacade.nullRequest"));
        }

        if (Globals.IS_SECURITY_ENABLED){
            return (RequestDispatcher)AccessController.doPrivileged(
                new GetRequestDispatcherPrivilegedAction(path));
        } else {
             return request.getRequestDispatcher(path);  
        }


方法行为：把获取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

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.    }  
 public RequestDispatcher getRequestDispatcher(String path) {
          if (path.startsWith("/"))
            return (context.getServletContext().getRequestDispatcher(path));

        //省略了部分代码
        return (context.getServletContext().getRequestDispatcher(relative)); 

    }


方法行为：把绝对路径转换成相对路径，最终的格式如“/testForward”。若已经是这种格式的相对路径，就无需再转换了。


最终转交给ServletContext来处理，ServletContext是web项目的一个上下文，包含所有的Servlet的集合，还定义了一些Servlet和容器之间交互的接口。

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.   }  
  public RequestDispatcher getRequestDispatcher(String path) {
            //省去部分代码
            context.getMapper().map(uriMB, mappingData);
            //省去部分代码
        Wrapper wrapper = (Wrapper) mappingData.wrapper;
        String wrapperPath = mappingData.wrapperPath.toString();
        String pathInfo = mappingData.pathInfo.toString();

        mappingData.recycle();
        
        // Construct a RequestDispatcher to process this request
        return new ApplicationDispatcher
            (wrapper, uriCC.toString(), wrapperPath, pathInfo, 
             queryString, null); 
    }


方法行为：根据路径名“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函数就够了。

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. }  
    public void map(MessageBytes uri, MappingData mappingData)
        throws Exception {

        uri.toChars();
        CharChunk uricc = uri.getCharChunk();
        uricc.setLimit(-1);
        internalMapWrapper(context, uricc, mappingData);

    }


方法行为：。。。。。。。就介绍下参数吧，uri可以理解是path(“/testforward”)的一个变形,而mappingData用于存储当前线程用到的部分数据。该函数是没有返回值的，处理之后的结果就是存放到mappingData里的。

internalMapWrapper(context, uricc, 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.        }  
 private final void internalMapWrapper(Context context, CharChunk path,
                                          MappingData mappingData)
        throws Exception {

        int pathOffset = path.getOffset();
        int pathEnd = path.getEnd();
        int servletPath = pathOffset;
        boolean noServletPath = false;

        int length = context.name.length();
        if (length != (pathEnd - pathOffset)) {
            servletPath = pathOffset + length;
        } else {
            noServletPath = true;
            path.append('/');
            pathOffset = path.getOffset();
            pathEnd = path.getEnd();
            servletPath = pathOffset+length;
        }

        path.setOffset(servletPath);

        // Rule 1 -- Exact Match
        Wrapper[] exactWrappers = context.exactWrappers;
        internalMapExactWrapper(exactWrappers, path, mappingData);

        // Rule 2 -- Prefix Match
        boolean checkJspWelcomeFiles = false;
        Wrapper[] wildcardWrappers = context.wildcardWrappers;
        if (mappingData.wrapper == null) {
            internalMapWildcardWrapper(wildcardWrappers, context.nesting, 
                                       path, mappingData);
            if (mappingData.wrapper != null && mappingData.jspWildCard) {
                char[] buf = path.getBuffer();
                if (buf[pathEnd - 1] == '/') {
                    /*
                     * Path ending in '/' was mapped to JSP servlet based on
                     * wildcard match (e.g., as specified in url-pattern of a
                     * jsp-property-group.
                     * Force the context's welcome files, which are interpreted
                     * as JSP files (since they match the url-pattern), to be
                     * considered. See Bugzilla 27664.
                     */ 
                    mappingData.wrapper = null;
                    checkJspWelcomeFiles = true;
                } else {
                    // See Bugzilla 27704
                    mappingData.wrapperPath.setChars(buf, path.getStart(),
                                                     path.getLength());
                    mappingData.pathInfo.recycle();
                }
            }
        }

        if(mappingData.wrapper == null && noServletPath) {
            // The path is empty, redirect to "/"
            mappingData.redirectPath.setChars
                (path.getBuffer(), pathOffset, pathEnd);
            path.setEnd(pathEnd - 1);
            return;
        }

        // Rule 3 -- Extension Match
        Wrapper[] extensionWrappers = context.extensionWrappers;
        if (mappingData.wrapper == null && !checkJspWelcomeFiles) {
            internalMapExtensionWrapper(extensionWrappers, path, mappingData);
        }

        // Rule 4 -- Welcome resources processing for servlets
        if (mappingData.wrapper == null) {
            boolean checkWelcomeFiles = checkJspWelcomeFiles;
            if (!checkWelcomeFiles) {
                char[] buf = path.getBuffer();
                checkWelcomeFiles = (buf[pathEnd - 1] == '/');
            }
            if (checkWelcomeFiles) {
                for (int i = 0; (i < context.welcomeResources.length)
                         && (mappingData.wrapper == null); i++) {
                    path.setOffset(pathOffset);
                    path.setEnd(pathEnd);
                    path.append(context.welcomeResources[i], 0,
                                context.welcomeResources[i].length());
                    path.setOffset(servletPath);

                    // Rule 4a -- Welcome resources processing for exact macth
                    internalMapExactWrapper(exactWrappers, path, mappingData);

                    // Rule 4b -- Welcome resources processing for prefix match
                    if (mappingData.wrapper == null) {
                        internalMapWildcardWrapper
                            (wildcardWrappers, context.nesting, 
                             path, mappingData);
                    }

                    // Rule 4c -- Welcome resources processing
                    //            for physical folder
                    if (mappingData.wrapper == null
                        && context.resources != null) {
                        Object file = null;
                        String pathStr = path.toString();
                        try {
                            file = context.resources.lookup(pathStr);
                        } catch(NamingException nex) {
                            // Swallow not found, since this is normal
                        }
                        if (file != null && !(file instanceof DirContext) ) {
                            internalMapExtensionWrapper(extensionWrappers,
                                                        path, mappingData);
                            if (mappingData.wrapper == null
                                && context.defaultWrapper != null) {
                                mappingData.wrapper =
                                    context.defaultWrapper.object;
                                mappingData.requestPath.setChars
                                    (path.getBuffer(), path.getStart(), 
                                     path.getLength());
                                mappingData.wrapperPath.setChars
                                    (path.getBuffer(), path.getStart(), 
                                     path.getLength());
                                mappingData.requestPath.setString(pathStr);
                                mappingData.wrapperPath.setString(pathStr);
                            }
                        }
                    }
                }

                path.setOffset(servletPath);
                path.setEnd(pathEnd);
            }
                                        
        }


方法行为：通过“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是两个不同的接口，不要混淆在一起，请看两个接口的方法签名

javax.servlet.FilterChain：

Java代码 复制代码
  1. public interface FilterChain {   
  2.        
  3.     /**  
  4.     * Causes the next filter in the chain to be invoked, or if the calling filter is the last filter  
  5.     * in the chain, causes the resource at the end of the chain to be invoked.  
  6.     *  
  7.     * @param request the request to pass along the chain.  
  8.     * @param response the response to pass along the chain.  
  9.     *  
  10.     * @since 2.3  
  11.     */  
  12.        
  13.     public void doFilter ( ServletRequest request, ServletResponse response ) throws IOException, ServletException;   
  14. }  
public interface FilterChain {
	
	/**
	* Causes the next filter in the chain to be invoked, or if the calling filter is the last filter
	* in the chain, causes the resource at the end of the chain to be invoked.
	*
	* @param request the request to pass along the chain.
	* @param response the response to pass along the chain.
	*
	* @since 2.3
	*/
	
    public void doFilter ( ServletRequest request, ServletResponse response ) throws IOException, ServletException;
}



javax.servlet.Filter：

Java代码 复制代码
  1. public interface Filter {      
  2.     /**  
  3.     * The <code>doFilter</code> method of the Filter is called by the container  
  4.     * each time a request/response pair is passed through the chain due  
  5.     * to a client request for a resource at the end of the chain. The FilterChain passed in to this  
  6.     * method allows the Filter to pass on the request and response to the next entity in the  
  7.     * chain.<p>  
  8.     * A typical implementation of this method would follow the following pattern:- <br>  
  9.     * 1. Examine the request<br>  
  10.     * 2. Optionally wrap the request object with a custom implementation to  
  11.     * filter content or headers for input filtering <br>  
  12.     * 3. Optionally wrap the response object with a custom implementation to  
  13.     * filter content or headers for output filtering <br>  
  14.     * 4. a) <strong>Either</strong> invoke the next entity in the chain using the FilterChain object (<code>chain.doFilter()</code>), <br>     
  15.     ** 4. b) <strong>or</strong> not pass on the request/response pair to the next entity in the filter chain to block the request processing<br>  
  16.     ** 5. Directly set headers on the response after invocation of the next entity in the filter chain.  
  17.     **/  
  18.     public void doFilter ( ServletRequest request, ServletResponse response, FilterChain chain ) throws IOException, ServletException;   
  19. }  
public interface Filter {	
	/**
	* The <code>doFilter</code> method of the Filter is called by the container
	* each time a request/response pair is passed through the chain due
	* to a client request for a resource at the end of the chain. The FilterChain passed in to this
	* method allows the Filter to pass on the request and response to the next entity in the
	* chain.<p>
	* A typical implementation of this method would follow the following pattern:- <br>
	* 1. Examine the request<br>
	* 2. Optionally wrap the request object with a custom implementation to
	* filter content or headers for input filtering <br>
	* 3. Optionally wrap the response object with a custom implementation to
	* filter content or headers for output filtering <br>
	* 4. a) <strong>Either</strong> invoke the next entity in the chain using the FilterChain object (<code>chain.doFilter()</code>), <br>   
	** 4. b) <strong>or</strong> not pass on the request/response pair to the next entity in the filter chain to block the request processing<br>
	** 5. Directly set headers on the response after invocation of the next entity in the filter chain.
	**/
    public void doFilter ( ServletRequest request, ServletResponse response, FilterChain chain ) throws IOException, ServletException;
}



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.     }  
private void doForward(ServletRequest request, ServletResponse response)
        throws ServletException, IOException
         //省略了部分代码
        // Handle an HTTP named dispatcher forward
        if ((servletPath == null) && (pathInfo == null)) {
//省略了部分代码
        } else {// Handle an HTTP path-based forward
            ApplicationHttpRequest wrequest =
                (ApplicationHttpRequest) wrapRequest(state);
            String contextPath = context.getPath();
            HttpServletRequest hrequest = state.hrequest;
            if (hrequest.getAttribute(Globals.FORWARD_REQUEST_URI_ATTR) == null) {
                wrequest.setAttribute(Globals.FORWARD_REQUEST_URI_ATTR,
                                      hrequest.getRequestURI());
                wrequest.setAttribute(Globals.FORWARD_CONTEXT_PATH_ATTR,
                                      hrequest.getContextPath());
                wrequest.setAttribute(Globals.FORWARD_SERVLET_PATH_ATTR,
                                      hrequest.getServletPath());
                wrequest.setAttribute(Globals.FORWARD_PATH_INFO_ATTR,
                                      hrequest.getPathInfo());
                wrequest.setAttribute(Globals.FORWARD_QUERY_STRING_ATTR,
                                      hrequest.getQueryString());
            }
 
            wrequest.setContextPath(contextPath);
            wrequest.setRequestURI(requestURI);
            wrequest.setServletPath(servletPath);
            wrequest.setPathInfo(pathInfo);
            if (queryString != null) {
                wrequest.setQueryString(queryString);
                wrequest.setQueryParams(queryString);
            }

            processRequest(request,response,state);
        }
        }
//省略了部分代码
    }


第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.           }  
  wrequest.setContextPath(contextPath);
            wrequest.setRequestURI(requestURI);
            wrequest.setServletPath(servletPath);
            wrequest.setPathInfo(pathInfo);
            if (queryString != null) {
                wrequest.setQueryString(queryString);
                wrequest.setQueryParams(queryString);
            }




第2步：组装FitlerChain链，根据web.xml配置信息，是否决定添加Filter----
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
<dispatcher>REQUEST</dispatcher>
</filter-mapping>

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.          
    分享到：
    | JDK中的URLConnection参数详解
    评论
    发表评论

    您还没有登录,请您登录后再发表评论

相关推荐

    servlet　源码

    - `forward()`方法将请求转发给另一个资源，而`redirect()`则告诉客户端重新发起一个新的请求。 6. **过滤器（Filter）**： - Filter是Servlet技术的一部分，可以对请求和响应进行预处理和后处理，如登录验证、...

    夏帮贵《Java web开发完全掌握》示例源代码（1-5章）

    读者可能会接触到RequestDispatcher和Forward/Redirect的区别，以及如何使用Filter进行请求和响应的拦截处理。此外，对于初学者来说，这一章可能也会讲解如何组织项目结构，以符合良好的编程习惯和标准。 总之，这...

    jsp中国移动计费系统

    两者通过RequestDispatcher或Forward、Redirect等方式进行交互。 2. **MVC设计模式**：Model-View-Controller模式是Web开发中的常见架构，其中Model代表业务逻辑，View负责渲染视图，Controller处理请求并协调Model...

    JSP课程目录

    - &lt;jsp:forward&gt;和&lt;jsp:redirect&gt;处理页面跳转 - 创建和操作JavaBean - 和设置和获取Bean属性 2. **JSTL（JavaServer Pages Standard Tag Library）** - JSTL简介和优点 - JSTL核心库（fmt, fmt, sql, ...

    java面试题

    20. forward 和redirect的区别 13 21. EJB与JAVA BEAN的区别？ 13 22. Static Nested Class 和 Inner Class的不同。 13 23. JSP中动态INCLUDE与静态INCLUDE的区别？ 14 24. List, Set, Map区别 14 25. 集合类都有...

    转发和重定向的区别

    在Web开发中，"转发"（Forward）和"重定向"（Redirect）是两种常见的页面跳转方式，它们虽然在效果上看似相似，但其实有着本质的区别。理解这两种技术的工作原理及其应用场景对于优化应用程序的性能和用户体验至关...

    jsp-forum.rar_jsp论坛_论坛

    JSP主要负责视图层的展示，但两者可以通过转发（Forward）或重定向（Redirect）等方式协作。Servlet与JSP的配合使用，实现了MVC（Model-View-Controller）设计模式，有助于提高代码的可维护性和可扩展性。 **3. ...

    超级有影响力霸气的Java面试题大全文档

    22、forward 和redirect的区别 　forward是服务器请求资源，服务器直接访问目标地址的URL，把那个URL的响应内容读取过来，然后把这些内容再发给浏览器，浏览器根本不知道服务器发送的内容是从哪儿来的，所以它的地址...

    J2EE课程总结

    - 常见的有转发（forward）和重定向（redirect）两种方式。 **4. 在Tomcat中配置数据源** - 通过配置文件`context.xml`设置数据库连接池。 **5. 持久化状态: Cookie, Session** - Cookie用于客户端存储少量数据，...

    Javaweb面试题.docx

    1. `forward()`与`redirect()`的区别： - `forward()`是服务器内部重定向，浏览器地址栏URL不变，请求参数仍有效，效率较高。 - `redirect()`是客户端重定向，浏览器重新发起请求，地址栏URL改变，请求参数需要...

Magicbox
Global site tag (gtag.js) - Google Analytics