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

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

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

 

一、用户权限模型

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

  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>  
posted @ 2016-10-18 15:35  剑客族长  阅读(3156)  评论(0)  编辑  收藏  举报