Spring Security4.1.3实现拦截登录后向登录页面跳转方式(redirect或forward)返回被拦截界面

一、看下内部原理

简化后的认证过程分为7步:

  1. 用户访问网站,打开了一个链接(origin url)。
  2. 请求发送给服务器,服务器判断用户请求了受保护的资源。
  3. 由于用户没有登录,服务器重定向到登录页面
  4. 填写表单,点击登录
  5. 浏览器将用户名密码以表单形式发送给服务器
  6. 服务器验证用户名密码。成功,进入到下一步。否则要求用户重新认证(第三步)
  7. 服务器对用户拥有的权限(角色)判定: 有权限,重定向到origin url; 权限不足,返回状态码403("forbidden").

从第3步,我们可以知道,用户的请求被中断了。

用户登录成功后(第7步),会被重定向到origin url,spring security通过使用缓存的request,使得被中断的请求能够继续执行。

 

使用缓存

用户登录成功后,页面重定向到origin url。浏览器发出的请求优先被拦截器RequestCacheAwareFilter拦截,RequestCacheAwareFilter通过其持有的RequestCache对象实现request的恢复。

[java] view plain copy

 

  1. public void doFilter(ServletRequest request, ServletResponse response,  
  2.             FilterChain chain) throws IOException, ServletException {  
  3.           
  4.         // request匹配,则取出,该操作同时会将缓存的request从session中删除  
  5.         HttpServletRequest wrappedSavedRequest = requestCache.getMatchingRequest(  
  6.                 (HttpServletRequest) request, (HttpServletResponse) response);  
  7.           
  8.         // 优先使用缓存的request  
  9.         chain.doFilter(wrappedSavedRequest == null ? request : wrappedSavedRequest,  
  10.                 response);  
  11.     }  

 

何时缓存

首先,我们需要了解下RequestCache以及ExceptionTranslationFilter。

RequestCache

RequestCache接口声明了缓存与恢复操作。默认实现类是HttpSessionRequestCache。HttpSessionRequestCache的实现比较简单,这里只列出接口的声明:

 

[java] view plain copy

 

  1. public interface RequestCache {  
  2.   
  3.     // 将request缓存到session中  
  4.     void saveRequest(HttpServletRequest request, HttpServletResponse response);  
  5.       
  6.     // 从session中取request  
  7.     SavedRequest getRequest(HttpServletRequest request, HttpServletResponse response);  
  8.       
  9.     // 获得与当前request匹配的缓存,并将匹配的request从session中删除  
  10.     HttpServletRequest getMatchingRequest(HttpServletRequest request,  
  11.             HttpServletResponse response);  
  12.       
  13.     // 删除缓存的request  
  14.     void removeRequest(HttpServletRequest request, HttpServletResponse response);  
  15. }  

 

 

 

 

 

 

ExceptionTranslationFilter

ExceptionTranslationFilter 是Spring Security的核心filter之一,用来处理AuthenticationException和AccessDeniedException两种异常。

在我们的例子中,AuthenticationException指的是未登录状态下访问受保护资源,AccessDeniedException指的是登陆了但是由于权限不足(比如普通用户访问管理员界面)。

ExceptionTranslationFilter 持有两个处理类,分别是AuthenticationEntryPoint和AccessDeniedHandler。

ExceptionTranslationFilter 对异常的处理是通过这两个处理类实现的,处理规则很简单:

[java] view plain copy

 

  1. 规则1. 如果异常是 AuthenticationException,使用 AuthenticationEntryPoint 处理  
  2. 规则2. 如果异常是 AccessDeniedException 且用户是匿名用户,使用 AuthenticationEntryPoint 处理  
  3. 规则3. 如果异常是 AccessDeniedException 且用户不是匿名用户,如果否则交给 AccessDeniedHandler 处理。  

对应以下代码

[java] view plain copy

 

  1. private void handleSpringSecurityException(HttpServletRequest request,  
  2.             HttpServletResponse response, FilterChain chain, RuntimeException exception)  
  3.             throws IOException, ServletException {  
  4.         if (exception instanceof AuthenticationException) {  
  5.             logger.debug(  
  6.                     "Authentication exception occurred; redirecting to authentication entry point",  
  7.                     exception);  
  8.   
  9.             sendStartAuthentication(request, response, chain,  
  10.                     (AuthenticationException) exception);  
  11.         }  
  12.         else if (exception instanceof AccessDeniedException) {  
  13.             if (authenticationTrustResolver.isAnonymous(SecurityContextHolder  
  14.                     .getContext().getAuthentication())) {  
  15.                 logger.debug(  
  16.                         "Access is denied (user is anonymous); redirecting to authentication entry point",  
  17.                         exception);  
  18.   
  19.                 sendStartAuthentication(  
  20.                         request,  
  21.                         response,  
  22.                         chain,  
  23.                         new InsufficientAuthenticationException(  
  24.                                 "Full authentication is required to access this resource"));  
  25.             }  
  26.             else {  
  27.                 logger.debug(  
  28.                         "Access is denied (user is not anonymous); delegating to AccessDeniedHandler",  
  29.                         exception);  
  30.   
  31.                 accessDeniedHandler.handle(request, response,  
  32.                         (AccessDeniedException) exception);  
  33.             }  
  34.         }  
  35.     }  

 

AccessDeniedHandler 默认实现是 AccessDeniedHandlerImpl。该类对异常的处理是返回403错误码。

[java] view plain copy

 

  1. public void handle(HttpServletRequest request, HttpServletResponse response,  
  2.             AccessDeniedException accessDeniedException) throws IOException,  
  3.             ServletException {  
  4.     if (!response.isCommitted()) {  
  5.         if (errorPage != null) {  // 定义了errorPage  
  6.             // errorPage中可以操作该异常  
  7.             request.setAttribute(WebAttributes.ACCESS_DENIED_403,  
  8.                     accessDeniedException);  
  9.   
  10.             // 设置403状态码  
  11.             response.setStatus(HttpServletResponse.SC_FORBIDDEN);  
  12.   
  13.             // 转发到errorPage  
  14.             RequestDispatcher dispatcher = request.getRequestDispatcher(errorPage);  
  15.             dispatcher.forward(request, response);  
  16.         }  
  17.         else { // 没有定义errorPage,则返回403状态码(Forbidden),以及错误信息  
  18.             response.sendError(HttpServletResponse.SC_FORBIDDEN,  
  19.                     accessDeniedException.getMessage());  
  20.         }  
  21.     }  
  22. }  

 

AuthenticationEntryPoint 默认实现是 LoginUrlAuthenticationEntryPoint, 该类的处理是转发或重定向到登录页面

 

[java] view plain copy

 

  1. public void commence(HttpServletRequest request, HttpServletResponse response,  
  2.             AuthenticationException authException) throws IOException, ServletException {  
  3.   
  4.     String redirectUrl = null;  
  5.   
  6.     if (useForward) {  
  7.   
  8.         if (forceHttps && "http".equals(request.getScheme())) {  
  9.             // First redirect the current request to HTTPS.  
  10.             // When that request is received, the forward to the login page will be  
  11.             // used.  
  12.             redirectUrl = buildHttpsRedirectUrlForRequest(request);  
  13.         }  
  14.   
  15.         if (redirectUrl == null) {  
  16.             String loginForm = determineUrlToUseForThisRequest(request, response,  
  17.                     authException);  
  18.   
  19.             if (logger.isDebugEnabled()) {  
  20.                 logger.debug("Server side forward to: " + loginForm);  
  21.             }  
  22.   
  23.             RequestDispatcher dispatcher = request.getRequestDispatcher(loginForm);  
  24.       
  25.             // 转发  
  26.             dispatcher.forward(request, response);  
  27.   
  28.             return;  
  29.         }  
  30.     }  
  31.     else {  
  32.         // redirect to login page. Use https if forceHttps true  
  33.   
  34.         redirectUrl = buildRedirectUrlToLoginPage(request, response, authException);  
  35.   
  36.     }  
  37.       
  38.     // 重定向  
  39.     redirectStrategy.sendRedirect(request, response, redirectUrl);  
  40. }  

 

 

 

 

 

 

了解完这些,回到我们的例子。

第3步时,用户未登录的情况下访问受保护资源,ExceptionTranslationFilter会捕获到AuthenticationException异常(规则1)。页面需要跳转,ExceptionTranslationFilter在跳转前使用requestCache缓存request。

[java] view plain copy

 

  1. protected void sendStartAuthentication(HttpServletRequest request,  
  2.             HttpServletResponse response, FilterChain chain,  
  3.             AuthenticationException reason) throws ServletException, IOException {  
  4.     // SEC-112: Clear the SecurityContextHolder's Authentication, as the  
  5.     // existing Authentication is no longer considered valid  
  6.     SecurityContextHolder.getContext().setAuthentication(null);  
  7.     // 缓存 request  
  8.     requestCache.saveRequest(request, response);  
  9.     logger.debug("Calling Authentication entry point.");  
  10.     authenticationEntryPoint.commence(request, response, reason);  
  11. }  

二、了解了以上原理以及上篇的forward和redirect的区别,配置实现如下,基于springsecurity4.1.3版本

配置文件:完整的

 

[html] view plain copy

 

  1. <?xml version="1.0" encoding="UTF-8"?>  
  2.   
  3. <beans:beans xmlns="http://www.springframework.org/schema/security"  
  4.     xmlns:beans="http://www.springframework.org/schema/beans"  
  5.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  6.     xsi:schemaLocation="http://www.springframework.org/schema/beans  
  7.         http://www.springframework.org/schema/beans/spring-beans.xsd  
  8.         http://www.springframework.org/schema/security  
  9.         http://www.springframework.org/schema/security/spring-security.xsd">  
  10.           
  11.     <http auto-config="true" use-expressions="true" entry-point-ref="myLoginUrlAuthenticationEntryPoint">  
  12.         <form-login   
  13.             login-page="/login"  
  14.             authentication-failure-url="/login?error"   
  15.             login-processing-url="/login"  
  16.             authentication-success-handler-ref="myAuthenticationSuccessHandler" />     
  17.          <!-- 认证成功用自定义类myAuthenticationSuccessHandler处理 -->  
  18.            
  19.          <logout logout-url="/logout"   
  20.                 logout-success-url="/"   
  21.                 invalidate-session="true"  
  22.                 delete-cookies="JSESSIONID"/>  
  23.           
  24.         <csrf disabled="true" />  
  25.         <intercept-url pattern="/order/*" access="hasRole('ROLE_USER')"/>  
  26.     </http>  
  27.       
  28.     <!-- 使用自定义类myUserDetailsService从数据库获取用户信息 -->  
  29.     <authentication-manager>    
  30.         <authentication-provider user-service-ref="myUserDetailsService">    
  31.             <!-- 加密 -->  
  32.             <password-encoder hash="md5">  
  33.             </password-encoder>  
  34.         </authentication-provider>  
  35.     </authentication-manager>  
  36.       
  37.     <!-- 被认证请求向登录界面跳转采用forward方式 -->  
  38.     <beans:bean id="myLoginUrlAuthenticationEntryPoint"   
  39.         class="org.springframework.security.web.authentication.LoginUrlAuthenticationEntryPoint">  
  40.         <beans:constructor-arg name="loginFormUrl" value="/login"></beans:constructor-arg>  
  41.         <beans:property name="useForward" value="true"/>  
  42.     </beans:bean>  
  43.       
  44. </beans:beans>  

主要配置

 

 

 

 

[html] view plain copy

 

  1. <pre code_snippet_id="1902646" snippet_file_name="blog_20160927_9_7050170" class="html" name="code"><http auto-config="true" use-expressions="true" entry-point-ref="myLoginUrlAuthenticationEntryPoint">  
  2.   
  3.  <!-- 被认证请求向登录界面跳转采用forward方式 -->  
  4.     <beans:bean id="myLoginUrlAuthenticationEntryPoint"   
  5.         class="org.springframework.security.web.authentication.LoginUrlAuthenticationEntryPoint">  
  6.         <beans:constructor-arg name="loginFormUrl" value="/login"></beans:constructor-arg>  
  7.         <beans:property name="useForward" value="true"/>  
  8.     </beans:bean></pre><br>  
  9. <pre></pre>  
  10. <p>从上面的分析可知,默认情况下采用的是redirect方式,这里通过配置从而实现了forward方式,这里还是直接利用的security自带的类LoginUrlAuthenticationEntryPoint,只不过进行了以上配置:</p>  
  11. <p></p><pre code_snippet_id="1902646" snippet_file_name="blog_20161215_10_1004934" class="java" name="code">/**  
  12.      * Performs the redirect (or forward) to the login form URL.  
  13.      */  
  14.     public void commence(HttpServletRequest request, HttpServletResponse response,  
  15.             AuthenticationException authException) throws IOException, ServletException {  
  16.   
  17.         String redirectUrl = null;  
  18.   
  19.         if (useForward) {  
  20.   
  21.             if (forceHttps && "http".equals(request.getScheme())) {  
  22.                 // First redirect the current request to HTTPS.  
  23.                 // When that request is received, the forward to the login page will be  
  24.                 // used.  
  25.                 redirectUrl = buildHttpsRedirectUrlForRequest(request);  
  26.             }  
  27.   
  28.             if (redirectUrl == null) {  
  29.                 String loginForm = determineUrlToUseForThisRequest(request, response,  
  30.                         authException);  
  31.   
  32.                 if (logger.isDebugEnabled()) {  
  33.                     logger.debug("Server side forward to: " + loginForm);  
  34.                 }  
  35.   
  36.                 RequestDispatcher dispatcher = request.getRequestDispatcher(loginForm);  
  37.   
  38.                 dispatcher.forward(request, response);  
  39.   
  40.                 return;  
  41.             }  
  42.         }  
  43.         else {  
  44.             // redirect to login page. Use https if forceHttps true  
  45.   
  46.             redirectUrl = buildRedirectUrlToLoginPage(request, response, authException);  
  47.   
  48.         }  
  49.   
  50.         redirectStrategy.sendRedirect(request, response, redirectUrl);  
  51.     }</pre><br>  
  52. <p></p>  
  53. <p></p>  
  54. <p></p>  
  55. <p></p>  
  56. <p>登录成功后的类配置,存入登录user信息后交给认证成功后的处理类MyAuthenticationSuccessHandler,该类集成了SavedRequestAwareAuthenticationSuccessHandler,他会从缓存中提取请求,从而可以恢复之前请求的数据</p>  
  57. <p></p><pre code_snippet_id="1902646" snippet_file_name="blog_20161215_11_4222490" class="java" name="code">/**  
  58.  * 登录后操作  
  59.  *   
  60.  * @author HHL  
  61.  * @date  
  62.  *   
  63.  */  
  64. @Component  
  65. public class MyAuthenticationSuccessHandler extends  
  66.         SavedRequestAwareAuthenticationSuccessHandler {  
  67.   
  68.     @Autowired  
  69.     private IUserService userService;  
  70.   
  71.     @Override  
  72.     public void onAuthenticationSuccess(HttpServletRequest request,  
  73.             HttpServletResponse response, Authentication authentication)  
  74.             throws IOException, ServletException {  
  75.   
  76.         // 认证成功后,获取用户信息并添加到session中  
  77.         UserDetails userDetails = (UserDetails) authentication.getPrincipal();  
  78.         MangoUser user = userService.getUserByName(userDetails.getUsername());  
  79.         request.getSession().setAttribute("user", user);  
  80.           
  81.         super.onAuthenticationSuccess(request, response, authentication);  
  82.       
  83.     }  
  84.   
  85.   
  86. }</pre><p></p>  
  87. <p></p>  
  88. <p></p>  
  89. <p></p>  
  90. <p>SavedRequestAwareAuthenticationSuccessHandler中的onAuthenticationSuccess方法;</p>  
  91. <p></p><pre code_snippet_id="1902646" snippet_file_name="blog_20161215_12_7440047" class="java" name="code">@Override  
  92.     public void onAuthenticationSuccess(HttpServletRequest request,  
  93.             HttpServletResponse response, Authentication authentication)  
  94.             throws ServletException, IOException {  
  95.         SavedRequest savedRequest = requestCache.getRequest(request, response);  
  96.   
  97.         if (savedRequest == null) {  
  98.             super.onAuthenticationSuccess(request, response, authentication);  
  99.   
  100.             return;  
  101.         }  
  102.         String targetUrlParameter = getTargetUrlParameter();  
  103.         if (isAlwaysUseDefaultTargetUrl()  
  104.                 || (targetUrlParameter != null && StringUtils.hasText(request  
  105.                         .getParameter(targetUrlParameter)))) {  
  106.             requestCache.removeRequest(request, response);  
  107.             super.onAuthenticationSuccess(request, response, authentication);  
  108.   
  109.             return;  
  110.         }  
  111.   
  112.         clearAuthenticationAttributes(request);  
  113.   
  114.         // Use the DefaultSavedRequest URL  
  115.         String targetUrl = savedRequest.getRedirectUrl();  
  116.         logger.debug("Redirecting to DefaultSavedRequest Url: " + targetUrl);  
  117.         getRedirectStrategy().sendRedirect(request, response, targetUrl);  
  118.     }</pre>4.1.3中如果默认不配置的话也是采用的SavedRequestAwareAuthenticationSuccessHandler进行处理,详情可参见:<a target="_blank" href="http://blog.csdn.net/honghailiang888/article/details/53541664">Spring实战篇系列----源码解析Spring Security中的过滤器Filter初始化  
  119. </a><br>  
  120. <br>  
  121. <br>  
  122. 上述实现了跳转到登录界面采用forward方式,就是浏览器地址栏没有变化,当然也可采用redirect方式,地址栏变为登录界面地址栏,当登录完成后恢复到原先的请求页面,请求信息会从requestCache中还原回来。可参考<a target="_blank" href="http://blog.csdn.net/honghailiang888/article/details/53520557"> Spring实战篇系列----spring security4.1.3配置以及踩过的坑</a><br>  
  123. <p></p>  
  124. <p></p>  
  125. <p></p>  
  126. <p></p>  
  127. <p></p>  
  128. <p></p>  
  129. <p><br>  
  130. </p>  
  131. <p><br>  
  132. </p>  
  133. <p>参考:</p>  
  134. <p><a target="_blank" href="https://segmentfault.com/a/1190000004183264">https://segmentfault.com/a/1190000004183264</a></p>  
  135. <p><a target="_blank" href="http://gtbald.iteye.com/blog/1214132">http://gtbald.iteye.com/blog/1214132</a></p>  
  136. <p><br>  
  137. <br>  
  138. <br>  
  139. </p>  
  140. <div style="top:0px"></div>  
  141. <div style="top:4827px"></div>  
  142. <div style="top:3353px"></div>  
  143.      

 

 http://blog.csdn.net/honghailiang888/article/details/52679264

 

时间: 2017-06-24

Spring Security4.1.3实现拦截登录后向登录页面跳转方式(redirect或forward)返回被拦截界面的相关文章

spring security cas整合如何实现注册后自动登录

问题描述 spring security cas整合如何实现注册后自动登录 spring security cas整合如何实现注册后自动登录,哪位高手有样例代码,万分感谢 解决方案 CAS 之 实现用户注册后自动登录

退出app再进后获取不到ContactList,但是退出登录后重新登录后又可以刷新出来

问题描述 而且第一次登录app会崩溃,再重新进又没有问题,求解 解决方案 你是怎么做的退出操作呢?杀死进程了吗?这个好友列表的获取是在MainActivity中执行的 asyncFetchContactsFromServer();方法,你看你退出再进入时执行了没有,和demo对比一下看看代码的执行有什么不同.解决方案二:同样问题,但第一次登录不会报错,不是杀死进程,正常退出后,再次登录引发空指针异常,位置:DemoHelper.getUserInfo(),如换用户登录,好友列表仍为上次登录用户的

Struts 拦截器权限控制【通过拦截器实现登录后跳转到登录前页面】

应用情形:在web项目中,经常会遇到用户未登录或SESSION失效时用户发出非法的权限操作,如新闻的评论.文件的下载等等,在此我们可以使用struts拦截器对该用户发出的请求进行拦截,拦截后判断用户是否登录或SESSION是否有效,然后进行其正常操作.具体实例如下: 新建一个拦截器类UserInterceptor ,UserInterceptor.java代码如下 [java] view plaincopyprint? package com.hsinghsu.test.interceptor;

怎么在登录后的窗口标题栏上显示用户名

问题描述 怎么在登录后的窗口标题栏上显示用户名 解决方案 解决方案二:问的太简单了,什么登录呢?登录后的窗口什么样子呢?web还是cs的客户端程序呢?解决方案三:web的话用session解决方案四:这个问题太宽泛了,是web就用session,是GUI可以在http流中读取相应的用户名字段,然后setTitle解决方案五:问的问题太简单了...登陆时放入session登陆后在要显示用户名的位置显示就好解决方案六:在你提交登录的时候,用户名在页面有一个属性name接着后台用session.set

WordPress中登陆后关闭登陆页面及设置用户不可见栏目_php技巧

用户登录后关闭登录页面WordPress默认的登录页面是:http://WP目录/wp-login.php,登录后会自动跳转到:http://WP目录/wp-admin.现在问题来了,如果用户已经登录,但是它又打开wp-login.php页面,会出现什么样的情况呢?答案是,WordPress不会做任何处理,还是直接给你显示登录窗口: 面对如此冰冷的登录框,用户会感到困惑,我刚刚不是已经登录了吗?怎么还要我输入用户名和密码?所以,用户登录后,我们不该让用户再看到登录框.解决此问题的办法有两个: 去

iframe页面点击按钮,父页面跳转到新页面,新页面点返回后显示iframe页面,如何返回父页面,同时保持父页面和子页面的数据

问题描述 A页面中有B,C,D三个子页面,在C页面中点击按钮后,A页面跳转到E页面,在E页面点击返回时,如何实现返回A页面,同时B,C,D页面的数据保持不变 解决方案 解决方案二:top.href=试试解决方案三:最近才做了一个有关iframe的项目,做了些笔记,可以参考一下

用spring springMVC mybatis实现用户登录验证,成功登录后显示用户数据

问题描述 用spring springMVC mybatis实现用户登录验证,成功登录后显示用户数据 ? 登陆成功后,将所有用户数据展示给用户,列出用户详细信息,并分页.用拦截器判断,如果没有登陆的话返回登陆页面并提示用户没有登陆 配置全部都写好了 求大神给写个 登录验证的页面 跟 登录成功后的页面 万分感谢! 急!!! 解决方案 http://download.csdn.net/detail/fengqilove520/8405907 解决方案二: SpringMVC + Mybatis 实现

spring security-web工程登录后无法访问主页

问题描述 web工程登录后无法访问主页 将工程部署在jetty后,用URL:"http://localhost:8080/custo/"可以重定向到"http://localhost:8080/custo/index.jsp",当我登录成功后,保持登录状态,在同一浏览器,访问同样的URL:"http://localhost:8080/custo/"却显示404,not found. 请问这个是怎么回事? 解决方案 用IE F12调试下,你登录以后

tomcat卡住-spring security4在tomcat7下起动卡住了,什么情况,求指点!

问题描述 spring security4在tomcat7下起动卡住了,什么情况,求指点! 准备学习下Spring Security 4,整合spring mvc时正常,加入spring security包后也下常,但是把Spring Security配置文件加入到web.xml启动配置后就有问题了. spring-4.1.6.RELEASE spring-security-4.0.1.RELEASE tomcat-7.0.28 Ideal 14 整个启动过程如以下及1,2楼回复所示,启动到初始