Manuel d'utilisation d'Apache Shiro (3) Autorisation Shiro

L'autorisation est un contrôle d'accès, qui déterminera si l'utilisateur dispose des droits d'accès correspondants aux ressources de l'application.

Par exemple, déterminez si un utilisateur a l'autorisation d'afficher des pages, l'autorisation de modifier des données, l'autorisation d'avoir un certain bouton et s'il a l'autorisation d'imprimer, etc.

1. Trois éléments d'autorisation

L'autorisation comporte trois éléments principaux : les autorisations, les rôles et les utilisateurs.

Autorisations

Les autorisations sont l'élément central du mécanisme de sécurité d'Apache Shiro. Il indique clairement le comportement et les performances autorisés dans l'application. Une déclaration d'autorisations bien formatée communique clairement les autorisations dont dispose un utilisateur sur la ressource.

La plupart des ressources prendront en charge les opérations CRUD typiques (créer, lire, mettre à jour, supprimer), mais il est logique que toute opération soit basée sur une ressource spécifique. Par conséquent, l’idée fondamentale de la déclaration d’autorisation est basée sur les ressources et les opérations.

Grâce à la déclaration d'autorisation, nous ne pouvons comprendre que ce que cette autorisation peut faire dans l'application, mais nous ne pouvons pas déterminer qui possède cette autorisation.

Nous devons donc associer les utilisateurs et les autorisations dans l'application.

L'approche habituelle consiste à attribuer des autorisations à un rôle puis à associer ce rôle à un ou plusieurs utilisateurs.

Déclaration d'autorisation et granularité

La déclaration d'autorisation Shiro utilise généralement des expressions séparées par des deux-points. Comme mentionné précédemment, une expression d'autorisation peut spécifier clairement le type de ressource, les opérations autorisées et les données accessibles. Dans le même temps, les expressions d'autorisation Shiro prennent en charge de simples caractères génériques, permettant des paramètres d'autorisation plus flexibles.

Ce qui suit utilise des exemples pour illustrer les expressions d'autorisation.

Peut interroger les données utilisateur

Utilisateur:afficher

Peut interroger ou modifier les données utilisateur

Utilisateur:afficher, modifier

Peut modifier Les données utilisateur effectuent toutes les opérations

Utilisateur :* ou l'utilisateur

peut modifier les données utilisateur avec l'identifiant 123

Utilisateur :modifier:123

rôle
Shiro prend en charge deux modes de rôle :

1. Rôle traditionnel : un rôle représente une série d'opérations lorsqu'une opération doit être autorisée et vérifiée, il vous suffit de déterminer s'il s'agit du rôle Can. . Ce type d'autorisations de rôle est relativement simple et vague, ce qui n'est pas propice à l'expansion.

2. Rôle d'autorisation : un rôle dispose d'un ensemble d'autorisations. Lors de la vérification de l'autorisation, il est nécessaire de déterminer si le rôle actuel dispose de l'autorisation. Ce type d'autorisations de rôle peut fournir des descriptions détaillées des autorisations pour le rôle et convient aux conceptions d'autorisations plus complexes.

La mise en œuvre de l'autorisation des deux modes de rôle sera décrite en détail ci-dessous.

2. Implémentation de l'autorisation

Shiro prend en charge trois façons d'implémenter le processus d'autorisation :

Implémentation du codage
Implémentation de l'annotation
Implémentation JSP Taglig

1. Implémentation d'autorisation basée sur le codage

1.1 Implémentation d'autorisation basée sur des rôles traditionnels

Lorsque vous devez vérifier si un utilisateur a un certain rôle, vous pouvez appeler la méthode hasRole* du Sujet exemple à vérifier.

Les méthodes de vérification associées sont les suivantes :

Subject currentUser = SecurityUtils.getSubject(); 

if (currentUser.hasRole("administrator")) { 

//show the admin button 

} else { 

//don't show the button? Grey it out? 

}

Description de la méthode du sujet

hasrole (String Rolename) 🎜>

hasRoles( List roleNames) Renvoie un tableau de valeurs booléennes correspondant dans l'ordre de la liste

hasAllRoles(Collection roleNames) Renvoie vrai si l'utilisateur a tous les rôles spécifiés

Prise en charge des assertions

Shiro prend également en charge la vérification des autorisations via des assertions. Si l'assertion réussit, aucune valeur n'est renvoyée et le programme continue son exécution ; si l'assertion échoue, un message d'exception sera généré. L'utilisation d'assertions peut rendre notre code plus concis.

Méthodes d'assertion pertinentes :

Subject currentUser = SecurityUtils.getSubject(); 

//guarantee that the current user is a bank teller and 

//therefore allowed to open the account: 

currentUser.checkRole("bankTeller"); 

openBankAccount();

Méthode du sujet                                                                                                                                                                              🎜>checkRoles(Collection roleNames. ) Affirmer si l'utilisateur a tous les rôles spécifiés

checkRoles(String ... roleNames) Surcharge de méthode de la méthode précédente

1.2 Implémentation d'autorisation basée sur les rôles d'autorisation

Par rapport au modèle de rôle traditionnel, le modèle de rôle basé sur les autorisations est moins couplé. modifier le code source en raison des changements de rôles. Par conséquent, le modèle de rôle basé sur les autorisations est une meilleure méthode de contrôle d'accès.

Son implémentation de code a les méthodes d'implémentation suivantes :

1. Implémentation basée sur l'objet d'autorisation

Créez une instance de org.apache.shiro.authz.Permission, et ceci. L'objet d'instance est transmis en tant que paramètre à Subject.isPerMIT() pour vérification.


Les méthodes pertinentes sont les suivantes :



Méthode du sujet Description

Permission printPermission = new PrinterPermission("laserjet4400n", "print"); 

Subject currentUser = SecurityUtils.getSubject(); 

if (currentUser.isPermitted(printPermission)) { 

//show the Print button 

} else { 

//don't show the button? Grey it out? 

} 

Permission printPermission = new PrinterPermission("laserjet4400n", "print"); 

Subject currentUser = SecurityUtils.getSubject(); 

if (currentUser.isPermitted(printPermission)) { 

//show the Print button 

} else { 

//don't show the button? Grey it out? 

}

isPermise(Permission p) Lorsque le sujet dispose de l'autorisation spécifiée, treu est revenu

isPermitted(List perms)    返回对应权限的boolean数组    

isPermittedAll(Collection perms)    Subject拥有所有制定权限时，返回true    

2、 基于字符串的实现 

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

Subject currentUser = SecurityUtils.getSubject(); 

if (currentUser.isPermitted("printer:print:laserjet4400n")) { 

//show the Print button 

} else { 

//don't show the button? Grey it out? 

}

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

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

类似基于对象的实现相关方法，基于字符串的实现相关方法： 

isPermitted(String perm)、isPermitted(String... perms)、isPermittedAll(String... perms) 

基于权限对象的断言实现 

Subject currentUser = SecurityUtils.getSubject(); 

//guarantee that the current user is permitted 

//to open a bank account: 

Permission p = new AccountPermission("open"); 

currentUser.checkPermission(p); 

openBankAccount();

基于字符串的断言实现 

Subject currentUser = SecurityUtils.getSubject(); 

//guarantee that the current user is permitted 

//to open a bank account: 

currentUser.checkPermission("account:open"); 

openBankAccount();

断言实现的相关方法 

Subject方法    说明    

checkPermission(Permission p)    断言用户是否拥有制定权限    

checkPermission(String perm)    断言用户是否拥有制定权限    

checkPermissions(Collection perms)    断言用户是否拥有所有指定权限    

checkPermissions(String... perms)    断言用户是否拥有所有指定权限

   

2、基于注解的授权实现 

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

相关的注解： 

@ RequiresAuthentication 

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

@RequiresAuthentication 

public void updateAccount(Account userAccount) { 

//this method will only be invoked by a 

//Subject that is guaranteed authenticated 

... 

} 

@ RequiresGuest

表明该用户需为”guest”用户 

@ RequiresPermissions 

当前用户需拥有制定权限 

@RequiresPermissions("account:create") 

public void createAccount(Account account) { 

//this method will only be invoked by a Subject 

//that is permitted to create an account 

... 

} 

@RequiresRoles

当前用户需拥有制定角色 

@ RequiresUser 

当前用户需为已认证用户或已记住用户 

3、基于JSP TAG的授权实现 

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

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

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

下面一一介绍Shiro的标签： 

guest标签 

验证当前用户是否为“访客”，即未认证（包含未记住）的用户 

<shiro:guest> 

Hi there! Please <a href="login.jsp">Login</a> or <a href="signup.jsp">Signup</a> today! 

</shiro:guest>

user标签 

认证通过或已记住的用户 

<shiro:user> 

Welcome back John! Not John? Click <a href="login.jsp">here<a> to login. 

</shiro:user>

authenticated标签 

已认证通过的用户。不包含已记住的用户，这是与user标签的区别所在。 

<shiro:authenticated> 

<a href="updateAccount.jsp">Update your contact information</a>. 

</shiro:authenticated> 

notAuthenticated标签

未认证通过用户，与authenticated标签相对应。与guest标签的区别是，该标签包含已记住用户。 

<shiro:notAuthenticated> 

Please <a href="login.jsp">login</a> in order to update your credit card information. 

</shiro:notAuthenticated>

principal 标签 

输出当前用户信息，通常为登录帐号信息 

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

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

<shiro:hasRole name="administrator"> 

<a href="admin.jsp">Administer the system</a> 

</shiro:hasRole>

lacksRole标签 

与hasRole标签逻辑相反，当用户不属于该角色时验证通过 

<shiro:lacksRole name="administrator"> 

Sorry, you are not allowed to administer the system. 

</shiro:lacksRole>

hasAnyRole标签 

验证当前用户是否属于以下任意一个角色。 

<shiro:hasAnyRoles name="developer, project manager, administrator"> 

You are either a developer, project manager, or administrator. 

</shiro:lacksRole>

hasPermission标签 

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

<shiro:hasPermission name="user:create"> 

<a href="createUser.jsp">Create a new User</a> 

</shiro:hasPermission>

lacksPermission标签 

与hasPermission标签逻辑相反，当前用户没有制定权限时，验证通过 

<shiro:hasPermission name="user:create"> 

<a href="createUser.jsp">Create a new User</a> 

</shiro:hasPermission>

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

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

2、Sbuject的实例通常是DelegatingSubject类（或子类）的实例对象，在认证开始时，会委托应用程序设置的securityManager实例调用相应的isPermitted*或hasRole*方法。 

3、接下来SecurityManager会委托内置的Authorizer的实例（默认是ModularRealmAuthorizer 类的实例，类似认证实例，它同样支持一个或多个Realm实例认证）调用相应的授权方法。 

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

当使用多个Realm时，不同于认证策略处理方式，授权处理过程中： 

1、当调用Realm出现异常时，将立即抛出异常，结束授权验证。 

2、只要有一个Realm验证成功，那么将认为授权成功，立即返回，结束认证。

以上就是Apache Shiro 使用手册（三）Shiro 授权的内容，更多相关内容请关注PHP中文网（www.php.cn）！