Maison >développement back-end >tutoriel php >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.
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( ListPrise 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
isPermittedAll(Collection
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
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中文网(m.sbmmt.com)!