springboot+vue项目之使用Sa-Token框架实现权限和认证

一、Sa-Token简介

  Sa-Token 是一个轻量级 Java 权限认证框架，主要解决：登录认证、权限认证、单点登录、OAuth2.0、分布式Session会话、微服务网关鉴权 等一系列权限相关问题。更多内容和使用参考官方文档：Sa-Token 

二、Sa-Token在本项目的具体使用

1、导入依赖

        <!-- Sa-Token 权限认证，在线文档：https://sa-token.cc -->
        <dependency>
            <groupId>cn.dev33</groupId>
            <artifactId>sa-token-spring-boot-starter</artifactId>
            <version>1.37.0</version>
        </dependency>

        <!-- Sa-Token 整合 Redis （使用 jackson 序列化方式） -->
        <dependency>
            <groupId>cn.dev33</groupId>
            <artifactId>sa-token-redis-jackson</artifactId>
            <version>1.37.0</version>
        </dependency>

        <!-- 提供Redis连接池 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

2、application.yml文件配置

sa-token:
  #拦截器，获取令牌的键
  token-name: Authorization
  #将cookie禁用 不能在cookie里面的到值
  is-read-cookie: false
  is-read-body: false
  #token有效期，单位s,默认30天
  timeout: 3600000
  #token临时有效期(置顶时间内无操作就视为token过期) 单位s
  active-timeout: -1
  #在多人登录同一账号时，是否共用一个token
  is-share: false
  #是否允许同一个账号并发执行
  allow-concurrent-login: true

3、增加配置类 SaTokenConfigure.java

@Configuration
public class SaTokenConfigure {
    @Autowired
    public void rewriteSaStrategy() {
        // 重写Sa-Token的注解处理器，增加注解合并功能
        SaStrategy.instance.getAnnotation = (element, annotationClass) -> {
            return AnnotatedElementUtils.getMergedAnnotation(element, annotationClass);
        };
    }
}

4、Sa-Token 权限认证工具类之管理员 StpAdminUtil.java

  可以参考网址sa-token-demo/sa-token-demo-case/src/main/java/com/pj/satoken/StpUserUtil.java · dromara/Sa-Token - Gitee.com自行配置

@Component
public class StpAdminUtil {
    private StpAdminUtil() {}

    /**
     * 多账号体系下的类型标识
     */
    public static final String TYPE = "admin";

    /**
     * 底层使用的 StpLogic 对象
     */
    private static StpLogic stpLogic = new StpLogic(TYPE){
        //获取HttpServlet的令牌
        /**
         * 防止新登录的token会覆盖掉旧登录的token，从而导致旧登录失效。
         * @return
         */
//        @Override
//        public String splicingKeyTokenName() {
//            return super.splicingKeyTokenName()+"-admin";
//        }
        @Override
        public void checkLogin() {
            super.checkLogin();
        }
    };


    /**
     * 获取当前 StpLogic 的账号类型
     *
     * @return /
     */
    public static String getLoginType(){
        return stpLogic.getLoginType();
    }

    /**
     * 安全的重置 StpLogic 对象
     *
     * <br> 1、更改此账户的 StpLogic 对象
     * <br> 2、put 到全局 StpLogic 集合中
     * <br> 3、发送日志
     *
     * @param newStpLogic /
     */
    public static void setStpLogic(StpLogic newStpLogic) {
        // 1、重置此账户的 StpLogic 对象
        stpLogic = newStpLogic;

        // 2、添加到全局 StpLogic 集合中
        //    以便可以通过 SaManager.getStpLogic(type) 的方式来全局获取到这个 StpLogic
        SaManager.putStpLogic(newStpLogic);

        // 3、$$ 发布事件：更新了 stpLogic 对象
        SaTokenEventCenter.doSetStpLogic(stpLogic);
    }

    /**
     * 获取 StpLogic 对象
     *
     * @return /
     */
    public static StpLogic getStpLogic() {
        return stpLogic;
    }


    // ------------------- 获取 token 相关 -------------------

    /**
     * 返回 token 名称，此名称在以下地方体现：Cookie 保存 token 时的名称、提交 token 时参数的名称、存储 token 时的 key 前缀
     *
     * @return /
     */
    public static String getTokenName() {
        return stpLogic.getTokenName();
    }

    /**
     * 在当前会话写入指定 token 值
     *
     * @param tokenValue token 值
     */
    public static void setTokenValue(String tokenValue){
        stpLogic.setTokenValue(tokenValue);
    }

    /**
     * 在当前会话写入指定 token 值
     *
     * @param tokenValue token 值
     * @param cookieTimeout Cookie存活时间(秒)
     */
    public static void setTokenValue(String tokenValue, int cookieTimeout){
        stpLogic.setTokenValue(tokenValue, cookieTimeout);
    }

    /**
     * 在当前会话写入指定 token 值
     *
     * @param tokenValue token 值
     * @param loginModel 登录参数
     */
    public static void setTokenValue(String tokenValue, SaLoginModel loginModel){
        stpLogic.setTokenValue(tokenValue, loginModel);
    }

    /**
     * 获取当前请求的 token 值
     *
     * @return 当前tokenValue
     */
    public static String getTokenValue() {
        return stpLogic.getTokenValue();
    }

    /**
     * 获取当前请求的 token 值 （不裁剪前缀）
     *
     * @return /
     */
    public static String getTokenValueNotCut(){
        return stpLogic.getTokenValueNotCut();
    }

    /**
     * 获取当前会话的 token 参数信息
     *
     * @return token 参数信息
     */
    public static SaTokenInfo getTokenInfo() {
        return stpLogic.getTokenInfo();
    }


    // ------------------- 登录相关操作 -------------------

    // --- 登录

    /**
     * 会话登录
     *
     * @param id 账号id，建议的类型：（long | int | String）
     */
    public static void login(Object id) {
        stpLogic.login(id);
    }

    /**
     * 会话登录，并指定登录设备类型
     *
     * @param id 账号id，建议的类型：（long | int | String）
     * @param device 设备类型
     */
    public static void login(Object id, String device) {
        stpLogic.login(id, device);
    }

    /**
     * 会话登录，并指定是否 [记住我]
     *
     * @param id 账号id，建议的类型：（long | int | String）
     * @param isLastingCookie 是否为持久Cookie，值为 true 时记住我，值为 false 时关闭浏览器需要重新登录
     */
    public static void login(Object id, boolean isLastingCookie) {
        stpLogic.login(id, isLastingCookie);
    }

    /**
     * 会话登录，并指定此次登录 token 的有效期, 单位:秒
     *
     * @param id      账号id，建议的类型：（long | int | String）
     * @param timeout 此次登录 token 的有效期, 单位:秒
     */
    public static void login(Object id, long timeout) {
        stpLogic.login(id, timeout);
    }

    /**
     * 会话登录，并指定所有登录参数 Model
     *
     * @param id 账号id，建议的类型：（long | int | String）
     * @param loginModel 此次登录的参数Model
     */
    public static void login(Object id, SaLoginModel loginModel) {
        stpLogic.login(id, loginModel);
    }

    /**
     * 创建指定账号 id 的登录会话数据
     *
     * @param id 账号id，建议的类型：（long | int | String）
     * @return 返回会话令牌
     */
    public static String createLoginSession(Object id) {
        return stpLogic.createLoginSession(id);
    }

    /**
     * 创建指定账号 id 的登录会话数据
     *
     * @param id 账号id，建议的类型：（long | int | String）
     * @param loginModel 此次登录的参数Model
     * @return 返回会话令牌
     */
    public static String createLoginSession(Object id, SaLoginModel loginModel) {
        return stpLogic.createLoginSession(id, loginModel);
    }

    // --- 注销

    /**
     * 在当前客户端会话注销
     */
    public static void logout() {
        stpLogic.logout();
    }

    /**
     * 会话注销，根据账号id
     *
     * @param loginId 账号id
     */
    public static void logout(Object loginId) {
        stpLogic.logout(loginId);
    }

    /**
     * 会话注销，根据账号id 和 设备类型
     *
     * @param loginId 账号id
     * @param device 设备类型 (填 null 代表注销该账号的所有设备类型)
     */
    public static void logout(Object loginId, String device) {
        stpLogic.logout(loginId, device);
    }

    /**
     * 会话注销，根据指定 Token
     *
     * @param tokenValue 指定 token
     */
    public static void logoutByTokenValue(String tokenValue) {
        stpLogic.logoutByTokenValue(tokenValue);
    }

    /**
     * 踢人下线，根据账号id
     * <p> 当对方再次访问系统时，会抛出 NotLoginException 异常，场景值=-5 </p>
     *
     * @param loginId 账号id
     */
    public static void kickout(Object loginId) {
        stpLogic.kickout(loginId);
    }

    /**
     * 踢人下线，根据账号id 和 设备类型
     * <p> 当对方再次访问系统时，会抛出 NotLoginException 异常，场景值=-5 </p>
     *
     * @param loginId 账号id
     * @param device 设备类型 (填 null 代表踢出该账号的所有设备类型)
     */
    public static void kickout(Object loginId, String device) {
        stpLogic.kickout(loginId, device);
    }

    /**
     * 踢人下线，根据指定 token
     * <p> 当对方再次访问系统时，会抛出 NotLoginException 异常，场景值=-5 </p>
     *
     * @param tokenValue 指定 token
     */
    public static void kickoutByTokenValue(String tokenValue) {
        stpLogic.kickoutByTokenValue(tokenValue);
    }

    /**
     * 顶人下线，根据账号id 和 设备类型
     * <p> 当对方再次访问系统时，会抛出 NotLoginException 异常，场景值=-4 </p>
     *
     * @param loginId 账号id
     * @param device 设备类型 （填 null 代表顶替该账号的所有设备类型）
     */
    public static void replaced(Object loginId, String device) {
        stpLogic.replaced(loginId, device);
    }

    // 会话查询

    /**
     * 判断当前会话是否已经登录
     *
     * @return 已登录返回 true，未登录返回 false
     */
    public static boolean isLogin() {
        return stpLogic.isLogin();
    }

    /**
     * 检验当前会话是否已经登录，如未登录，则抛出异常
     */
    public static void checkLogin() {
        stpLogic.checkLogin();
    }

    /**
     * 获取当前会话账号id，如果未登录，则抛出异常
     *
     * @return 账号id
     */
    public static Object getLoginId() {
        return stpLogic.getLoginId();
    }

    /**
     * 获取当前会话账号id, 如果未登录，则返回默认值
     *
     * @param <T> 返回类型
     * @param defaultValue 默认值
     * @return 登录id
     */
    public static <T> T getLoginId(T defaultValue) {
        return stpLogic.getLoginId(defaultValue);
    }

    /**
     * 获取当前会话账号id, 如果未登录，则返回null
     *
     * @return 账号id
     */
    public static Object getLoginIdDefaultNull() {
        return stpLogic.getLoginIdDefaultNull();
    }

    /**
     * 获取当前会话账号id, 并转换为 String 类型
     *
     * @return 账号id
     */
    public static String getLoginIdAsString() {
        return stpLogic.getLoginIdAsString();
    }

    /**
     * 获取当前会话账号id, 并转换为 int 类型
     *
     * @return 账号id
     */
    public static int getLoginIdAsInt() {
        return stpLogic.getLoginIdAsInt();
    }

    /**
     * 获取当前会话账号id, 并转换为 long 类型
     *
     * @return 账号id
     */
    public static long getLoginIdAsLong() {
        return stpLogic.getLoginIdAsLong();
    }

    /**
     * 获取指定 token 对应的账号id，如果未登录，则返回 null
     *
     * @param tokenValue token
     * @return 账号id
     */
    public static Object getLoginIdByToken(String tokenValue) {
        return stpLogic.getLoginIdByToken(tokenValue);
    }

    /**
     * 获取当前 Token 的扩展信息（此函数只在jwt模式下生效）
     *
     * @param key 键值
     * @return 对应的扩展数据
     */
    public static Object getExtra(String key) {
        return stpLogic.getExtra(key);
    }

    /**
     * 获取指定 Token 的扩展信息（此函数只在jwt模式下生效）
     *
     * @param tokenValue 指定的 Token 值
     * @param key 键值
     * @return 对应的扩展数据
     */
    public static Object getExtra(String tokenValue, String key) {
        return stpLogic.getExtra(tokenValue, key);
    }


    // ------------------- Account-Session 相关 -------------------

    /**
     * 获取指定账号 id 的 Account-Session, 如果该 SaSession 尚未创建，isCreate=是否新建并返回
     *
     * @param loginId 账号id
     * @param isCreate 是否新建
     * @return SaSession 对象
     */
    public static SaSession getSessionByLoginId(Object loginId, boolean isCreate) {
        return stpLogic.getSessionByLoginId(loginId, isCreate);
    }

    /**
     * 获取指定 key 的 SaSession, 如果该 SaSession 尚未创建，则返回 null
     *
     * @param sessionId SessionId
     * @return Session对象
     */
    public static SaSession getSessionBySessionId(String sessionId) {
        return stpLogic.getSessionBySessionId(sessionId);
    }

    /**
     * 获取指定账号 id 的 Account-Session，如果该 SaSession 尚未