Apache Shiro-Benutzerhandbuch (3) Shiro-Autorisierung

Autorisierung ist eine Zugriffskontrolle, die bestimmt, ob der Benutzer über die entsprechenden Zugriffsrechte auf Ressourcen in der Anwendung verfügt.

Bestimmen Sie beispielsweise, ob ein Benutzer die Berechtigung zum Anzeigen von Seiten, die Berechtigung zum Bearbeiten von Daten, die Berechtigung für eine bestimmte Schaltfläche und die Berechtigung zum Drucken usw. hat.

1. Drei Elemente der Autorisierung

Autorisierung besteht aus drei Kernelementen: Berechtigungen, Rollen und Benutzer.

Berechtigungen

Berechtigungen sind das Kernelement des Apache Shiro-Sicherheitsmechanismus. Darin werden das zulässige Verhalten und die zulässige Leistung in der Anwendung klar dargelegt. Eine gut formatierte Berechtigungserklärung kommuniziert klar und deutlich die Berechtigungen, die ein Benutzer für die Ressource hat.

Die meisten Ressourcen unterstützen typische CRUD-Vorgänge (Erstellen, Lesen, Aktualisieren, Löschen), aber es ist sinnvoll, dass jeder Vorgang auf einer bestimmten Ressource basiert. Daher basiert die Grundidee der Berechtigungsdeklaration auf Ressourcen und Vorgängen.

Durch die Berechtigungserklärung können wir nur verstehen, was diese Berechtigung in der Anwendung bewirken kann, aber wir können nicht bestimmen, wer diese Berechtigung hat.

Also müssen wir Benutzer und Berechtigungen in der Anwendung zuordnen.

Der übliche Ansatz besteht darin, einer Rolle Berechtigungen zuzuweisen und diese Rolle dann einem oder mehreren Benutzern zuzuordnen.

Berechtigungsdeklaration und Granularität

Shiro-Berechtigungsdeklaration verwendet normalerweise durch Doppelpunkte getrennte Ausdrücke. Wie bereits erwähnt, kann ein Berechtigungsausdruck den Ressourcentyp, zulässige Vorgänge und zugängliche Daten klar angeben. Gleichzeitig unterstützen Shiro-Berechtigungsausdrücke einfache Platzhalter und ermöglichen so flexiblere Berechtigungseinstellungen.

Im Folgenden werden Beispiele zur Veranschaulichung von Berechtigungsausdrücken verwendet.

Kann Benutzerdaten abfragen

Benutzer:Anzeigen

Kann Benutzerdaten abfragen oder bearbeiten

Benutzer:Anzeigen,Bearbeiten

Kann bearbeiten Benutzerdaten führen alle Vorgänge aus

Benutzer:* oder Benutzer

können Benutzerdaten mit der ID 123

Benutzer:edit:123

Rolle
bearbeiten
Shiro unterstützt zwei Rollenmodi:

1. Eine Rolle stellt eine Reihe von Vorgängen dar. Wenn ein Vorgang autorisiert und überprüft werden muss, müssen Sie nur feststellen, ob es sich um die Rolle handelt . Diese Art von Rollenberechtigungen ist relativ einfach und vage, was einer Erweiterung nicht förderlich ist.

2. Berechtigungsrolle: Eine Rolle verfügt über eine Reihe von Berechtigungen. Bei der Berechtigungsüberprüfung muss festgestellt werden, ob die aktuelle Rolle über die Berechtigung verfügt. Diese Art von Rollenberechtigungen kann eine detaillierte Berechtigungsbeschreibung für die Rolle bereitstellen, die für komplexere Berechtigungsdesigns geeignet ist.

Die Berechtigungsimplementierung der beiden Rollenmodi wird im Folgenden ausführlich beschrieben.

2. Autorisierungsimplementierung

Shiro unterstützt drei Möglichkeiten zur Implementierung des Autorisierungsprozesses:

Codierungsimplementierung
Annotationsimplementierung
JSP Taglig-Implementierung

1. Autorisierungsimplementierung basierend auf Codierung

1.1 Autorisierungsimplementierung basierend auf herkömmlichen Rollen

Wenn Sie überprüfen müssen, ob ein Benutzer eine bestimmte Rolle hat, können Sie die hasRole*-Methode des Subjekts aufrufen Instanz zur Überprüfung.

Subject currentUser = SecurityUtils.getSubject(); 

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

//show the admin button 

} else { 

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

}

Die zugehörigen Überprüfungsmethoden lauten wie folgt:

Beschreibung der Betreffmethode

hasrole (string Rolename) 🎜>

hasRoles( List RoleNames) Gibt ein entsprechendes boolesches Wertearray in Listenreihenfolge zurück

hasAllRoles(Collection RoleNames) Gibt true zurück, wenn der Benutzer alle angegebenen Rollen hat

Assertion-Unterstützung

Shiro unterstützt auch die Autorisierungsüberprüfung durch Behauptungen. Wenn die Behauptung erfolgreich ist, wird kein Wert zurückgegeben und das Programm setzt die Ausführung fort; wenn die Behauptung fehlschlägt, wird eine Ausnahmemeldung ausgegeben. Die Verwendung von Behauptungen kann unseren Code prägnanter machen.

Relevante Methoden der Behauptung:

Subject currentUser = SecurityUtils.getSubject(); 

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

//therefore allowed to open the account: 

currentUser.checkRole("bankTeller"); 

openBankAccount();

Subjektmethode                                                                                                                                                               der Benutzer hat alle angegebenen Rollen

checkRoles(String ... RoleNames) Methodenüberladung der vorherigen Methode

1.2 Autorisierungsimplementierung basierend auf Berechtigungsrollen

Im Vergleich zum herkömmlichen Rollenmodell ist das berechtigungsbasierte Rollenmodell weniger gekoppelt. Dies wird nicht der Fall sein Ändern Sie den Quellcode aufgrund von Rollenänderungen. Daher ist das berechtigungsbasierte Rollenmodell eine bessere Zugriffskontrollmethode.

Die Code-Implementierung verfügt über die folgenden Implementierungsmethoden:

1. Implementierung basierend auf dem Berechtigungsobjekt

Erstellen Sie eine Instanz von org.apache.shiro.authz.Permission und This Das Instanzobjekt wird zur Überprüfung als Parameter an Subject.isPermitted() übergeben.


Die relevanten Methoden sind wie folgt:

Betreff-Methode Beschreibung

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? 

}

isPermitted(Permission p) Wenn der Betreff die angegebene Berechtigung hat, treu wird zurückgegeben

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）！