shiro中基于注解实现的权限认证过程

Posted 2020-08-15 剑客族长

授权即访问控制，它将判断用户在应用程序中对资源是否拥有相应的访问权限。 

如，判断一个用户有查看页面的权限，编辑数据的权限，拥有某一按钮的权限等等。 

 

一、用户权限模型

为实现一个较为灵活的用户权限数据模型，通常把用户信息单独用一个实体表示，用户权限信息用两个实体表示。

1. 用户信息用 LoginAccount 表示，最简单的用户信息可能只包含用户名 loginName 及密码 password 两个属性。实际应用中可能会包含用户是否被禁用，用户信息是否过期等信息。
2. 用户权限信息用 Role 与 Permission 表示，Role 与 Permission 之间构成多对多关系。Permission 可以理解为对一个资源的操作，Role 可以简单理解为 Permission 的集合。
3. 用户信息与 Role 之间构成多对多关系。表示同一个用户可以拥有多个 Role，一个 Role 可以被多个用户所拥有。

 

 

权限声明及粒度 

Shiro权限声明通常是使用以冒号分隔的表达式。就像前文所讲，一个权限表达式可以清晰的指定资源类型，允许的操作。同时，Shiro权限表达式支持简单的通配符，可以更加灵活的进行权限设置。 

下面以实例来说明权限表达式。 

可查询用户数据 

User:view 

可查询或编辑用户数据 

User:view,edit 

可对用户数据进行所有操作 

User:*或 user 

可编辑id为123的用户数据 

User:edit:123 

 

授权处理过程

认证通过后接受 Shiro 授权检查，授权验证时，需要判断当前角色是否拥有该权限。

只有授权通过，才可以访问受保护 URL 对应的资源，否则跳转到“未经授权页面”。

如果我们自定义Realm实现，比如我后面的例子中，自定义了ShiroDbRealm类，当访问被@RequiresPermissions注解的方法时，会先执行ShiroDbRealm.doGetAuthorizationInfo()进行授权。

 

[java] view plain copy

 

1. <span style="font-size:18px">@Controller  
2. @RequestMapping(value = "/user")  
3. public class UserController {  
4.    
5. @Resource(name="userService")  
6. private IUserService userService;  
7.    
8. /** 
9.  * 测试权限 
10.  * 只有拥有 user:create权限，才能进行注册 
11.  * @param user 
12.  * @return 
13.  */  
14. @RequestMapping(value = "/register")  
15. @ResponseBody  
16. @RequiresPermissions("user:create")  
17. public boolean register(User user){  
18. return userService.register(user);  
19. }</span>  

 

 

 

二、授权实现 

Shiro支持三种方式实现授权过程： 

• 编码实现
• 注解实现
• JSP Taglig实现

 

1、基于编码的授权实现 

1、基于权限对象的实现 

创建org.apache.shiro.authz.Permission的实例，将该实例对象作为参数传递给Subject.isPermitted（）进行验证。 

      

[java] view plain copy

 

1. Permission printPermission = new PrinterPermission("laserjet4400n", "print");    
2. Subject currentUser = SecurityUtils.getSubject();    
3. if (currentUser.isPermitted(printPermission)) {    
4.     //show the Print button    
5. } else {    
6.     //don‘t show the button?  Grey it out?    
7. }    

 

 

 

2、基于字符串的实现 

相比笨重的基于对象的实现方式，基于字符串的实现便显得更加简洁。 

       

[java] view plain copy

 

1. Subject currentUser = SecurityUtils.getSubject();    
2. if (currentUser.isPermitted("printer:print:laserjet4400n")) {    
3.     //show the Print button    
4. } else {    
5.     //don‘t show the button?  Grey it out?    
6. }    

 

 

使用冒号分隔的权限表达式是org.apache.shiro.authz.permission.WildcardPermission默认支持的实现方式。 

这里分别代表了资源类型：操作：资源ID 

 

2、基于注解的授权实现 

Shiro注解支持AspectJ、Spring、Google-Guice等，可根据应用进行不同的配置。 

 

相关的注解： 

@RequiresAuthentication 

可以用户类/属性/方法，用于表明当前用户需是经过认证的用户。  

        

[java] view plain copy

 

1. @RequiresAuthentication    
2. public void updateAccount(Account userAccount) {    
3.     //this method will only be invoked by a     
4.     //Subject that is guaranteed authenticated    
5.     ...    
6. }   

 

 

@RequiresPermissions 

当前用户需拥有制定权限 

       

[java] view plain copy

 

1. @RequiresPermissions("account:create")    
2. public void createAccount(Account account) {    
3.     //this method will only be invoked by a Subject    
4.     //that is permitted to create an account    
5.     ...    
6. }   

 

 

 

3、基于JSP TAG的授权实现 

Shiro提供了一套JSP标签库来实现页面级的授权控制。 

在使用Shiro标签库前，首先需要在JSP引入shiro标签： 

 

[html] view plain copy

 

1. <%@ taglib prefix="shiro" uri="http://shiro.apache.org/tags" %>  

 

 

hasRole标签 

验证当前用户是否属于该角色

 

[html] view plain copy

 

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

 

 

hasPermission标签 

验证当前用户是否拥有制定权限 

 

[html] view plain copy

 

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

 

 

三、Shiro授权的内部处理机制 

 

1、在应用程序中调用授权验证方法(Subject的isPermitted*或hasRole*等) 

2、Sbuject会委托应用程序设置的securityManager实例调用相应的isPermitted*或hasRole*方法。 

3、接下来SecurityManager会委托内置的Authorizer的实例（默认是ModularRealmAuthorizer类的实例，类似认证实例）调用相应的授权方法。 

4、每一个Realm将检查是否实现了相同的Authorizer 接口。然后，将调用Reaml自己的相应的授权验证方法。 

 

四、授权代码

UserController：处理用户登录后的请求（注册）

    

[java] view plain copy

 

1. package org.shiro.demo.controller;  
2.   
3. import javax.annotation.Resource;  
4.   
5. import org.apache.shiro.authz.annotation.RequiresPermissions;  
6. import org.apache.shiro.authz.annotation.RequiresRoles;  
7. import org.shiro.demo.entity.User;  
8. import org.shiro.demo.service.IUserService;  
9. import org.springframework.stereotype.Controller;  
10. import org.springframework.web.bind.annotation.RequestMapping;  
11. import org.springframework.web.bind.annotation.ResponseBody;  
12.   
13. @Controller  
14. @RequestMapping(value = "/user")  
15. public class UserController {  
16.       
17.     @Resource(name="userService")  
18.     private IUserService userService;  
19.   
20.     /** 
21.      * 测试权限 
22.      * 只有拥有 user:create 权限，才能进行注册 
23.      * @param user 
24.      * @return 
25.      */  
26.     @RequestMapping(value = "/register")  
27.     @ResponseBody  
28.     @RequiresPermissions("user:create")  
29.     public boolean register(User user){  
30.         return userService.register(user);  
31.     }  
32.       
33.     /** 
34.      * 测试角色 
35.      * 只有拥有 administrator 角色，才能跳转到register页面 
36.      * @return 
37.      */  
38.     @RequestMapping(value = "/toRegister")  
39.     @RequiresRoles("administrator")  
40.     public String toRegister(){  
41.         return "/system/user/register";  
42.     }  
43. }  

 

 

 

ShiroDbRealm：自定义的指定Shiro验证用户授权的类

 

[java] view plain copy

 

1. <span style="font-size:18px">packageorg.shiro.demo.service.realm;  
2.    
3. importjava.util.ArrayList;  
4. importjava.util.List;  
5.    
6. importjavax.annotation.Resource;  
7.    
8. importorg.apache.commons.lang.StringUtils;  
9. importorg.apache.shiro.authc.AuthenticationException;  
10. importorg.apache.shiro.authc.AuthenticationInfo;  
11. importorg.apache.shiro.authc.AuthenticationToken;  
12. importorg.apache.shiro.authc.SimpleAuthenticationInfo;  
13. importorg.apache.shiro.authc.UsernamePasswordToken;  
14. importorg.apache.shiro.authz.AuthorizationException;  
15. importorg.apache.shiro.authz.AuthorizationInfo;  
16. importorg.apache.shiro.authz.SimpleAuthorizationInfo;  
17. importorg.apache.shiro.realm.AuthorizingRealm;  
18. importorg.apache.shiro.subject.PrincipalCollection;  
19. importorg.shiro.demo.entity.Permission;  
20. importorg.shiro.demo.entity.Role;  
21. importorg.shiro.demo.entity.User;  
22. importorg.shiro.demo.service.IUserService;  
23.    
24. /** 
25.  * 自定义的指定Shiro验证用户登录的类 
26.  * @author TCH 
27.  * 
28.  */  
29. publicclass ShiroDbRealm extends AuthorizingRealm{  
30.    
31. //@Resource(name="userService")  
32. privateIUserService userService;  
33.    
34. publicvoid setUserService(IUserService userService) {  
35. this.userService= userService;  
36. }  
37.    
38.     /** 
39.      * 为当前登录的Subject授予角色和权限 
40.      * @see 经测试:本例中该方法的调用时机为需授权资源被访问时 
41.      * @see经测试:并且每次访问需授权资源时都会执行该方法中的逻辑,这表明本例未启用AuthorizationCache 
42.      * @seeweb层可以有shiro的缓存，dao层可以配有hibernate的缓存（后面介绍） 
43.      */  
44. protectedAuthorizationInfo doGetAuthorizationInfo(  
45. PrincipalCollectionprincipals) {  
46.    
47. //获取当前登录的用户名,等价于(String)principals.fromRealm(this.getName()).iterator().next()   
48. Stringaccount = (String) super.getAvailablePrincipal(principals);  
49.    
50. List<String>roles = new ArrayList<String>();   
51. List<String>permissions = new ArrayList<String>();  
52.    
53. //从数据库中获取当前登录用户的详细信息   
54. Useruser = userService.getByAccount(account);  
55.    
56. if(user!= null){  
57. //实体类User中包含有用户角色的实体类信息   
58. if(user.getRoles() != null && user.getRoles().size() > 0) {  
59. //获取当前登录用户的角色  
60. for(Role role : user.getRoles()) {  
61. roles.add(role.getName());  
62.  //实体类Role中包含有角色权限的实体类信息   
63. if(role.getPmss() != null && role.getPmss().size() > 0) {  
64.  //获取权限   
65. for(Permission pmss : role.getPmss()) {  
66. if(!StringUtils.isEmpty(pmss.getPermission())){  
67. permissions.add(pmss.getPermission());  
68. }  
69. }  
70. }  
71. }  
72. }  
73. }else{  
74. thrownew AuthorizationException();  
75. }  
76.    
77. //为当前用户设置角色和权限  
78. SimpleAuthorizationInfoinfo = new SimpleAuthorizationInfo();  
79. info.addRoles(roles);  
80.         info.addStringPermissions(permissions);  
81.          
82. returninfo;  
83.    
84. }  
85.    
86. }</span>