简体中文（ZH-CN）English（EN）繁体中文（ZH-TW）日本語（JA）한국어（KO）Melayu（MS）Français（FR）Deutsch（DE）
Heim
Artikel
Fragen und Antworten
Kurs
Thema
Herunterladen
Spiel
Wörterbuch
kürzliche Updates

Heim  >  Artikel  >  Java  >  Wie SpringBoot Sa-Token verwendet, um die Berechtigungsauthentifizierung zu implementieren

Wie SpringBoot Sa-Token verwendet, um die Berechtigungsauthentifizierung zu implementieren

PHPz
PHPznach vorne
2023-05-16 13:19:131109Durchsuche

1. Designideen

Die sogenannte Berechtigungsauthentifizierung, die Kernlogik besteht darin, festzustellen, ob ein Konto über bestimmte Berechtigungen verfügt:

  • #🎜 🎜#Ja, das ist es. Lass dich passieren.

  • Nein? Dann ist der Zutritt verboten!

Wenn wir tief in die zugrunde liegenden Daten eintauchen, verfügt jedes Konto über einen Satz Berechtigungscodes, und das Framework überprüft, ob dieser Satz den angegebenen Berechtigungscode enthält.

Zum Beispiel: Das aktuelle Konto hat den Berechtigungscodesatz ["user-add", "user-delete", "user-get"], dann werde ich es überprüfen die Berechtigungen "user-update", das Ergebnis ist:

Überprüfung fehlgeschlagen, Zugriff auf ["user-add", "user-delete", "user-get"]，这时候我来校验权限 "user-update"，则其结果就是：验证失败，禁止访问。

所以现在问题的核心就是：

  • 如何获取一个账号所拥有的的权限码集合？

  • 本次操作需要验证的权限码是哪个？

接下来，我们将介绍在 SpringBoot 中如何使用 Sa-Token 完成权限认证操作。

Sa-Token 是一个轻量级 java 权限认证框架，主要解决登录认证、权限认证、单点登录、OAuth3、微服务网关鉴权 等一系列权限相关问题。

首先在项目中引入 Sa-Token 依赖：

<!-- Sa-Token 权限认证 -->
<dependency>
    <groupId>cn.dev33</groupId>
    <artifactId>sa-token-spring-boot-starter</artifactId>
    <version>1.34.0</version>
</dependency>

注：如果你使用的是 SpringBoot 3.x，只需要将 sa-token-spring-boot-starter 修改为 sa-token-spring-boot3-starter 即可。

二、获取当前账号权限码集合

因为每个项目的需求不同，其权限设计也千变万化，因此 [ 获取当前账号权限码集合 ] 这一操作不可能内置到框架中，所以 Sa-Token 将此操作以接口的方式暴露给你，以方便你根据自己的业务逻辑进行重写。

你需要做的就是新建一个类，实现 StpInterface接口，例如以下代码：

/**
 * 自定义权限验证接口扩展
 */
@Component	// 保证此类被SpringBoot扫描，完成Sa-Token的自定义权限验证扩展 
public class StpInterfaceImpl implements StpInterface {

	/**
	 * 返回一个账号所拥有的权限码集合 
	 */
	@Override
	public List<String> getPermissionList(Object loginId, String loginType) {
		// 本list仅做模拟，实际项目中要根据具体业务逻辑来查询权限
		List<String> list = new ArrayList<String>();	
		list.add("101");
		list.add("user.add");
		list.add("user.update");
		list.add("user.get");
		// list.add("user.delete");
		list.add("art.*");
		return list;
	}

	/**
	 * 返回一个账号所拥有的角色标识集合 (权限与角色可分开校验)
	 */
	@Override
	public List<String> getRoleList(Object loginId, String loginType) {
		// 本list仅做模拟，实际项目中要根据具体业务逻辑来查询角色
		List<String> list = new ArrayList<String>();	
		list.add("admin");
		list.add("super-admin");
		return list;
	}

}

参数解释：

  • loginId：账号id，即你在调用 StpUtil.login(id) 时写入的标识值。

  • loginType：账号体系标识，此处可以暂时忽略，在 [ 多账户认证 ] 章节下会对这个概念做详细的解释。

注意点：类上一定要加上 @Component 注解，保证组件被 Springboot 扫描到，成功注入到 Sa-Token 框架内。

三、权限校验

启动类：

@SpringBootApplication
public class SaTokenCaseApplication {
	public static void main(String[] args) {
		SpringApplication.run(SaTokenCaseApplication.class, args); 
		System.out.println("\n启动成功：Sa-Token配置如下：" + SaManager.getConfig());
	}	
}

然后就可以用以下api来鉴权了

// 获取：当前账号所拥有的权限集合
StpUtil.getPermissionList();

// 判断：当前账号是否含有指定权限, 返回 true 或 false
StpUtil.hasPermission("user.add");		

// 校验：当前账号是否含有指定权限, 如果验证未通过，则抛出异常: NotPermissionException 
StpUtil.checkPermission("user.add");		

// 校验：当前账号是否含有指定权限 [指定多个，必须全部验证通过]
StpUtil.checkPermissionAnd("user.add", "user.delete", "user.get");		

// 校验：当前账号是否含有指定权限 [指定多个，只要其一验证通过即可]
StpUtil.checkPermissionOr("user.add", "user.delete", "user.get");

扩展：NotPermissionException 对象可通过 getLoginType() 方法获取具体是哪个 StpLogic 抛出的异常

四、角色校验

在Sa-Token中，角色和权限可以独立验证

// 获取：当前账号所拥有的角色集合
StpUtil.getRoleList();

// 判断：当前账号是否拥有指定角色, 返回 true 或 false
StpUtil.hasRole("super-admin");		

// 校验：当前账号是否含有指定角色标识, 如果验证未通过，则抛出异常: NotRoleException
StpUtil.checkRole("super-admin");		

// 校验：当前账号是否含有指定角色标识 [指定多个，必须全部验证通过]
StpUtil.checkRoleAnd("super-admin", "shop-admin");		

// 校验：当前账号是否含有指定角色标识 [指定多个，只要其一验证通过即可] 
StpUtil.checkRoleOr("super-admin", "shop-admin");

扩展：NotRoleException 对象可通过 getLoginType() 方法获取具体是哪个 StpLogic 抛出的异常

五、拦截全局异常

有同学要问，鉴权失败，抛出异常，然后呢？要把异常显示给用户看吗？当然不可以！

你可以创建一个全局异常拦截器，统一返回给前端的格式，参考：

@RestControllerAdvice
public class GlobalExceptionHandler {
    // 全局异常拦截 
    @ExceptionHandler
    public SaResult handlerException(Exception e) {
        e.printStackTrace(); 
        return SaResult.error(e.getMessage());
    }
}

六、权限通配符

Sa-Token允许你根据通配符指定泛权限，例如当一个账号拥有art.*的权限时，art.add、art.delete、art.update都将匹配通过

// 当拥有 art.* 权限时
StpUtil.hasPermission("art.add");        // true
StpUtil.hasPermission("art.update");     // true
StpUtil.hasPermission("goods.add");      // false

// 当拥有 *.delete 权限时
StpUtil.hasPermission("art.delete");      // true
StpUtil.hasPermission("user.delete");     // true
StpUtil.hasPermission("user.update");     // false

// 当拥有 *.js 权限时
StpUtil.hasPermission("index.js");        // true
StpUtil.hasPermission("index.css");       // false
StpUtil.hasPermission("index.html");      // false

上帝权限：当一个账号拥有 "*" 权限时，他可以验证通过任何权限码 （角色认证同理）

七、如何把权限精确到按钮级？

权限精确到按钮级的意思就是指：权限范围可以控制到页面上的每一个按钮是否显示。

思路：如此精确的范围控制只依赖后端已经难以完成，此时需要前端进行一定的逻辑判断。

如果是前后端一体项目，可以参考：Thymeleaf 标签方言，如果是前后端分离项目，则：

  • 在登录时，把当前账号拥有的所有权限码一次性返回给前端。

  • 前端将权限码集合保存在localStorage或其它全局状态管理对象中。

  • 在需要权限控制的按钮上，使用 js 进行逻辑判断，例如在Vue框架中我们可以使用如下写法：

<button v-if="arr.indexOf(&#39;user.delete&#39;) > -1">删除按钮</button>

其中：arr是当前用户拥有的权限码数组，user.delete是显示按钮需要拥有的权限码，删除按钮 ist verboten.

Der Kern des Problems ist nun also:

Wie erhalte ich den Satz von Berechtigungscodes, die einem Konto gehören?

#🎜🎜#Welcher Berechtigungscode muss für diesen Vorgang überprüft werden? #🎜🎜##🎜🎜##🎜🎜##🎜🎜#Als nächstes stellen wir vor, wie Sie Sa-Token verwenden, um Berechtigungsauthentifizierungsvorgänge in SpringBoot abzuschließen. #🎜🎜#
#🎜🎜#Sa-Token ist ein leichtes Java-Berechtigungsauthentifizierungsframework, das hauptsächlich eine Reihe von berechtigungsbezogenen Problemen löst, wie z. B. Anmeldeauthentifizierung, Berechtigungsauthentifizierung, Single Sign-On, OAuth3 und Microservice-Gateway-Authentifizierung . #🎜🎜#
#🎜🎜#Führen Sie zunächst die Sa-Token-Abhängigkeit in das Projekt ein: #🎜🎜#
package com.pj.cases.use;

import java.util.List;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import cn.dev33.satoken.stp.StpUtil;
import cn.dev33.satoken.util.SaResult;

/**
 * Sa-Token 权限认证示例 
 * 
 * @author kong
 * @since 2022-10-13
 */
@RestController
@RequestMapping("/jur/")
public class JurAuthController {

	/*
	 * 前提1：首先调用登录接口进行登录，代码在 com.pj.cases.use.LoginAuthController 中有详细解释，此处不再赘述 
	 * 		---- http://localhost:8081/acc/doLogin?name=zhang&pwd=123456
	 * 
	 * 前提2：项目实现 StpInterface 接口，代码在  com.pj.satoken.StpInterfaceImpl
	 * 		Sa-Token 将从此实现类获取 每个账号拥有哪些权限。
	 * 
	 * 然后我们就可以使用以下示例中的代码进行鉴权了 
	 */
	
	// 查询权限   ---- http://localhost:8081/jur/getPermission
	@RequestMapping("getPermission")
	public SaResult getPermission() {
		// 查询权限信息 ，如果当前会话未登录，会返回一个空集合 
		List<String> permissionList = StpUtil.getPermissionList();
		System.out.println("当前登录账号拥有的所有权限：" + permissionList);
		
		// 查询角色信息 ，如果当前会话未登录，会返回一个空集合 
		List<String> roleList = StpUtil.getRoleList();
		System.out.println("当前登录账号拥有的所有角色：" + roleList);
		
		// 返回给前端 
		return SaResult.ok()
				.set("roleList", roleList)
				.set("permissionList", permissionList);
	}
	
	// 权限校验  ---- http://localhost:8081/jur/checkPermission
	@RequestMapping("checkPermission")
	public SaResult checkPermission() {
		
		// 判断：当前账号是否拥有一个权限，返回 true 或 false
		// 		如果当前账号未登录，则永远返回 false 
		StpUtil.hasPermission("user.add");
		StpUtil.hasPermissionAnd("user.add", "user.delete", "user.get");  // 指定多个，必须全部拥有才会返回 true 
		StpUtil.hasPermissionOr("user.add", "user.delete", "user.get");	 // 指定多个，只要拥有一个就会返回 true 
		
		// 校验：当前账号是否拥有一个权限，校验不通过时会抛出 `NotPermissionException` 异常 
		// 		如果当前账号未登录，则永远校验失败 
		StpUtil.checkPermission("user.add");
		StpUtil.checkPermissionAnd("user.add", "user.delete", "user.get");  // 指定多个，必须全部拥有才会校验通过 
		StpUtil.checkPermissionOr("user.add", "user.delete", "user.get");  // 指定多个，只要拥有一个就会校验通过 
		
		return SaResult.ok();
	}

	// 角色校验  ---- http://localhost:8081/jur/checkRole
	@RequestMapping("checkRole")
	public SaResult checkRole() {
		
		// 判断：当前账号是否拥有一个角色，返回 true 或 false
		// 		如果当前账号未登录，则永远返回 false 
		StpUtil.hasRole("admin");
		StpUtil.hasRoleAnd("admin", "ceo", "cfo");  // 指定多个，必须全部拥有才会返回 true 
		StpUtil.hasRoleOr("admin", "ceo", "cfo");	  // 指定多个，只要拥有一个就会返回 true 
		
		// 校验：当前账号是否拥有一个角色，校验不通过时会抛出 `NotRoleException` 异常 
		// 		如果当前账号未登录，则永远校验失败 
		StpUtil.checkRole("admin");
		StpUtil.checkRoleAnd("admin", "ceo", "cfo");  // 指定多个，必须全部拥有才会校验通过 
		StpUtil.checkRoleOr("admin", "ceo", "cfo");  // 指定多个，只要拥有一个就会校验通过 
		
		return SaResult.ok();
	}

	// 权限通配符  ---- http://localhost:8081/jur/wildcardPermission
	@RequestMapping("wildcardPermission")
	public SaResult wildcardPermission() {
		
		// 前提条件：在 StpInterface 实现类中，为账号返回了 "art.*" 泛权限
		StpUtil.hasPermission("art.add");  // 返回 true 
		StpUtil.hasPermission("art.delete");  // 返回 true 
		StpUtil.hasPermission("goods.add");  // 返回 false，因为前缀不符合  
		
		// * 符合可以出现在任意位置，比如权限码的开头，当账号拥有 "*.delete" 时  
		StpUtil.hasPermission("goods.add");        // false
		StpUtil.hasPermission("goods.delete");     // true
		StpUtil.hasPermission("art.delete");      // true
		
		// 也可以出现在权限码的中间，比如当账号拥有 "shop.*.user" 时  
		StpUtil.hasPermission("shop.add.user");  // true
		StpUtil.hasPermission("shop.delete.user");  // true
		StpUtil.hasPermission("shop.delete.goods");  // false，因为后缀不符合 

		// 注意点：
		// 1、上帝权限：当一个账号拥有 "*" 权限时，他可以验证通过任何权限码
		// 2、角色校验也可以加 * ，指定泛角色，例如： "*.admin"，暂不赘述 
		
		return SaResult.ok();
	}
}
#🎜🎜#Hinweis: Wenn Sie SpringBoot 3.x verwenden, Ändern Sie einfach sa-token-spring-boot-starter in sa-token-spring-boot3-starter. #🎜🎜##🎜🎜# 2. Holen Sie sich den Berechtigungscodesatz für das aktuelle Konto #🎜🎜##🎜🎜# Da die Anforderungen jedes Projekts unterschiedlich sind, ändert sich auch das Berechtigungsdesign ständig, also [Holen Sie sich die Berechtigung für das aktuelle Konto Codesatz] Diese Operation kann nicht in das Framework integriert werden, daher stellt Ihnen Sa-Token diese Operation in Form einer Schnittstelle zur Verfügung, sodass Sie sie entsprechend Ihrer eigenen Geschäftslogik neu schreiben können. #🎜🎜##🎜🎜#Was Sie tun müssen, ist, eine neue Klasse zu erstellen und die StpInterface-Schnittstelle zu implementieren, wie zum Beispiel den folgenden Code: #🎜🎜#rrreee#🎜🎜##🎜🎜 #Parametererklärung: #🎜 🎜##🎜🎜##🎜🎜##🎜🎜##🎜🎜#loginId: Konto-ID, das ist der Identifikationswert, den Sie schreiben, wenn Sie StpUtil.login(id)aufrufen >. #🎜🎜##🎜🎜##🎜🎜##🎜🎜#loginType: Kontosystem-ID, die hier vorübergehend ignoriert werden kann. Dieses Konzept wird im Kapitel [Authentifizierung mehrerer Konten] ausführlich erläutert. #🎜🎜##🎜🎜##🎜🎜##🎜🎜##🎜🎜#Hinweis: Die Klasse #🎜🎜# muss mit @Component annotiert werden, um sicherzustellen, dass die Komponente von Springboot gescannt wird , erfolgreich in das Sa-Token-Framework eingefügt. #🎜🎜##🎜🎜#3. Berechtigungsüberprüfung#🎜🎜##🎜🎜#Startup-Klasse: #🎜🎜#rrreee#🎜🎜#Dann können Sie die folgende API zur Authentifizierung verwenden #🎜🎜#rrreee#🎜 🎜# Erweiterung: Das NotPermissionException-Objekt kann die Methode getLoginType() verwenden, um die spezifische Ausnahme zu erhalten, die von StpLogic#🎜🎜##🎜🎜# 4 ausgelöst wird . Rollenüberprüfung#🎜🎜##🎜🎜#In Sa-Token können Rollen und Berechtigungen unabhängig überprüft werden#🎜🎜#rrreee#🎜🎜#Erweiterung: NotRoleException Objekt kann übergeben werden Das Die Methode getLoginType() ruft die von StpLogic ausgelöste spezifische Ausnahme ab. #🎜🎜##🎜🎜#5 Abfangen globaler Ausnahmen #🎜🎜##🎜🎜# Die Authentifizierung schlägt fehl und es wird eine Ausnahme ausgelöst. Was dann? Möchten Sie dem Benutzer Ausnahmen anzeigen? #🎜🎜#Natürlich nicht! #🎜🎜##🎜🎜##🎜🎜#Sie können einen globalen Ausnahme-Interceptor erstellen, um das an das Frontend zurückgegebene Format zu vereinheitlichen, Referenz: #🎜🎜#rrreee#🎜🎜# 6. Berechtigungsplatzhalter #🎜🎜##🎜 🎜 Mit #Sa-Token können Sie #🎜🎜#allgemeine Berechtigungen#🎜🎜# basierend auf Platzhaltern angeben. Wenn ein Konto beispielsweise die Berechtigungen art.* hat, art.add , Sowohl art.delete als auch art.update stimmen mit #🎜🎜#rrreee
#🎜🎜#Gottes Erlaubnis: wenn ein Konto "*" Beim Zugriff auf Berechtigungen kann er jeden Berechtigungscode überprüfen (dasselbe gilt für die Rollenauthentifizierung) #🎜🎜#
#🎜🎜# 7. Wie kann man Berechtigungen auf Tastenebene genau festlegen? #🎜🎜##🎜🎜#Berechtigungen auf Schaltflächenebene genau bedeuten: #🎜🎜#Der Berechtigungsbereich kann steuern, ob jede Schaltfläche auf der Seite #🎜🎜# anzeigt. #🎜🎜##🎜🎜# Idee: Eine solch präzise Bereichskontrolle ist schwer zu erreichen, wenn man sich nur auf das Backend verlässt. Zu diesem Zeitpunkt muss das Frontend bestimmte logische Urteile fällen. #🎜🎜##🎜🎜# Wenn es sich um ein integriertes Front-End- und Back-End-Projekt handelt, können Sie sich auf Folgendes beziehen: Thymeleaf-Tag-Dialekt. Wenn es sich um ein separates Front-End- und Back-End-Projekt handelt, dann: #🎜🎜 ##🎜🎜##🎜🎜##🎜🎜# Geben Sie beim Anmelden alle Berechtigungscodes des aktuellen Kontos auf einmal an das Frontend zurück. #🎜🎜##🎜🎜##🎜🎜##🎜🎜#Das Frontend speichert die Berechtigungscodesammlung in localStorage oder anderen globalen Statusverwaltungsobjekten. #🎜🎜##🎜🎜##🎜🎜##🎜🎜#Verwenden Sie bei Schaltflächen, die eine Berechtigungskontrolle erfordern, js, um logische Urteile zu fällen. Im Vue-Framework können wir beispielsweise die folgende Schreibweise verwenden : #🎜 🎜##🎜🎜##🎜🎜#rrreee#🎜🎜#Wobei: arr ist das Array von Berechtigungscodes, die dem aktuellen Benutzer gehören, user.delete ist erforderlich, um den Berechtigungscode der Schaltfläche anzuzeigen. Schaltfläche löschen ist ein Inhalt, den Benutzer nur sehen können, wenn sie über den Berechtigungscode verfügen. #🎜🎜##🎜🎜#Hinweis: Die obige Schreibmethode dient nur als Referenzbeispiel. Verschiedene Frameworks verfügen über unterschiedliche Schreibmethoden. Sie können je nach Projekttechnologie-Stack flexibel kapseln und aufrufen. #🎜🎜##🎜🎜# 8. Wenn das Front-End über eine Authentifizierung verfügt, benötigt das Back-End noch eine Authentifizierung? #🎜🎜##🎜🎜##🎜🎜#Bedürfnis! #🎜🎜##🎜🎜#

前端的鉴权只是一个辅助功能，对于专业人员这些限制都是可以轻松绕过的，为保证服务器安全，无论前端是否进行了权限校验，后端接口都需要对会话请求再次进行权限校验！

九、来个小示例，加深一下印象

新建 JurAuthController，复制以下代码

package com.pj.cases.use;

import java.util.List;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import cn.dev33.satoken.stp.StpUtil;
import cn.dev33.satoken.util.SaResult;

/**
 * Sa-Token 权限认证示例 
 * 
 * @author kong
 * @since 2022-10-13
 */
@RestController
@RequestMapping("/jur/")
public class JurAuthController {

	/*
	 * 前提1：首先调用登录接口进行登录，代码在 com.pj.cases.use.LoginAuthController 中有详细解释，此处不再赘述 
	 * 		---- http://localhost:8081/acc/doLogin?name=zhang&pwd=123456
	 * 
	 * 前提2：项目实现 StpInterface 接口，代码在  com.pj.satoken.StpInterfaceImpl
	 * 		Sa-Token 将从此实现类获取 每个账号拥有哪些权限。
	 * 
	 * 然后我们就可以使用以下示例中的代码进行鉴权了 
	 */
	
	// 查询权限   ---- http://localhost:8081/jur/getPermission
	@RequestMapping("getPermission")
	public SaResult getPermission() {
		// 查询权限信息 ，如果当前会话未登录，会返回一个空集合 
		List<String> permissionList = StpUtil.getPermissionList();
		System.out.println("当前登录账号拥有的所有权限：" + permissionList);
		
		// 查询角色信息 ，如果当前会话未登录，会返回一个空集合 
		List<String> roleList = StpUtil.getRoleList();
		System.out.println("当前登录账号拥有的所有角色：" + roleList);
		
		// 返回给前端 
		return SaResult.ok()
				.set("roleList", roleList)
				.set("permissionList", permissionList);
	}
	
	// 权限校验  ---- http://localhost:8081/jur/checkPermission
	@RequestMapping("checkPermission")
	public SaResult checkPermission() {
		
		// 判断：当前账号是否拥有一个权限，返回 true 或 false
		// 		如果当前账号未登录，则永远返回 false 
		StpUtil.hasPermission("user.add");
		StpUtil.hasPermissionAnd("user.add", "user.delete", "user.get");  // 指定多个，必须全部拥有才会返回 true 
		StpUtil.hasPermissionOr("user.add", "user.delete", "user.get");	 // 指定多个，只要拥有一个就会返回 true 
		
		// 校验：当前账号是否拥有一个权限，校验不通过时会抛出 `NotPermissionException` 异常 
		// 		如果当前账号未登录，则永远校验失败 
		StpUtil.checkPermission("user.add");
		StpUtil.checkPermissionAnd("user.add", "user.delete", "user.get");  // 指定多个，必须全部拥有才会校验通过 
		StpUtil.checkPermissionOr("user.add", "user.delete", "user.get");  // 指定多个，只要拥有一个就会校验通过 
		
		return SaResult.ok();
	}

	// 角色校验  ---- http://localhost:8081/jur/checkRole
	@RequestMapping("checkRole")
	public SaResult checkRole() {
		
		// 判断：当前账号是否拥有一个角色，返回 true 或 false
		// 		如果当前账号未登录，则永远返回 false 
		StpUtil.hasRole("admin");
		StpUtil.hasRoleAnd("admin", "ceo", "cfo");  // 指定多个，必须全部拥有才会返回 true 
		StpUtil.hasRoleOr("admin", "ceo", "cfo");	  // 指定多个，只要拥有一个就会返回 true 
		
		// 校验：当前账号是否拥有一个角色，校验不通过时会抛出 `NotRoleException` 异常 
		// 		如果当前账号未登录，则永远校验失败 
		StpUtil.checkRole("admin");
		StpUtil.checkRoleAnd("admin", "ceo", "cfo");  // 指定多个，必须全部拥有才会校验通过 
		StpUtil.checkRoleOr("admin", "ceo", "cfo");  // 指定多个，只要拥有一个就会校验通过 
		
		return SaResult.ok();
	}

	// 权限通配符  ---- http://localhost:8081/jur/wildcardPermission
	@RequestMapping("wildcardPermission")
	public SaResult wildcardPermission() {
		
		// 前提条件：在 StpInterface 实现类中，为账号返回了 "art.*" 泛权限
		StpUtil.hasPermission("art.add");  // 返回 true 
		StpUtil.hasPermission("art.delete");  // 返回 true 
		StpUtil.hasPermission("goods.add");  // 返回 false，因为前缀不符合  
		
		// * 符合可以出现在任意位置，比如权限码的开头，当账号拥有 "*.delete" 时  
		StpUtil.hasPermission("goods.add");        // false
		StpUtil.hasPermission("goods.delete");     // true
		StpUtil.hasPermission("art.delete");      // true
		
		// 也可以出现在权限码的中间，比如当账号拥有 "shop.*.user" 时  
		StpUtil.hasPermission("shop.add.user");  // true
		StpUtil.hasPermission("shop.delete.user");  // true
		StpUtil.hasPermission("shop.delete.goods");  // false，因为后缀不符合 

		// 注意点：
		// 1、上帝权限：当一个账号拥有 "*" 权限时，他可以验证通过任何权限码
		// 2、角色校验也可以加 * ，指定泛角色，例如： "*.admin"，暂不赘述 
		
		return SaResult.ok();
	}
}

代码注释已针对每一步操作做出详细解释，大家可根据可参照注释中的访问链接进行逐步测试。

Das obige ist der detaillierte Inhalt vonWie SpringBoot Sa-Token verwendet, um die Berechtigungsauthentifizierung zu implementieren. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!

Stellungnahme：
Dieser Artikel ist reproduziert unter:yisu.com. Bei Verstößen wenden Sie sich bitte an admin@php.cn löschen
Vorheriger Artikel：So verwenden Sie den SpringBoot-InterceptorNächster Artikel：So verwenden Sie den SpringBoot-Interceptor

In Verbindung stehende Artikel

Mehr sehen