權限控制框架-shiro

時間  2021-01-05

一。 shiro簡介

Apache Shiro（發音爲「shee-roh」，日語「堡壘（Castle）」的意思）是一個強大易用的Java安全框架，提供了認證、授權、加密和會話管理功能，可爲任何應用提供安全保障 - 從命令行應用、移動應用到大型網絡及企業應用。
Shiro爲解決下列問題（我喜歡稱它們爲應用安全的四要素）提供了保護應用的API：

  • 認證 - 用戶身份識別，常被稱爲用戶「登錄」；
  • 授權 - 訪問控制；
  • 密碼加密 - 保護或隱藏數據防止被偷窺；
  • 會話管理 - 每用戶相關的時間敏感的狀態。
Shiro還支持一些輔助特性，如Web應用安全、單元測試和多線程，它們的存在強化了上面提到的四個要素

從2003年至今，框架選擇方面的情況已經改變了不少，但今天仍有令人信服的理由讓你選擇Shiro。其實理由相當多，Apache Shiro：

  • 易於使用 - 易用性是這個項目的最終目標。應用安全有可能會非常讓人糊塗，令人沮喪，並被認爲是「必要之惡」【譯註：比喻應用安全方面的編程。】。若是能讓它簡化到新手都能很快上手，那它將不再是一種痛苦了。
  • 廣泛性 - 沒有其他安全框架可以達到Apache Shiro宣稱的廣度，它可以爲你的安全需求提供「一站式」服務。
  • 靈活性 - Apache Shiro可以工作在任何應用環境中。雖然它工作在Web、EJB和IoC環境中，但它並不依賴這些環境。Shiro既不強加任何規範，也無需過多依賴。
  • Web能力 - Apache Shiro對Web應用的支持很神奇，允許你基於應用URL和Web協議（如REST）創建靈活的安全策略，同時還提供了一套控制頁面輸出的JSP標籤庫。
  • 可插拔 - Shiro乾淨的API和設計模式使它可以方便地與許多的其他框架和應用進行集成。你將看到Shiro可以與諸如Spring、Grails、Wicket、Tapestry、Mule、Apache Camel、Vaadin這類第三方框架無縫集成。
支持 - Apache Shiro是Apache軟件基金會成員，這是一個公認爲了社區利益最大化而行動的組織。項目開發和用戶組都有隨時願意提供幫助的友善成員。像Katasoft這類商業公司，還可以給你提供需要的專業支持和服務。

核心概念：Subject，SecurityManager和Realms 

Subject 

       Subject一詞是一個安全術語，其基本意思是「當前的操作用戶」。稱之爲「用戶」並不準確，因爲「用戶」一詞通常跟人相關。在安全領域，術語「Subject」可以是人，也可以是第三方進程、後臺帳戶（Daemon Account）或其他類似事物。它僅僅意味着「當前跟軟件交互的東西」。但考慮到大多數目的和用途，你可以把它認爲是Shiro的「用戶」概念。在代碼的任何地方，你都能輕易的獲得Shiro Subject，

SecurityManager

Subject的「幕後」推手是SecurityManager。Subject代表了當前用戶的安全操作，SecurityManager則管理所有用戶的安全操作。它是Shiro框架的核心，充當「保護傘」，引用了多個內部嵌套安全組件，它們形成了對象圖。但是，一旦SecurityManager及其內部對象圖配置好，它就會退居幕後，應用開發人員幾乎把他們的所有時間都花在Subject API調用上。
那麼，如何設置SecurityManager呢？嗯，這要看應用的環境。例如，Web應用通常會在Web.xml中指定一個Shiro Servlet Filter，這會創建SecurityManager實例，如果你運行的是一個獨立應用，你需要用其他配置方式，但有很多配置選項。
一個應用幾乎總是隻有一個SecurityManager實例。它實際是應用的Singleton（儘管不必是一個靜態Singleton）。跟Shiro裏的幾乎所有組件一樣，SecurityManager的缺省實現是POJO，而且可用POJO兼容的任何配置機制進行配置 - 普通的Java代碼、Spring XML、YAML、.properties和.ini文件等。基本來講，能夠實例化類和調用JavaBean兼容方法的任何配置形式都可使用。
爲此，Shiro藉助基於文本的INI配置提供了一個缺省的「公共」解決方案。INI易於閱讀、使用簡單並且需要極少依賴。你還能看到，只要簡單地理解對象導航，INI可被有效地用於配置像SecurityManager那樣簡單的對象圖。注意，Shiro還支持Spring XML配置及其他方式，但這裏只我們只討論INI。
Realms
Shiro的第三個也是最後一個概念是Realm。Realm充當了Shiro與應用安全數據間的「橋樑」或者「連接器」。也就是說，當切實與像用戶帳戶這類安全相關數據進行交互，執行認證（登錄）和授權（訪問控制）時，Shiro會從應用配置的Realm中查找很多內容。
從這個意義上講，Realm實質上是一個安全相關的DAO：它封裝了數據源的連接細節，並在需要時將相關數據提供給Shiro。當配置Shiro時，你必須至少指定一個Realm，用於認證和（或）授權。配置多個Realm是可以的，但是至少需要一個。
Shiro內置了可以連接大量安全數據源（又名目錄）的Realm，如LDAP、關係數據庫（JDBC）、類似INI的文本配置資源以及屬性文件等。如果缺省的Realm不能滿足需求，你還可以插入代表自定義數據源的自己的Realm實現

文字摘自 （http://www.infoq.com/cn/articles/apache-shiro）

shiro架構 


除前面所講Subject、SecurityManager 、Realm三個核心組件外，Shiro主要組件還包括： 

  • Authenticator ：認證就是覈實用戶身份的過程。這個過程的常見例子是大家都熟悉的「用戶/密碼」組合。多數用戶在登錄軟件系統時，通常提供自己的用戶名（當事人）和支持他們的密碼（證書）。如果存儲在系統中的密碼（或密碼錶示）與用戶提供的匹配，他們就被認爲通過認證。 
  • Authorizer ：授權實質上就是訪問控制 - 控制用戶能夠訪問應用中的哪些內容，比如資源、Web頁面等等。 
  • SessionManager ：在安全框架領域，Apache Shiro提供了一些獨特的東西：可在任何應用或架構層一致地使用Session API。即，Shiro爲任何應用提供了一個會話編程範式 - 從小型後臺獨立應用到大型集羣Web應用。這意味着，那些希望使用會話的應用開發者，不必被迫使用Servlet或EJB容器了。或者，如果正在使用這些容器，開發者現在也可以選擇使用在任何層統一一致的會話API，取代Servlet或EJB機制。 
  • CacheManager :對Shiro的其他組件提供緩存支持。 
  • Cryptography 提供安全的支持

常用的操作
ini配置權限信息（參考http://shiro.apache.org/configuration.html）

[html]  view plain  copy
  1. # =======================  
  2. # Shiro INI configuration  
  3. # =======================  
  4.   
  5. [main]  
  6.   
  7. [users]  
  8. # 設置用戶信息  
  9. # 語法是 username = password, roleName1, roleName2, …, roleNameN  
  10. jiaozi = 123456,role1  
  11.   
  12. [roles]  
  13. # 角色信息和角色擁有的權限  
  14. #語法是 rolename = permissionDefinition1, permissionDefinition2, …, permissionDefinitionN  
  15. #權限的語法 * 表示所有權限  一般語法是 權限類型.權限動作.權限的資源id  比如  user:delete:1 表示擁有刪除1號用戶的權限  user:delete:*表示刪除所有用戶權限  
  16. admin = *  
  17. role1 = user:query:*, user:delete:1  
  18.   
  19. [urls]  
  20. # web中的url過濾  
maven項目添加支持
[html]  view plain  copy
  1.     <dependency>  
  2.         <groupId>org.apache.shiro</groupId>  
  3.         <artifactId>shiro-core</artifactId>  
  4.         <version>1.4.0</version>  
  5.     </dependency>  
  6.     <!-- https://mvnrepository.com/artifact/commons-logging/commons-logging -->  
  7. <dependency>  
  8.     <groupId>commons-logging</groupId>  
  9.     <artifactId>commons-logging</artifactId>  
  10.     <version>1.2</version>  
  11. </dependency>  
測試驗證權限過程（參考http://shiro.apache.org/10-minute-tutorial.html）
[html]  view plain  copy
  1. package shiro;  
  2.   
  3. import org.apache.shiro.SecurityUtils;  
  4. import org.apache.shiro.authc.UsernamePasswordToken;  
  5. import org.apache.shiro.config.IniSecurityManagerFactory;  
  6. import org.apache.shiro.session.Session;  
  7. import org.apache.shiro.subject.Subject;  
  8. import org.apache.shiro.util.Factory;  
  9.   
  10. public class TestShiro {  
  11.     public static void main(String[] args) {  
  12.         testIni();  
  13.     }  
  14.     public static void testIni() {  
  15.         //從配置文件中讀取用戶的權限信息  
  16.         Factory<org.apache.shiro.mgt.SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro.ini");  
  17.         org.apache.shiro.mgt.SecurityManager securityManager = (org.apache.shiro.mgt.SecurityManager)factory.getInstance();  
  18.         SecurityUtils.setSecurityManager(securityManager);  
  19.         //獲取登錄用戶信息  
  20.         Subject currentUser = SecurityUtils.getSubject();  
  21.         Session session = currentUser.getSession();  
  22.         session.setAttribute( "保存數據的鍵", "保存數據的值" );  
  23.         /**  
  24.          * 用戶包括兩部分   
  25. //       *    principals and credentials  
  26.          *     principals（本人）表示用戶的標識信息 比如用戶名 用戶地址等  
  27.          *     credentials（憑證）表示用戶用於登錄的憑證 比如密碼 證書等  
  28.          */  
  29.         //isAuthenticated判斷是否登錄過  
  30.         if ( !currentUser.isAuthenticated() ) {  
  31.             //令牌 用戶名和密碼 其實就是credentials  
  32.             UsernamePasswordToken token = new UsernamePasswordToken("jiaozi", "123456");  
  33.             token.setRememberMe(true);  
  34.             //開始登錄操作  操作後 isAuthenticated就是true  
  35.             currentUser.login(token);  
  36.             System.out.println("登錄成功");  
  37.             //判斷是否有某個角色  
  38.             if(currentUser.hasRole("role1")){  
  39.                 System.out.println("擁有角色role1");  
  40.             }  
  41.             if(currentUser.isPermitted("user:query:1")){  
  42.                 System.out.println("擁有查詢1號用戶權限");  
  43.             }  
  44.         }  
  45.           
  46.         currentUser.logout();  
  47.           
  48.     }  
  49.       
  50. }  
一般權限信息存在於是數據庫 我這裏模擬放在內存變量map中 

添加realm的實現類

[html]  view plain  copy
  1. package shiro;  
  2.   
  3. import java.util.HashMap;  
  4. import java.util.HashSet;  
  5. import java.util.Map;  
  6. import java.util.Set;  
  7.   
  8. import org.apache.shiro.authc.AuthenticationException;  
  9. import org.apache.shiro.authc.AuthenticationInfo;  
  10. import org.apache.shiro.authc.AuthenticationToken;  
  11. import org.apache.shiro.authc.SimpleAccount;  
  12. import org.apache.shiro.authc.UsernamePasswordToken;  
  13. import org.apache.shiro.authz.AuthorizationInfo;  
  14. import org.apache.shiro.authz.SimpleAuthorizationInfo;  
  15. import org.apache.shiro.realm.AuthorizingRealm;  
  16. import org.apache.shiro.subject.PrincipalCollection;  
  17. /**  
  18.  * 自定義realm的實現  
  19.  * @author jiaozi  
  20.  *  
  21.  */  
  22. public class MyRealm extends AuthorizingRealm {  
  23.     //用於存放用戶信息  
  24.     static Map<String,String> userList=null;  
  25.     //用於存放角色信息  
  26.     static Map<String,String> roleList=null;  
  27.     //每個realm都有一個名字  
  28.     static String REALM_NAME="myrealm";  
  29.     static{  
  30.         //這裏也可以從數據庫讀取  
  31.         //模擬用戶  
  32.         userList=new HashMap();  
  33.         userList.put("zs", "123456,role2,role3");  
  34.         //模擬權限  
  35.         roleList=new HashMap();  
  36.         roleList.put("role2","user:query:*");  
  37.         roleList.put("role3", "user:*");  
  38.     }  
  39.     /**  
  40.      * 支持哪種令牌   
  41.      */  
  42.     @Override  
  43.     public boolean supports(AuthenticationToken token) {  
  44.         // TODO Auto-generated method stub  
  45.         return token instanceof UsernamePasswordToken;  
  46.     }  
  47.     /**  
  48.      * 獲取權限過程  
  49.      */  
  50.     @Override  
  51.     protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {  
  52.         //獲取用戶名  
  53.         String userName=principals.getPrimaryPrincipal().toString();  
  54.         //構建權限的類  
  55.         SimpleAuthorizationInfo sai=new SimpleAuthorizationInfo();  
  56.         Set<String> proleList=new HashSet<String>();  
  57.         Set<String> stringPermissions=new HashSet<String>();  
  58.         if(userList.containsKey(userName)){  
  59.             String[] roles=userList.get(userName).toString().split(",");  
  60.             for(int i=1;i<roles.length;i++){  
  61.                 proleList.add(roles[i]);  
  62.                 String pp=roleList.get(roles[i]);  
  63.                 String[] ppArry=pp.split(",");  
  64.                 for(int j=0;j<ppArry.length;j++){  
  65.                     stringPermissions.add(ppArry[j]);  
  66.                 }  
  67.             }  
  68.         }  
  69.         sai.setRoles(proleList);  
  70.         sai.setStringPermissions(stringPermissions);  
  71.         return sai;  
  72.     }  
  73.     /**  
  74.      * 認證過程  
  75.      */  
  76.     @Override  
  77.     protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {  
  78.         UsernamePasswordToken upt=(UsernamePasswordToken)token;  
  79.         String userName=token.getPrincipal().toString();  
  80.         String password=String.valueOf(upt.getPassword());  
  81.         if(userList.containsKey(userName)){  
  82.             String realPwd=userList.get(userName).toString().split(",")[0];  
  83.             if(realPwd.equals(password)){  
  84.                 SimpleAccount sa=new SimpleAccount(userName,password,"REALM_NAME");  
  85.                 return sa;  
  86.             }  
  87.         }  
  88.         return null;  
  89.     }  
  90.   
  91. }  
ini配置文件中配置該realm  main的部分添加
[html]  view plain  copy
  1. [main]  
  2. # 定義securityManager, Realms and 其他  
  3. myRealm= shiro.MyRealm  
  4. securityManager.realms=$iniRealm , $myRealm  
  5. #iniRealm是內置的默認realm讀取ini文件的傳入 如果自定義了realm該realm被替代 如果還想使用可以直接引用  
  6. #如果有多個realm 策略是所有的realm都要驗證通過 還是隻需要一個驗證通過  我這裏只需要一個驗證通過 默認是所有  
  7. #參考http://shiro.apache.org/authentication.html  
  8. authcStrategy = org.apache.shiro.authc.pam.FirstSuccessfulStrategy  
  9. securityManager.authenticator.authenticationStrategy = $authcStrategy  
同上測試  只要ini或者自定義ream存在的用戶都能登錄  

二。 shiro web

集成web集成 參考 http://shiro.apache.org/web.html#programmatic-support

在之前例子基礎上進行拓展 添加war項目 添加shiro-web依賴

[html]  view plain  copy
  1. <dependency>  
  2.     <groupId>org.apache.shiro</groupId>  
  3.     <artifactId>shiro-web</artifactId>  
  4.     <version>1.4.0</version>  
  5. </dependency>  

web.xml添加shiro支持的過濾器和ini文件路徑配置參數

[html]  view plain  copy
  1. <context-param>  
  2.     <param-name>shiroConfigLocations</param-name>  
  3.     <param-value>/WEB-INF/shiro.ini</param-value>  
  4.   </context-param>  
  5.   <listener>  
  6.     <listener-class>org.apache.shiro.web.env.EnvironmentLoaderListener</listener-class>  
  7.   </listener>  
  8.   <filter>  
  9.     <filter-name>ShiroFilter</filter-name>  
  10.     <filter-class>org.apache.shiro.web.servlet.ShiroFilter</filter-class>  
  11.   </filter>  
  12.   <filter-mapping>  
  13.     <filter-name>ShiroFilter</filter-name>  
  14.     <url-pattern>/*</url-pattern>  
  15.     <dispatcher>REQUEST</dispatcher>  
  16.     <dispatcher>FORWARD</dispatcher>  
  17.     <dispatcher>INCLUDE</dispatcher>  
  18.     <dispatcher>ERROR</dispatcher>  
  19.   </filter-mapping>  

添加幾個html和jsp用於測試

login.html添加用於登錄的表單

[html]  view plain  copy
  1. <form action="loginServlet" method="post">  
  2.      用戶名 :<input type="text" name="userName"/>  
  3.    密碼:<input type="text" name="password"/>  
  4.    <input type="submit">  
  5.   </form>  
添加query.jsp用於當登錄成功後跳轉的頁面 
[html]  view plain  copy
  1. <body>  
  2.   這是測試查詢頁面  
  3. </body>  
添加add.jsp用於測試擁有某個角色才能進入的頁面
[html]  view plain  copy
  1. <body>  
  2.   這是測試新增頁面  
  3. </body>  
添加一個檢測沒有角色失敗頁面 un.jsp
[html]  view plain  copy
  1. <body>  
  2.   沒有權限  
  3. </body  
t添加一個登錄的servlet
web.xml
[html]  view plain  copy
  1. <servlet>  
  2.    <description></description>  
  3.    <display-name>LoginServlet</display-name>  
  4.    <servlet-name>LoginServlet</servlet-name>  
  5.    <servlet-class>cn.et.web.LoginServlet</servlet-class>  
  6.  </servlet>  
  7.  <servlet-mapping>  
  8.    <servlet-name>LoginServlet</servlet-name>  
  9.    <url-pattern>/loginServlet</url-pattern>  
  10.  </servlet-mapping>  
servlet類
[html]  view plain  copy
  1. package cn.et.web;  
  2.   
  3. import java.io.IOException;  
  4.   
  5. import javax.servlet.ServletException;  
  6. import javax.servlet.http.HttpServlet;  
  7. import javax.servlet.http.HttpServletRequest;  
  8. import javax.servlet.http.HttpServletResponse;  
  9.   
  10. import org.apache.shiro.SecurityUtils;  
  11. import org.apache.shiro.authc.AuthenticationException;  
  12. import org.apache.shiro.authc.UsernamePasswordToken;  
  13. import org.apache.shiro.subject.Subject;  
  14.   
  15. public class LoginServlet extends HttpServlet {  
  16.     private static final long serialVersionUID = 1L;  
  17.   
  18.     /**  
  19.      * 登錄進入方法  
  20.      */  
  21.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {  
  22.         Subject subject = SecurityUtils.getSubject();  
  23.         UsernamePasswordToken upt=new UsernamePasswordToken(request.getParameter("userName"), request.getParameter("password"));  
  24.         try {  
  25.             subject.login(upt);  
  26.             request.getRequestDispatcher("/query.jsp").forward(request, response);  
  27.         } catch (AuthenticationException e) {  
  28.             request.getRequestDispatcher("/login.html").forward(request, response);  
  29.         }  
  30.     }  
  31.   
  32.     /**  
  33.      * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)  
  34.      */  
  35.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {  
  36.         // TODO Auto-generated method stub  
  37.         doGet(request, response);  
  38.     }  
  39.   
  40. }  
修改shiro.ini添加路徑過濾
[html]  view plain  copy
  1. # =======================  
  2. # Shiro INI configuration  
  3. # =======================  
  4.   
  5. [main]  
  6. # 定義securityManager, Realms and 其他  
  7. myRealm= shiro.MyRealm  
  8. securityManager.realms=$iniRealm , $myRealm  
  9. #如果有多個realm 策略是所有的realm都要驗證通過 還是隻需要一個驗證通過  我這裏只需要一個驗證通過 默認是所有  
  10. authcStrategy = org.apache.shiro.authc.pam.FirstSuccessfulStrategy  
  11. securityManager.authenticator.authenticationStrategy = $authcStrategy  
  12. authc.loginUrl = /login.html  
  13. #如果沒有登錄 會先跳轉到loginUrl 如果登錄了沒權限 跳轉到unauthorizedUrl指定頁面  
  14. roles.loginUrl= /login.html  
  15. roles.unauthorizedUrl= /un.html  
  16.   
  17. [users]  
  18. # 設置用戶信息  
  19. # 語法是 username = password, roleName1, roleName2, …, roleNameN  
  20. jiaozi = 123456,role1  
  21.   
  22. [roles]  
  23. # 角色信息和角色擁有的權限  
  24. #語法是 rolename = permissionDefinition1, permissionDefinition2, …, permissionDefinitionN  
  25. #權限的語法 * 表示所有權限  一般語法是 權限類型.權限動作.權限的資源id  比如  user:delete:1 表示擁有刪除1號用戶的權限  user:delete:*表示刪除所有用戶權限  
  26. admin = *  
  27. role1 = user:query:*, user:delete:1  
  28.   
  29. [urls]  
  30. # web中的url過濾    
  31. #語法是  某個路徑  = 怎麼樣過濾1，過濾2   常用的過濾有  
  32. #  anon 匿名用戶   
  33. #  authc 表示用戶和密碼驗證過濾 類 org.apache.shiro.web.filter.authc.FormAuthenticationFilter 沒有登錄自動跳轉到登錄頁  
  34. #  perms 是否擁有某些權限過濾 類 org.apache.shiro.web.filter.authz.PermissionsAuthorizationFilter 用法 perms["remote:invoke"]  
  35. #   roles是否擁有某個角色   org.apache.shiro.web.filter.authz.RolesAuthorizationFilter  用法roles[administrator]  
  36. #  user 是否是某個用戶 org.apache.shiro.web.filter.authc.UserFilter   
  37. # 也可以在main中自定義filter url就可以應用 參考http://shiro.apache.org/web.html#programmatic-support  
  38.   
  39. /login.html = anon  
  40. /loginServlet = anon  
  41. /query.jsp = authc  
  42. /add.jsp = roles[role2]  
測試不登錄直接訪問 query.jsp或者add.jsp直接跳轉到login.html中
測試登錄ini中的jiaozi用戶登錄成功後可以訪問query.jsp訪問add.jsp自動跳轉到un.jsp 因爲jiaozi用戶沒有role2這個juese

測試登錄自定義relam的zs用戶 發現都可以進入

shiro通過自定義過濾器 定製自己的過濾規則 比如url信息全部位於數據庫 需要所有的除了控制層的路徑都經過自定義的url過濾可以添加類 繼承自AuthorizationFilter實現isAccessAllowed方法 

[html]  view plain  copy
  1. package cn.et.conf;  
  2.   
  3. import javax.servlet.ServletRequest;  
  4. import javax.servlet.ServletResponse;  
  5.   
  6. import org.apache.shiro.web.filter.authz.AuthorizationFilter;  
  7.   
  8. public class MyFilter extends AuthorizationFilter {  
  9.   
  10.     /*  
  11.      * 返回true表示允許訪問 false表示不允許訪問  
  12.          */  
  13.     @Override  
  14.     protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue)  
  15.             throws Exception {  
  16.         return false;  
  17.     }  
  18.   
  19. }  
在main中定義該filter 直接在url中引用即可
[html]  view plain  copy
  1. myfilter=cn.et.conf.MyFilter  
  2. /** myfilter  

當用戶訪問了某個頁面 通過authc過濾跳轉到登錄頁面 當用戶登錄後 希望自動跳轉到之前的頁面 如果是直接進入的登錄頁就進入默認的頁面 的實現過程
偶爾 有些無法跳轉 結果下載了fav.ico 因爲有時一個請求到頁面 會順帶一個獲取圖標的請求  如果圖標請求在後面 shiro記錄的前面的途徑就是這個圖標的請求 此時在html添加 禁止網頁圖標的請求

[html]  view plain  copy
  1. <link rel="icon" href="data:image/ico;base64,aWNv">  
登錄實現

[html]  view plain  copy
  1. @RequestMapping("loginBlog")  
  2.     public String login(String userName,String password,HttpServletRequest request){  
  3.         Subject subject = SecurityUtils.getSubject();  
  4.         UsernamePasswordToken upt=new UsernamePasswordToken(userName,password);  
  5.         try {  
  6.             subject.login(upt);  
  7.             subject.getSession().setAttribute("userInfo", userDao.queryByContent(userName, password).get(0));  
  8.                         //關鍵代碼 shiro自動保存了上一次請求的地址  只需要獲取並重新跳轉即可  
  9.                         //可以使用WebUtils.issueRedirect重定向跳轉  
  10.             SavedRequest savedRequest = WebUtils.getSavedRequest(request);  
  11.             if(savedRequest!=null)  
  12.                 return "redirect:"+savedRequest.getRequestURI()+"?"+savedRequest.getQueryString();  
  13.             return "/queryBlog";  
  14.         } catch (AuthenticationException e) {  
  15.             return "redirect:/login.html";  
  16.         }  
  17.           
  18.     }  

三。 shiro集成springboot

參考官網 spring集成 只是換成springboot （http://shiro.apache.org/spring.html）
添加maven的jsp支持和shiro-spring和springboot

[html]  view plain  copy
  1. <parent>  
  2.     <groupId>org.springframework.boot</groupId>  
  3.     <artifactId>spring-boot-starter-parent</artifactId>  
  4.     <version>1.5.9.RELEASE</version>  
  5.   </parent>  
  6.   <dependencies>  
  7.    <dependency>  
  8.         <groupId>org.springframework.boot</groupId>  
  9.         <artifactId>spring-boot-starter-web</artifactId>  
  10.     </dependency>  
  11.     <dependency>  
  12.             <groupId>org.apache.tomcat.embed</groupId>  
  13.             <artifactId>tomcat-embed-jasper</artifactId>  
  14.         </dependency>  
  15.     <dependency>  
  16.         <groupId>org.apache.shiro</groupId>  
  17.         <artifactId>shiro-core</artifactId>  
  18.         <version>1.4.0</version>  
  19.     </dependency>  
  20.     <!-- https://mvnrepository.com/artifact/org.apache.shiro/shiro-web -->  
  21. <dependency>  
  22.     <groupId>org.apache.shiro</groupId>  
  23.     <artifactId>shiro-web</artifactId>  
  24.     <version>1.4.0</version>  
  25. </dependency>  
  26.     <!-- https://mvnrepository.com/artifact/org.apache.shiro/shiro-spring -->  
  27. <dependency>  
  28.     <groupId>org.apache.shiro</groupId>  
  29.     <artifactId>shiro-spring</artifactId>  
  30.     <version>1.4.0</version>  
  31. </dependency>  
  32.       
  33.     <!-- https://mvnrepository.com/artifact/commons-logging/commons-logging -->  
  34. <dependency>  
  35.     <groupId>commons-logging</groupId>  
  36.     <artifactId>commons-logging</artifactId>  
  37.     <version>1.2</version>  
  38. </dependency>  
  39.       
  40.   </dependencies>  
html和realm還是之前的 ini文件被替換成在spring中配置  添加配置的bean
[html]  view plain  copy
  1. package cn.et.boot;  
  2.   
  3. import java.util.HashMap;  
  4. import java.util.LinkedHashSet;  
  5. import java.util.Map;  
  6.   
  7. import org.apache.shiro.realm.Realm;  
  8. import org.apache.shiro.spring.LifecycleBeanPostProcessor;  
  9. import org.apache.shiro.spring.web.ShiroFilterFactoryBean;  
  10. import org.apache.shiro.web.mgt.DefaultWebSecurityManager;  
  11. import org.springframework.beans.factory.annotation.Autowired;  
  12. import org.springframework.boot.web.servlet.FilterRegistrationBean;  
  13. import org.springframework.context.annotation.Bean;  
  14. import org.springframework.context.annotation.Configuration;  
  15. import org.springframework.web.filter.DelegatingFilterProxy;  
  16.   
  17. import shiro.MyRealm;  
  18.   
  19. @Configuration  
  20. public class Config {  
  21.     /**  
  22.      * 等價於 web.xml配置  
  23.      * 自動 將 /*的請求 委託給spring容器中 bean名字和filter-name一致的bean處理  
  24.      *   
  25.        <filter>  
  26.         <filter-name>shiroFilter</filter-name>  
  27.         <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>  
  28.         <init-param>  
  29.             <param-name>targetFilterLifecycle</param-name>  
  30.             <param-value>true</param-value>  
  31.         </init-param>  
  32.         </filter>  
  33.         <filter-mapping>  
  34.             <filter-name>shiroFilter</filter-name>  
  35.             <url-pattern>/*</url-pattern>  
  36.         </filter-mapping>  
  37.      * @return  
  38.      */  
  39.     @Bean  
  40.     public FilterRegistrationBean webShiroFilter(){  
  41.         FilterRegistrationBean frb=new FilterRegistrationBean();  
  42.         DelegatingFilterProxy dfp=new DelegatingFilterProxy();  
  43.         frb.setFilter(dfp);  
  44.         frb.setName("shiroFilter");  
  45.         LinkedHashSet<String> linkedHashSet = new LinkedHashSet<String>();  
  46.         linkedHashSet.add("/*");  
  47.         frb.setUrlPatterns(linkedHashSet);  
  48.           
  49.           
  50.         Map<String, String> initParameters=new HashMap<String, String>();  
  51.         initParameters.put("targetFilterLifecycle", "true");  
  52.         frb.setInitParameters(initParameters);  
  53.         return frb;  
  54.     }  
  55.     /**  
  56.      * 配置我的realm  
  57.      * @return  
  58.      */  
  59.     @Bean  
  60.     public Realm myRealm(){  
  61.         return new MyRealm();  
  62.     }  
  63.     /**  
  64.      * 定義默認的securityManager  
  65.      * @return  
  66.      */  
  67.     @Bean  
  68.     public DefaultWebSecurityManager securityManager(@Autowired Realm myRealm){  
  69.         DefaultWebSecurityManager dwm=new DefaultWebSecurityManager();  
  70.         dwm.setRealm(myRealm);  
  71.         return dwm;  
  72.     }  
  73.       
  74.     /**  
  75.      * 定義和過濾器一致名字的ShiroFilterFactoryBean  
  76.      */  
  77.     @Bean  
  78.     public ShiroFilterFactoryBean shiroFilter(@Autowired org.apache.shiro.mgt.SecurityManager securityManager){  
  79.         ShiroFilterFactoryBean sffb=new ShiroFilterFactoryBean();  
  80.         sffb.setSecurityManager(securityManager);  
  81.         sffb.setLoginUrl("/login.html");  
  82.         sffb.setUnauthorizedUrl("/un.jsp");  
  83.         Map<String, String> urls=new HashMap<String, String>();  
  84.         /*  
  85.          *    定義url  
  86.             /login.html = anon  
  87.             /loginServlet = anon  
  88.             /query.jsp = authc  
  89.             /add.jsp = roles[role2]  
  90.          * */  
  91.           
  92.         urls.put("/login.html", "anon");  
  93.         urls.put("/loginServlet", "anon");  
  94.         urls.put("/query.jsp", "authc");  
  95.         urls.put("/add.jsp", "roles[role1]");  
  96.         sffb.setFilterChainDefinitionMap(urls);  
  97.         return sffb;  
  98.     }  
  99.     /**  
  100.      * 定義後置處理器  
  101.      * @return  
  102.      */  
  103.     @Bean  
  104.     public LifecycleBeanPostProcessor lifecycleBeanPostProcessor(){  
  105.         return new LifecycleBeanPostProcessor();  
  106.     }  
  107. }  
將之前servlet替換成springmvc的controller
[html]  view plain  copy
  1. package cn.et.boot;  
  2.   
  3. import org.apache.shiro.SecurityUtils;  
  4. import org.apache.shiro.authc.AuthenticationException;  
  5. import org.apache.shiro.authc.UsernamePasswordToken;  
  6. import org.apache.shiro.subject.Subject;  
  7. import org.springframework.stereotype.Controller;  
  8. import org.springframework.web.bind.annotation.RequestMapping;  
  9. @Controller  
  10. public class LoginController {  
  11.     @RequestMapping("loginServlet")  
  12.     public String login(String userName,String password){  
  13.         Subject subject = SecurityUtils.getSubject();  
  14.         UsernamePasswordToken upt=new UsernamePasswordToken(userName,password);  
  15.         try {  
  16.             subject.login(upt);  
  17.             return "/query.jsp";  
  18.         } catch (AuthenticationException e) {  
  19.             return "redirect:/login.html";  
  20.         }  
  21.           
  22.     }  
  23. }  
添加一個springboot啓動類 just run
[html]  view plain  copy
  1. package cn.et.boot;  
  2.   
  3. import org.springframework.boot.SpringApplication;  
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;  
  5.   
  6. @SpringBootApplication  
  7. public class Main {  
  8.   
  9.     public static void main(String[] args) {  
  10.         SpringApplication.run(Main.class, args);  
  11.     }  
  12.   
  13. }  
通過  http://localhost:8080/login.html 訪問
 測試 輸入錯誤的密碼
 測試使用zs登錄 訪問 add.jsp發現跳轉到un.jsp 

四。自定義filter實現動態配置url攔截

  如果在spring中配置靜態的url攔截 添加一個新的路徑 每次都需要修改配置文件 如果使用springboot 每次都需要修改urls這個map 這個map是初始化bean

的時候創建 後面再往裏面加是沒有效果的 所以需要在攔截時自己手工調用對應的filter邏輯 

[html]  view plain  copy
  1. @Bean  
  2.     public ShiroFilterFactoryBean shiroFilter(@Autowired org.apache.shiro.mgt.SecurityManager securityManager){  
  3.         ShiroFilterFactoryBean sffb=new ShiroFilterFactoryBean();  
  4.         sffb.setSecurityManager(securityManager);  
  5.         sffb.setLoginUrl("/login.html");  
  6.         sffb.setUnauthorizedUrl("/un.jsp");  
  7.         Map<String, String> urls=new HashMap<String, String>();  
  8.         /*  
  9.          *    定義url  
  10.             /login.html = anon  
  11.             /loginServlet = anon  
  12.             /query.jsp = authc  
  13.             /add.jsp = roles[role2]  
  14.          * */  
  15.           
  16.         urls.put("/login.html", "anon");  
  17.         urls.put("/loginServlet", "anon");  
  18.         urls.put("/query.jsp", "authc");  
  19.         urls.put("/add.jsp", "roles[role1]");  
  20.         sffb.setFilterChainDefinitionMap(urls);  
  21.         return sffb;  
  22.     }  
自定義過濾器的代碼是 注意添加到spring容器中 添加@Component註解
[html]  view plain  copy
  1. package cn.et.conf;  
  2.   
  3. import java.util.HashMap;  
  4. import java.util.Map;  
  5. import java.util.Set;  
  6. import java.util.regex.Pattern;  
  7.   
  8. import javax.servlet.Filter;  
  9. import javax.servlet.ServletRequest;  
  10. import javax.servlet.ServletResponse;  
  11. import javax.servlet.http.HttpServletRequest;  
  12.   
  13. import org.apache.shiro.spring.web.ShiroFilterFactoryBean;  
  14. import org.apache.shiro.subject.Subject;  
  15. import org.apache.shiro.util.CollectionUtils;  
  16. import org.apache.shiro.web.filter.authc.FormAuthenticationFilter;  
  17. import org.apache.shiro.web.filter.authz.AuthorizationFilter;  
  18. import org.apache.shiro.web.filter.authz.PermissionsAuthorizationFilter;  
  19. import org.apache.shiro.web.filter.authz.RolesAuthorizationFilter;  
  20. import org.springframework.beans.factory.annotation.Autowired;  
  21. import org.springframework.stereotype.Component;  
  22. @Component  
  23. public class MyFilter extends AuthorizationFilter {  
  24.     static Map<String, String> urls=new HashMap<String, String>();  
  25.       
  26.     @Autowired  
  27.     private ShiroFilterFactoryBean sffb;  
  28.     /**  
  29.      * 匹配指定過濾器規則的url  
  30.      * @param regex  
  31.      * @param url  
  32.      * @return  
  33.      */  
  34.     public static boolean matchUrl(String regex,String url){  
  35.         regex=regex.replaceAll("/+", "/");  
  36.         if(regex.equals(url)){  
  37.             return true;  
  38.         }  
  39.         regex=regex.replaceAll("\\.", "\\\\.");  
  40.         // /login.html  /l*.html  
  41.         regex=regex.replaceAll("\\*", ".*");  
  42.         // /**/login.html  /a/b/login.html  
  43.         if(regex.indexOf("/.*.*/")>=0){  
  44.             regex=regex.replaceAll("/\\.\\*\\.\\*/", "((/.*/)+|/)");  
  45.         }  
  46.         System.out.println(regex+"----"+url);  
  47.         return Pattern.matches(regex, url);  
  48.     }  
  49.     /**  
  50.      * 測試  
  51.      * @param args  
  52.      */  
  53.     public static void main(String[] args) {  
  54.         System.out.println(matchUrl("/**/s*.html","/t/g/login.html"));  
  55.     }  
  56.     /**  
  57.      * 在map中模擬 這個也可以將來定義在數據庫中  
  58.      */  
  59.     static{  
  60.         urls.put("/login.html", "anon");  
  61.         urls.put("/loginBlog", "anon");  
  62.         urls.put("/un.jsp", "anon");  
  63.         urls.put("/queryBlogByToken", "anon");  
  64.         urls.put("/query.jsp", "authc");  
  65.         urls.put("/add.jsp", "roles[role1]");  
  66.     }  
  67.     /**  
  68.      * isAccessAllowed用於判斷當前url的請求是否能驗證通過  如果驗證失敗 調用父類的onAccessDenied決定跳轉到登錄失敗頁還是授權失敗頁面  
  69.      */  
  70.     @Override  
  71.     protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue)  
  72.             throws Exception {  
  73.         HttpServletRequest req=(HttpServletRequest)request;  
  74.         String url=req.getRequestURI();  
  75.         //通過url獲取授權類型  
  76.         String urlAuth=urls.get(url);  
  77.         if(urlAuth==null){  
  78.             return false;  
  79.         }  
  80.         //配置的過濾器是anon 直接放過  
  81.         if(urlAuth.startsWith("anon")){  
  82.             return true;  
  83.         }  
  84.         //配置的是authc 判斷當前用戶是否認證通過  
  85.         Subject subject = getSubject(request, response);  
  86.         if(urlAuth.startsWith("authc")){  
  87.             return subject.isAuthenticated();  
  88.         }  
  89.         //授權認證 也需要判斷是否登錄 沒有登錄返回 登錄繼續下面的驗證  
  90.         boolean ifAuthc=subject.isAuthenticated();  
  91.         if(!ifAuthc)  
  92.             return ifAuthc;  
  93.         //如果是定義的roles過濾器  獲取所有的roles 一般是roles[a,b]  
  94.         if(urlAuth.startsWith("roles")){  
  95.             String[] rolesArray=urlAuth.split("roles\\[")[1].split("\\]")[0].split(",");  
  96.             if (rolesArray == null || rolesArray.length == 0) {  
  97.                 return true;  
  98.             }  
  99.             Set<String> roles = CollectionUtils.asSet(rolesArray);  
  100.             return subject.hasAllRoles(roles);  
  101.         }  
  102.         if(urlAuth.startsWith("perms")){  
  103.             String[] perms=urlAuth.split("perms\\[")[1].split("\\]")[0].split(",");  
  104.             boolean isPermitted = true;  
  105.             if (perms != null && perms.length > 0) {  
  106.                 if (perms.length == 1) {  
  107.                     if (!subject.isPermitted(perms[0])) {  
  108.                         isPermitted = false;  
  109.                     }  
  110.                 } else {  
  111.                     if (!subject.isPermittedAll(perms)) {  
  112.                         isPermitted = false;  
  113.                     }  
  114.                 }  
  115.             }  
  116.   
  117.             return isPermitted;  
  118.         }  
  119.         return false;  
  120.     }  
  121.   
  122. }  
修改springboot的Config類 將所有的請求都交給自定義的過濾器處理
[html]  view plain  copy
  1. @Bean  
  2.     public ShiroFilterFactoryBean shiroFilter(@Autowired org.apache.shiro.mgt.SecurityManager securityManager){  
  3.         ShiroFilterFactoryBean sffb=new ShiroFilterFactoryBean();  
  4.         sffb.setSecurityManager(securityManager);  
  5.         sffb.setLoginUrl("/login.html");  
  6.         sffb.setUnauthorizedUrl("/un.jsp");  
  7.         Map<String, String> urls=new HashMap<String, String>();  
  8.         urls.put("/**", "myFilter");          
  9.         sffb.setFilterChainDefinitionMap(urls);  
  10.         return sffb;  
  11.     }  
添加一個過濾匹配的策略 定義多個relms 只要有一個realm的數據通過則通過 （這裏只有一個realm不配置也可 留着做記錄 將來怕要用）
[html]  view plain  copy
  1. /**  
  2.      * <span style="font-size:13.3333px;">多個relms 只要有一個realm的數據通過則通過</span>  
  3.      * @return  
  4.      */  
  5.     @Bean  
  6.     public ModularRealmAuthenticator authentictor(){  
  7.         org.apache.shiro.authc.pam.ModularRealmAuthenticator mra=new org.apache.shiro.authc.pam.ModularRealmAuthenticator();  
  8.         mra.setAuthenticationStrategy(new org.apache.shiro.authc.pam.FirstSuccessfulStrategy());  
  9.         return mra;  
  10.     }  
  11.     /**  
  12.      * 定義默認的securityManager  
  13.      * @return  
  14.      */  
  15.     @Bean  
  16.     public DefaultWebSecurityManager securityManager(@Autowired Realm myRealm,@Autowired ModularRealmAuthenticator authentictor){  
  17.         DefaultWebSecurityManager dwm=new DefaultWebSecurityManager();  
  18.         dwm.setRealm(myRealm);  
  19.         authentictor.setRealms(dwm.getRealms());  
  20.         dwm.setAuthenticator(authentictor);  
  21.         return dwm;  
  22.     }  
联系我们 沪ICP备2021010478号-7