碼上歡樂
相關內容    簡體    繁體

spring security四種實現方式

本文轉載自   查看原文   2018-03-08 16:09   2388    security/ 開發經驗/ 工作總結/ Security/ Spring/ Spring Security 

                                            spring security四種實現方式                    </a>
            </span>
        </h1>
    </div>
    <div class="article_manage clearfix">
    <div class="article_l">
</div>
    <div class="article_r">
   
                </div>


                </div>
    <div style="clear:both"></div><div style="border:solid 1px #ccc; background:#eee; float:left; min-width:200px;padding:4px 10px;"><p style="text-align:right;margin:0;"><span style="float:left;">目錄<a href="http://blog.csdn.net/bao19901210/article/details/52574340" title="系統根據文章中H1到H6標簽自動生成文章目錄">(?)</a></span><a href="#" onclick="javascript:return openct(this);" title="展開">[+]</a></p><ol style="display:none;margin-left:14px;padding-left:14px;line-height:160%;"><li><a href="http://blog.csdn.net/bao19901210/article/details/52574340#t0">最簡單配置spring-securityxml實現1</a></li><li><a href="http://blog.csdn.net/bao19901210/article/details/52574340#t1">實現UserDetailsService</a></li><li><a href="http://blog.csdn.net/bao19901210/article/details/52574340#t2">實現動態過濾用戶權限</a></li><li><a href="http://blog.csdn.net/bao19901210/article/details/52574340#t3">實現AuthenticationProvider自定義參數驗證</a></li></ol></div><div style="clear:both"></div><div id="article_content" class="article_content csdn-tracking-statistics" data-pid="blog" data-mod="popu_307" data-dsm="post" style="overflow: hidden;">
                <link rel="stylesheet" href="http://csdnimg.cn/release/phoenix/production/htmledit_views-b569b0e3ef.css">
        <div class="htmledit_views">

spring security實現方式大致可以分為這幾種：

    1.配置文件實現，只需要在配置文件中指定攔截的url所需要權限、配置userDetailsService指定用戶名、密碼、對應權限，就可以實現。

    2.實現UserDetailsService，loadUserByUsername(String userName)方法，根據userName來實現自己的業務邏輯返回UserDetails的實現類，需要自定義User類實現UserDetails，比較重要的方法是getAuthorities()，用來返回該用戶所擁有的權限。

    3.通過自定義filter重寫spring security攔截器，實現動態過濾用戶權限。

    4.通過自定義filter重寫spring security攔截器，實現自定義參數來檢驗用戶，並且過濾權限。

1.最簡單配置spring-security.xml，實現1

[html] view plain copy
print ?
  1. <beans xmlns="http://www.springframework.org/schema/beans"    
  2.     xmlns:security="http://www.springframework.org/schema/security"    
  3.     xmlns:p="http://www.springframework.org/schema/p" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"    
  4.     xsi:schemaLocation="http://www.springframework.org/schema/beans    
  5.           http://www.springframework.org/schema/beans/spring-beans-4.0.xsd    
  6.           http://www.springframework.org/schema/security    
  7.           http://www.springframework.org/schema/security/spring-security-4.0.xsd">    
  8.     
  9.     <!-- use-expressions:Spring 表達式語言配置訪問控制 -->    
  10.     <security:http auto-config="true" use-expressions="false">    
  11.             <!-- 配置權限攔截，訪問所有url，都需要用戶登錄，且擁有ROLE_USER權限 -->  
  12.         <security:intercept-url pattern="/**" access="ROLE_USER" />    
  13.              
  14.     </security:http>    
  15.     
  16.     <security:authentication-manager alias="authenticationManager">    
  17.         <security:authentication-provider>    
  18.                 <!-- 配置默認用戶，用戶名：admin 密碼：123456 擁有權限：ROLE_USER -->  
  19.             <security:user-service>    
  20.                 <security:user name="admin" password="123456"    
  21.                     authorities="ROLE_USER" />    
  22.             </security:user-service>    
  23.         </security:authentication-provider>    
  24.            
  25.     </security:authentication-manager>    
  26.           
  27. </beans>    


2.實現UserDetailsService

先整理下spring secruity驗證流程：

springSecurity的登錄驗證是由org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter這個過濾器來完成的,在該類的父類AbstractAuthenticationProcessingFilter中有一個AuthenticationManager接口屬性,驗證工作主要是通過這個AuthenticationManager接口的實例來完成的。在默認情況下，springSecurity框架會把org.springframework.security.authentication.ProviderManager類的實例注入到該屬性

UsernamePasswordAuthenticationFilter的驗證過程如下：

1. 首先過濾器會調用自身的attemptAuthentication方法，從request中取出authentication, authentication是在org.springframework.security.web.context.SecurityContextPersistenceFilter過濾器中通過捕獲用戶提交的登錄表單中的內容生成的一個org.springframework.security.core.Authentication接口實例.

2. 拿到authentication對象后，過濾器會調用ProviderManager類的authenticate方法，並傳入該對象

3.ProviderManager類的authenticate方法中會調用類中的List<AuthenticationProvider> providers集合中的各個AuthenticationProvider接口實現類中的authenticate(Authentication authentication)方法進行驗證，由此可見，真正的驗證邏輯是由各個AuthenticationProvider接口實現類來完成的。DaoAuthenticationProvider類是默認情況下注入的一個AuthenticationProvider接口實現類

4.provider的實現類在驗證用戶時，會調用userDetailsService的實現類的loadUserByUsername方法來獲取用戶信息，


首先spring-security配置文件

[html] view plain copy
print ?
  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-4.3.xsd  
  8.                         http://www.springframework.org/schema/security   
  9.                         http://www.springframework.org/schema/security/spring-security.xsd">  
  10.   <!--   use-expressions=”true” 需要使用表達式方式來寫權限-->  
  11.     <http auto-config="true"  use-expressions="false">        
  12.        <!--這是spring 提供的http/https信道安全的這個是重要的！你的請求信道是安全的！-->  
  13.        <!--  
  14.        釋放用戶登陸page 允許任何人訪問該頁面 ，IS_AUTHENTICATED_ANONYMOUSLY表示不攔截  
  15.        另一種不攔截資源的配置：<http pattern="/login.jsp" security="none">  
  16.        -->  
  17.       
  18.        <intercept-url pattern="/login.jsp*" access="IS_AUTHENTICATED_ANONYMOUSLY"/>  
  19.          
  20.         <!-- 配置用戶正常訪問page-->  
  21.         <intercept-url pattern="/**" access="ROLE_USER"/>  
  22.           
  23.         <!-- 自定義用戶登陸page default-target-url登陸成功跳轉的page ，authentication-failure-url="/login.jsp?error=true"這里是登陸失敗跳轉的page-->  
  24.         <form-login login-page="/login.jsp" default-target-url="/jsp/index/main.jsp" authentication-failure-url="/login.jsp?error=true"/>  
  25.         <!-- 記住密碼 -->   
  26. <!--         <remember-me key="elim" user-service-ref="securityManager"/> -->  
  27.      </http>  
  28.        
  29.     <authentication-manager alias="authenticationManager">  
  30.         <!--   
  31.              authentication-provider 引用UserDetailsService實現類時使用user-service-ref屬性，引用authentication實現類時，使用ref屬性  
  32.              這兩個屬性的區別在於    
  33.        ref：直接將ref依賴的bean注入到AuthenticationProvider的providers集合中    
  34.        user-service-ref：定義DaoAuthenticationProvider的bean注入到AuthenticationProvider的providers集合中，    
  35.        並且DaoAuthenticationProvider的變量userDetailsService由user-service-ref依賴的bean注入。  
  36.         -->  
  37.         <authentication-provider user-service-ref="msecurityManager">  
  38.             <!-- 密碼加密 -->  
  39.             <password-encoder ref="myPasswordEncoder"/>  
  40.         </authentication-provider>  
  41.     </authentication-manager>  
  42.       
  43.     <!-- 實現UserDetailsService -->  
  44.     <beans:bean id="msecurityManager" class="com.ultrapower.me.util.security.support.SecurityManagerSupport"></beans:bean>  
  45.     <!-- 密碼加密 -->  
  46.     <beans:bean id="myPasswordEncoder" class="com.ultrapower.me.util.security.MyPasswordEncoder"/>  
  47.       
  48. </beans:beans>  


userDetailsService實現：

[java] view plain copy
print ?
  1. /** 
  2.  *  
  3.  */  
  4. package com.ultrapower.me.util.security.support;  
  5.   
  6. import java.util.ArrayList;  
  7. import java.util.HashMap;  
  8. import java.util.HashSet;  
  9. import java.util.List;  
  10. import java.util.Map;  
  11. import java.util.Set;  
  12.   
  13. import org.apache.commons.logging.Log;  
  14. import org.apache.commons.logging.LogFactory;  
  15. import org.springframework.dao.DataAccessException;  
  16. import org.springframework.jdbc.core.JdbcTemplate;  
  17. import org.springframework.security.core.userdetails.UserDetails;  
  18. import org.springframework.security.core.userdetails.UserDetailsService;  
  19. import org.springframework.security.core.userdetails.UsernameNotFoundException;  
  20.   
  21. import com.ultrapower.me.util.Constants;  
  22. import com.ultrapower.me.util.dbDao.SpringBeanUtil;  
  23. import com.ultrapower.me.util.security.SecurityManager;  
  24. import com.ultrapower.me.util.security.entity.Resource;  
  25. import com.ultrapower.me.util.security.entity.Role;  
  26. import com.ultrapower.me.util.security.entity.User;  
  27. import com.ultrapower.me.util.task.PasswordUtils;  
  28.   
  29.   
  30. public class SecurityManagerSupport  implements UserDetailsService{  
  31.     private   Log   log   = LogFactory.getLog(this.getClass().getName());   
  32.        
  33.   
  34.     public UserDetails loadUserByUsername(String userName) throws UsernameNotFoundException, DataAccessException {  
  35. //        List<User> users = getHibernateTemplate().find("FROM User user WHERE user.name = ? AND user.disabled = false", userName);  
  36.         log.info("SecurityManagerSupport.loadUserByUsername.userName:"+userName);  
  37.           
  38.         User user =null;  
  39.         if("admin".equals(userName)){         
  40.             Set<Role> roles = new HashSet<Role>() ;  
  41.             Role role = new Role();  
  42.             role.setRoleid("ROLE_USER");  
  43.             role.setRoleName("ROLE_USER");  
  44.               
  45.             Set<Resource> resources=new HashSet<Resource>() ;  
  46.               
  47.             Resource res = new Resource();  
  48.             res.setResid("ME001");  
  49.             res.setResName("首頁");  
  50.             res.setResUrl("/jsp/index/main.jsp");  
  51.             res.setType("ROLE_USER");  
  52.             res.setRoles(roles);  
  53.             resources.add(res);  
  54.               
  55.             role.setResources(resources);  
  56.               
  57.             roles.add(role);  
  58.             user = new User();  
  59.             user.setAccount("admin");  
  60.             user.setDisabled(false);  
  61.             user.setPassword(PasswordUtils.entryptPassword(Constants.securityKey));  
  62.             log.info(user.getPassword());  
  63.             user.setRoles(roles);             
  64.         }  
  65.       return user;//返回UserDetails的實現user不為空，則驗證通過  
  66.     }  
  67.       
  68. }  


UserDetails實現：

[java] view plain copy
print ?
  1. /** 
  2.  *  
  3.  */  
  4. package com.ultrapower.me.util.security.entity;  
  5.   
  6. import java.util.ArrayList;  
  7. import java.util.Collection;  
  8. import java.util.HashMap;  
  9. import java.util.List;  
  10. import java.util.Map;  
  11. import java.util.Set;  
  12.   
  13. import org.apache.commons.lang.StringUtils;  
  14. import org.springframework.security.core.GrantedAuthority;  
  15. import org.springframework.security.core.authority.SimpleGrantedAuthority;  
  16. import org.springframework.security.core.userdetails.UserDetails;  
  17.   
  18.    
  19. public class User implements UserDetails {  
  20.       
  21.     private static final long serialVersionUID = 8026813053768023527L;  
  22.   
  23.      
  24.     private String account;  
  25.       
  26.     private String name;  
  27.       
  28.     private String password;  
  29.       
  30.     private boolean disabled;  
  31.    
  32.     private Set<Role> roles;  
  33.       
  34.    
  35.     private Map<String, List<Resource>> roleResources;  
  36.       
  37.     /** 
  38.      * The default constructor 
  39.      */  
  40.     public User() {  
  41.           
  42.     }  
  43.       
  44.     /** 
  45.      * Returns the authorites string 
  46.      *  
  47.      * eg.  
  48.      *    downpour --- ROLE_ADMIN,ROLE_USER 
  49.      *    robbin --- ROLE_ADMIN 
  50.      *  
  51.      * @return 
  52.      */  
  53.     public String getAuthoritiesString() {  
  54.         List<String> authorities = new ArrayList<String>();  
  55.         for(GrantedAuthority authority : this.getAuthorities()) {  
  56.             authorities.add(authority.getAuthority());  
  57.         }  
  58.         return StringUtils.join(authorities, ",");  
  59.     }  
  60.   
  61.     @Override  
  62.     public Collection<? extends GrantedAuthority> getAuthorities() {  
  63.         // 根據自定義邏輯來返回用戶權限，如果用戶權限返回空或者和攔截路徑對應權限不同，驗證不通過  
  64.         if(!roles.isEmpty()){  
  65.             List<GrantedAuthority> list = new ArrayList<GrantedAuthority>();  
  66.             GrantedAuthority au = new SimpleGrantedAuthority("ROLE_USER");  
  67.             list.add(au);  
  68.             return list;  
  69.         }  
  70.         return null;  
  71.     }  
  72.   
  73.     /*  
  74.      * 密碼 
  75.      */  
  76.     public String getPassword() {  
  77.         return password;  
  78.     }  
  79.   
  80.     /*  
  81.      * 用戶名 
  82.      */  
  83.     public String getUsername() {  
  84.         return name;  
  85.     }  
  86.   
  87.     /*  
  88.      *帳號是否不過期，false則驗證不通過 
  89.      */  
  90.     public boolean isAccountNonExpired() {  
  91.         return true;  
  92.     }  
  93.   
  94.     /*  
  95.      * 帳號是否不鎖定，false則驗證不通過 
  96.      */  
  97.     public boolean isAccountNonLocked() {  
  98.         return true;  
  99.     }  
  100.   
  101.     /*  
  102.      * 憑證是否不過期，false則驗證不通過 
  103.      */  
  104.     public boolean isCredentialsNonExpired() {  
  105.         return true;  
  106.     }  
  107.   
  108.     /*  
  109.      * 該帳號是否啟用，false則驗證不通過 
  110.      */  
  111.     public boolean isEnabled() {  
  112.         return !disabled;  
  113.     }  
  114.   
  115.    
  116.   
  117.     /** 
  118.      * @return the name 
  119.      */  
  120.     public String getName() {  
  121.         return name;  
  122.     }  
  123.   
  124.     /** 
  125.      * @return the disabled 
  126.      */  
  127.     public boolean isDisabled() {  
  128.         return disabled;  
  129.     }  
  130.   
  131.     /** 
  132.      * @return the roles 
  133.      */  
  134.     public Set<Role> getRoles() {  
  135.         return roles;  
  136.     }  
  137.   
  138.     /** 
  139.      * @return the roleResources 
  140.      */  
  141.     public Map<String, List<Resource>> getRoleResources() {  
  142.         // init roleResources for the first time  
  143.         System.out.println("---------------------------------------------------");  
  144.         if(this.roleResources == null) {  
  145.               
  146.             this.roleResources = new HashMap<String, List<Resource>>();  
  147.               
  148.             for(Role role : this.roles) {  
  149.                 String roleName = role.getRoleName();  
  150.                 Set<Resource> resources = role.getResources();  
  151.                 for(Resource resource : resources) {  
  152.                     String key = roleName + "_" + resource.getType();  
  153.                     if(!this.roleResources.containsKey(key)) {  
  154.                         this.roleResources.put(key, new ArrayList<Resource>());  
  155.                     }  
  156.                     this.roleResources.get(key).add(resource);                    
  157.                 }  
  158.             }  
  159.               
  160.         }  
  161.         return this.roleResources;  
  162.     }  
  163.   
  164.    
  165.     /** 
  166.      * @param name the name to set 
  167.      */  
  168.     public void setName(String name) {  
  169.         this.name = name;  
  170.     }  
  171.   
  172.     /** 
  173.      * @param password the password to set 
  174.      */  
  175.     public void setPassword(String password) {  
  176.         this.password = password;  
  177.     }  
  178.   
  179.     /** 
  180.      * @param disabled the disabled to set 
  181.      */  
  182.     public void setDisabled(boolean disabled) {  
  183.         this.disabled = disabled;  
  184.     }  
  185.   
  186.     /** 
  187.      * @param roles the roles to set 
  188.      */  
  189.     public void setRoles(Set<Role> roles) {  
  190.         this.roles = roles;  
  191.     }  
  192.   
  193.     public String getAccount() {  
  194.         return account;  
  195.     }  
  196.   
  197.     public void setAccount(String account) {  
  198.         this.account = account;  
  199.     }  
  200.   
  201.     public void setRoleResources(Map<String, List<Resource>> roleResources) {  
  202.         this.roleResources = roleResources;  
  203.     }  
  204.       
  205. }  

3.實現動態過濾用戶權限

在spring-security配置文件的http標簽中添加如下配置
[html] view plain copy
print ?
  1. <custom-filter before="FILTER_SECURITY_INTERCEPTOR" ref="securityInterceptor"/>  
在spring-security配置文件中添加如下配置
[html] view plain copy
print ?
  1. <!--     自定義攔截器 -->  
  2.     <beans:bean id="securityInterceptor" class="com.ultrapower.me.util.security.interceptor.SecurityInterceptor">  
  3.         <beans:property name="authenticationManager" ref="authenticationManager"/>  
  4.         <beans:property name="accessDecisionManager" ref="mesecurityAccessDecisionManager"/>  
  5.         <beans:property name="securityMetadataSource" ref="secureResourceFilterInvocationDefinitionSource" />  
  6.     </beans:bean>  
  7. <!--     獲取訪問url對應的所有權限 -->  
  8.     <beans:bean id="secureResourceFilterInvocationDefinitionSource" class="com.ultrapower.me.util.security.interceptor.SecureResourceFilterInvocationDefinitionSource" />  
  9. <!--     校驗用戶的權限是否足夠 -->  
  10.     <beans:bean id="mesecurityAccessDecisionManager" class="com.ultrapower.me.util.security.interceptor.SecurityAccessDecisionManager" />  
  11.       




securityInterceptor繼承AbstractSecurityInterceptor過濾器，實現Filter過濾器
[java] view plain copy
print ?
  1. package com.ultrapower.me.util.security.interceptor;  
  2.   
  3. import java.io.IOException;  
  4.   
  5. import javax.servlet.Filter;  
  6. import javax.servlet.FilterChain;  
  7. import javax.servlet.FilterConfig;  
  8. import javax.servlet.ServletException;  
  9. import javax.servlet.ServletRequest;  
  10. import javax.servlet.ServletResponse;  
  11.   
  12. import org.springframework.security.access.SecurityMetadataSource;  
  13. import org.springframework.security.access.intercept.AbstractSecurityInterceptor;  
  14. import org.springframework.security.access.intercept.InterceptorStatusToken;  
  15. import org.springframework.security.web.FilterInvocation;  
  16. import org.springframework.security.web.access.intercept.FilterInvocationSecurityMetadataSource;  
  17.   
  18. public class SecurityInterceptor extends AbstractSecurityInterceptor implements Filter{  
  19.   
  20.     //配置文件注入  
  21.     private FilterInvocationSecurityMetadataSource securityMetadataSource;  
  22.       
  23.     public FilterInvocationSecurityMetadataSource getSecurityMetadataSource() {  
  24.         return securityMetadataSource;  
  25.     }  
  26.   
  27.     public void setSecurityMetadataSource(  
  28.             FilterInvocationSecurityMetadataSource securityMetadataSource) {  
  29.         this.securityMetadataSource = securityMetadataSource;  
  30.     }  
  31.   
  32.     @Override  
  33.     public void doFilter(ServletRequest request, ServletResponse response,  
  34.             FilterChain chain) throws IOException, ServletException {  
  35.         // TODO Auto-generated method stub\  
  36.           
  37.         FilterInvocation fi = new FilterInvocation(request, response, chain);  
  38.         //fi里面有一個被攔截的url  
  39.         //里面調用MyInvocationSecurityMetadataSource的getAttributes(Object object)這個方法獲取fi對應的所有權限  
  40.         //再調用MyAccessDecisionManager的decide方法來校驗用戶的權限是否足夠  
  41.         InterceptorStatusToken token = super.beforeInvocation(fi);  
  42.         try {  
  43.             //執行下一個攔截器  
  44.             fi.getChain().doFilter(fi.getRequest(), fi.getResponse());     
  45.         } finally {   
  46.             super.afterInvocation(token, null);    
  47.         }     
  48.           
  49.     }  
  50.   
  51.     @Override  
  52.     public void init(FilterConfig arg0) throws ServletException {  
  53.         // TODO Auto-generated method stub  
  54.           
  55.     }  
  56.   
  57.     @Override  
  58.     public Class<?> getSecureObjectClass() {  
  59.         // TODO Auto-generated method stub  
  60.         return FilterInvocation.class;   
  61.     }  
  62.   
  63.     @Override  
  64.     public SecurityMetadataSource obtainSecurityMetadataSource() {  
  65.         // TODO Auto-generated method stub  
  66.         return this.securityMetadataSource;     
  67.     }  
  68.   
  69.     @Override  
  70.     public void destroy() {  
  71.         // TODO Auto-generated method stub  
  72.     }  
  73. }  


登陸后，每次訪問資源都會被這個攔截器攔截，會執行doFilter這個方法，這個方法調用了invoke方法，其中fi斷點顯示是一個url（可能重寫了toString方法吧，但是里面還有一些方法的），最重要的是beforeInvocation這個方法，它首先會調用MyInvocationSecurityMetadataSource類的getAttributes方法獲取被攔截url所需的權限，在調用MyAccessDecisionManager類decide方法判斷用戶是否夠權限。弄完這一切就會執行下一個攔截器。


secureResourceFilterInvocationDefinitionSource實現
[java] view plain copy
print ?
  1. /** 
  2.  *  
  3.  */  
  4. package com.ultrapower.me.util.security.interceptor;  
  5.   
  6. import java.util.ArrayList;  
  7. import java.util.Collection;  
  8. import java.util.HashMap;  
  9. import java.util.Iterator;  
  10. import java.util.Map;  
  11.   
  12. import javax.servlet.ServletContext;  
  13.   
  14. import org.springframework.beans.factory.InitializingBean;  
  15. import org.springframework.security.access.ConfigAttribute;  
  16. import org.springframework.security.access.SecurityConfig;  
  17. import org.springframework.security.web.FilterInvocation;  
  18. import org.springframework.security.web.access.intercept.FilterInvocationSecurityMetadataSource;  
  19. import org.springframework.util.AntPathMatcher;  
  20. import org.springframework.util.PathMatcher;  
  21.   
  22.   
  23. public class SecureResourceFilterInvocationDefinitionSource implements FilterInvocationSecurityMetadataSource, InitializingBean {  
  24.       
  25.     private PathMatcher matcher;  
  26.       
  27.     private static Map<String, Collection<ConfigAttribute>> map = new HashMap<String, Collection<ConfigAttribute>>();  
  28.   
  29.     /*  
  30.      * 初始化用戶權限，為了簡便操作沒有從數據庫獲取 
  31.      * 實際操作可以從數據庫中獲取所有資源路徑url所對應的權限 
  32.      */  
  33.     public void afterPropertiesSet() throws Exception {  
  34.         this.matcher = new AntPathMatcher();//用來匹配訪問資源路徑  
  35.         Collection<ConfigAttribute> atts = new ArrayList<ConfigAttribute>();   
  36.         ConfigAttribute ca = new SecurityConfig("ROLE_USER");  
  37.         atts.add(ca);   
  38.         map.put("/jsp/index/main.jsp", atts);    
  39.         Collection<ConfigAttribute> attsno =new ArrayList<ConfigAttribute>();  
  40.         ConfigAttribute cano = new SecurityConfig("ROLE_NO");  
  41.         attsno.add(cano);  
  42.         map.put("/http://blog.csdn.net/u012367513/article/details/other.jsp", attsno);     
  43.     }  
  44.       
  45.        
  46.   
  47.     @Override  
  48.     public Collection<ConfigAttribute> getAttributes(Object object)  
  49.             throws IllegalArgumentException {  
  50.         // TODO Auto-generated method stub  
  51.         FilterInvocation filterInvocation = (FilterInvocation) object;  
  52.           
  53.         String requestURI = filterInvocation.getRequestUrl();  
  54.         //循環資源路徑，當訪問的Url和資源路徑url匹配時，返回該Url所需要的權限  
  55.         for(Iterator<Map.Entry<String, Collection<ConfigAttribute>>> iter = map.entrySet().iterator(); iter.hasNext();) {  
  56.               Map.Entry<String, Collection<ConfigAttribute>> entry = iter.next();  
  57.               String url = entry.getKey();  
  58.                 
  59.               if(matcher.match(url, requestURI)) {  
  60.                   return map.get(requestURI);  
  61.               }  
  62.         }  
  63.         
  64.         return null;  
  65.     }  
  66.   
  67.     @Override  
  68.     public Collection<ConfigAttribute> getAllConfigAttributes() {  
  69.         // TODO Auto-generated method stub  
  70.         return null;  
  71.     }  
  72.   
  73.     /* (non-Javadoc) 
  74.      * @see org.springframework.security.intercept.ObjectDefinitionSource#getConfigAttributeDefinitions() 
  75.      */  
  76.     @SuppressWarnings("rawtypes")  
  77.     public Collection getConfigAttributeDefinitions() {  
  78.         return null;  
  79.     }  
  80.   
  81.     /* (non-Javadoc) 
  82.      * @see org.springframework.security.intercept.ObjectDefinitionSource#supports(java.lang.Class) 
  83.      */  
  84.     public boolean supports(@SuppressWarnings("rawtypes") Class clazz) {  
  85.         return true;  
  86.     }  
  87.       
  88.     /** 
  89.      *  
  90.      * @param filterInvocation 
  91.      * @return 
  92.      */  
  93.     @SuppressWarnings("unchecked")  
  94.     private Map<String, String> getUrlAuthorities(org.springframework.security.web.FilterInvocation filterInvocation) {  
  95.         ServletContext servletContext = filterInvocation.getHttpRequest().getSession().getServletContext();  
  96.         return (Map<String, String>)servletContext.getAttribute("urlAuthorities");  
  97.     }  
  98.   
  99. }  


mesecurityAccessDecisionManager實現

[java] view plain copy
print ?
  1. package com.ultrapower.me.util.security.interceptor;  
  2.   
  3. import java.util.Collection;  
  4. import java.util.Iterator;  
  5.   
  6. import org.springframework.security.access.AccessDecisionManager;  
  7. import org.springframework.security.access.AccessDeniedException;  
  8. import org.springframework.security.access.ConfigAttribute;  
  9. import org.springframework.security.access.SecurityConfig;  
  10. import org.springframework.security.authentication.InsufficientAuthenticationException;  
  11. import org.springframework.security.core.Authentication;  
  12. import org.springframework.security.core.GrantedAuthority;  
  13.   
  14. public class SecurityAccessDecisionManager implements AccessDecisionManager {  
  15.       
  16.     /** 
  17.      * 檢查用戶是否夠權限訪問資源 
  18.      * authentication 是從spring的全局緩存SecurityContextHolder中拿到的，里面是用戶的權限信息 
  19.      * object 是url 
  20.      * configAttributes 所需的權限 
  21.      * @see org.springframework.security.access.AccessDecisionManager#decide(org.springframework.security.core.Authentication, java.lang.Object, java.util.Collection) 
  22.      */  
  23.     @Override  
  24.     public void decide(Authentication authentication, Object object,  
  25.             Collection<ConfigAttribute> configAttributes)  
  26.             throws AccessDeniedException, InsufficientAuthenticationException {  
  27.         // 對應url沒有權限時，直接跳出方法  
  28.        if(configAttributes == null){   
  29.            return;         
  30.        }    
  31.           
  32.        Iterator<ConfigAttribute> ite=configAttributes.iterator();  
  33.        //判斷用戶所擁有的權限，是否符合對應的Url權限，如果實現了UserDetailsService，則用戶權限是loadUserByUsername返回用戶所對應的權限  
  34.        while(ite.hasNext()){  
  35.            ConfigAttribute ca=ite.next();    
  36.            String needRole=((SecurityConfig)ca).getAttribute();  
  37.            for(GrantedAuthority ga : authentication.getAuthorities()){   
  38.                System.out.println(":::::::::::::"+ga.getAuthority());  
  39.                if(needRole.equals(ga.getAuthority())){    
  40.                    return;                
  41.                }              
  42.            }        
  43.        }   
  44.        //注意：執行這里，后台是會拋異常的，但是界面會跳轉到所配的access-denied-page頁面  
  45.        throw new AccessDeniedException("no right");    
  46.     }  
  47.     @Override  
  48.     public boolean supports(ConfigAttribute attribute) {  
  49.         return true;  
  50.     }  
  51.     @Override  
  52.     public boolean supports(Class<?> clazz) {  
  53.         return true;  
  54.     }  
  55.   
  56. }  

4.實現AuthenticationProvider，自定義參數驗證

這種驗證以前項目用過，現在沒有寫示例代碼，先寫下大概流程和需要用到的類
這種驗證的好處：可以在自定義登錄界面添加登錄時需要的參數，如多個驗證碼等、可以修改默認登錄名稱和密碼的參數名

整體流程：
1.用戶登錄時，先經過自定義的passcard_filter過濾器，該過濾器繼承了AbstractAuthenticationProcessingFilter，並且綁定了登錄失敗和成功時需要的處理器(跳轉頁面使用)
2.執行attemptAuthentication方法，可以通過request獲取登錄頁面傳遞的參數，實現自己的邏輯，並且把對應參數set到AbstractAuthenticationToken的實現類中
3.驗證邏輯走完后，調用 this.getAuthenticationManager().authenticate(token);方法，執行AuthenticationProvider的實現類的supports方法
4.如果返回true則繼續執行authenticate方法
5.在authenticate方法中，首先可以根據用戶名獲取到用戶信息，再者可以拿自定義參數和用戶信息做邏輯驗證，如密碼的驗證
6.自定義驗證通過以后，獲取用戶權限set到User中，用於springSecurity做權限驗證
7.this.getAuthenticationManager().authenticate(token)方法執行完后，會返回Authentication，如果不為空，則說明驗證通過
8.驗證通過后，可實現自定義邏輯操作，如記錄cookie信息
9.attemptAuthentication方法執行完成后，由springSecuriy來進行對應權限驗證，成功於否會跳轉到相對應處理器設置的界面。

1.自定義PassCardAuthenticationToken類，繼承AbstractAuthenticationToken類，用於定義參數，需要實現的方法
[java] view plain copy
print ?
  1. /** 
  2.      * 憑證，用戶密碼 
  3.      */  
  4.     @Override  
  5.     public Object getCredentials() {  
  6.         return password;  
  7.     }  
  8.   
  9.     /** 
  10.      * 當事人，登錄名 用戶Id 
  11.      */  
  12.     @Override  
  13.     public Object getPrincipal() {  
  14.         return userID;  
  15.     }  
posted @ 2018-03-08 16:09  星朝  閱讀( 2374)  評論( 0)  編輯  收藏


免責聲明！

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



猜您在找 實現spring事務的四種方式 spring AOP四種實現方式 Spring中bean的四種注入方式 四種方式實現Flex頁面跳轉 swift實現單例的四種方式 【前端】JavaScript繼承實現的四種方式 四種方式實現SQLServer 分頁查詢 Java多線程實現的四種方式 java多線程的四種實現方式 Python實現協程的四種方式
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM