ITPub博客
首页 博客 专栏 学院 社区 IT新媒体评选
发博

首页 > 数据库 > 数据库开发技术 > 集成sa-token实现登录和RBAC权限控制

集成sa-token实现登录和RBAC权限控制

原创 数据库开发技术 作者：Java大飞哥 时间：2024-04-16 13:09:51 0 删除 编辑


1.sa-token是什么？

1.1简介

Sa-Token 是一个轻量级 Java 权限认证框架，主要解决：登录认证、权限认证、单点登录、OAuth2.0、分布式Session会话、微服务网关鉴权 等一系列权限相关问题。


1.2官网

https://sa-token.cc/v/v1.36.0/doc.html#/


1.3 Sa-Token 功能一览

Sa-Token 目前主要五大功能模块：登录认证、权限认证、单点登录、OAuth2.0、微服务鉴权。

  • 登录认证 —— 单端登录、多端登录、同端互斥登录、七天内免登录
  • 权限认证 —— 权限认证、角色认证、会话二级认证
  • Session会话 —— 全端共享Session、单端独享Session、自定义Session
  • 踢人下线 —— 根据账号id踢人下线、根据Token值踢人下线
  • 账号封禁 —— 登录封禁、按照业务分类封禁、按照处罚阶梯封禁
  • 持久层扩展 —— 可集成Redis、Memcached等专业缓存中间件，重启数据不丢失
  • 分布式会话 —— 提供jwt集成、共享数据中心两种分布式会话方案
  • 微服务网关鉴权 —— 适配Gateway、ShenYu、Zuul等常见网关的路由拦截认证
  • 单点登录 —— 内置三种单点登录模式：无论是否跨域、是否共享Redis，都可以搞定
  • OAuth2.0认证 —— 轻松搭建 OAuth2.0 服务，支持openid模式
  • 二级认证 —— 在已登录的基础上再次认证，保证安全性
  • Basic认证 —— 一行代码接入 Http Basic 认证
  • 独立Redis —— 将权限缓存与业务缓存分离
  • 临时Token认证 —— 解决短时间的Token授权问题
  • 模拟他人账号 —— 实时操作任意用户状态数据
  • 临时身份切换 —— 将会话身份临时切换为其它账号
  • 前后端分离 —— APP、小程序等不支持Cookie的终端
  • 同端互斥登录 —— 像QQ一样手机电脑同时在线，但是两个手机上互斥登录
  • 多账号认证体系 —— 比如一个商城项目的user表和admin表分开鉴权
  • Token风格定制 —— 内置六种Token风格，还可：自定义Token生成策略、自定义Token前缀
  • 注解式鉴权 —— 优雅的将鉴权与业务代码分离
  • 路由拦截式鉴权 —— 根据路由拦截鉴权，可适配restful模式
  • 自动续签 —— 提供两种Token过期策略，灵活搭配使用，还可自动续签
  • 会话治理 —— 提供方便灵活的会话查询接口
  • 记住我模式 —— 适配[记住我]模式，重启浏览器免验证
  • 密码加密 —— 提供密码加密模块，可快速MD5、SHA1、SHA256、AES、RSA加密
  • 全局侦听器 —— 在用户登陆、注销、被踢下线等关键性操作时进行一些AOP操作
  • 开箱即用 —— 提供SpringMVC、WebFlux等常见web框架starter集成包，真正的开箱即用


1.4 功能结构图


2.集成sa-token及配置

2.1 pom依赖

sa-token的依赖组件也很多，根据自己的需求去官方网站参考引入即可：
       <dependency>            <groupId>cn.dev33</groupId>            <artifactId>sa-token-spring-boot-starter</artifactId>            <version>1.37.0</version>        </dependency>        <dependency>            <groupId>cn.dev33</groupId>            <artifactId>sa-token-jwt</artifactId>            <version>1.37.0</version>        </dependency>        <dependency>            <groupId>cn.dev33</groupId>            <artifactId>sa-token-redis-jackson</artifactId>            <version>1.37.0</version>        </dependency>        <dependency>            <groupId>cn.dev33</groupId>            <artifactId>sa-token-spring-aop</artifactId>            <version>1.37.0</version>        </dependency>

2.2 yaml配置

sa-token:  # token 名称（同时也是 cookie 名称）  token-name: satoken  token-prefix: Bearer  # token 有效期（单位：秒） 默认30天，-1 代表永久有效 这里设置为1天  timeout: 86400  # token 最低活跃频率（单位：秒），如果 token 超过此时间没有访问系统就会被冻结，默认-1 代表不限制，永不冻结  active-timeout: -1  # 是否允许同一账号多地同时登录 （为 true 时允许一起登录, 为 false 时新登录挤掉旧登录）  is-concurrent: true  # 在多人登录同一账号时，是否共用一个 token （为 true 时所有登录共用一个 token, 为 false 时每次登录新建一个 token）  is-share: false  # token 风格（默认可取值：uuid、simple-uuid、random-32、random-64、random-128、tik）  token-style: uuid  # 是否输出操作日志  is-log: true  # jwt秘钥  jwt-secret-key: adfdfdsdasdasifdfdffhueuiwyudfdfddfdfsfsdfrfewbfjsdafjk
解决反向代理 uri 丢失的问题
https://sa-token.cc/v/v1.36.0/doc.html#/fun/curr-domain


2.3 代码配置

SaTokenConfigure配置jwt简单模式、全局过滤器SaServletFilter，RestResponse该类是自定义响应前端的类，可以自己去定义写，下面的代码只是一个大概的雏形，项目使用前后端分离的方式所以需要使用SaServletFilter的方式配置全局过滤器（所以不使用拦截器的方式配置），下面的配置决绝了跨越问题，配合上面引入的sa-token-spring-aop注解权限校验，在任意地方可以使用sa-token的注解鉴权了（@SaIgnore:不拦截，直接放行;@SaCheckPermission("xxx.xxxx"):有xxx.xxxx权限才可以访问,官方还支持很多注解权限校验注解的），注意：sa-token-spring-aop + 全局过滤器SaServletFilter这种配合使用是没有啥问题的，使用拦截器的方式就不用引入sa-token-spring-aop了，拦截器默认只是控制到controller层，而sa-token-spring-aop + 全局过滤器SaServletFilter的方式是可以在任意位置都可以使用注解权限校验。
https://sa-token.cc/v/v1.36.0/doc.html#/plugin/aop-at
https://sa-token.cc/v/v1.36.0/doc.html#/use/at-check
#使用 Sa-Token 的全局过滤器解决跨域问题（三种方式全版）
https://juejin.cn/post/7247376558367981627

SaTokenConfigure配置

package xxxxx.config;
import cn.dev33.satoken.SaManager;import cn.dev33.satoken.context.SaHolder;import cn.dev33.satoken.exception.SaTokenException;import cn.dev33.satoken.filter.SaServletFilter;import cn.dev33.satoken.jwt.StpLogicJwtForSimple;import cn.dev33.satoken.router.SaHttpMethod;import cn.dev33.satoken.router.SaRouter;import cn.dev33.satoken.stp.StpLogic;import cn.dev33.satoken.stp.StpUtil;import xxxxx.RestResponse;import lombok.extern.slf4j.Slf4j;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Slf4j@Configurationpublic class SaTokenConfigure implements WebMvcConfigurer {
    // Sa-Token 整合 jwt (Simple 简单模式)    @Bean    public StpLogic getStpLogicJwt() {        return new StpLogicJwtForSimple();    }
    /**     * 注册 [Sa-Token 全局过滤器]     */    @Bean    public SaServletFilter getSaServletFilter() {        return new SaServletFilter()                // 指定 [拦截路由] 与 [放行路由]                .addInclude("/**")                // 登录认证 -- 拦截所有路由，并排除/user/login 用于开放登录                .addExclude("/user/**")                .addExclude("/favicon.ico")                .addExclude("*.js")                .addExclude("*.css")                // 认证函数: 每次请求执行                .setAuth(obj -> {                    SaManager.getLog().debug("----- 请求path={}  提交token={}", SaHolder.getRequest().getRequestPath(), StpUtil.getTokenValue());                    // ...                    SaRouter.match("/**")    // 拦截的 path 列表，可以写多个                                .check(r -> StpUtil.checkLogin());// 要执行的校验动作，可以写完整的 lambda 表达式
                    // 根据路由划分模块，不同模块不同鉴权                                SaRouter.match("/xxx/xxxx/**", r -> StpUtil.checkPermission("xxxx.xxx"));                    ,,,,,,,,,,,,,,,,,,,,,                    ,,,,,,,,,,,,,,,,,,,,,                    ,,,,,,,,,,,,,,,,,,,,,                                      // 更多拦截处理方式，请参考“路由拦截式鉴权”章节 */                })
                // 异常处理函数：每次认证函数发生异常时执行此函数                .setError(e1 -> {                    log.error("sa-token异常:{}", e1.getMessage());                    // 设置响应头                    SaHolder.getResponse().setHeader("Content-Type", "application/json;charset=UTF-8");                    /**                     * sa-token登录相关异常处理                     * https://sa-token.cc/v/v1.36.0/doc.html#/fun/exception-code                     */                    if (e1 instanceof SaTokenException) {                        SaTokenException e = (SaTokenException) e1;                        // 根据不同异常细分状态码返回不同的提示                        if (e.getCode() == 11001) {                            return RestResponse.fail("未能读取到有效Token");                        }                        if (e.getCode() == 11002) {                            return RestResponse.fail("登录时的账号为空");                        }                        if (e.getCode() == 11011) {                            return RestResponse.fail("未能读取到有效Token");                        }                        if (e.getCode() == 11012) {                            return RestResponse.fail("Token无效");                        }                        if (e.getCode() == 11013) {                            return RestResponse.fail("Token已过期");                        }                        if (e.getCode() == 11014) {                            return RestResponse.fail("Token已被顶下线");                        }                        if (e.getCode() == 11015) {                            return RestResponse.fail("Token已被踢下线");                        }                        if (e.getCode() == 11016) {                            return RestResponse.fail("Token已被冻结");                        }                        if (e.getCode() == 11017) {                            return RestResponse.fail("未按照指定前缀提交token");                        }                        if (e.getCode() == 11041) {                            return RestResponse.fail("缺少指定的角色");                        }                        if (e.getCode() == 11051) {                            return RestResponse.fail("缺少指定的权限");                        }                        if (e.getCode() == 11061) {                            return RestResponse.fail("当前账号未通过服务封禁校验");                        }                        if (e.getCode() == 11062) {                            return RestResponse.fail("提供要解禁的账号无效");                        }                        if (e.getCode() == 12001) {                            return RestResponse.fail("请求中缺少指定的参数");                        }                        if (e.getCode() == 12111) {                            return RestResponse.fail("密码md5加密异常");                        }                        if (e.getCode() == 30201) {                            return RestResponse.fail("对jwt字符串解析失败");                        }                        if (e.getCode() == 30202) {                            return RestResponse.fail("此jwt的签名无效");                        }                        if (e.getCode() == 30203) {                            return RestResponse.fail("此jwt的loginType字段不符合预期");                        }                        if (e.getCode() == 30204) {                            return RestResponse.fail("此jwt已超时");                        }                        if (e.getCode() == 30205) {                            return RestResponse.fail("没有配置jwt秘钥");                        }                        if (e.getCode() == 30206) {                            return RestResponse.fail("登录时提供的账号为空");                        }                        // 更多 code 码判断 ...                        // 默认的提示                        return RestResponse.fail("登录异常，请联系管理员处理...");                    }                    return RestResponse.fail(e1.getMessage());                })
                // 前置函数：在每次认证函数之前执行                .setBeforeAuth(obj -> {                    // ---------- 设置一些安全响应头 ----------                    SaHolder.getResponse()                            // 服务器名称                            //.setServer("sa-server")                            // 是否可以在iframe显示视图：DENY=不可以 | SAMEORIGIN=同域下可以 | ALLOW-FROM uri=指定域名下可以                            .setHeader("X-Frame-Options", "SAMEORIGIN")                            // 是否启用浏览器默认XSS防护：0=禁用 | 1=启用 | 1; mode=block 启用, 并在检查到XSS攻击时，停止渲染页面                            .setHeader("X-XSS-Protection", "1; mode=block")                            // 禁用浏览器内容嗅探                            .setHeader("X-Content-Type-Options", "nosniff")                            // ---------- 设置跨域响应头 ----------                            // 允许指定域访问跨域资源                            .setHeader("Access-Control-Allow-Origin", "*")                            // 允许所有请求方式                            .setHeader("Access-Control-Allow-Methods", "*")                            // 允许的header参数                            .setHeader("Access-Control-Allow-Headers", "*")                            // 有效时间                            .setHeader("Access-Control-Max-Age", "3600");
                    // 如果是预检请求，则立即返回到前端                    SaRouter.match(SaHttpMethod.OPTIONS)                            .free(r -> log.info("--------OPTIONS预检请求，不做处理"))                            .back();                });    }
}

自定义权限加载接口实现类：

package xxxxx.config;
import cn.dev33.satoken.stp.StpInterface;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Component;
import java.io.Serializable;import java.util.ArrayList;import java.util.List;import java.util.Objects;
/** * 自定义权限加载接口实现类 * 保证此类被 SpringBoot 扫描，完 * 成 Sa-Token 的自定义权限验证扩展 */@Componentpublic class StpInterfaceImpl implements StpInterface {
    /**     * 返回一个账号所拥有的权限码集合     */    @Override    public List<String> getPermissionList(Object loginId, String loginType) {        List<String> permissionList = new ArrayList<>();        //TODO 根据登录的loginId(登录用户id)去查权限，可以存缓存中，从缓存中取，权限有变动更新缓存        return permissionList;    }
    /**     * 返回一个账号所拥有的角色标识集合 (权限与角色可分开校验)     */    @Override    public List<String> getRoleList(Object loginId, String loginType) {        List<String> roleList = new ArrayList<>();        //TODO 根据登录的loginId(登录用户id)去查角色，可以存缓存，从缓存中取，角色变动更新缓存        return roleList;    }
}

4.RBAC权限控制表设计

RBAC：基于角色的访问控制（需要实现对用户、角色、资源的管理）
用户-角色-资源之间的对应关系是多对多的一个关系

角色表-role表：

资源表-resource表：

角色所拥有的资源权限表-role_resource_power表：

角色用户表-role-admin(role-user)表：

资源表-resource表里面有一个父级id，顶级父类的父类id是0或者是null，子资源需要设置所属哪个父资源下，所以就需要设置子资源的父级id，这种关系就形成了一颗菜单权限树。


5.菜单权限树构造实现

5.1菜单权限数据sql查询

with recursive menu_power_tree(id, parent_id, type, name,remarks,source_type,menu_sort,menu_level) AS (  -- 初始查询，选择所有没有父级别的分类（即根分类）  SELECT id, parent_id, type, name,remarks,source_type,menu_sort,menu_level  FROM dyict_resource  WHERE parent_id = 0 and source_type = 1   UNION ALL   -- 递归查询，选择所有子分类  SELECT  c1.id, c1.parent_id, c1.type, c1.name, c1.remarks,c1.source_type,c1.menu_sort,c1.menu_level FROM  (  SELECT id, parent_id, type, name,remarks,source_type,menu_sort,menu_level  FROM dyict_resource c WHERE c.parent_id <> 0  ) c1  INNER JOIN menu_power_tree ct ON ct.id = c1.parent_id )SELECT a.id, a.parent_id, a.type, a.name,a.remarks,a.source_type,a.menu_sort,a.menu_level,(SELECT count(*) FROM dyict_role_resource_power b WHERE a.id = b.resource_id and b.role_id in(1)) as pFROM menu_power_tree aORDER BY parent_id,id;


5.2菜单权限树构建

基础接口RoleResourcePowerMapper：

public interface RoleResourcePowerMapper extends BaseMapper<RoleResourcePower> {

    /**     * 角色对应的菜单权限用于获取权限和构建权限     *     * @param sourceType     * @param roleIds     * @return     */    List<MenuPowerTreeDto> menuPowerTree(@Param("sourceType") Integer sourceType, @Param("roleIds") List<Integer> roleIds);

}

RoleResourcePowerMapper.xml

<select id="menuPowerTree" resultType="xxxx.dto.MenuPowerTreeDto">        with recursive menu_power_tree(id, parent_id, type, name,remarks,source_type,menu_sort,menu_level) AS (        -- 初始查询，选择所有没有父级别的分类（即根分类）        SELECT id, parent_id, type, name,remarks,source_type,menu_sort,menu_level        FROM dyict_resource        WHERE parent_id = 0        <if test="sourceType != null">            and source_type = #{sourceType}        </if>        UNION ALL        -- 递归查询，选择所有子分类        SELECT c1.id, c1.parent_id, c1.type, c1.name, c1.remarks,c1.source_type,c1.menu_sort,c1.menu_level FROM        (        SELECT id, parent_id, type, name,remarks,source_type,menu_sort,menu_level        FROM dyict_resource c WHERE c.parent_id <![CDATA[<> ]]>0        ) c1        INNER JOIN menu_power_tree ct ON ct.id = c1.parent_id        )        SELECT a.id, a.parent_id, a.type, a.name,a.remarks,a.source_type,a.menu_sort,a.menu_level,        (SELECT count(*) FROM dyict_role_resource_power b WHERE a.id = b.resource_id        <if test="roleIds != null and roleIds.size() > 0 ">            and            b.role_id in            <foreach collection="roleIds" item="id" index="index" open="(" close=")" separator=",">                #{id}            </foreach>        </if>        ) as p        FROM menu_power_tree a        ORDER BY parent_id,id    </select>

MenuPowerTreeDto类：

package xxxx.dto;
import lombok.Data;
import java.io.Serializable;
@Datapublic class MenuPowerTreeDto implements Serializable {
    private static final long serialVersionUID = -8644290706362470684L;
    private Integer id;
    private Integer parentId;
    private Integer type;
    private String name;
    private String remarks;
    private Integer sourceType;
    private Integer menuSort;
    private Integer menuLevel;
    private Integer p;
}

MenuPowerTreeVo类：

package xxxx.vo;
import lombok.Data;
import java.io.Serializable;import java.util.List;
@Datapublic class MenuPowerTreeVo implements Serializable {
    private static final long serialVersionUID = 3214808951975328795L;
    private Integer id;
    private Integer parentId;
    private Integer type;
    private String name;
    private String remarks;
    private Integer sourceType;
    private Integer menuSort;
    private Integer menuLevel;
    private Boolean hasPower;
    private List<MenuPowerTreeVo> childrenMenuType;
    private List<MenuPowerTreeVo> childrenButtonType;
}

RoleResourcePowerServiceImpl类：

package xxxxx.service.impl;
import cn.hutool.core.collection.CollectionUtil;import com.alibaba.fastjson.JSON;import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;import lombok.extern.slf4j.Slf4j;import org.springframework.beans.BeanUtils;import org.springframework.stereotype.Service;
import java.util.ArrayList;import java.util.Arrays;import java.util.Collections;import java.util.Comparator;import java.util.List;import java.util.Objects;import java.util.stream.Collectors;
@Slf4j@Servicepublic class RoleResourcePowerServiceImpl extends ServiceImpl<RoleResourcePowerMapper, RoleResourcePower> implements RoleResourcePowerService {
    @Override    public MenuPowerTreeVo queryMenuPowerTreeVo(Integer sourceType, Integer roleId) {        if (Objects.nonNull(sourceType) && Objects.nonNull(roleId)) {            List<MenuPowerTreeDto> menuPowerTrees = this.baseMapper.menuPowerTree(sourceType, Arrays.asList(roleId));            if (CollectionUtil.isNotEmpty(menuPowerTrees)) {                MenuPowerTreeVo menuPowerTreeVo = new MenuPowerTreeVo();                List<MenuPowerTreeDto> oneMenuPowerTrees = menuPowerTrees.stream().filter(e -> e.getParentId() == 0).collect(Collectors.toList());                if (CollectionUtil.isNotEmpty(oneMenuPowerTrees)) {                    this.buildeTree(oneMenuPowerTrees, menuPowerTrees, menuPowerTreeVo);                    if (oneMenuPowerTrees.size() == 1) {                        List<MenuPowerTreeVo> children = new ArrayList<>();                        children.add(menuPowerTreeVo);                        MenuPowerTreeVo menuPowerTreeVo2 = new MenuPowerTreeVo();                        menuPowerTreeVo2.setId(-1);                        menuPowerTreeVo2.setName("父节点");                        menuPowerTreeVo2.setParentId(-1);                        menuPowerTreeVo2.setMenuSort(0);                        menuPowerTreeVo2.setChildrenMenuType(children);                        return menuPowerTreeVo2;                    }                    return menuPowerTreeVo;                }            }        }        return null;    }
    private void buildeTree(List<MenuPowerTreeDto> oneMenuPowerTrees, List<MenuPowerTreeDto> menuPowerTrees, MenuPowerTreeVo menuPowerTreeVo) {        if (oneMenuPowerTrees.size() > 1) {            menuPowerTreeVo.setId(-1);            menuPowerTreeVo.setName("父节点");            menuPowerTreeVo.setParentId(-1);            menuPowerTreeVo.setMenuSort(0);            List<MenuPowerTreeDto> childrens = oneMenuPowerTrees;            this.commonBuildTree(menuPowerTrees, menuPowerTreeVo, childrens);        } else if (oneMenuPowerTrees.size() == 1) {            for (MenuPowerTreeDto mp : oneMenuPowerTrees) {                BeanUtils.copyProperties(mp, menuPowerTreeVo);                if (Objects.nonNull(mp.getP()) && mp.getP() > 0) {                    menuPowerTreeVo.setHasPower(true);                }                Integer id = mp.getId();                List<MenuPowerTreeDto> childrens = menuPowerTrees.stream().filter(e -> Objects.nonNull(e.getParentId()) && e.getParentId() == id).collect(Collectors.toList());                this.commonBuildTree(menuPowerTrees, menuPowerTreeVo, childrens);            }        }    }
    private void commonBuildTree(List<MenuPowerTreeDto> menuPowerTrees, MenuPowerTreeVo menuPowerTreeVo, List<MenuPowerTreeDto> childrens) {        if (CollectionUtil.isNotEmpty(childrens)) {            List<MenuPowerTreeDto> childrenButtonTypeDto = childrens.stream().filter(e -> Objects.nonNull(e.getType()) && e.getType() == 2).collect(Collectors.toList());            if (CollectionUtil.isNotEmpty(childrenButtonTypeDto)) {                List<MenuPowerTreeVo> childrenButtonType = new ArrayList<>();                for (MenuPowerTreeDto mb : childrenButtonTypeDto) {                    MenuPowerTreeVo menuPowerTreeVo2 = new MenuPowerTreeVo();                    BeanUtils.copyProperties(mb, menuPowerTreeVo2);                    if (Objects.nonNull(mb.getP()) && mb.getP() > 0) {                        menuPowerTreeVo2.setHasPower(true);                    }                    childrenButtonType.add(menuPowerTreeVo2);                }                menuPowerTreeVo.setChildrenButtonType(childrenButtonType);            }            List<MenuPowerTreeDto> childrenMenuTypeDto = childrens.stream().filter(e -> Objects.nonNull(e.getType()) && e.getType() == 1).collect(Collectors.toList());            if (CollectionUtil.isNotEmpty(childrenMenuTypeDto)) {                List<MenuPowerTreeVo> childrenMenuType = new ArrayList<>();                for (MenuPowerTreeDto mp2 : childrenMenuTypeDto) {                    MenuPowerTreeVo menuPowerTreeVo1 = new MenuPowerTreeVo();                    List<MenuPowerTreeDto> oneMenuType = new ArrayList<>();                    oneMenuType.add(mp2);                    this.buildeTree(oneMenuType, menuPowerTrees, menuPowerTreeVo1);                    childrenMenuType.add(menuPowerTreeVo1);                }                Collections.sort(childrenMenuType, Comparator.comparing(MenuPowerTreeVo::getMenuSort));                menuPowerTreeVo.setChildrenMenuType(childrenMenuType);            }        }    }
    @Override    public List<String> queryMenuPower(Integer sourceType, List<Integer> roleIds) {        List<String> powerList = new ArrayList<>();        if (Objects.nonNull(sourceType) && CollectionUtil.isNotEmpty(roleIds)) {            List<MenuPowerTreeDto> menuPowerTrees = this.baseMapper.menuPowerTree(sourceType, roleIds);            if (CollectionUtil.isNotEmpty(menuPowerTrees)) {                List<MenuPowerTreeDto> hasPower = menuPowerTrees.stream().filter(e -> Objects.nonNull(e.getP()) && e.getP() > 0).collect(Collectors.toList());                if (CollectionUtil.isNotEmpty(hasPower)) {                    for (MenuPowerTreeDto p : hasPower) {                        powerList.add(p.getName());                    }                }            }        }        log.info("queryMenuPower.sourceType:{}.roleIds:{}.powerList:{}", sourceType, JSON.toJSONString(roleIds), JSON.toJSONString(powerList));        return powerList;    }
}

实现效果：

{    "code": "000000",    "msg": "success",    "timestamp": "2024-04-07 17:38:35",    "data": {        "id": -1,        "parentId": -1,        "type": null,        "name": "父节点",        "remarks": null,        "sourceType": null,        "menuSort": 0,        "menuLevel": null,        "hasPower": null,        "childrenMenuType": [            {                "id": 3,                "parentId": 0,                "type": 1,                "name": "xxx.xxx",                "remarks": "xxx.xxx",                "sourceType": 1,                "menuSort": 1,                "menuLevel": 1,                "hasPower": true,                "childrenMenuType": [                    {                        "id": 4,                        "parentId": 3,                        "type": 1,                        "name": "xxx.xxx",                        "remarks": "xxx.xxx",                        "sourceType": 1,                        "menuSort": 1,                        "menuLevel": 2,                        "hasPower": true,                        "childrenMenuType": null,                        "childrenButtonType": Array[2]                    },                    {                        "id": 5,                        "parentId": 3,                        "type": 1,                        "name": "xxx.xxx",                        "remarks": "xxx.xxx",                        "sourceType": 1,                        "menuSort": 2,                        "menuLevel": 2,                        "hasPower": true,                        "childrenMenuType": null,                        "childrenButtonType": Array[1]                    },                    {                        "id": 6,                        "parentId": 3,                        "type": 1,                        "name": "xxx.xxx",                        "remarks": "xxx.xxx",                        "sourceType": 1,                        "menuSort": 3,                        "menuLevel": 2,                        "hasPower": null,                        "childrenMenuType": null,                        "childrenButtonType": Array[9]                    },                    {                        "id": 7,                        "parentId": 3,                        "type": 1,                        "name": "xxx.xxx",                        "remarks": "xxx.xxx",                        "sourceType": 1,                        "menuSort": 4,                        "menuLevel": 2,                        "hasPower": null,                        "childrenMenuType": null,                        "childrenButtonType": null                    },                    {                        "id": 22,                        "parentId": 3,                        "type": 1,                        "name": "xxx.xxx",                        "remarks": "xxx.xxx",                        "sourceType": 1,                        "menuSort": 5,                        "menuLevel": 2,                        "hasPower": null,                        "childrenMenuType": null,                        "childrenButtonType": Array[3]                    },                    {                        "id": 23,                        "parentId": 3,                        "type": 1,                        "name": "xxx.xxx",                        "remarks": "xxx.xxx",                        "sourceType": 1,                        "menuSort": 6,                        "menuLevel": 2,                        "hasPower": null,                        "childrenMenuType": null,                        "childrenButtonType": Array[1]                    }                ],                "childrenButtonType": Array[2]            }        ],        "childrenButtonType": null    }}
==========================================
{    "code": "000000",    "msg": "success",    "timestamp": "2024-04-07 17:39:19",    "data": {        "id": -1,        "parentId": -1,        "type": null,        "name": "父节点",        "remarks": null,        "sourceType": null,        "menuSort": 0,        "menuLevel": null,        "hasPower": null,        "childrenMenuType": [            {                "id": 28,                "parentId": 0,                "type": 1,                "name": "xxx.xxx",                "remarks": "xxx.xxx",                "sourceType": 2,                "menuSort": 1,                "menuLevel": null,                "hasPower": true,                "childrenMenuType": null,                "childrenButtonType": null            },            {                "id": 29,                "parentId": 0,                "type": 1,                "name": "xxx.xxx",                "remarks": "xxx.xxx",                "sourceType": 2,                "menuSort": 2,                "menuLevel": null,                "hasPower": true,                "childrenMenuType": null,                "childrenButtonType": [                    {                        "id": 30,                        "parentId": 29,                        "type": 2,                        "name": "xxx.xxx",                        "remarks": "xxx.xxx",                        "sourceType": 2,                        "menuSort": 0,                        "menuLevel": null,                        "hasPower": null,                        "childrenMenuType": null,                        "childrenButtonType": null                    },                    {                        "id": 31,                        "parentId": 29,                        "type": 2,                        "name": "xxx.xxx",                        "remarks": "xxx.xxx",                        "sourceType": 2,                        "menuSort": 0,                        "menuLevel": null,                        "hasPower": null,                        "childrenMenuType": null,                        "childrenButtonType": null                    }                ]            },            {                "id": 32,                "parentId": 0,                "type": 1,                "name": "xxx.xxx",                "remarks": "xxx.xxx",                "sourceType": 2,                "menuSort": 3,                "menuLevel": null,                "hasPower": null,                "childrenMenuType": null,                "childrenButtonType": null            },            {                "id": 33,                "parentId": 0,                "type": 1,                "name": "xxx.xxx",                "remarks": "xxx.xxx",                "sourceType": 2,                "menuSort": 4,                "menuLevel": null,                "hasPower": null,                "childrenMenuType": null,                "childrenButtonType": [                    {                        "id": 35,                        "parentId": 33,                        "type": 2,                        "name": "xxx.xxx",                        "remarks": "xxx.xxx",                        "sourceType": 2,                        "menuSort": 0,                        "menuLevel": null,                        "hasPower": null,                        "childrenMenuType": null,                        "childrenButtonType": null                    }                ]            },            {                "id": 34,                "parentId": 0,                "type": 1,                "name": "xxx.xxx",                "remarks": "xxx.xxx",                "sourceType": 2,                "menuSort": 5,                "menuLevel": null,                "hasPower": null,                "childrenMenuType": null,                "childrenButtonType": null            }        ],        "childrenButtonType": null    }}
根据角色id可以构建一棵该角色所拥有的资源权限树，返回给前端遍历展示菜单权限树，用于重新给该角色勾选菜单权限，然后将勾选的资源id和角色id写入到角色所拥有的资源权限表-role_resource_power表中，勾选的资源id可以通过跟数据库里面求一个交并补集来实现重新设置新的权限，比如说roleId为1的角色，现在从数据库查出来的资源id是[1,2,3]，后面重新勾选授权前端传给厚端的资源id集合是[3,4,5],两次操作3这个资源没有变，之前的拥有的1,2资源权限删除，4,5新给的权限插入即可，这种一操作就达到了给加色授权的目的，其它的管理操作都是CRUD了。


6.登录实现

package xxx.controller;
import cn.dev33.satoken.stp.SaLoginConfig;import cn.dev33.satoken.stp.SaLoginModel;import cn.dev33.satoken.stp.SaTokenInfo;import cn.dev33.satoken.stp.StpUtil;import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;import lombok.extern.slf4j.Slf4j;import org.apache.commons.lang3.StringUtils;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.web.bind.annotation.PostMapping;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RestController;
import java.util.List;import java.util.Objects;
@Slf4j@RestController@RequestMapping("/user")public class AdminController {

    //TODO 系统登录和登出    //TODO 改为POST请求    //登录    @RequestMapping("/login")    public RestResponse login(String account, String pwdCipherText, Integer isRememberMe) {        //TODO 可以加上登录失败次数校验,错误次数存redis中        //TODO 密码加密,这里使用MD5加密,后台分配管理员设置账号时需要存储明文和加密密文,这里取的是加密密文对比        //TODO 或者可以加入一个生成验证码验证,提供一个获取验证码的接口给前端,生成后输入验证码验证登录,可以防止接口被刷的风险        if (StringUtils.isBlank(account) || StringUtils.isBlank(pwdCipherText)) {            return RestResponse.fail("登录账号或密码不为空!");        }        try {            //TODO 根据account、Md5加密密码pwdCipherText查询User/admin            User user = xxxx            if (Objects.isNull(user)) {                return RestResponse.fail("登录账号不存在!");            }            if ((StringUtils.isNotBlank(user.getAccount())                    && !user.getAccount().equals(account))                    || (StringUtils.isNotBlank(user.getCipherText()) && !user.getCipherText().equals(pwdCipherText))) {                return RestResponse.fail("登录账号或密码不为正确!");            }            // 记住我--->`SaLoginModel`为登录参数Model，其有诸多参数决定登录时的各种逻辑            SaLoginModel saLoginModel = SaLoginConfig                    .setDevice("PC")                // 此次登录的客户端设备类型, 用于[同端互斥登录]时指定此次登录的设备类型                    .setIsLastingCookie(true)        // 是否为持久Cookie（临时Cookie在浏览器关闭时会自动删除，持久Cookie在重新打开后依然存在）                    .setIsWriteHeader(false);       // 是否在登录后将 Token 写入到响应头            if (Objects.nonNull(isRememberMe) && isRememberMe.intValue() == 1) {                // 指定此次登录token的有效期, 单位:秒 （如未指定，自动取全局配置的 timeout 值）,全局的timeout设置的是1天,记住我设置的是7天                saLoginModel.setTimeout(60 * 60 * 24 * 7);            }            //加入权限和角色            List<String> roleList = StpUtil.getRoleList(admin.getId());            saLoginModel.setExtra("roles", roleList);            List<String> permissionList = StpUtil.getPermissionList(admin.getId());            saLoginModel.setExtra("permissions", permissionList);            //这里的id是admin的id主键            StpUtil.login(admin.getId(), saLoginModel);            SaTokenInfo tokenInfo = StpUtil.getTokenInfo();            return RestResponse.success(tokenInfo);        } catch (Exception e) {            log.error("企业会员外部系统登录异常:{}", e.getMessage());            if (StringUtils.isBlank(e.getMessage())) {                return RestResponse.fail("登录失败");            }            return RestResponse.fail("登录失败:{}", e.getMessage());        }    }

    // 查询登录状态 请求头带上login的satoken的值 Bearer XXXXXXX    @RequestMapping("/isLogin")    public RestResponse isLogin() {        return RestResponse.success("是否登录：" + StpUtil.isLogin());    }
    //TODO 改为POST请求    //注销 请求头带上login的satoken的值 Bearer XXXXXXX    @RequestMapping("/logout")    public RestResponse logout() {        StpUtil.logout();        return RestResponse.success();    }
}
登录的雏形基本已经实现了，如果你对访问接口的安全性有要求还可以使用sa-token的一个很好的功能：API 接口参数签名
https://sa-token.cc/v/v1.36.0/doc.html#/plugin/api-sign
使用该功能让你写的系统安全性更高。



7.总结

由于最近在写一个项目，涉及到后台管理登录管理等功能，所以就构思了基于RBAC角色资源访问控制设计实现了菜单权限的控制，控制权限可以精确到按钮级别，然后接触了sa-token的这个国产开源框架，加入了社区交流群和参看官方文档（仔细看才不会遗漏任何一句有用的话），将项目源码拉下来大概的翻了一下，实现的还是挺优雅的，在项目中集成使用让你的登录功能、菜单权限功能的实现更加优雅，代码量更少，只需要按需引入依赖，简单配置即可优雅实现功能，让开发人员只需要去关注解决业务问题即可，相比于Spring Security+OAuth2来实现登录认证来说，代码量更少、更简单，还有一个开源项目值得更大家分享，JustAuth开箱即用的整合第三方登录的开源组件
https://www.justauth.cn/
有兴趣的可以去看一看，在集成使用sa-token的时候会遇到的问题：
1.跨越问题:上面有解决方法。
2.项目中集成了fegin方式的接口调用，fegin接口调用说白了其实本质还是一个http请求，所以会被sa-token拦截根据uri校验，所以只需要将fegin的接口的顶级uil路径写入到SaServletFilter().addExclude("/xxxx/xxxx")或者在SaServletFilter().setAuth(obj -> {SaRouter.notMatch(“/xxxxx/xxxx”)})里面即可放行。
3.集成了sa-token-spring-aop使用@SaIgnore注解不生效，这个问题正常集成是没有啥问题的，不生效估计是项目依赖有冲突导致不成效，所以可以使用如下办法：

将加了@SaIgnore的请求方法路径解析为一个List<Sting> 设置在SaServletFilter().addExclude("/xxxx/xxxx")或者在SaServletFilter().setAuth(obj -> {SaRouter.notMatch(“/xxxxx/xxxx”)})里面即可放行，上面是一个sa-token的群友写的，我觉得写的还是可以的，拿来分享下。
3.解决反向代理 uri 丢失的问题
https://sa-token.cc/v/v1.36.0/doc.html#/fun/curr-domain
4.其它问题：参看官方的常见问题排查
https://sa-token.cc/v/v1.36.0/doc.html#/more/common-questions
到此我分享就结束了，希望能对你有所启发和帮助，请一键三连，么么么哒！


原文作者：Java大飞哥；如有侵权，请联系管理员删除。

0
0
上一篇： 推荐两款好用开源分布式id生成器
下一篇： @Validated或@Valid参数注解校验、自定义手机号注解检验及优雅统一异常处理
请登录后发表评论 登录
全部评论
BigFei

注册时间：2024-12-26

  • 博文量
    115
  • 访问量
    73139

最新文章

支持我们 作者招募 用户协议 FAQ Contact Us

北京盛拓优讯信息技术有限公司. 版权所有  京ICP备16024965号-8 北京市公安局海淀分局网监中心备案编号：11010802021510 niuxiaotong@pcpop.com 17352615567 未成年人举报专区

广播电视节目制作经营许可证(京) 字第1234号 中国互联网协会会员

违法和不良信息举报电话:18101376593