经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置:技术经验 » 程序设计 » 编程经验 » 查看文章
手把手带你开发一套用户权限系统,精确到按钮级
来源:cnblogs  作者:潘志的研发笔记  时间:2024/6/17 15:13:22  对本文有异议

在实际的软件项目开发过程中,用户权限控制可以说是所有运营系统中必不可少的一个重点功能,根据业务的复杂度,设计的时候可深可浅,但无论怎么变化,设计的思路基本都是围绕着用户、角色、菜单这三个部分展开

如何设计一套可以精确到按钮级别的用户权限功能呢?

今天通过这篇文章一起来了解一下相关的实现逻辑,不多说了,直接上案例代码!

01、数据库设计

在进入项目开发之前,首先我们需要进行相关的数据库设计,以便能存储相关的业务数据。

对于【用户权限控制】功能,通常5张表基本就可以搞定,分别是:用户表、角色表、用户角色表、菜单表、角色菜单表,相关表结构示例如下。

其中,用户和角色是多对多的关系角色与菜单也是多对多的关系用户通过角色来关联到菜单,当然也有的用户权限控制模型中,直接通过用户关联到菜单,实现用户对某个菜单权限独有控制,这都不是问题,可以自由灵活扩展。

用户、角色表的结构设计,比较简单。下面,我们重点来解读一下菜单表的设计,如下:

可以看到,整个菜单表就是一个父子表结构,关键字段如下

  • name:菜单名称
  • menu_code:菜单编码,用于后端权限控制
  • parent_id:菜单父节点ID,方便递归遍历菜单
  • node_type:菜单节点类型,可以是文件夹、页面或者按钮类型
  • link_url:菜单对应的地址,如果是文件夹或者按钮类型,可以为空
  • level:菜单树的层次,以便于查询指定层级的菜单
  • path:树id的路径,主要用于存放从根节点到当前树的父节点的路径,想要找父节点时会特别快

为了方便项目后续开发,在此我们创建一个名为menu_auth_db的数据库,SQL 初始脚本如下:

  1. CREATE DATABASE IF NOT EXISTS `menu_auth_db` default charset utf8mb4 COLLATE utf8mb4_unicode_ci;
  2. CREATE TABLE `menu_auth_db`.`tb_user` (
  3. `id` bigint(20) unsigned NOT NULL COMMENT '用户ID',
  4. `mobile` varchar(20) NOT NULL DEFAULT '' COMMENT '用户手机号',
  5. `name` varchar(100) NOT NULL DEFAULT '' COMMENT '用户姓名',
  6. `password` varchar(128) NOT NULL DEFAULT '' COMMENT '用户密码',
  7. `is_delete` tinyint(4) NOT NULL DEFAULT '0' COMMENT '是否删除 1:已删除;0:未删除',
  8. PRIMARY KEY (`id`),
  9. ) ENGINE=InnoDB COMMENT='用户表';
  10. CREATE TABLE `menu_auth_db`.`tb_user_role` (
  11. `id` bigint(20) unsigned NOT NULL COMMENT '主键',
  12. `user_id` bigint(20) NOT NULL COMMENT '用户ID',
  13. `role_id` bigint(20) NOT NULL COMMENT '角色ID',
  14. PRIMARY KEY (`id`),
  15. ) ENGINE=InnoDB COMMENT='用户角色表';
  16. CREATE TABLE `menu_auth_db`.`tb_role` (
  17. `id` bigint(20) unsigned NOT NULL COMMENT '角色ID',
  18. `name` varchar(100) NOT NULL DEFAULT '' COMMENT '角色名称',
  19. `code` varchar(100) NOT NULL DEFAULT '' COMMENT '角色编码',
  20. `is_delete` tinyint(4) NOT NULL DEFAULT '0' COMMENT '是否删除 1:已删除;0:未删除',
  21. PRIMARY KEY (`id`),
  22. ) ENGINE=InnoDB COMMENT='角色表';
  23. CREATE TABLE `menu_auth_db`.`tb_role_menu` (
  24. `id` bigint(20) unsigned NOT NULL COMMENT '主键',
  25. `role_id` bigint(20) NOT NULL COMMENT '角色ID',
  26. `menu_id` bigint(20) NOT NULL COMMENT '菜单ID',
  27. PRIMARY KEY (`id`),
  28. ) ENGINE=InnoDB COMMENT='角色菜单表';
  29. CREATE TABLE `menu_auth_db`.`tb_menu` (
  30. `id` bigint(20) NOT NULL COMMENT '菜单ID',
  31. `name` varchar(100) COLLATE utf8mb4_unicode_ci NOT NULL DEFAULT '' COMMENT '菜单名称',
  32. `menu_code` varchar(100) COLLATE utf8mb4_unicode_ci NOT NULL DEFAULT '' COMMENT '菜单编码',
  33. `parent_id` bigint(20) DEFAULT NULL COMMENT '父节点',
  34. `node_type` tinyint(4) NOT NULL DEFAULT '1' COMMENT '节点类型,1文件夹,2页面,3按钮',
  35. `icon_url` varchar(255) COLLATE utf8mb4_unicode_ci DEFAULT '' COMMENT '菜单图标地址',
  36. `sort` int(11) NOT NULL DEFAULT '1' COMMENT '排序号',
  37. `link_url` varchar(500) COLLATE utf8mb4_unicode_ci DEFAULT '' COMMENT '菜单对应的地址',
  38. `level` int(11) NOT NULL DEFAULT '0' COMMENT '菜单层次',
  39. `path` varchar(2500) COLLATE utf8mb4_unicode_ci DEFAULT '' COMMENT '树id的路径,主要用于存放从根节点到当前树的父节点的路径',
  40. `is_delete` tinyint(4) NOT NULL DEFAULT '0' COMMENT '是否删除 1:已删除;0:未删除',
  41. PRIMARY KEY (`id`) USING BTREE,
  42. KEY idx_parent_id (`parent_id`) USING BTREE
  43. ) ENGINE=InnoDB COMMENT='菜单表';

02、项目构建

菜单权限模块的数据库设计搞定之后,就可以正式进入系统开发阶段了。

2.1、创建项目

为了快速构建项目,这里采用的是springboot+mybatisPlus框架来快速开发,借助mybatisPlus提供的生成代码器,可以一键生成所需的daoserviceweb层的服务代码,以便帮助我们剩去 CRUD 中重复编程的工作量,内容如下:

CRUD 代码生成完成之后,此时我们就可以编写业务逻辑代码了,相关示例如下!

2.2、菜单功能开发

2.2.1、菜单新增逻辑示例
  1. @Override
  2. public void addMenu(Menu menu) {
  3. //如果插入的当前节点为根节点,parentId指定为0
  4. if(menu.getParentId().longValue() == 0){
  5. menu.setLevel(1);//默认根节点层级为1
  6. menu.setPath(null);//默认根节点路径为空
  7. }else{
  8. Menu parentMenu = baseMapper.selectById(menu.getParentId());
  9. if(parentMenu == null){
  10. throw new CommonException("未查询到对应的父菜单节点");
  11. }
  12. menu.setLevel(parentMenu.getLevel().intValue() + 1);
  13. // 重新设置菜单节点路径,多个用【,】隔开
  14. if(StringUtils.isNotEmpty(parentMenu.getPath())){
  15. menu.setPath(parentMenu.getPath() + "," + parentMenu.getId());
  16. }else{
  17. menu.setPath(parentMenu.getId().toString());
  18. }
  19. }
  20. // 设置菜单ID,可以用发号器来生成
  21. menu.setId(System.currentTimeMillis());
  22. // 将菜单信息插入到数据库
  23. super.save(menu);
  24. }
2.2.2、菜单查询逻辑示例

首先,编写一个视图对象,用于数据展示。

  1. public class MenuVo {
  2. /**
  3. * 主键
  4. */
  5. private Long id;
  6. /**
  7. * 名称
  8. */
  9. private String name;
  10. /**
  11. * 菜单编码
  12. */
  13. private String menuCode;
  14. /**
  15. * 父节点
  16. */
  17. private Long parentId;
  18. /**
  19. * 节点类型,1文件夹,2页面,3按钮
  20. */
  21. private Integer nodeType;
  22. /**
  23. * 图标地址
  24. */
  25. private String iconUrl;
  26. /**
  27. * 排序号
  28. */
  29. private Integer sort;
  30. /**
  31. * 页面对应的地址
  32. */
  33. private String linkUrl;
  34. /**
  35. * 层次
  36. */
  37. private Integer level;
  38. /**
  39. * 树id的路径 整个层次上的路径id,逗号分隔,想要找父节点特别快
  40. */
  41. private String path;
  42. /**
  43. * 子菜单集合
  44. */
  45. List<MenuVo> childMenu;
  46. // set、get方法等...
  47. }

接着编写菜单查询逻辑,这里需要用到递归算法来封装菜单视图。

  1. @Override
  2. public List<MenuVo> queryMenuTree() {
  3. Wrapper queryObj = new QueryWrapper<>().orderByAsc("level","sort");
  4. List<Menu> allMenu = super.list(queryObj);
  5. // 0L:表示根节点的父ID
  6. List<MenuVo> resultList = transferMenuVo(allMenu, 0L);
  7. return resultList;
  8. }

递归算法,方法实现逻辑如下!

  1. /**
  2. * 封装菜单视图
  3. * @param allMenu
  4. * @param parentId
  5. * @return
  6. */
  7. private List<MenuVo> transferMenuVo(List<Menu> allMenu, Long parentId){
  8. List<MenuVo> resultList = new ArrayList<>();
  9. if(!CollectionUtils.isEmpty(allMenu)){
  10. for (Menu source : allMenu) {
  11. if(parentId.longValue() == source.getParentId().longValue()){
  12. MenuVo menuVo = new MenuVo();
  13. BeanUtils.copyProperties(source, menuVo);
  14. //递归查询子菜单,并封装信息
  15. List<MenuVo> childList = transferMenuVo(allMenu, source.getId());
  16. if(!CollectionUtils.isEmpty(childList)){
  17. menuVo.setChildMenu(childList);
  18. }
  19. resultList.add(menuVo);
  20. }
  21. }
  22. }
  23. return resultList;
  24. }

最后编写一个菜单查询接口,将其响应给客户端。

  1. @RestController
  2. @RequestMapping("/menu")
  3. public class MenuController {
  4. @Autowired
  5. private MenuService menuService;
  6. @PostMapping(value = "/queryMenuTree")
  7. public List<MenuVo> queryTreeMenu(){
  8. return menuService.queryMenuTree();
  9. }
  10. }

为了便于演示,这里我们先在数据库中初始化几条数据,最后三条数据指的是按钮类型的菜单,用户真正请求的时候,实际上请求的是这三个功能,内容如下:

queryMenuTree接口发起请求,返回的数据结果如下图:

将返回的数据,通过页面进行渲染之后,结果类似如下图:

2.3、用户权限开发

在上文,我们提到了用户通过角色来关联菜单,因此,很容易想到,用户控制菜单的流程如下:

  • 第一步:用户登陆系统之后,查询当前用户拥有哪些角色;
  • 第二步:再通过角色查询关联的菜单权限点;
  • 第三步:最后将用户拥有的角色名下所有的菜单权限点,封装起来返回给用户;

带着这个思路,我们一起来看看具体的实现过程。

2.3.1、用户权限点查询逻辑示例

首先,编写一个通过用户ID查询菜单的服务,代码示例如下!

  1. @Override
  2. public List<MenuVo> queryMenus(Long userId) {
  3. // 第一步:先查询当前用户对应的角色
  4. Wrapper queryUserRoleObj = new QueryWrapper<>().eq("user_id", userId);
  5. List<UserRole> userRoles = userRoleService.list(queryUserRoleObj);
  6. if(!CollectionUtils.isEmpty(userRoles)){
  7. // 第二步:通过角色查询菜单(默认取第一个角色)
  8. Wrapper queryRoleMenuObj = new QueryWrapper<>().eq("role_id", userRoles.get(0).getRoleId());
  9. List<RoleMenu> roleMenus = roleMenuService.list(queryRoleMenuObj);
  10. if(!CollectionUtils.isEmpty(roleMenus)){
  11. Set<Long> menuIds = new HashSet<>();
  12. for (RoleMenu roleMenu : roleMenus) {
  13. menuIds.add(roleMenu.getMenuId());
  14. }
  15. //查询对应的菜单
  16. Wrapper queryMenuObj = new QueryWrapper<>().in("id", new ArrayList<>(menuIds));
  17. List<Menu> menus = super.list(queryMenuObj);
  18. if(!CollectionUtils.isEmpty(menus)){
  19. //将菜单下对应的父节点也一并全部查询出来
  20. Set<Long> allMenuIds = new HashSet<>();
  21. for (Menu menu : menus) {
  22. allMenuIds.add(menu.getId());
  23. if(StringUtils.isNotEmpty(menu.getPath())){
  24. String[] pathIds = StringUtils.split(",", menu.getPath());
  25. for (String pathId : pathIds) {
  26. allMenuIds.add(Long.valueOf(pathId));
  27. }
  28. }
  29. }
  30. // 第三步:查询对应的所有菜单,并进行封装展示
  31. List<Menu> allMenus = super.list(new QueryWrapper<Menu>().in("id", new ArrayList<>(allMenuIds)));
  32. List<MenuVo> resultList = transferMenuVo(allMenus, 0L);
  33. return resultList;
  34. }
  35. }
  36. }
  37. return null;
  38. }

然后,编写一个通过用户ID查询菜单的接口,将数据结果返回给用户,代码示例如下!

  1. @PostMapping(value = "/queryMenus")
  2. public List<MenuVo> queryMenus(Long userId){
  3. //查询当前用户下的菜单权限
  4. return menuService.queryMenus(userId);
  5. }

2.4、用户鉴权开发

完成以上的逻辑开发之后,可以实现哪些用户拥有哪些菜单权限点的操作,比如用户【张三】,拥有【用户管理】菜单,那么他只能看到【用户管理】的界面;用户【李四】,用于【角色管理】菜单,同样的,他只能看到【角色管理】的界面,无法看到其他的界面。

但是某些技术人员发生漏洞之后,可能会绕过页面展示逻辑,直接对接口服务发起请求,依然能正常操作,例如利用用户【张三】的账户,操作【角色管理】的数据,这个时候就会发生数据安全隐患的问题。

为此,我们还需要一套用户鉴权的功能,对接口请求进行验证,只有满足要求的才能获取数据。

其中上文提到的菜单编码menuCode就是一个前、后端联系的桥梁。其实所有后端的接口,与前端对应的都是按钮操作,因此我们可以以按钮为基准,实现前后端双向权限控制

以【角色管理-查询】这个为例,前端可以通过菜单编码实现是否展示这个查询按钮,后端可以通过菜单编码来鉴权当前用户是否具备请求接口的权限,实现过程如下!

2.4.1、权限控制逻辑示例

在此,我们采用权限注解+代理拦截器的方式,来实现接口权限的安全验证。

首先,编写一个权限注解CheckPermissions

  1. @Target({ElementType.TYPE, ElementType.METHOD})
  2. @Retention(RetentionPolicy.RUNTIME)
  3. public @interface CheckPermissions {
  4. String value() default "";
  5. }

然后,编写一个代理拦截器,拦截所有被@CheckPermissions注解标注的方法

  1. @Aspect
  2. @Component
  3. public class CheckPermissionsAspect {
  4. @Autowired
  5. private MenuMapper menuMapper;
  6. @Pointcut("@annotation(com.company.project.core.annotation.CheckPermissions)")
  7. public void checkPermissions() {}
  8. @Before("checkPermissions()")
  9. public void doBefore(JoinPoint joinPoint) throws Throwable {
  10. Long userId = null;
  11. // 获取请求参数
  12. Object[] args = joinPoint.getArgs();
  13. Object requestParam = args[0];
  14. // 用户请求参数实体类中的用户ID
  15. if(!Objects.isNull(requestParam)){
  16. // 获取请求对象中属性为【userId】的值
  17. Field field = requestParam.getClass().getDeclaredField("userId");
  18. field.setAccessible(true);
  19. userId = (Long) field.get(parobj);
  20. }
  21. if(!Objects.isNull(userId)){
  22. // 获取方法上有CheckPermissions注解的参数
  23. Class clazz = joinPoint.getTarget().getClass();
  24. String methodName = joinPoint.getSignature().getName();
  25. Class[] parameterTypes = ((MethodSignature)joinPoint.getSignature()).getMethod().getParameterTypes();
  26. // 寻找目标方法
  27. Method method = clazz.getMethod(methodName, parameterTypes);
  28. if(method.getAnnotation(CheckPermissions.class) != null){
  29. // 获取注解上的参数值
  30. CheckPermissions annotation = method.getAnnotation(CheckPermissions.class);
  31. String menuCode = annotation.value();
  32. if (StringUtils.isNotBlank(menuCode)) {
  33. // 通过用户ID、菜单编码查询是否有关联
  34. int count = menuMapper.selectAuthByUserIdAndMenuCode(userId, menuCode);
  35. if(count == 0){
  36. throw new CommonException("接口无访问权限");
  37. }
  38. }
  39. }
  40. }
  41. }
  42. }
2.4.2、鉴权逻辑验证

我们以上文说到的【角色管理-查询】为例,编写一个服务接口来验证一下逻辑的正确性。

首先,编写一个请求实体类RoleDTO,添加userId属性

  1. public class RoleDTO extends Role {
  2. //添加用户ID
  3. private Long userId;
  4. // set、get方法等...
  5. }

其次,编写一个角色查询接口,并在方法上添加@CheckPermissions注解,表示此方法需要鉴权,满足条件的用户才能请求通过。

  1. @RestController
  2. @RequestMapping("/role")
  3. public class RoleController {
  4. private RoleService roleService;
  5. @CheckPermissions(value="roleMgr:list")
  6. @PostMapping(value = "/queryRole")
  7. public List<Role> queryRole(RoleDTO roleDTO){
  8. return roleService.list();
  9. }
  10. }

最后,在数据库中初始化相关的数据。例如给用户【张三】分配一个【访客人员】角色,同时这个角色只有【系统配置】、【用户管理】菜单权限。

启动项目,在postman中传入用户【张三】的ID,查询用户具备的菜单权限,只有两个,结果如下:

同时,利用用户【张三】发起【角色管理-查询】操作,提示:接口无访问权限,结果如下:

与预期结果一致!因为没有配置角色查询接口,所以无权访问!

03、小结

最后总结一下,【用户权限控制】功能在实际的软件系统中非常常见,希望本篇的知识能帮助到大家。

此外,想要获取项目源代码的小伙伴,可以点击:用户权限控制,即可获取取项目的源代码。

原文链接:https://www.cnblogs.com/dxflqm/p/18249492

 友情链接:直通硅谷  点职佳  北美留学生论坛

本站QQ群:前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

W3xue 的所有内容仅供测试,对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接(目前9元/月)请联系QQ:27243702 沸活量
皖ICP备17017327号-2 皖公网安备34020702000426号