recherche

Maison  >  Article  >  Java  >  Comment SpringBoot utilise Sa-Token pour implémenter l'authentification des autorisations

Comment SpringBoot utilise Sa-Token pour implémenter l'authentification des autorisations

PHPz
PHPzavant
2023-05-16 13:19:131166parcourir

1. Idées de conception

Ce qu'on appelle l'authentification par autorisation, la logique de base est de déterminer si un compte a spécifié des autorisations :

  • #🎜 🎜#Oui, c'est ça Laissez-vous passer.

  • Non ? Alors l'accès est interdit !

En approfondissant les données sous-jacentes, chaque compte aura un ensemble de codes d'autorisation, et le framework vérifiera si cet ensemble contient le code d'autorisation spécifié.

Par exemple : le compte actuel a le code d'autorisation défini ["user-add", "user-delete", "user-get"], alors je vérifierai les autorisations "user-update", le résultat est :

Échec de la vérification, l'accès à ["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是显示按钮需要拥有的权限码，删除按钮 est interdit.

Le cœur du problème est maintenant :

Comment obtenir l'ensemble des codes d'autorisation appartenant à un compte ?

#🎜🎜#Quel est le code d'autorisation qui doit être vérifié pour cette opération ? #🎜🎜##🎜🎜##🎜🎜##🎜🎜#Ensuite, nous présenterons comment utiliser Sa-Token pour effectuer les opérations d'authentification des autorisations dans SpringBoot. #🎜🎜#
#🎜🎜#Sa-Token est un cadre d'authentification d'autorisation Java léger qui résout principalement une série de problèmes liés aux autorisations tels que l'authentification de connexion, l'authentification d'autorisation, l'authentification unique, OAuth3 et l'authentification de passerelle de microservice. . #🎜🎜#
#🎜🎜#Introduisez d'abord la dépendance Sa-Token dans le projet : #🎜🎜#
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();
	}
}
#🎜🎜#Remarque : Si vous utilisez SpringBoot 3.x, Remplacez simplement sa-token-spring-boot-starter par sa-token-spring-boot3-starter. #🎜🎜##🎜🎜# 2. Obtenez le jeu de codes d'autorisation du compte actuel #🎜🎜##🎜🎜# Parce que les besoins de chaque projet sont différents, la conception des autorisations est également en constante évolution, donc [Obtenez l'autorisation du compte actuel code set] Cette opération Il est impossible de l'intégrer dans le framework, donc Sa-Token vous expose cette opération sous la forme d'une interface, afin que vous puissiez la réécrire selon votre propre logique métier. #🎜🎜##🎜🎜#Ce que vous devez faire est de créer une nouvelle classe et d'implémenter l'interface StpInterface, comme le code suivant : #🎜🎜#rrreee#🎜🎜##🎜🎜 #Explication du paramètre : #🎜 🎜##🎜🎜##🎜🎜##🎜🎜##🎜🎜#loginId : identifiant du compte, qui est la valeur d'identification que vous écrivez lors de l'appel de StpUtil.login(id). #🎜🎜##🎜🎜##🎜🎜##🎜🎜#loginType : Identifiant du système de compte, qui peut être temporairement ignoré ici. Ce concept sera expliqué en détail dans le chapitre [Authentification de comptes multiples]. #🎜🎜##🎜🎜##🎜🎜##🎜🎜##🎜🎜#Remarque : La classe #🎜🎜# doit être annotée avec @Component pour garantir que le composant est analysé par Springboot , injecté avec succès dans le framework Sa-Token. #🎜🎜##🎜🎜#3. Vérification des autorisations#🎜🎜##🎜🎜#Classe de démarrage : #🎜🎜#rrreee#🎜🎜#Ensuite, vous pouvez utiliser l'API suivante pour vous authentifier #🎜🎜#rrreee#🎜 🎜# Extension : L'objet NotPermissionException peut utiliser la méthode getLoginType() pour obtenir l'exception spécifique levée par StpLogic#🎜🎜##🎜🎜# 4 . Vérification des rôles#🎜🎜##🎜🎜#Dans Sa-Token, les rôles et les autorisations peuvent être vérifiés indépendamment#🎜🎜#rrreee#🎜🎜#Extension : l'objet NotRoleException peut être transmis Le La méthode getLoginType() obtient l'exception spécifique levée par StpLogic#🎜🎜##🎜🎜#5 Interception des exceptions globales#🎜🎜##🎜🎜#Certains étudiants veulent demander, L'authentification échoue et une exception est levée, et alors ? Voulez-vous afficher les exceptions à l'utilisateur ? #🎜🎜#Bien sûr que non ! #🎜🎜##🎜🎜##🎜🎜#Vous pouvez créer un intercepteur d'exception global pour unifier le format renvoyé au front-end, référence : #🎜🎜#rrreee#🎜🎜# 6. Caractère générique d'autorisation #🎜🎜##🎜 🎜 #Sa-Token vous permet de spécifier des #🎜🎜#autorisations générales#🎜🎜# en fonction de caractères génériques. Par exemple, lorsqu'un compte dispose des autorisations de art.*, art.add. , art.delete et art.update correspondront à #🎜🎜#rrreee
#🎜🎜#Autorisation de Dieu : lorsqu'un compte a "*" Lors de l'accès aux autorisations, il peut vérifier n'importe quel code d'autorisation (il en va de même pour l'authentification du rôle) #🎜🎜#
#🎜🎜# 7. Comment rendre les autorisations précises au niveau du bouton ? #🎜🎜##🎜🎜#Les autorisations précises au niveau du bouton signifient : #🎜🎜#La portée des autorisations peut contrôler si chaque bouton de la page affiche #🎜🎜#. #🎜🎜##🎜🎜# Idée : un contrôle de portée aussi précis est difficile à obtenir en s'appuyant uniquement sur le backend. À l'heure actuelle, le frontend doit faire certains jugements logiques. #🎜🎜##🎜🎜# S'il s'agit d'un projet front-end et back-end intégré, vous pouvez vous référer à : Dialecte de balise Thymeleaf S'il s'agit d'un projet front-end et back-end séparés, alors : #🎜🎜. ##🎜🎜##🎜🎜##🎜🎜# lors de la connexion, renvoyez simultanément tous les codes d'autorisation appartenant au compte actuel au front-end. #🎜🎜##🎜🎜##🎜🎜##🎜🎜#Le frontal enregistre la collection de codes d'autorisation dans localStorage ou d'autres objets de gestion d'état global. #🎜🎜##🎜🎜##🎜🎜##🎜🎜#Sur les boutons qui nécessitent un contrôle d'autorisation, utilisez js pour porter des jugements logiques. Par exemple, dans le framework Vue, nous pouvons utiliser l'écriture suivante. : #🎜 🎜##🎜🎜##🎜🎜#rrreee#🎜🎜#Où : arr est le tableau de codes d'autorisation appartenant à l'utilisateur actuel, user.delete est requis pour afficher le bouton Code d'autorisation, le Bouton Supprimer est un contenu que les utilisateurs ne peuvent voir que s'ils disposent du code d'autorisation. #🎜🎜##🎜🎜#Remarque : la méthode d'écriture ci-dessus sert uniquement à fournir un exemple de référence. Différents frameworks ont des méthodes d'écriture différentes. Vous pouvez encapsuler et appeler de manière flexible en fonction de la pile technologique du projet. #🎜🎜##🎜🎜# 8. Si le front-end a une authentification, le back-end a-t-il toujours besoin d'une authentification ? #🎜🎜##🎜🎜##🎜🎜#Besoin ! #🎜🎜##🎜🎜#

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

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

新建 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();
	}
}

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

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!

Déclaration：
Cet article est reproduit dans:. en cas de violation, veuillez contacter admin@php.cn Supprimer
Article précédent：Comment utiliser l'intercepteur SpringBootArticle suivant：Comment utiliser l'intercepteur SpringBoot

Articles Liés

Voir plus