RequestCacheAwareFilter过滤器对应的类路径为 

org.springframework.security.web.savedrequest.RequestCacheAwareFilter 

这个filter的用途官方解释是 

用于用户登录成功后，重新恢复因为登录被打断的请求
 

这个解释也有几点需要说明 

被打算的请求：简单点说就是出现了AuthenticationException、AccessDeniedException两类异常 

重新恢复：既然能够恢复，那肯定请求信息被保存到cache中了 

首先看被打断请求是如何保存到cache中的 

实际上，上一篇的ExceptionTranslationFilter分析已经提到了 

requestCache.saveRequest(request, response)
 

是的，如果出现AuthenticationException或者是匿名登录的抛出了AccessDeniedException，都会把当前request保存到cache中。这里的cache是HttpSessionRequestCache，接着看HttpSessionRequestCache的saveRequest方法 

Java代码  

1. public void saveRequest(HttpServletRequest request, HttpServletResponse response) {  
2.     //由于构造HttpSessionRequestCache的bean时，没有设置justUseSavedRequestOnGet属性，所以该属性为默认值false。  
3.     if (!justUseSavedRequestOnGet || “GET”.equals(request.getMethod())) {  
4.         //构造DefaultSavedRequest，并且设置到session中  
5.         DefaultSavedRequest savedRequest = new DefaultSavedRequest(request, portResolver);  
6.   
7.         if (createSessionAllowed || request.getSession(false) != null) {  
8.             request.getSession().setAttribute(DefaultSavedRequest.SPRING_SECURITY_SAVED_REQUEST_KEY, savedRequest);  
9.         }  
10.     }  
11.   
12. }  

这里应该知道，实际上被打断的请求被封装成DefaultSavedRequest对象保存到session中了 

分析完保存被打断的请求，接着就分析如何恢复被打断的请求了。RequestCacheAwareFilter过滤器就是完成恢复的工作。看doFilter方法 

Java代码  

1. public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)  
2.         throws IOException, ServletException {  
3.     //根据当前session取出DefaultSavedRequest，如果有被打断的请求，就把当前请求与被打断请求做匹配。如果匹配成功，对当前请求封装，再传递到下一个过滤器  
4.     HttpServletRequest wrappedSavedRequest =  
5.         requestCache.getMatchingRequest((HttpServletRequest)request, (HttpServletResponse)response);  
6.     chain.doFilter(wrappedSavedRequest == null ? request : wrappedSavedRequest, response);  
7. }  

继续看HttpSessionRequestCache处理过程 

Java代码  

1. //从当前session中提取DefaultSavedRequest对象  
2. public SavedRequest getRequest(HttpServletRequest currentRequest, HttpServletResponse response) {  
3.     HttpSession session = currentRequest.getSession(false);  
4.   
5.     if (session != null) {  
6.         return (DefaultSavedRequest) session.getAttribute(DefaultSavedRequest.SPRING_SECURITY_SAVED_REQUEST_KEY);  
7.     }  
8.   
9.     return null;  
10. }  
11. //清除被打断请求  
12. public void removeRequest(HttpServletRequest currentRequest, HttpServletResponse response) {  
13.     HttpSession session = currentRequest.getSession(false);  
14.   
15.     if (session != null) {  
16.         logger.debug(“Removing DefaultSavedRequest from session if present”);  
17.         session.removeAttribute(DefaultSavedRequest.SPRING_SECURITY_SAVED_REQUEST_KEY);  
18.     }  
19. }  
20. //请求匹配  
21. public HttpServletRequest getMatchingRequest(HttpServletRequest request, HttpServletResponse response) {  
22.     DefaultSavedRequest saved = (DefaultSavedRequest) getRequest(request, response);  
23.     //如果没有被打断请求，直接返回null，不做处理  
24.     if (saved == null) {  
25.         return null;  
26.     }  
27.     //如果当前请求与被打断请求不匹配，直接返回null，不做处理  
28.     if (!saved.doesRequestMatch(request, portResolver)) {  
29.         logger.debug(“saved request doesn’t match”);  
30.         return null;  
31.     }  
32.     //清除被打断请求  
33.     removeRequest(request, response);  
34.     //重新包装当前请求为被打断请求的各项信息  
35.     return new SavedRequestAwareWrapper(saved, request);  
36. }  

接着分析doesRequestMatch方法，看请求是如何匹配的 

Java代码  

1. //就是比较request与cache中被打断请求的各项信息是否相同  
2. //这里有个疑惑（由于被打断请求包括POST、GET提交方式的，而这里要求必须为GET方式的请求才会匹配成功）  
3. public boolean doesRequestMatch(HttpServletRequest request, PortResolver portResolver) {  
4.   
5.     if (!propertyEquals(“pathInfo”, this.pathInfo, request.getPathInfo())) {  
6.         return false;  
7.     }  
8.   
9.     if (!propertyEquals(“queryString”, this.queryString, request.getQueryString())) {  
10.         return false;  
11.     }  
12.   
13.     if (!propertyEquals(“requestURI”, this.requestURI, request.getRequestURI())) {  
14.         return false;  
15.     }  
16.   
17.     if (!“GET”.equals(request.getMethod()) && “GET”.equals(method)) {  
18.         // A save GET should not match an incoming non-GET method  
19.         return false;  
20.     }  
21.   
22.     if (!propertyEquals(“serverPort”, new Integer(this.serverPort), new Integer(portResolver.getServerPort(request))))  
23.     {  
24.         return false;  
25.     }  
26.   
27.     if (!propertyEquals(“requestURL”, this.requestURL, request.getRequestURL().toString())) {  
28.         return false;  
29.     }  
30.   
31.     if (!propertyEquals(“scheme”, this.scheme, request.getScheme())) {  
32.         return false;  
33.     }  
34.   
35.     if (!propertyEquals(“serverName”, this.serverName, request.getServerName())) {  
36.         return false;  
37.     }  
38.   
39.     if (!propertyEquals(“contextPath”, this.contextPath, request.getContextPath())) {  
40.         return false;  
41.     }  
42.   
43.     if (!propertyEquals(“servletPath”, this.servletPath, request.getServletPath())) {  
44.         return false;  
45.     }  
46.   
47.     return true;  
48. }  

这里为何对POST请求匹配不成功，目前还不知道具体设计思路。知道后会进行补充