九色国产,午夜在线视频,新黄色网址,九九色综合,天天做夜夜做久久做狠狠,天天躁夜夜躁狠狠躁2021a,久久不卡一区二区三区

打開APP
userphoto
未登錄

開通VIP，暢享免費電子書等14項超值服

開通VIP

首頁

好書

留言交流

下載APP

聯(lián)系客服
spring security 3.1配置過程從簡單到復雜詳細配置

  1. <span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);">廢話不多說，直接進入主題。此文章會慢慢跟新。我就在此做一個記錄。以后方便自己查閱。</span>  

spring security3.1的文檔可以去官網下，里面有jar包和說明文檔

關于Spring Security3.1的配置網上也很多，但是看看是沒有用的，還是需要自己慢慢研究搭環(huán)境。

先從最簡單的開始說起。


測試項目在：http://download.csdn.net/detail/cctv99999999/7112505    可以下載，測試通過可用。數(shù)據庫采用mysql。需要的同學可以去看一下。jar包已經配好。


環(huán)境搭建

首先我們先把環(huán)境搭起來，

我用的是spring mvc+spring securiity3.1,先要配置web.xml文件，

  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <web-app version="3.0"   
  3.     xmlns="http://java.sun.com/xml/ns/javaee"   
  4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   
  5.     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee   
  6.     http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">  
  7.       
  8.       
  9.       
  10.     <context-param>  
  11.         <param-name>contextConfigLocation</param-name>  
  12.         <param-value>/WEB-INF/security/*.xml</param-value>  
  13.     </context-param>  
  14.     <listener>  
  15.         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
  16.     </listener>  
  17.       
  18.     <servlet>  
  19.         <servlet-name>dispatcher</servlet-name>  
  20.         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  
  21.         <init-param>  
  22.             <param-name>contextConfigLocation</param-name>  
  23.             <param-value>/WEB-INF/security/dispatcher-servlet.xml</param-value>  
  24.         </init-param>  
  25.         <load-on-startup>1</load-on-startup>  
  26.     </servlet>  
  27.     <servlet-mapping>  
  28.         <servlet-name>dispatcher</servlet-name>  
  29.         <url-pattern>*.do</url-pattern>  
  30.     </servlet-mapping>  
  31.  <!-- 權限 -->    
  32.      <filter>  
  33.          <filter-name>springSecurityFilterChain</filter-name>  
  34.          <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>  
  35.      </filter>  
  36.   
  37.     <filter-mapping>  
  38.       <filter-name>springSecurityFilterChain</filter-name>  
  39.       <url-pattern>/*</url-pattern>  
  40.     </filter-mapping>  
  41.   
  42. </web-app>  

spring-security.xml是用來配置security的，dispatcher-servlet.xml是用來配置spring mvc的，

spring mvc的配置很簡單，我上面都打了注釋。

  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.        xmlns:mvc="http://www.springframework.org/schema/mvc"  
  5.        xmlns:p="http://www.springframework.org/schema/p"  
  6.        xmlns:context="http://www.springframework.org/schema/context"  
  7.        xmlns:aop="http://www.springframework.org/schema/aop"  
  8.        xmlns:tx="http://www.springframework.org/schema/tx"  
  9.        xsi:schemaLocation="http://www.springframework.org/schema/beans  
  10.             http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
  11.             http://www.springframework.org/schema/context   
  12.             http://www.springframework.org/schema/context/spring-context-3.0.xsd  
  13.             http://www.springframework.org/schema/aop   
  14.             http://www.springframework.org/schema/aop/spring-aop-3.0.xsd  
  15.             http://www.springframework.org/schema/tx   
  16.             http://www.springframework.org/schema/tx/spring-tx-3.0.xsd  
  17.             http://www.springframework.org/schema/mvc   
  18.             http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">  
  19.     <!-- 
  20.         使Spring支持自動檢測組件，如注解的Controller 
  21.     -->  
  22.    
  23.     <context:component-scan base-package="com"/>  
  24.     <aop:aspectj-autoproxy/> <!-- 開啟AOP  -->  
  25.     
  26.     
  27.      
  28.     <bean id="viewResolver"  
  29.           class="org.springframework.web.servlet.view.InternalResourceViewResolver"  
  30.           p:prefix="/jsp/"  
  31.           p:suffix=".jsp"   
  32.           />   
  33.             
  34.             
  35.             
  36.      <bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">      
  37.         <property name="messageConverters">      
  38.             <list >      
  39.                 <ref bean="mappingJacksonHttpMessageConverter" />      
  40.             </list>      
  41.         </property>      
  42.     </bean>  
  43.       
  44.       
  45.     <bean id="mappingJacksonHttpMessageConverter" class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter" />      
  46.     <!-- 數(shù)據庫連接配置 -->  
  47.     <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">  
  48.         <property name="driverClass" value="com.mysql.jdbc.Driver"></property>  
  49.         <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/power"></property>  
  50.         <property name="user" value="root"></property>  
  51.         <property name="password" value="516725"></property>  
  52.         <property name="minPoolSize" value="10"></property>  
  53.         <property name="MaxPoolSize" value="50"></property>  
  54.         <property name="MaxIdleTime" value="60"></property><!-- 最少空閑連接 -->  
  55.         <property name="acquireIncrement" value="5"></property><!-- 當連接池中的連接耗盡的時候 c3p0一次同時獲取的連接數(shù)。 -->  
  56.         <property name="TestConnectionOnCheckout" value="true" ></property>  
  57.     </bean>  
  58.     <bean id="JdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">  
  59.         <property name="dataSource">  
  60.             <ref local="dataSource"/>  
  61.         </property>  
  62.     </bean>  
  63.     <!-- 事務申明 -->  
  64.     <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
  65.         <property name="dataSource" >  
  66.             <ref local="dataSource"/>  
  67.         </property>  
  68.     </bean>  
  69.     <!-- Aop切入點 -->  
  70.     <aop:config>  
  71.         <aop:pointcut expression="within(com.ucs.security.dao.*)" id="serviceOperaton"/>  
  72.         <aop:advisor advice-ref="txadvice" pointcut-ref="serviceOperaton"/>  
  73.     </aop:config>  
  74.     <tx:advice id="txadvice" transaction-manager="transactionManager">  
  75.         <tx:attributes>  
  76.             <tx:method name="delete*" propagation="REQUIRED"/>  
  77.         </tx:attributes>  
  78.     </tx:advice>  
  79. </beans>  

這時候去配置security，我們可以去查閱官方的文檔資料。主要的配置在這網頁上：

spring-security-3.1.4.RELEASE-dist/spring-security-3.1.4.RELEASE/docs/reference/ns-config.html，在3,。1中我們可以看大下面的基礎配置文件



我們可以將第二段段基礎配置文件復制到spring-security.xml中，如下

  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans:beans xmlns="http://www.springframework.org/schema/security"  
  3.   xmlns:beans="http://www.springframework.org/schema/beans"  
  4.   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  5.   xsi:schemaLocation="http://www.springframework.org/schema/beans  
  6.            http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
  7.            http://www.springframework.org/schema/security  
  8.            http://www.springframework.org/schema/security/spring-security-3.1.xsd">  
  9.    
  10. </beans:beans>     

這樣環(huán)境基本就搭建好了。

硬編碼的簡單配置

在春天spring-securoty.xml配置文件中添加如下配置：

  1. <!-- 對所有頁面進行攔截，需要ROLE_USER權限-->  
  2.  <http auto-config='true'>  
  3.    <intercept-url pattern="/**" access="ROLE_USER" />  
  4.  </http>  
  5.  <!-- 權限配置 jimi擁有兩種權限 bob擁有一種權限-->  
  6. <authentication-manager>  
  7.    <authentication-provider>  
  8.      <user-service>  
  9.        <user name="jimi" password="123" authorities="ROLE_USER, ROLE_ADMIN" />  
  10.        <user name="bob" password="456" authorities="ROLE_USER" />  
  11.      </user-service>  
  12.    </authentication-provider>  
  13.  </authentication-manager>  
然后基本就可以啟動了。security會自動生成登錄頁面的。http://localhost:8080/spring-security/spring_security_login，這是自動生成的網頁代碼



他有默認的請求路徑和post字段，如果我們自己寫登錄頁面這些都是不能改的。


第二種是通過查數(shù)據庫來找到用戶擁有的權限來控制用戶的訪問：

建表sql 數(shù)據庫采用mysql

  1. CREATE TABLE `user` (  
  2.   
  3. `Id` int(11) NOT NULL auto_increment,  
  4.   
  5. `logname` varchar(255) default NULL,  
  6.   
  7. `password` varchar(255) default NULL,  
  8.   
  9. `role_ids` varchar(255) default NULL,  
  10.   
  11. PRIMARY KEY  (`Id`)  
  12. ) ENGINE=InnoDB DEFAULT CHARSET=utf8;  

修改spring-security.xml文件：

  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans:beans xmlns="http://www.springframework.org/schema/security"  
  3.   xmlns:beans="http://www.springframework.org/schema/beans"  
  4.   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  5.   xsi:schemaLocation="http://www.springframework.org/schema/beans  
  6.            http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
  7.            http://www.springframework.org/schema/security  
  8.            http://www.springframework.org/schema/security/spring-security-3.1.xsd">  
  9.   
  10.     <!-- 啟用方法控制訪問權限  用于直接攔截接口上的方法，擁有權限才能訪問此方法-->  
  11.     <global-method-security jsr250-annotations="enabled"/>  
  12.     <!-- 自己寫登錄頁面，并且登陸頁面不攔截 -->  
  13.     <http pattern="/jsp/login.jsp" security="none" />  
  14.       
  15.     <!-- 配置攔截頁面  -->                              <!-- 啟用頁面級權限控制 使用表達式 -->  
  16.     <http auto-config='true' access-denied-page="/jsp/403.jsp" use-expressions="true">  
  17.         <intercept-url pattern="/**" access="hasRole('ROLE_USER')" />  
  18.         <!-- 設置用戶默認登錄頁面 -->  
  19.         <form-login login-page="/jsp/login.jsp"/>  
  20.     </http>  
  21.       
  22.     <authentication-manager>  
  23.         <!-- 權限控制 引用 id是myUserDetailsService的server -->  
  24.         <authentication-provider user-service-ref="myUserDetailsService"/>  
  25.     </authentication-manager>  
  26.     
  27. </beans:beans>   

首先編輯自己的登錄頁面：登錄界面中提交的字段必須是security默認的，

  1. <%@ page language="java" contentType="text/html; charset=utf-8"  
  2.     pageEncoding="utf-8"%>  
  3. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">  
  4. <html>  
  5. <head>  
  6. <meta http-equiv="Content-Type" content="text/html; charset=utf-8">  
  7. <title>登錄界面</title>  
  8. </head>  
  9. <body>  
  10.     <h3>登錄界面</h3>  
  11.       
  12.         <form action="/spring-security/j_spring_security_check" method="post">  
  13.             <table>  
  14.                 <tr><td>User:</td><td><input type='text' name='j_username' value=''></td></tr>  
  15.                 <tr><td>Password:</td><td><input type='password' name='j_password'/></td></tr>  
  16.                 <tr><td colspan='2'><input name="submit" type="submit" value="Login"/></td></tr>  
  17.             </table>  
  18.         </form>  
  19.       
  20. </body>  
  21. </html>  

user.jsp頁面：user頁面是ROLE_USER權限界面，其中引用了security標簽，在配置文件中 use-expressions="true"代表啟用頁面控制語言，就是根據不同的權限頁面顯示該權限應該顯示的內容。如果查看網頁源代碼也是看不到初自己權限以外的內容的。

  1. <%@ page language="java" contentType="text/html; charset=utf-8" pageEncoding="utf-8"%>  
  2. <%@ taglib prefix="sec" uri="http://www.springframework.org/security/tags" %>  
  3. <%@ taglib prefix="s" uri="http://www.springframework.org/tags/form" %>  
  4. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">  
  5. <html>  
  6. <head>  
  7. <meta http-equiv="Content-Type" content="text/html; utf-8">  
  8. <title>Insert title here</title>  
  9. </head>  
  10. <body>  
  11.     <h5><a href="../j_spring_security_logout">logout</a></h5>  
  12.     <!-- 擁有ROLE_ADMIN權限的才看的到 -->  
  13.     <sec:authorize access="hasRole('ROLE_ADMIN')">  
  14.     <form action="#">  
  15.         賬號：<input type="text" /><br/>  
  16.         密碼：<input type="password"/><br/>  
  17.         <input type="submit" value="submit"/>  
  18.     </form>  
  19.     </sec:authorize>  
  20.       
  21.     <p/>  
  22.     <sec:authorize access="hasRole('ROLE_USER')">  
  23.     顯示擁有ROLE_USER權限的頁面<br/>  
  24.     <form action="#">  
  25.         賬號：<input type="text" /><br/>  
  26.         密碼：<input type="password"/><br/>  
  27.         <input type="submit" value="submit"/>  
  28.     </form>  
  29.       
  30.     </sec:authorize>  
  31.     <p/>  
  32.     <h5>測試方法控制訪問權限</h5>  
  33.     <a href="addreport_admin.do">添加報表管理員</a><br/>  
  34.     <a href="deletereport_admin.do">刪除報表管理員</a>  
  35. </body>  
  36. </html>  

Controller層

  1. package com.ucs.security.server;  
  2.   
  3.   
  4. import javax.annotation.Resource;  
  5. import javax.servlet.http.HttpServletRequest;  
  6.   
  7. import org.springframework.stereotype.Controller;  
  8. import org.springframework.web.bind.annotation.RequestMapping;  
  9. import org.springframework.web.bind.annotation.ResponseBody;  
  10. import org.springframework.web.servlet.ModelAndView;  
  11.   
  12. import com.ucs.security.face.SecurityTestInterface;  
  13.   
  14. @Controller  
  15. public class SecurityTest {  
  16.     @Resource  
  17.     private SecurityTestInterface dao;  
  18.       
  19.     @RequestMapping(value="/jsp/getinput")//查看最近收入  
  20.     @ResponseBody  
  21.     public boolean getinput(HttpServletRequest req,HttpServletRequest res){  
  22.         boolean b=dao.getinput();  
  23.         return b;  
  24.     }  
  25.       
  26.       
  27.     @RequestMapping(value="/jsp/geoutput")//查看最近支出  
  28.     @ResponseBody  
  29.     public boolean geoutput(HttpServletRequest req,HttpServletRequest res){  
  30.         boolean b=dao.geoutput();  
  31.         return b;  
  32.     }  
  33.       
  34.     @RequestMapping(value="/jsp/addreport_admin")//添加報表管理員  
  35.     @ResponseBody  
  36.     public boolean addreport_admin(HttpServletRequest req,HttpServletRequest res){  
  37.         boolean b=dao.addreport_admin();  
  38.         return b;  
  39.     }  
  40.       
  41.     @RequestMapping(value="/jsp/deletereport_admin")//刪除報表管理員  
  42.     @ResponseBody  
  43.     public boolean deletereport_admin(HttpServletRequest req,HttpServletRequest res){  
  44.         boolean b=dao.deletereport_admin();  
  45.         return b;  
  46.     }  
  47.       
  48.     @RequestMapping(value="/jsp/user")//普通用戶登錄  
  49.     public ModelAndView user_login(HttpServletRequest req,HttpServletRequest res){  
  50.         dao.user_login();  
  51.         return new ModelAndView("user");  
  52.     }  
  53.       
  54. }  

接口： 在配置文件中<global-method-security jsr250-annotations="enabled"/>就是在接口上設置權限，當擁有權限時才能調用方法，沒有權限是不能調用方法的，保證了安全性

  1. package com.ucs.security.face;  
  2.   
  3. import javax.annotation.security.RolesAllowed;  
  4.   
  5. import com.ucs.security.pojo.Users;  
  6.   
  7. public interface SecurityTestInterface {  
  8.   
  9.     boolean getinput();  
  10.   
  11.     boolean geoutput();  
  12.     @RolesAllowed("ROLE_ADMIN")//擁有ROLE_ADMIN權限的用戶才可進入此方法  
  13.     boolean addreport_admin();  
  14.     @RolesAllowed("ROLE_ADMIN")  
  15.     boolean deletereport_admin();  
  16.       
  17.     Users findbyUsername(String name);  
  18.     @RolesAllowed("ROLE_USER")  
  19.     void user_login();  
  20.   
  21. }  

實現(xiàn)類 dao

  1. package com.ucs.security.dao;  
  2. import java.sql.SQLException;  
  3. import javax.annotation.Resource;  
  4. import org.apache.log4j.Logger;  
  5. import org.springframework.jdbc.core.JdbcTemplate;  
  6. import org.springframework.jdbc.core.RowCallbackHandler;  
  7. import org.springframework.stereotype.Repository;  
  8. import com.ucs.security.face.SecurityTestInterface;  
  9. import com.ucs.security.pojo.Users;  
  10.   
  11. @Repository("SecurityTestDao")  
  12. public class SecurityTestDao implements SecurityTestInterface{  
  13.     Logger log=Logger.getLogger(SecurityTestDao.class);  
  14.       
  15.     @Resource  
  16.     private JdbcTemplate jdbcTamplate;  
  17.     public boolean getinput() {  
  18.         log.info("getinput");  
  19.         return true;  
  20.     }  
  21.       
  22.     public boolean geoutput() {  
  23.         log.info("geoutput");  
  24.         return true;  
  25.     }  
  26.   
  27.     public boolean addreport_admin() {  
  28.         log.info("addreport_admin");  
  29.         return true;  
  30.     }  
  31.   
  32.     public boolean deletereport_admin() {  
  33.         log.info("deletereport_admin");  
  34.         return true;  
  35.     }  
  36.   
  37.   
  38.     public Users findbyUsername(String name) {  
  39.         final Users users = new Users();    
  40.         jdbcTamplate.query("SELECT * FROM USER WHERE logname = ?",    
  41.                             new Object[] {name},    
  42.                             new RowCallbackHandler() {    
  43.                                 @Override  
  44.                                 public void processRow(java.sql.ResultSet rs)  
  45.                                         throws SQLException {  
  46.                                  users.setName(rs.getString("logname"));  
  47.                                  users.setPassword(rs.getString("password"));  
  48.                                  users.setRole(rs.getString("role_ids"));  
  49.                                 }    
  50.                             });    
  51.         log.info(users.getName()+"    "+users.getPassword()+"    "+users.getRole());  
  52.         return users;  
  53.     }  
  54.   
  55.       
  56.           
  57.     @Override  
  58.     public void user_login() {  
  59.         log.info("擁有ROLE_USER權限的方法訪問：user_login");  
  60.           
  61.     }  
  62.   
  63. }  

下面就是重要的一個類：MyUserDetailsService這個類需要去實現(xiàn)UserDetailsService這個接口；

  1. package com.ucs.security.context;  
  2.   
  3. import java.util.HashSet;  
  4. import java.util.Set;  
  5.   
  6. import javax.annotation.Resource;  
  7.   
  8. import org.springframework.security.core.GrantedAuthority;  
  9. import org.springframework.security.core.authority.GrantedAuthorityImpl;  
  10. import org.springframework.security.core.userdetails.User;  
  11. import org.springframework.security.core.userdetails.UserDetails;  
  12. import org.springframework.security.core.userdetails.UserDetailsService;  
  13. import org.springframework.security.core.userdetails.UsernameNotFoundException;  
  14. import org.springframework.stereotype.Service;  
  15.   
  16. import com.ucs.security.face.SecurityTestInterface;  
  17. import com.ucs.security.pojo.Users;  
  18. /** 
  19.  * 在spring-security.xml中如果配置了 
  20.  * <authentication-manager> 
  21.         <authentication-provider user-service-ref="myUserDetailsService" /> 
  22.   </authentication-manager> 
  23.  * 將會使用這個類進行權限的驗證。 
  24.  *  
  25.  * **/  
  26. @Service("myUserDetailsService")  
  27. public class MyUserDetailsService implements UserDetailsService{  
  28.     @Resource  
  29.     private SecurityTestInterface dao;  
  30.   
  31.     //登錄驗證  
  32.     public UserDetails loadUserByUsername(String name)  
  33.             throws UsernameNotFoundException {  
  34.         System.out.println("show login name："+name+" ");  
  35.         Users users =dao.findbyUsername(name);  
  36.         Set<GrantedAuthority> grantedAuths=obtionGrantedAuthorities(users);  
  37.           
  38.         boolean enables = true;  
  39.         boolean accountNonExpired = true;  
  40.         boolean credentialsNonExpired = true;  
  41.         boolean accountNonLocked = true;  
  42.         //封裝成spring security的user  
  43.         User userdetail = new User(users.getName(), users.getPassword(), enables, accountNonExpired, credentialsNonExpired, accountNonLocked, grantedAuths);  
  44.         return userdetail;  
  45.     }  
  46.     //查找用戶權限  
  47.     public Set<GrantedAuthority> obtionGrantedAuthorities(Users users){  
  48.         Set<GrantedAuthority> authSet=new HashSet<GrantedAuthority>();  
  49.         authSet.add(new GrantedAuthorityImpl(users.getRole()));  
  50.         return authSet;  
  51.     }  
  52.   
  53. }  
登錄的時候獲取登錄的用戶名，然后通過數(shù)據庫去查找該用戶擁有的權限將權限增加到Set<GrantedAuthority>中，當然可以加多個權限進去，只要用戶擁有其中一個權限就可以登錄進來。

然后將從數(shù)據庫查到的密碼和權限設置到security自己的User類中，security會自己去匹配前端發(fā)來的密碼和用戶權限去對比，然后判斷用戶是否可以登錄進來。登錄失敗還是停留在登錄界面。

在user.jsp中測試了用戶權限來驗證是否可以攔截沒有權限用戶去訪問資源：

點擊添加報表管理員或者刪除報表管理員時候會跳到403.jsp因為沒有權限去訪問資源，在接口上我們設置了訪問的權限：

  1. @RolesAllowed("ROLE_ADMIN")//擁有ROLE_ADMIN權限的用戶才可進入此方法  
  2.     boolean addreport_admin();  
  3.     @RolesAllowed("ROLE_ADMIN")  
  4.     boolean deletereport_admin();  

因為登錄進來的用戶時ROLE_USER權限的。就被攔截下來。logout是登出，返回到登錄界面，并且用戶在security中的緩存清掉了。一樣會對資源進行攔截。


接下來應該是對訪問url進行資源權限管理，

先說說上面的那種方法吧，在接口上加上權限，其實這已經差不多可以在一般的項目中可以使用。作為管理員用戶他可以有多種角色，那么他可以在訪問ROLE_USER,ROLE_ADMIN的東西，而在接口上沒有加上訪問權限的，最為公共部分，每個人都可以訪問的，訪問需要驗證的資源就會自動跳轉到登錄界面，登錄后訪問沒有權限的資源就會提示403,沒有權限?；究梢詽M足項目需求。在spring-security.xml中也就不需要配置，可以讓所有的地址同行。這種方法是簡單，但是不靈活。如果項目是在做了的時候固定什么用戶有什么權限，可以訪問哪些方法，那么這種配置時比較簡單的，但是如果項目需要后期超級管理員可以更改角色可以訪問哪些資源的話，那么這種昂發(fā)就不行了。需要用將角色可訪問資源鏈接保存到數(shù)據庫，可以隨時更改。

下面就介紹這種可以修改角色訪問資源的靈活配置。用哪種方法還是更具項目需求而定。


需要修改配置文件在http標簽里添加custom-filter，添加資源權限控制配置，資源權限控制中涉及到兩個類。MyAccessDecisionManager和MySecurityMetadataSource

先寫上spring-security.xml的配置文件；

  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans:beans xmlns="http://www.springframework.org/schema/security"  
  3.   xmlns:beans="http://www.springframework.org/schema/beans"  
  4.   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  5.   xsi:schemaLocation="http://www.springframework.org/schema/beans  
  6.            http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
  7.            http://www.springframework.org/schema/security  
  8.            http://www.springframework.org/schema/security/spring-security-3.1.xsd">  
  9.   
  10.   
  11.     <!-- 啟用方法控制訪問權限  用于直接攔截接口上的方法，擁有權限才能訪問此方法-->  
  12.     <global-method-security jsr250-annotations="enabled"/>  
  13.     <!-- 自己寫登錄頁面，并且登陸頁面不攔截 -->  
  14.     <http pattern="/jsp/login.jsp" security="none" />  
  15.       
  16.     <!-- 配置攔截頁面  -->                              <!-- 啟用頁面級權限控制 使用表達式 -->  
  17.     <http auto-config='true' access-denied-page="/jsp/403.jsp" use-expressions="true">  
  18.                                     <!-- requires-channel="any" 設置訪問類型http或者https -->  
  19.         <intercept-url pattern="/admin/**" access="hasRole('ROLE_ADMIN')" requires-channel="any"/>    
  20.         <!-- intercept-url pattern="/admin/**" 攔截地址的設置有加載先后的順序，  
  21.         admin/**在前面請求admin/admin.jsp會先去拿用戶驗證是否有ROLE_ADMIN權限，有則通過，沒有就攔截。如果shi   
  22.         pattern="/**" 設置在前面，當前登錄的用戶有ROLE_USER權限，那么就可以登錄到admin/admin.jsp  
  23.         所以兩個配置有先后的。  
  24.          -->  
  25.         <intercept-url pattern="/**" access="hasRole('ROLE_USER')" requires-channel="any"/>     
  26.           
  27.         <!-- 設置用戶默認登錄頁面 -->  
  28.         <form-login login-page="/jsp/login.jsp"/>  
  29.         <!-- 基于url的權限控制，加載權限資源管理攔截器,如果進行這樣的設置，那么  
  30.          <intercept-url pattern="/admin/**" 就可以不進行配置了，會在數(shù)據庫的資源權限中得到對應。  
  31.          對于沒有找到資源的權限為null的值就不需要登錄才可以查看，相當于public的。可以公共訪問  
  32.           -->  
  33.         <custom-filter ref="securityFilter" before="FILTER_SECURITY_INTERCEPTOR"/>  
  34.     </http>  
  35.       
  36.     <!-- 當基于方法權限控制的時候只需要此配置，在接口上加上權限即可控制方法的調用  
  37.     <authentication-manager>  
  38.         <authentication-provider user-service-ref="myUserDetailsService"/>  
  39.     </authentication-manager>  
  40.       -->  
  41.       
  42.       
  43.     <!-- 資源權限控制 -->  
  44.     <beans:bean id="securityFilter" class="com.ucs.security.context.MySecurityFilter">  
  45.         <!-- 用戶擁有的權限 -->  
  46.         <beans:property name="authenticationManager" ref="myAuthenticationManager" />  
  47.         <!-- 用戶是否擁有所請求資源的權限 -->  
  48.         <beans:property name="accessDecisionManager" ref="myAccessDecisionManager" />  
  49.         <!-- 資源與權限對應關系 -->  
  50.         <beans:property name="securityMetadataSource" ref="mySecurityMetadataSource" />  
  51.     </beans:bean>  
  52.       
  53.       
  54.     <authentication-manager alias="myAuthenticationManager">  
  55.         <!-- 權限控制 引用 id是myUserDetailsService的server -->  
  56.         <authentication-provider user-service-ref="myUserDetailsService"/>  
  57.     </authentication-manager>  
  58. </beans:beans>              

在http標簽中添加了：<custom-filter ref="securityFilter" before="FILTER_SECURITY_INTERCEPTOR"/>,用于地址的攔截

MySecurityFilter這個類是攔截中一個主要的類，攔截的時候會先通過這里：

  1. package com.ucs.security.context;  
  2.   
  3. import java.io.IOException;  
  4.   
  5. import javax.annotation.Resource;  
  6. import javax.servlet.Filter;  
  7. import javax.servlet.FilterChain;  
  8. import javax.servlet.FilterConfig;  
  9. import javax.servlet.ServletException;  
  10. import javax.servlet.ServletRequest;  
  11. import javax.servlet.ServletResponse;  
  12.   
  13. import org.apache.log4j.Logger;  
  14. import org.springframework.security.access.SecurityMetadataSource;  
  15. import org.springframework.security.access.intercept.AbstractSecurityInterceptor;  
  16. import org.springframework.security.access.intercept.InterceptorStatusToken;  
  17. import org.springframework.security.web.FilterInvocation;  
  18. import org.springframework.security.web.access.intercept.FilterInvocationSecurityMetadataSource;  
  19.   
  20.   
  21.   
  22. public class MySecurityFilter extends AbstractSecurityInterceptor implements Filter {  
  23.     Logger log=Logger.getLogger(MySecurityFilter.class);  
  24.       
  25.     private FilterInvocationSecurityMetadataSource securityMetadataSource;  
  26.     public SecurityMetadataSource obtainSecurityMetadataSource() {  
  27.         return this.securityMetadataSource;  
  28.     }  
  29.     public FilterInvocationSecurityMetadataSource getSecurityMetadataSource() {  
  30.         return securityMetadataSource;  
  31.     }  
  32.   
  33.     public void setSecurityMetadataSource(  
  34.             FilterInvocationSecurityMetadataSource securityMetadataSource) {  
  35.         this.securityMetadataSource = securityMetadataSource;  
  36.     }  
  37.   
  38.     @Override  
  39.     public void destroy() {  
  40.         // TODO Auto-generated method stub  
  41.           
  42.     }  
  43.   
  44.     @Override  
  45.     public void doFilter(ServletRequest req, ServletResponse res,  
  46.             FilterChain chain) throws IOException, ServletException {  
  47.         FilterInvocation fi=new FilterInvocation(req,res,chain);  
  48.         log.info("--------MySecurityFilter--------");  
  49.         invok(fi);  
  50.     }  
  51.   
  52.       
  53.   
  54.     private void invok(FilterInvocation fi) throws IOException, ServletException {  
  55.         // object為FilterInvocation對象  
  56.         //1.獲取請求資源的權限  
  57.         //執(zhí)行Collection<ConfigAttribute> attributes = SecurityMetadataSource.getAttributes(object);  
  58.         //2.是否擁有權限  
  59.         //獲取安全主體，可以強制轉換為UserDetails的實例  
  60.         //1) UserDetails  
  61.         // Authentication authenticated = authenticateIfRequired();  
  62.         //this.accessDecisionManager.decide(authenticated, object, attributes);  
  63.         //用戶擁有的權限  
  64.         //2) GrantedAuthority  
  65.         //Collection<GrantedAuthority> authenticated.getAuthorities()  
  66.         log.info("用戶發(fā)送請求！ ");  
  67.         InterceptorStatusToken token = null;  
  68.           
  69.         token = super.beforeInvocation(fi);  
  70.           
  71.         try {  
  72.             fi.getChain().doFilter(fi.getRequest(), fi.getResponse());  
  73.         } finally {  
  74.             super.afterInvocation(token, null);  
  75.         }  
  76.     }  
  77.   
  78.     @Override  
  79.     public void init(FilterConfig arg0) throws ServletException {  
  80.         // TODO Auto-generated method stub  
  81.           
  82.     }  
  83.   
  84.       
  85.     public Class<? extends Object> getSecureObjectClass() {  
  86.         //下面的MyAccessDecisionManager的supports方面必須放回true,否則會提醒類型錯誤  
  87.         return FilterInvocation.class;  
  88.     }  
  89.       
  90.   
  91. }  

MySecurityMetadataSource這個類是查找和匹配所有角色的資源對應關系的，通過訪問一個資源，可以得到這個資源的角色，返貨給下一個類MyAccessDecisionManager去判斷是夠可以放行通過驗證。

  1. package com.ucs.security.context;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.Collection;  
  5. import java.util.HashMap;  
  6. import java.util.Iterator;  
  7. import java.util.List;  
  8. import java.util.Map;  
  9. import java.util.Set;  
  10. import java.util.Map.Entry;  
  11.   
  12. import javax.annotation.Resource;  
  13.   
  14. import org.apache.log4j.Logger;  
  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.stereotype.Service;  
  20.   
  21. import com.google.gson.Gson;  
  22. import com.ucs.security.face.SecurityTestInterface;  
  23. import com.ucs.security.pojo.URLResource;  
  24.   
  25.   
  26.   
  27. @Service("mySecurityMetadataSource")  
  28. public class MySecurityMetadataSource implements FilterInvocationSecurityMetadataSource{  
  29.     //由spring調用  
  30.     Logger log=Logger.getLogger(MySecurityMetadataSource.class);  
  31.     @Resource  
  32.     private SecurityTestInterface dao;  
  33.     private static Map<String, Collection<ConfigAttribute>> resourceMap = null;  
  34.   
  35.     /*public MySecurityMetadataSource() { 
  36.          
  37.         loadResourceDefine(); 
  38.     }*/  
  39.       
  40.   
  41.     public Collection<ConfigAttribute> getAllConfigAttributes() {  
  42.         // TODO Auto-generated method stub  
  43.         return null;  
  44.     }  
  45.   
  46.     public boolean supports(Class<?> clazz) {  
  47.         // TODO Auto-generated method stub  
  48.         return true;  
  49.     }  
  50.     //加載所有資源與權限的關系  
  51.     private void loadResourceDefine() {  
  52.         if(resourceMap == null) {  
  53.             resourceMap = new HashMap<String, Collection<ConfigAttribute>>();  
  54.             /*List<String> resources ; 
  55.             resources = Lists.newArrayList("/jsp/user.do","/jsp/getoutput.do");*/  
  56.             List<URLResource> findResources = dao.findResource();  
  57.               
  58.             for(URLResource url_resource:findResources){  
  59.                 Collection<ConfigAttribute> configAttributes = new ArrayList<ConfigAttribute>();  
  60.                 ConfigAttribute configAttribute = new SecurityConfig(url_resource.getRole_Name());  
  61.                 for(String resource:url_resource.getRole_url()){  
  62.                     configAttributes.add(configAttribute);  
  63.                     resourceMap.put(resource, configAttributes);  
  64.                 }  
  65.                   
  66.             }  
  67.             //以權限名封裝為Spring的security Object  
  68.               
  69.         }  
  70.         Gson gson =new Gson();  
  71.         log.info("權限資源對應關系："+gson.toJson(resourceMap));  
  72.           
  73.           
  74.         Set<Entry<String, Collection<ConfigAttribute>>> resourceSet = resourceMap.entrySet();  
  75.         Iterator<Entry<String, Collection<ConfigAttribute>>> iterator = resourceSet.iterator();  
  76.           
  77.     }  
  78.     //返回所請求資源所需要的權限  
  79.     public Collection<ConfigAttribute> getAttributes(Object object) throws IllegalArgumentException {  
  80.           
  81.         String requestUrl = ((FilterInvocation) object).getRequestUrl();  
  82.         log.info("requestUrl is " + requestUrl);  
  83.         if(resourceMap == null) {  
  84.             loadResourceDefine();  
  85.         }  
  86.         log.info("通過資源定位到的權限："+resourceMap.get(requestUrl));  
  87.         return resourceMap.get(requestUrl);  
  88.     }  
  89.   
  90. }  

MyAccessDecisionManager這個類，就是獲取到請求資源的角色后判斷用戶是否有這個權限可以訪問這個資源。如果獲取到的角色是null，那就放行通過，這主要是對于那些不需要驗證的公共可以訪問的方法。就不需要權限了?？梢灾苯釉L問。

  1. import java.util.Collection;  
  2. import java.util.Iterator;  
  3. import org.apache.log4j.Logger;  
  4. import org.springframework.security.access.AccessDecisionManager;  
  5. import org.springframework.security.access.AccessDeniedException;  
  6. import org.springframework.security.access.ConfigAttribute;  
  7. import org.springframework.security.authentication.InsufficientAuthenticationException;  
  8. import org.springframework.security.core.Authentication;  
  9. import org.springframework.security.core.GrantedAuthority;  
  10. import org.springframework.stereotype.Service;  
  11. @Service("myAccessDecisionManager")  
  12. public class MyAccessDecisionManager implements AccessDecisionManager{  
  13.     Logger log=Logger.getLogger(MyAccessDecisionManager.class);  
  14.     @Override  
  15.     public void decide(Authentication authentication, Object object,  
  16.             Collection<ConfigAttribute> configAttributes) throws AccessDeniedException,  
  17.             InsufficientAuthenticationException {  
  18.             // TODO Auto-generated method stub  
  19.         //如果對應資源沒有找到角色 則放行  
  20.             if(configAttributes == null){  
  21.                   
  22.                 return ;  
  23.             }  
  24.           
  25.             log.info("object is a URL:"+object.toString());  //object is a URL.  
  26.             Iterator<ConfigAttribute> ite=configAttributes.iterator();  
  27.             while(ite.hasNext()){  
  28.                 ConfigAttribute ca=ite.next();  
  29.                 String needRole=ca.getAttribute();  
  30.                 for(GrantedAuthority ga:authentication.getAuthorities()){  
  31.                     if(needRole.equals(ga.getAuthority())){  //ga is user's role.  
  32.                         return;  
  33.                     }  
  34.                 }  
  35.             }  
  36.             throw new AccessDeniedException("no right");  
  37.               
  38.           
  39.   
  40.           
  41.     }  
  42.   
  43.     @Override  
  44.     public boolean supports(ConfigAttribute arg0) {  
  45.         // TODO Auto-generated method stub  
  46.         return true;  
  47.     }  
  48.   
  49.     @Override  
  50.     public boolean supports(Class<?> arg0) {  
  51.         // TODO Auto-generated method stub  
  52.         return true;  
  53.     }  
  54.   
  55. }  

dao的數(shù)據庫的查找的代碼就補貼出來了。

security的權限控制小總結

首先用戶沒有登錄的時候可以訪問一些公共的資源，但是必須把<intercept-url pattern="/**" access="hasRole('ROLE_USER')" requires-channel="any"/>  配置刪掉，不攔截，任何資源都可以訪問，這樣公共資源可以任意訪問。

對于需要權限的資源已經在數(shù)據庫配置，如果去訪問會直接跳到登錄界面。需要登錄。

根據登錄用戶不同分配到的角色就不一樣，根據角色不同來獲取該角色可以訪問的資源。

擁有ROLE_USER角色用戶去訪問ROLE_ADMIN的資源會返回到403.jsp頁面。擁有ROLE_USER和ROLE_ADMIN角色的用戶可以去訪問兩種角色的資源。公共的資源兩種角色都可以訪問。

security提供了默認的登出地址。登出后用戶在spring中的緩存就清除了。

之前做過基于spring-AOP的url和角色的控制，那時候覺得還不錯，能做一些簡單的權限控制。學習完security發(fā)現(xiàn)security真的是很專業(yè)啊。能做復雜的權限控制，還只支持頁面上的權限控制。





本站僅提供存儲服務，所有內容均由用戶發(fā)布，如發(fā)現(xiàn)有害或侵權內容，請點擊舉報。
打開APP，閱讀全文并永久保存 查看更多類似文章
猜你喜歡
類似文章
Spring Security3的使用方法有4種
使用Spring Security實現(xiàn)權限管理
Spring Security筆記：使用數(shù)據庫進行用戶認證(form login using database)
spring boot-admin 監(jiān)控中心 配置登錄密碼
SpringSide 3 中的安全框架
Dubbo與Zookeeper、SpringMVC整合和使用（負載均衡、容錯）配置詳解，dubbo-admin 下載
更多類似文章 >>
生活服務
熱點新聞
分享 收藏 導長圖 關注 下載文章
綁定賬號成功
后續(xù)可登錄賬號暢享VIP特權！
如果VIP功能使用有故障，
可點擊這里聯(lián)系客服！

聯(lián)系客服