Comment SpringBoot utilise Sa-Token pour implémenter l'authentification de connexion-javaDidacticiel-php.cn

1. Idées de conception

Pour certaines interfaces accessibles uniquement après la connexion (par exemple : interroger les informations de mon compte), notre approche habituelle consiste à ajouter une couche de vérification de l'interface :

Si la vérification réussit, alors : renvoie normalement les données.
Si la vérification échoue, alors : lancez une exception et informez-les qu'ils doivent d'abord se connecter.

Alors, quelle est la base pour déterminer si une session est connectée ? Analysons d'abord brièvement le processus d'accès à la connexion :

L'utilisateur soumet les paramètres nom + mot de passe et appelle l'interface de connexion.
Connexion réussie, les informations d'identification de la session Token de l'utilisateur seront renvoyées.
Chaque demande ultérieure de l'utilisateur portera ce jeton.
Le serveur détermine si la session est connectée avec succès en fonction du jeton.

La soi-disant authentification de connexion fait référence au processus dans lequel le serveur vérifie le mot de passe du compte et délivre un identifiant de session Token à l'utilisateur. Ce Token est également la clé de notre jugement ultérieur quant à savoir si la session est connectée.

Démonstration du diagramme dynamique :

Comment SpringBoot utilise Sa-Token pour implémenter lauthentification de connexion

Ensuite, nous présenterons comment utiliser Sa-Token pour terminer l'opération d'authentification de connexion dans SpringBoot.

Sa-Token est un cadre d'authentification des autorisations Java qui résout principalement une série de problèmes liés aux autorisations tels que l'authentification de connexion, l'authentification des autorisations, l'authentification unique, OAuth3, l'authentification de la passerelle de microservice, etc.
Adresse open source Gitee : https://gitee.com/dromara/sa-token

Introduisez d'abord la dépendance Sa-Token dans le projet :

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

Copier après la connexion

Remarque : si vous utilisez SpringBoot 3.x, il vous suffit d'ajouter sa- Remplacez simplement token-spring-boot-starter par sa-token-spring-boot3-starter.

2. Connexion et déconnexion

Sur la base des idées ci-dessus, nous avons besoin d'une fonction pour la connexion de session :

// 会话登录：参数填写要登录的账号id，建议的数据类型：long | int | String， 不可以传入复杂类型，如：User、Admin 等等
StpUtil.login(Object id);

Copier après la connexion

Avec juste cette phrase de code, la connexion de session peut réussir. En fait, Sa-Token a fait beaucoup. de travail en coulisses. Y compris, mais sans s'y limiter :

Vérifiez si ce compte a déjà été connecté
Générer des informations d'identification de jeton et une session pour le compte
Informez l'auditeur global que le compte xx a connecté avec succès
Injecter le jeton Dans le contexte de la demande
et autres travaux... Vous n'avez pas besoin de bien comprendre l'ensemble du processus de connexion pour le moment. Il vous suffit de vous souvenir du point clé : Sa-Token crée un identifiant de jeton pour ce compte et il est renvoyé au front-end via le contexte Cookie.

// 会话登录接口 
@RequestMapping("doLogin")
public SaResult doLogin(String name, String pwd) {
    // 第一步：比对前端提交的账号名称、密码
    if("zhang".equals(name) && "123456".equals(pwd)) {
        // 第二步：根据账号id，进行登录 
        StpUtil.login(10001);
        return SaResult.ok("登录成功");
    }
    return SaResult.error("登录失败");
}

Copier après la connexion

Si vous n'êtes pas stressé par la lecture du code ci-dessus, vous remarquerez peut-être un point un peu étrange : seule la connexion à la session se fait ici, mais elle ne renvoie pas activement les informations de jeton au front-end.

Est-ce parce que ce n’est pas nécessaire ? À proprement parler, c'est obligatoire, mais la méthode StpUtil.login(id) profite de la fonction d'injection automatique de Cookie, en omettant votre code manuscrit pour renvoyer le jeton.

Si vous ne savez pas grand-chose sur la fonction Cookie, ne vous inquiétez pas, nous expliquerons la fonction Cookie en détail dans le chapitre [Backend et Backend Separation] plus tard. Il ne vous reste plus qu'à comprendre les deux points les plus fondamentaux :

Cookie La valeur du jeton peut être écrite dans le navigateur à partir du contrôle backend.

Cookie soumettra automatiquement la valeur du jeton chaque fois que le front-end fera une demande.
Par conséquent, avec le support de la fonction Cookie, nous pouvons compléter l'authentification de connexion avec une seule ligne de code StpUtil.login(id).

// 当前会话注销登录
StpUtil.logout();

// 获取当前会话是否已经登录，返回true=已登录，false=未登录
StpUtil.isLogin();

// 检验当前会话是否已经登录, 如果未登录，则抛出异常：`NotLoginException`
StpUtil.checkLogin();

Copier après la connexion

NotLoginException signifie que la session en cours n'a pas encore été connectée. Il existe de nombreuses raisons possibles :

Le front-end n'a pas soumis le Token, le Token soumis par. le front-end n'est pas valide, le jeton soumis par le front-end a expiré... Attendez.

Tableau de référence des valeurs de scénario sans connexion Sa-Token :

Valeur du scénarioConstante correspondante-1NotLoginException.NOT_TOKENNotLoginException.INVALID_TOKENNotLoginException.TOKEN_TIMEOUTNotLoginException.BE_REPLACEDNotLoginException.KICK_OUTAlors, comment obtenir la valeur de la scène ? Arrêtez de dire des bêtises et passez directement au code :

// 全局异常拦截（拦截项目中的NotLoginException异常）
@ExceptionHandler(NotLoginException.class)
public SaResult handlerNotLoginException(NotLoginException nle)
        throws Exception {

    // 打印堆栈，以供调试
    nle.printStackTrace(); 
    
    // 判断场景值，定制化异常信息 
    String message = "";
    if(nle.getType().equals(NotLoginException.NOT_TOKEN)) {
        message = "未提供token";
    }
    else if(nle.getType().equals(NotLoginException.INVALID_TOKEN)) {
        message = "token无效";
    }
    else if(nle.getType().equals(NotLoginException.TOKEN_TIMEOUT)) {
        message = "token已过期";
    }
    else if(nle.getType().equals(NotLoginException.BE_REPLACED)) {
        message = "token已被顶下线";
    }
    else if(nle.getType().equals(NotLoginException.KICK_OUT)) {
        message = "token已被踢下线";
    }
    else {
        message = "当前会话未登录";
    }
    
    // 返回给前端
    return SaResult.error(message);
}

Copier après la connexion

Remarque : Le code ci-dessus n'est pas le meilleur moyen de traiter la logique. Il s'agit simplement de démontrer l'acquisition et l'application des valeurs de scène avec le code le plus simple possible. personnalisez-le en fonction des besoins de votre propre projet

Explication de la signification
n'a pas pu être lu depuis le request Arrive Token		-2
Le jeton a été lu, mais le jeton n'est pas valide		-3
Le jeton a été lu, mais le jeton a expiré		-4
Le jeton a été lu, mais le jeton a été mis hors ligne		-5
Le jeton a été lu, mais le jeton a été expulsé hors ligne

3. Requête de session

// 获取当前会话账号id, 如果未登录，则抛出异常：`NotLoginException`
StpUtil.getLoginId();

// 类似查询API还有：
StpUtil.getLoginIdAsString();    // 获取当前会话账号id, 并转化为`String`类型
StpUtil.getLoginIdAsInt();       // 获取当前会话账号id, 并转化为`int`类型
StpUtil.getLoginIdAsLong();      // 获取当前会话账号id, 并转化为`long`类型

// ---------- 指定未登录情形下返回的默认值 ----------

// 获取当前会话账号id, 如果未登录，则返回null 
StpUtil.getLoginIdDefaultNull();

// 获取当前会话账号id, 如果未登录，则返回默认值 （`defaultValue`可以为任意类型）
StpUtil.getLoginId(T defaultValue);

Copier après la connexion

4. Requête de jeton

// 获取当前会话的token值
StpUtil.getTokenValue();

// 获取当前`StpLogic`的token名称
StpUtil.getTokenName();

// 获取指定token对应的账号id，如果未登录，则返回 null
StpUtil.getLoginIdByToken(String tokenValue);

// 获取当前会话剩余有效期（单位：s，返回-1代表永久有效）
StpUtil.getTokenTimeout();

// 获取当前会话的token信息参数
StpUtil.getTokenInfo();

Copier après la connexion

TokenInfo est le modèle d'informations de jeton, utilisé pour décrire les paramètres communs d'un jeton :

{
    "tokenName": "satoken",           // token名称
    "tokenValue": "e67b99f1-3d7a-4a8d-bb2f-e888a0805633",      // token值
    "isLogin": true,                  // 此token是否已经登录
    "loginId": "10001",               // 此token对应的LoginId，未登录时为null
    "loginType": "login",              // 账号类型标识
    "tokenTimeout": 2591977,          // token剩余有效期 (单位: 秒)
    "sessionTimeout": 2591977,        // User-Session剩余有效时间 (单位: 秒)
    "tokenSessionTimeout": -2,        // Token-Session剩余有效时间 (单位: 秒) (-2表示系统中不存在这个缓存)
    "tokenActivityTimeout": -1,       // token剩余无操作有效时间 (单位: 秒)
    "loginDevice": "default-device"   // 登录设备类型 
}

Copier après la connexion

5. test pour approfondir notre compréhension

Créez un nouveau LoginAuthController et copiez le code suivant

package com.pj.cases.use;

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

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

/**
 * Sa-Token 登录认证示例 
 * 
 * @author kong
 * @since 2022-10-13
 */
@RestController
@RequestMapping("/acc/")
public class LoginAuthController {

    // 会话登录接口  ---- http://localhost:8081/acc/doLogin?name=zhang&pwd=123456
    @RequestMapping("doLogin")
    public SaResult doLogin(String name, String pwd) {
        
        // 第一步：比对前端提交的 账号名称 & 密码 是否正确，比对成功后开始登录 
        //         此处仅作模拟示例，真实项目需要从数据库中查询数据进行比对 
        if("zhang".equals(name) && "123456".equals(pwd)) {
            
            // 第二步：根据账号id，进行登录 
            //         此处填入的参数应该保持用户表唯一，比如用户id，不可以直接填入整个 User 对象 
            StpUtil.login(10001);
            
            // SaResult 是 Sa-Token 中对返回结果的简单封装，下面的示例将不再赘述 
            return SaResult.ok("登录成功");
        }
        
        return SaResult.error("登录失败");
    }

    // 查询当前登录状态  ---- http://localhost:8081/acc/isLogin
    @RequestMapping("isLogin")
    public SaResult isLogin() {
        // StpUtil.isLogin() 查询当前客户端是否登录，返回 true 或 false 
        boolean isLogin = StpUtil.isLogin();
        return SaResult.ok("当前客户端是否登录：" + isLogin);
    }

    // 校验当前登录状态  ---- http://localhost:8081/acc/checkLogin
    @RequestMapping("checkLogin")
    public SaResult checkLogin() {
        // 检验当前会话是否已经登录, 如果未登录，则抛出异常：`NotLoginException`
        StpUtil.checkLogin();

        // 抛出异常后，代码将走入全局异常处理（GlobalException.java），如果没有抛出异常，则代表通过了登录校验，返回下面信息 
        return SaResult.ok("校验登录成功，这行字符串是只有登录后才会返回的信息");
    }

    // 获取当前登录的账号是谁  ---- http://localhost:8081/acc/getLoginId
    @RequestMapping("getLoginId")
    public SaResult getLoginId() {
        // 需要注意的是，StpUtil.getLoginId() 自带登录校验效果
        // 也就是说如果在未登录的情况下调用这句代码，框架就会抛出 `NotLoginException` 异常，效果和 StpUtil.checkLogin() 是一样的 
        Object userId = StpUtil.getLoginId();
        System.out.println("当前登录的账号id是：" + userId);
        
        // 如果不希望 StpUtil.getLoginId() 触发登录校验效果，可以填入一个默认值
        // 如果会话未登录，则返回这个默认值，如果会话已登录，将正常返回登录的账号id 
        Object userId2 = StpUtil.getLoginId(0);
        System.out.println("当前登录的账号id是：" + userId2);
        
        // 或者使其在未登录的时候返回 null 
        Object userId3 = StpUtil.getLoginIdDefaultNull();
        System.out.println("当前登录的账号id是：" + userId3);
        
        // 类型转换：
        // StpUtil.getLoginId() 返回的是 Object 类型，你可以使用以下方法指定其返回的类型 
        int userId4 = StpUtil.getLoginIdAsInt();  // 将返回值转换为 int 类型 
        long userId5 = StpUtil.getLoginIdAsLong();  // 将返回值转换为 long 类型 
        String userId6 = StpUtil.getLoginIdAsString();  // 将返回值转换为 String 类型 
        
        // 疑问：数据基本类型不是有八个吗，为什么只封装以上三种类型的转换？
        // 因为大多数项目都是拿 int、long 或 String 声明 UserId 的类型的，实在没见过哪个项目用 double、float、boolean 之类来声明 UserId 
        System.out.println("当前登录的账号id是：" + userId4 + " --- " + userId5 + " --- " + userId6);
        
        // 返回给前端 
        return SaResult.ok("当前客户端登录的账号id是：" + userId);
    }

    // 查询 Token 信息  ---- http://localhost:8081/acc/tokenInfo
    @RequestMapping("tokenInfo")
    public SaResult tokenInfo() {
        // TokenName 是 Token 名称的意思，此值也决定了前端提交 Token 时应该使用的参数名称 
        String tokenName = StpUtil.getTokenName();
        System.out.println("前端提交 Token 时应该使用的参数名称：" + tokenName);
        
        // 使用 StpUtil.getTokenValue() 获取前端提交的 Token 值 
        // 框架默认前端可以从以下三个途径中提交 Token：
        //         Cookie         （浏览器自动提交）
        //         Header头    （代码手动提交）
        //         Query 参数    （代码手动提交） 例如： /user/getInfo?satoken=xxxx-xxxx-xxxx-xxxx 
        // 读取顺序为： Query 参数 --> Header头 -- > Cookie 
        // 以上三个地方都读取不到 Token 信息的话，则视为前端没有提交 Token 
        String tokenValue = StpUtil.getTokenValue();
        System.out.println("前端提交的Token值为：" + tokenValue);
        
        // TokenInfo 包含了此 Token 的大多数信息 
        SaTokenInfo info = StpUtil.getTokenInfo();
        System.out.println("Token 名称：" + info.getTokenName());
        System.out.println("Token 值：" + info.getTokenValue());
        System.out.println("当前是否登录：" + info.getIsLogin());
        System.out.println("当前登录的账号id：" + info.getLoginId());
        System.out.println("当前登录账号的类型：" + info.getLoginType());
        System.out.println("当前登录客户端的设备类型：" + info.getLoginDevice());
        System.out.println("当前 Token 的剩余有效期：" + info.getTokenTimeout()); // 单位：秒，-1代表永久有效，-2代表值不存在
        System.out.println("当前 Token 的剩余临时有效期：" + info.getTokenActivityTimeout()); // 单位：秒，-1代表永久有效，-2代表值不存在
        System.out.println("当前 User-Session 的剩余有效期" + info.getSessionTimeout()); // 单位：秒，-1代表永久有效，-2代表值不存在
        System.out.println("当前 Token-Session 的剩余有效期" + info.getTokenSessionTimeout()); // 单位：秒，-1代表永久有效，-2代表值不存在
        
        // 返回给前端 
        return SaResult.data(StpUtil.getTokenInfo());
    }
    
    // 会话注销  ---- http://localhost:8081/acc/logout
    @RequestMapping("logout")
    public SaResult logout() {
        // 退出登录会清除三个地方的数据：
        //         1、Redis中保存的 Token 信息
        //         2、当前请求上下文中保存的 Token 信息 
        //         3、Cookie 中保存的 Token 信息（如果未使用Cookie模式则不会清除）
        StpUtil.logout();
        
        // StpUtil.logout() 在未登录时也是可以调用成功的，
        // 也就是说，无论客户端有没有登录，执行完 StpUtil.logout() 后，都会处于未登录状态 
        System.out.println("当前是否处于登录状态：" + StpUtil.isLogin());
        
        // 返回给前端 
        return SaResult.ok("退出登录成功");
    }
    
}

Copier après la connexion

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!