shiro框架總結

本文轉載自查看原文 2019-06-21 20:55 4782 shiro權限框架總結

一、概念

shiro是一個安全框架，主要可以幫助我們解決程序開發中認證和授權的問題。基於攔截器做的權限系統，權限控制的粒度有限，為了方便各種各樣的常用的權限管理需求的實現，，我們有必要使用比較好的安全框架，早期spring security 作為一個比較完善的安全框架比較火，但是spring security學習成本比較高，於是就出現了shiro安全框架，學習成本降低了很多，而且基本的功能也比較完善。

二、shiro提供的功能

1、Authentication：身份認證/登陸，驗證用戶是不是擁有相對應的身份；

2、Authorization：授權，即權限驗證，驗證某個已認證的用戶是否擁有某個權限；即判斷用戶是否能做事情，常見的如：驗證某個用戶是否擁有某個角色。或者粒度的驗證某個用戶對某個資源是否具有權限；

3、Session Manager：會話管理，即用戶登陸后就是一次會話，在沒有退出之前，它的所有信息都在會話中；會話可以是普通JavaSE環境的，也可以是Web環境的；

4、Cryptographt：加密，保護數據，如密碼加密存儲到數據庫，而不是明文存儲；

5、Web Support：Web支持，可以非常容易的繼承到Web環境的；

6、Caching：緩存，比如用戶登陸后，其用戶信息、擁有的角色/權限不必每次去查，這樣提高效率；

7、Concurrency：shiro支持多線程應用的並發驗證，即如在一個線程中開啟另一個線程，能把權限自動傳播過去；

8、Testing：提供測試支持；

9、Run As：允許一個用戶假裝另一個用戶（如果我們允許）的身份進行訪問；

10、Remember Me：記住我，這個是非常常見的功能，即一次登陸后，下次再來的話不用登陸了。

三、shiro的架構

Subject：主題被驗證的對象，一般指的當前用戶對象。但是不僅僅可以指當前用戶對象，還可以是其他東西，線程等等。spring mvc中一個一個的用戶的請求。

SecurityManager：安全認證管理器。是shiro的核心，會在安全認證管理器中所做所有的認證操作。類似於之前spring mvc中的前端控制器（DispacherServlet）。

Realm：域的意思。負責訪問安全認證數據。shiro框架並不存在安全認證數據，安全認證數據需要用戶自己存儲。shiro支持很多的Realm實現，也就是說安全認證數據我們可以放到數據庫中，也可以放到文件中等等。可以把realm理解為以前web項目的dao層。

四、shiro的認證

第一步，搭建框架引入jar包

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <project xmlns="http://maven.apache.org/POM/4.0.0"
 3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 5 <modelVersion>4.0.0</modelVersion>
 6 <groupId>aaa</groupId>
 7 <artifactId>test_shiro_qy97_02</artifactId>
 8 <version>1.0-SNAPSHOT</version>
 9 <dependencies>
10 <dependency>
11 <groupId>commons-logging</groupId>
12 <artifactId>commons-logging</artifactId><version>1.0.4</version>
13 </dependency>
14 <dependency>
15 <groupId>org.apache.shiro</groupId>
16 <artifactId>shiro-core</artifactId>
17 <version>1.3.0</version>
18 </dependency>
19   <!-- 導入shiro和spring繼承的jar包 -->
20             <dependency>
21                 <groupId>org.apache.shiro</groupId>
22                 <artifactId>shiro-spring</artifactId>
23                 <version>1.2.3</version>
24             </dependency>
25             <!-- 導入shiro和web的jar包-->
26             <dependency>
27                 <groupId>org.apache.shiro</groupId>
28                 <artifactId>shiro-web</artifactId>
29                 <version>1.2.3</version>
30             </dependency>
31 </dependencies>
32 </project>

第二步，在web.xml中聲明shiro攔截權限的過濾器

 1 <filter>
 2 <filter-name>shiroFilter</filter-name>
 3 <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
 4 <init-param>
 5 <!--保證該過濾器的生命周期和spring 工廠中shiro過濾器對象的生命周期一致-->
 6 <param-name>targetFilterLifecycle</param-name>
 7 <param-value>true</param-value>
 8 </init-param>
 9 <!--聲明該過濾器代理工廠類中的id為什么的shiro過濾器對象--><init-param>
10 <param-name>targetBeanName</param-name>
11 <param-value>shiroFilter</param-value>
12 </init-param>
13 </filter>
14 <filter-mapping>
15 <filter-name>shiroFilter</filter-name>
16 <url-pattern>/*</url-pattern>
17 </filter-mapping>

第三步，在spring的主配置文件匯總聲明shiro的配置信息

shiro的配置信息比較多，一般不和spring的主配置文件放到一起，一般都會單獨建立一個shiro和spring繼承的配置文件，創建好之后，在spring.xml中引入該文件。

spring-shiro中配置：

 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 xsi:schemaLocation="http://www.springframework.org/schema/beans
 5 http://www.springframework.org/schema/beans/spring-beans.xsd">
 6 <!--創建自定義域對象-->
 7 <bean id="authRealm" class="com.aaa.ssm.realm.AuthRealm"></bean>
 8 <!--創建shiro的安全管理器對象-->
 9 <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
10 <!--要聲明域，在域中讀取認證和授權的數據-->
11 <property name="realm" ref="authRealm"></property>
12 </bean>
13 <!--創建shiro的過濾器對象-->
14 <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
15 <!--要注入安全管理器對象-->
16 <property name="securityManager" ref="securityManager"></property>
17 <!--配置登錄請求的路徑-->
18 <property name="loginUrl" value="/user/login.do"></property>
19 <!--配置shiro認證和授權的過濾器-->
20 <property name="filterChainDefinitions">
21 <value>
22 <!--對靜態資源不攔截-->
23 <!--anon指匿名訪問的過濾器，所有匿名用戶都可以訪問static下面的資源-->
24 /static/*=anon
25 /user/login.do=anon
26 /login.jsp=anon
27 <!--authc指必須經過認證（登錄過之后）才能訪問的請求 /*代表所有有一個斜杠的請求都要經過認證 -->
28 /*=authc
29 /*/*=authc
30 </value>
31 </property></bean>
32 </beans>

第四步，創建自定義域對象

 1 package com.aaa.ssm.realm;
 2 import com.aaa.ssm.entity.Users;
 3 import com.aaa.ssm.service.UserService;
 4 import org.apache.shiro.authc.*import org.apache.shiro.authz.AuthorizationInfo;
 5 import org.apache.shiro.realm.AuthorizingRealm;
 6 import org.apache.shiro.realm.Realm;
 7 import org.apache.shiro.subject.PrincipalCollection;
 8 import org.springframework.beans.factory.annotation.Autowired;
 9 /**
10 * 實現自定義域
11 * Authorization 授權（權限校驗）
12 *
13 * Authentication 認證（登錄校驗）
14 *
15 */
16 public class AuthRealm extends AuthorizingRealm {
17 @Autowired
18 private UserService userService;
19 //獲取授權信息
20 protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
21 return null;
22 }//獲取認證信息
23 protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws
24 AuthenticationException {
25 //獲取用戶名 不過一般往shiro中放置用戶身份信息的時候，不直接放用戶名字符串，放用戶對象
26 String username = token.getPrincipal().toString();
27 //有了用戶名，要根據用戶名在數據庫中查詢用戶對象
28 Users user = userService.findByUsername(username);
29 //判斷如果用戶對象不存在，拋出UnknownAccountException
30 if(user==null){
31 throw new UnknownAccountException("用戶名不存在");
32 }
33 //封裝用戶的身份對象 返回這個身份對象
34 SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(user,user.getPassword(),"authRealm");
35 return info;
36 }
37 }

第五步，在控制器（Controller）中使用shiro去做登陸認證

 1 /**
 2 * 用戶登錄的請求
 3 * @param user
 4 * @return
 5 */
 6 @RequestMapping("/login")
 7 public String login(Users user, Model model, HttpSession session){
 8 /* user = userService.checkUser(user)//判斷user是否為空
 9 if(user!=null){
10 //用戶名和密碼輸入正確
11 //登錄成功之后把用戶對象放置到session中
12 //登錄成功之后，查詢用戶能操作的模塊
13 session.setAttribute(Constants.SESSION_USER,user);
14 List<Module> oneModules = userService.queryUsersModules(user);
15 //獲取用戶能操作的所有模塊的路徑，放置到session中
16 List<String> permiteUrls = userService.queryPermitUrls(oneModules);
17 session.setAttribute(Constants.PERMIT_URLS,permiteUrls);
18 model.addAttribute("oneModules",oneModules);
19 return "index";
20 }else{
21 return "redirect:/login.jsp";
22 }*/
23 //獲取用戶的主體對象就可以了
24 Subject subject = SecurityUtils.getSubject();//封裝用戶名和密碼的認證信息對象
25 UsernamePasswordToken upt = new UsernamePasswordToken(user.getUsername(),user.getPassword());
26 //進行登錄認證
27 try {
28 subject.login(upt);
29 }catch (Exception e){
30 e.printStackTrace();
31 System.out.println("用戶名或者密碼錯誤");
32 return "redirect:/login.jsp";
33 }
34 return "index";
35 }

五、密碼加密

一般在數據庫中存儲明文的密碼是不安全的，一般都會對項目中的密碼進行加密。加密算法分為兩大類，一類是可逆加密，另一類是不可逆加密。可逆加密分兩類，一類是堆成加密，另外一類是非對稱加密。一般對稱加密的私鑰在客戶端和服務器端都是一致的。非對稱加密私鑰在客戶端和服務器端是不一樣的。非可逆加密，任何加密算法的安全性都要建立在你的源碼已經被別人獲取的情況下還算安全，那這種加密算法才算是成功的，這就是非可逆加密。常用的非可逆加密算法有MD5和SHA1，SHA256等等。

 1 package com.aaa.ssm.util;
 2 import org.apache.shiro.crypto.hash.SimpleHash;
 3 /**
 4 * 測試非可逆加密算法
 5 */
 6 public class PasswordUtil {
 7 public static void main(String[] args) {
 8 String str = "123456";
 9 //第一個參數代表加密使用的算法 第二個參數要加密的字符串 第三個參數 加入的鹽的值 第四個參數 hash迭代的次數
10 //以后再保存用戶的密碼應該使用加密算法加密
11 SimpleHash simpleHash = new SimpleHash("md5",str,"123",10);
12 String code = simpleHash.toString();
13 System.out.println("加密后的密文:"+code);
14 }
15 }

密碼加密存儲之后，在使用shiro做校驗，應該在realm中做如下配置：

 1 <!--創建自定義域對象-->
 2     <bean id="authRealm" class="com.aaa.ssm.realm.AuthRealm">
 3         <property name="credentialsMatcher" ref="credentialsMatcher"></property>
 4     </bean>
 5     <!-- 創建憑證匹配器對象-->
 6     <bean id="credentialsMatcher" class="org.apache.shiro.authc.credential.HashedCredentialsMatcher">
 7         <!--指定要對用戶傳過來的明文的密碼最什么加密-->
 8         <property name="hashAlgorithmName" value="md5"></property>
 9         <!--指明hash迭代的次數-->
10         <property name="hashIterations" value="10"></property>
11     </bean>

在自定義的realm中，傳入用戶密碼對應的鹽值：

 1 package com.aaa.ssm.realm;
 2 
 3 import com.aaa.ssm.entity.Module;
 4 import com.aaa.ssm.entity.Users;
 5 import com.aaa.ssm.service.IUserServiceDAO;
 6 import org.apache.shiro.authc.*;
 7 import org.apache.shiro.authz.AuthorizationInfo;
 8 import org.apache.shiro.authz.SimpleAuthorizationInfo;
 9 import org.apache.shiro.realm.AuthorizingRealm;
10 import org.apache.shiro.subject.PrincipalCollection;
11 import org.apache.shiro.util.ByteSource;
12 import org.springframework.beans.factory.annotation.Autowired;
13 
14 import java.util.List;
15 
16 /**
17  * 實現自定義域
18  * Authorization  授權（權限校驗）
19  *
20  * Authentication 認證（登錄校驗）
21  *
22  */
23 public class AuthRealm extends AuthorizingRealm {
24 
25     @Autowired
26     private IUserServiceDAO userService;
27     //獲取授權信息
28     protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
29         //獲取當前的用戶對象
30         Users user = (Users) principalCollection.getPrimaryPrincipal();
31         //查詢用戶有哪些權限
32         List<Module> modules = userService.userModule(user);
33         List<String> namespaces = userService.queryPrimaryUrl(modules);
34         //創建授權對象
35         SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
36         //把用戶能操作的資源的信息放置到授權對象中
37         info.addStringPermissions(namespaces);
38         return info;
39     }
40 
41     //獲取認證信息
42     protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
43         Object pri =  token.getPrincipal();
44         if(pri==null){
45             throw new UnknownAccountException("用戶名為空");
46         }
47         //獲取用戶名 不過一般往shiro中放置用戶身份信息的時候，不直接放用戶名字符串，放用戶對象
48         String username = pri.toString();
49         //有了用戶名，要根據用戶名在數據庫中查詢用戶對象
50         Users user = userService.findByUsername(username);
51         //判斷如果用戶對象不存在，拋出UnknownAccountException
52         if(user==null){
53             throw new UnknownAccountException("用戶名不存在");
54         }
55         //鹽值一般每個用戶是不一樣的
56         ByteSource bytes = ByteSource.Util.bytes("123");
57         //封裝用戶的身份對象 返回這個身份對象
58         SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(user,user.getPassword(),bytes,"authRealm");
59         return info;
60     }
61 }

六、授權（用戶登陸之后能訪問所有的請求）

1、配置文件的方式

xml的方式

第一步，在shiro的主配置文件中配置授權信息

 1  <!--創建shiro的過濾器對象-->
 2     <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
 3         <!--要注入安全管理器對象-->
 4         <property name="securityManager" ref="securityManager"></property>
 5         <!--配置登錄請求的路徑-->
 6         <property name="loginUrl" value="/user/toLogin.do"></property>
 7         <!--如果用戶沒有經過授權跳轉到的錯誤界面-->
 8         <property name="unauthorizedUrl" value="/error.jsp"></property>
 9         <!--配置shiro認證和授權的過濾器-->
10         <property name="filterChainDefinitions">
11             <value>
12                 <!--對靜態資源不攔截-->
13                 <!--anon指匿名訪問的過濾器，所有匿名用戶都可以訪問static下面的資源-->
14                 /static/*=anon
15                 /user/login.do=anon
16                 <!--不攔截跳轉到主界面的請求-->
17                 /user/index.do=anon
18                 <!--配置登出請求的過濾器-->
19                 /user/logout.do=logout
20                 <!--配置/user/list.do必須有user的權限才能訪問-->
21                 /user/list.do=anon
22                 /role/*.do=perms[role]
23                 <!--authc指必須經過認證（登錄過之后）才能訪問的請求   /*代表所有有一個斜杠的請求都要經過認證 -->
24                 /*=authc
25                 /*/*=authc
26             </value>
27         </property>
28     </bean>

第二步，當前登陸用戶有哪些授權信息從自定義的realm中讀取（

AuthorizationInfo）

 1 package com.aaa.ssm.realm;
 2 
 3 import com.aaa.ssm.entity.Module;
 4 import com.aaa.ssm.entity.Users;
 5 import com.aaa.ssm.service.IUserServiceDAO;
 6 import org.apache.shiro.authc.*;
 7 import org.apache.shiro.authz.AuthorizationInfo;
 8 import org.apache.shiro.authz.SimpleAuthorizationInfo;
 9 import org.apache.shiro.realm.AuthorizingRealm;
10 import org.apache.shiro.subject.PrincipalCollection;
11 import org.apache.shiro.util.ByteSource;
12 import org.springframework.beans.factory.annotation.Autowired;
13 
14 import java.util.List;
15 
16 /**
17  * 實現自定義域
18  * Authorization  授權（權限校驗）
19  *
20  * Authentication 認證（登錄校驗）
21  *
22  */
23 public class AuthRealm extends AuthorizingRealm {
24 
25     @Autowired
26     private IUserServiceDAO userService;
27     //獲取授權信息
28     protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
29         //獲取當前的用戶對象
30         Users user = (Users) principalCollection.getPrimaryPrincipal();
31         //查詢用戶有哪些權限
32         List<Module> modules = userService.userModule(user);
33         List<String> namespaces = userService.queryPrimaryUrl(modules);
34         //創建授權對象
35         SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
36         //把用戶能操作的資源的信息放置到授權對象中
37         info.addStringPermissions(namespaces);
38         return info;
39     }
40 
41     //獲取認證信息
42     protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
43         Object pri =  token.getPrincipal();
44         if(pri==null){
45             throw new UnknownAccountException("用戶名為空");
46         }
47         //獲取用戶名 不過一般往shiro中放置用戶身份信息的時候，不直接放用戶名字符串，放用戶對象
48         String username = pri.toString();
49         //有了用戶名，要根據用戶名在數據庫中查詢用戶對象
50         Users user = userService.findByUsername(username);
51         //判斷如果用戶對象不存在，拋出UnknownAccountException
52         if(user==null){
53             throw new UnknownAccountException("用戶名不存在");
54         }
55         //鹽值一般每個用戶是不一樣的
56         ByteSource bytes = ByteSource.Util.bytes("123");
57         //封裝用戶的身份對象 返回這個身份對象
58         SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(user,user.getPassword(),bytes,"authRealm");
59         return info;
60     }
61 }

2、注解的方式

第一步，開始spring的shiro的注解支持

注意，開啟注解的支持之前，應該保證項目中有spring的aop的jar包，aspectj等的jar包

 1 <dependency>
 2 <groupId>org.springframework</groupId>
 3 <artifactId>spring-aop</artifactId>
 4 <version>${spring.version}</version</dependency>
 5 <!-- aspectj相關jar包-->
 6 <dependency>
 7 <groupId>org.aspectj</groupId>
 8 <artifactId>aspectjrt</artifactId>
 9 <version>1.7.4</version></dependency>
10 <dependency>
11 <groupId>org.aspectj</groupId>
12 <artifactId>aspectjweaver</artifactId>
13 <version>1.7.4</version>
14 </dependency>

要在spring mvc的主配置文件中聲明shiro的注解的支持：

1  <!--開啟aop-->
2     <aop:config proxy-target-class="true"></aop:config>
3     <!--開啟shiro的aop注解的支持-->
4     <bean class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor" >
5         <property name="securityManager" ref="securityManager"></property>
6     </bean>

第二步，在控制器的代碼中增加需要授權的注解

第三步，同xml的方式的第二步，配置當前登陸用戶有哪些授權信息從自定義的realm中讀取（

AuthorizationInfo）

第四步，聲明spring mvc的統一異常處理

1    <!--聲明spring mvc的統一異常處理界面-->
2     <bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
3         <property name="defaultErrorView" value="../../error"></property>
4     </bean>

七、shiro會話管理器

shiro中提供的類似於web中的session的機制

 1 /**
 2 * 跳轉到系統管理的主界面
 3 * @return
 4 */
 5 @RequestMapping("/index")
 6 public String index(Model model){
 7 //可以通過Subject獲取shiro會話中的用戶身份對象
 8 Users user = (Users)SecurityUtils.getSubject().getPrincipal();
 9 List<Module> oneModules = userService.queryUsersModules(user);
10 model.addAttribute("oneModules",oneModules);
11 return "index";
12 }
13 /**
14 * 用戶登錄的請求
15 * @param user
16 * @return
17 */
18 @RequestMapping("/login")
19 public String login(Users user, Model model, HttpSession session){
20 //獲取用戶的主體對象就可以了
21 Subject subject = SecurityUtils.getSubject();
22 //封裝用戶名和密碼的認證信息對象
23 UsernamePasswordToken upt = new UsernamePasswordToken(user.getUsername(),user.getPassword());
24 //進行登錄認證try {
25 subject.login(upt);
26 }catch (Exception e){
27 e.printStackTrace();
28 model.addAttribute("error","用戶名或者密碼錯誤");
29 return "login";
30 }
31 return "redirect:/user/index.do";
32 }

tomcat的session可以控制超時時間，shiro的session也可以控制。如果需要控制類似於超時時間這些session的屬性，就需要在shiro的主配置文件中配置sessionManager對象

 1  <!--創建會話管理器對象-->
 2     <bean id="sessionManager" class="org.apache.shiro.web.session.mgt.DefaultWebSessionManager">
 3         <!--配置session的超時時間,默認單位是毫秒-->
 4         <property name="globalSessionTimeout" value="1000"></property>
 5     </bean>
 6     <!--創建shiro的安全管理器對象-->
 7     <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
 8         <!--要聲明域，在域中讀取認證和授權的數據-->
 9         <property name="realm"  ref="authRealm"></property>
10 
11         <!--聲明會話管理器屬性-->
12         <property name="sessionManager" ref="sessionManager" ></property>
13 
14         <property name="rememberMeManager" ref="rememberMeManager"></property>
15 
16 
17     <!--<property name="cacheManager" ref="cacheManager"></property>-->
18     </bean>

八、登出

首先需要在用戶登陸后的主界面寫一個登出的連接

然后在控制器中實現登出的方法，注意在此方法中不用寫任何邏輯

在shiro的主配置文件中配置，登出的請求經過的過濾器就可以，在shiro的過濾器中有一個名稱為logout的過濾器專門為我們處理登出請求：

 1  <!--配置shiro認證和授權的過濾器-->
 2         <property name="filterChainDefinitions">
 3             <value>
 4                 <!--對靜態資源不攔截-->
 5                 <!--anon指匿名訪問的過濾器，所有匿名用戶都可以訪問static下面的資源-->
 6                 /static/*=anon
 7                 /user/login.do=anon
 8                 <!--不攔截跳轉到主界面的請求-->
 9                 /user/index.do=anon
10                 <!--配置登出請求的過濾器-->
11                 /user/logout.do=logout
12                 <!--配置/user/list.do必須有user的權限才能訪問-->
13                 /user/list.do=anon
14                 /role/*.do=perms[role]
15                 <!--authc指必須經過認證（登錄過之后）才能訪問的請求   /*代表所有有一個斜杠的請求都要經過認證 -->
16                 /*=authc
17                 /*/*=authc
18             </value>
19         </property>

九、Remember Me 記住我

第一步，首先在登陸界面聲明“記住我”的復選框

第二步，在控制器中，接收rememberMe的參數：

第三步，在shiro主配置文件中實現記住我的功能：

十、shiro標簽庫的使用

shiro為我們提供了一些簡單的標簽可以在jsp中使用，可以用來控制用戶權限做一些操作

第一步，使用標簽庫，首先導入shiro的標簽庫：

第二步，寫所需要的標簽

shiro常用標簽：

guest標簽：驗證當前用戶是否為“訪客”，即未認證（包含未記住）的用戶

1 <shiro:guest> 
2  
3 Hi there!  Please <a href="login.jsp">Login</a> or <a href="signup.jsp">Signup</a> today! 
4  
5 </shiro:guest>

user標簽：認證通過或者已記住的用戶

1 <shiro:user> 
2  
3     Welcome back John!  Not John? Click <a href="login.jsp">here<a> to login. 
4  
5 </shiro:user>

authenticated標簽：已認證通過的用戶。不包含已記住的用戶，這是與user標簽的區別

1 <shiro:authenticated> 
2  
3     <a href="updateAccount.jsp">Update your contact information</a>. 
4  
5 </shiro:authenticated>

noAuthenticated標簽：未認證通過用戶，與authenticated標簽相對應。與guest標簽的區別是，該標簽包含已記住用戶

1 <shiro:notAuthenticated> 
2  
3     Please <a href="login.jsp">login</a> in order to update your credit card information. 
4  
5 </shiro:notAuthenticated>

principal標簽：輸出當前用戶信息，通常為登陸賬號信息

1 Hello, <shiro:principal/>, how are you today?

hashRole標簽：驗證當前用戶是否屬於該角色

1 <shiro:hasRole name="administrator"> 
2  
3     <a href="admin.jsp">Administer the system</a> 
4  
5 </shiro:hasRole>

lackRole標簽：與hasRole標簽邏輯相反，當用戶不輸入該角色時驗證通過

1 <shiro:lacksRole name="administrator"> 
2  
3     Sorry, you are not allowed to administer the system. 
4  
5 </shiro:lacksRole>

hasAnyRole標簽：驗證當前用戶是否屬於以下任意一個角色

1 <shiro:hasAnyRoles name="developer, project manager, administrator"> 
2  
3     You are either a developer, project manager, or administrator. 
4  
5 </shiro:hasAnyRoles>

hasPermission標簽：驗證當前用戶是否擁有指定權限

1 <shiro:hasPermission name="user:create"> 
2  
3     <a href="createUser.jsp">Create a new User</a> 
4  
5 </shiro:hasPermission>

lacksPermission標簽：與hasPermission標簽邏輯相反，當前用戶沒有制定權限時，驗證通過

1 <shiro:lacksPermission name="user:create"> 
2  
3     <a href="createUser.jsp">Create a new User</a> 
4  
5 </shiro:lacksPermission>

免責聲明！

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

猜您在找 Shiro權限框架使用總結 Shiro 權限框架使用總結 shiro框架 shiro（java安全框架） Shiro安全框架案例 shiro框架詳解 shiro 框架之加密處理。 Springboot整合shiro框架 Shiro安全框架-簡介 shiro 框架基本講解