RuoYi 阶段六：角色与菜单管理

NOTE
本文是 RuoYi 学习路线的阶段六，聚焦 RBAC 权限模型。学完本篇你应该能：

理解 RBAC 权限模型的设计思想

掌握角色和菜单的关联关系

知道如何构建动态菜单树

前端视角：RBAC 像什么？#

RuoYi RBAC	前端类比
`SysRole` 角色	用户角色类型 (admin/user/guest)
`SysMenu` 菜单	路由配置 + 侧边栏菜单项
权限标识	按钮级别权限控制 (v-permission)
菜单树	TreeSelect 组件数据
角色关联菜单	角色权限配置面板

RBAC 权限模型#

RBAC (Role-Based Access Control) 基于角色的访问控制，核心思想：

1
用户 (User) → 角色 (Role) → 权限 (Permission/Menu)

数据表关系#

1
sys_user ←→ sys_user_role ←→ sys_role ←→ sys_role_menu ←→ sys_menu
2
   |              |                |              |               |
3
 用户表        用户角色关联       角色表        角色菜单关联      菜单表

权限流程图#

1
用户登录
2
    ↓
3
查询用户的角色列表
4
    ↓
5
查询角色关联的菜单列表
6
    ↓
7
提取权限标识 (如 system:user:add)
8
    ↓
9
Shiro 授权
10
    ↓
11
页面显示对应按钮/菜单

角色实体类 (SysRole)#

1
package com.ruoyi.common.core.domain.entity;
2

3
import javax.validation.constraints.*;
4
import org.apache.commons.lang3.builder.ToStringBuilder;
5
import org.apache.commons.lang3.builder.ToStringStyle;
6
import com.ruoyi.common.annotation.Excel;
7
import com.ruoyi.common.annotation.Excel.ColumnType;
8
import com.ruoyi.common.core.domain.BaseEntity;
9

10
/**
11
 * 角色表 sys_role
12
 *
13
 * @author ruoyi
14
 */
15
public class SysRole extends BaseEntity {
16
    private static final long serialVersionUID = 1L;
17

18
    /** 角色ID */
19
    @Excel(name = "角色序号", cellType = ColumnType.NUMERIC)
20
    private Long roleId;
21

22
    /** 角色名称 */
23
    @Excel(name = "角色名称")
24
    private String roleName;
25

26
    /** 角色权限字符串 */
27
    @Excel(name = "角色权限")
28
    private String roleKey;
29

30
    /** 角色排序 */
31
    @Excel(name = "角色排序", cellType = ColumnType.NUMERIC)
32
    private Integer roleSort;
33

34
    /** 数据范围（1：全部数据权限；2：自定义数据权限；3：本部门数据权限；4：本部门及以下数据权限；5：仅本人数据权限） */
35
    @Excel(name = "数据范围", readConverterExp = "1=所有数据权限,2=自定义数据权限,3=本部门数据权限,4=本部门及以下数据权限,5=仅本人数据权限")
36
    private String dataScope;
37

38
    /** 角色状态（0正常 1停用） */
39
    @Excel(name = "角色状态", readConverterExp = "0=正常,1=停用")
40
    private String status;
41

42
    /** 删除标志（0代表存在 2代表删除） */
43
    private String delFlag;
44

45
    /** 用户是否存在此角色标识 */
46
    private boolean flag = false;
47

48
    /** 菜单组 */
49
    private Long[] menuIds;
50

51
    /** 部门组（数据权限） */
52
    private Long[] deptIds;
53

54
    public SysRole() {
55
    }
56

57
    public SysRole(Long roleId) {
58
        this.roleId = roleId;
59
    }
60

61
    public Long getRoleId() {
62
        return roleId;
63
    }
64

65
    public void setRoleId(Long roleId) {
66
        this.roleId = roleId;
67
    }
68

69
    public boolean isAdmin() {
70
        return isAdmin(this.roleId);
71
    }
72

73
    public static boolean isAdmin(Long roleId) {
74
        return roleId != null && 1L == roleId;
75
    }
76

77
    @NotBlank(message = "角色名称不能为空")
78
    @Size(min = 0, max = 30, message = "角色名称长度不能超过30个字符")
79
    public String getRoleName() {
80
        return roleName;
81
    }
82

83
    @NotBlank(message = "权限字符不能为空")
84
    @Size(min = 0, max = 100, message = "权限字符长度不能超过100个字符")
85
    public String getRoleKey() {
86
        return roleKey;
87
    }
88

89
    @NotBlank(message = "显示顺序不能为空")
90
    public Integer getRoleSort() {
91
        return roleSort;
92
    }
93

94
    public String getDataScope() {
95
        return dataScope;
96
    }
97

98
    public void setDataScope(String dataScope) {
99
        this.dataScope = dataScope;
100
    }
101

102
    public String getStatus() {
103
        return status;
104
    }
105

106
    public void setStatus(String status) {
107
        this.status = status;
108
    }
109

110
    public String getDelFlag() {
111
        return delFlag;
112
    }
113

114
    public void setDelFlag(String delFlag) {
115
        this.delFlag = delFlag;
116
    }
117

118
    public boolean isFlag() {
119
        return flag;
120
    }
121

122
    public void setFlag(boolean flag) {
123
        this.flag = flag;
124
    }
125

126
    public Long[] getMenuIds() {
127
        return menuIds;
128
    }
129

130
    public void setMenuIds(Long[] menuIds) {
131
        this.menuIds = menuIds;
132
    }
133

134
    public Long[] getDeptIds() {
135
        return deptIds;
136
    }
137

138
    public void setDeptIds(Long[] deptIds) {
139
        this.deptIds = deptIds;
140
    }
141

142
    @Override
143
    public String toString() {
144
        return new ToStringBuilder(this, ToStringStyle.MULTI_LINE_STYLE)
145
            .append("roleId", getRoleId())
146
            .append("roleName", getRoleName())
147
            .append("roleKey", getRoleKey())
148
            .append("roleSort", getRoleSort())
149
            .append("dataScope", getDataScope())
150
            .append("status", getStatus())
151
            .append("delFlag", getDelFlag())
152
            .append("createBy", getCreateBy())
153
            .append("createTime", getCreateTime())
154
            .append("updateBy", getUpdateBy())
155
            .append("updateTime", getUpdateTime())
156
            .append("remark", getRemark())
157
            .toString();
158
    }
159
}

菜单实体类 (SysMenu)#

1
package com.ruoyi.system.domain;
2

3
import java.util.ArrayList;
4
import java.util.List;
5
import javax.validation.constraints.*;
6
import org.apache.commons.lang3.builder.ToStringBuilder;
7
import org.apache.commons.lang3.builder.ToStringStyle;
8
import com.ruoyi.common.core.domain.BaseEntity;
9

10
/**
11
 * 菜单权限表 sys_menu
12
 *
13
 * @author ruoyi
14
 */
15
public class SysMenu extends BaseEntity {
16
    private static final long serialVersionUID = 1L;
17

18
    /** 菜单ID */
19
    private Long menuId;
20

21
    /** 菜单名称 */
22
    private String menuName;
23

24
    /** 父菜单名称 */
25
    private String parentName;
26

27
    /** 父菜单ID */
28
    private Long parentId;
29

30
    /** 显示顺序 */
31
    private Integer orderNum;
32

33
    /** 菜单URL */
34
    private String url;
35

36
    /** 打开方式（menuItem页签 menuBlank新窗口） */
37
    private String target;
38

39
    /** 类型（M目录 C菜单 F按钮） */
40
    private String menuType;
41

42
    /** 菜单状态（0显示 1隐藏） */
43
    private String visible;
44

45
    /** 是否刷新（0刷新 1不刷新） */
46
    private String isRefresh;
47

48
    /** 权限字符串 */
49
    private String perms;
50

51
    /** 菜单图标 */
52
    private String icon;
53

54
    /** 子菜单 */
55
    private List<SysMenu> children = new ArrayList<SysMenu>();
56

57
    public Long getMenuId() {
58
        return menuId;
59
    }
60

61
    public void setMenuId(Long menuId) {
62
        this.menuId = menuId;
63
    }
64

65
    @NotBlank(message = "菜单名称不能为空")
66
    @Size(min = 0, max = 50, message = "菜单名称长度不能超过50个字符")
67
    public String getMenuName() {
68
        return menuName;
69
    }
70

71
    public void setMenuName(String menuName) {
72
        this.menuName = menuName;
73
    }
74

75
    public String getParentName() {
76
        return parentName;
77
    }
78

79
    public void setParentName(String parentName) {
80
        this.parentName = parentName;
81
    }
82

83
    public Long getParentId() {
84
        return parentId;
85
    }
86

87
    public void setParentId(Long parentId) {
88
        this.parentId = parentId;
89
    }
90

91
    @NotNull(message = "显示顺序不能为空")
92
    public Integer getOrderNum() {
93
        return orderNum;
94
    }
95

96
    public void setOrderNum(Integer orderNum) {
97
        this.orderNum = orderNum;
98
    }
99

100
    @Size(min = 0, max = 200, message = "请求地址不能超过200个字符")
101
    public String getUrl() {
102
        return url;
103
    }
104

105
    public void setUrl(String url) {
106
        this.url = url;
107
    }
108

109
    public String getTarget() {
110
        return target;
111
    }
112

113
    public void setTarget(String target) {
114
        this.target = target;
115
    }
116

117
    @NotBlank(message = "菜单类型不能为空")
118
    public String getMenuType() {
119
        return menuType;
120
    }
121

122
    public void setMenuType(String menuType) {
123
        this.menuType = menuType;
124
    }
125

126
    public String getVisible() {
127
        return visible;
128
    }
129

130
    public void setVisible(String visible) {
131
        this.visible = visible;
132
    }
133

134
    public String getIsRefresh() {
135
        return isRefresh;
136
    }
137

138
    public void setIsRefresh(String isRefresh) {
139
        this.isRefresh = isRefresh;
140
    }
141

142
    @Size(min = 0, max = 100, message = "权限标识长度不能超过100个字符")
143
    public String getPerms() {
144
        return perms;
145
    }
146

147
    public void setPerms(String perms) {
148
        this.perms = StringUtils.isEmpty(perms) ? "" : perms.trim();
149
    }
150

151
    public String getIcon() {
152
        return icon;
153
    }
154

155
    public void setIcon(String icon) {
156
        this.icon = icon;
157
    }
158

159
    public List<SysMenu> getChildren() {
160
        return children;
161
    }
162

163
    public void setChildren(List<SysMenu> children) {
164
        this.children = children;
165
    }
166

167
    @Override
168
    public String toString() {
169
        return new ToStringBuilder(this, ToStringStyle.MULTI_LINE_STYLE)
170
            .append("menuId", getMenuId())
171
            .append("menuName", getMenuName())
172
            .append("parentId", getParentId())
173
            .append("orderNum", getOrderNum())
174
            .append("url", getUrl())
175
            .append("target", getTarget())
176
            .append("menuType", getMenuType())
177
            .append("visible", getVisible())
178
            .append("perms", getPerms())
179
            .append("icon", getIcon())
180
            .append("createBy", getCreateBy())
181
            .append("createTime", getCreateTime())
182
            .append("updateBy", getUpdateBy())
183
            .append("updateTime", getUpdateTime())
184
            .append("remark", getRemark())
185
            .toString();
186
    }
187
}

菜单类型#

类型	值	说明
目录	M	一级菜单，不直接访问页面
菜单	C	二级菜单，对应具体页面
按钮	F	按钮级权限，如新增/修改/删除

角色 Service 实现#

接口定义#

1
package com.ruoyi.system.service;
2

3
import java.util.List;
4
import java.util.Set;
5
import com.ruoyi.common.core.domain.entity.SysRole;
6
import com.ruoyi.system.domain.SysUserRole;
7

8
/**
9
 * 角色业务层
10
 *
11
 * @author ruoyi
12
 */
13
public interface ISysRoleService {
14
    /**
15
     * 根据条件分页查询角色数据
16
     */
17
    public List<SysRole> selectRoleList(SysRole role);
18

19
    /**
20
     * 根据用户ID查询角色
21
     */
22
    public Set<SysRole> selectRolesByUserId(Long userId);
23

24
    /**
25
     * 查询所有角色
26
     */
27
    public List<SysRole> selectRoleAll();
28

29
    /**
30
     * 通过角色ID查询角色
31
     */
32
    public SysRole selectRoleById(Long roleId);
33

34
    /**
35
     * 通过角色ID删除角色
36
     */
37
    public boolean deleteRoleById(Long roleId);
38

39
    /**
40
     * 批量删除角色用户信息
41
     */
42
    public int deleteRoleByIds(String ids);
43

44
    /**
45
     * 新增保存角色信息
46
     */
47
    public int insertRole(SysRole role);
48

49
    /**
50
     * 修改保存角色信息
51
     */
52
    public int updateRole(SysRole role);
53

54
    /**
55
     * 修改数据权限信息
56
     */
57
    public int authDataScope(SysRole role);
58

59
    /**
60
     * 校验角色名称是否唯一
61
     */
62
    public String checkRoleNameUnique(SysRole role);
63

64
    /**
65
     * 校验角色权限是否唯一
66
     */
67
    public String checkRoleKeyUnique(SysRole role);
68

69
    /**
70
     * 校验角色是否允许操作
71
     */
72
    public void checkRoleAllowed(SysRole role);
73

74
    /**
75
     * 取消授权用户角色
76
     */
77
    public int deleteAuthUser(SysUserRole userRole);
78

79
    /**
80
     * 批量取消授权用户角色
81
     */
82
    public int deleteAuthUsers(Long roleId, String userIds);
83

84
    /**
85
     * 批量选择授权用户角色
86
     */
87
    public int insertAuthUsers(Long roleId, String userIds);
88
}

实现类核心方法#

1
package com.ruoyi.system.service.impl;
2

3
import java.util.*;
4
import org.springframework.beans.factory.annotation.Autowired;
5
import org.springframework.stereotype.Service;
6
import org.springframework.transaction.annotation.Transactional;
7
import com.ruoyi.common.annotation.DataScope;
8
import com.ruoyi.common.constant.UserConstants;
9
import com.ruoyi.common.core.domain.entity.SysRole;
10
import com.ruoyi.common.core.domain.entity.SysUser;
11
import com.ruoyi.common.core.text.Convert;
12
import com.ruoyi.common.exception.ServiceException;
13
import com.ruoyi.common.utils.StringUtils;
14
import com.ruoyi.common.utils.spring.SpringUtils;
15
import com.ruoyi.system.domain.SysRoleDept;
16
import com.ruoyi.system.domain.SysRoleMenu;
17
import com.ruoyi.system.domain.SysUserRole;
18
import com.ruoyi.system.mapper.*;
19
import com.ruoyi.system.service.ISysRoleService;
20

21
/**
22
 * 角色 业务层处理
23
 *
24
 * @author ruoyi
25
 */
26
@Service
27
public class SysRoleServiceImpl implements ISysRoleService {
28
    @Autowired
29
    private SysRoleMapper roleMapper;
30

31
    @Autowired
32
    private SysRoleMenuMapper roleMenuMapper;
33

34
    @Autowired
35
    private SysUserRoleMapper userRoleMapper;
36

37
    @Autowired
38
    private SysRoleDeptMapper roleDeptMapper;
39

40
    /**
41
     * 根据条件分页查询角色数据
42
     */
43
    @Override
44
    @DataScope(deptAlias = "d")
45
    public List<SysRole> selectRoleList(SysRole role) {
46
        return roleMapper.selectRoleList(role);
47
    }
48

49
    /**
50
     * 根据用户ID查询角色
51
     */
52
    @Override
53
    public Set<SysRole> selectRolesByUserId(Long userId) {
54
        List<SysRole> userRoles = roleMapper.selectRolesByUserId(userId);
55
        List<SysRole> roles = selectRoleAll();
56
        for (SysRole role : roles) {
57
            for (SysRole userRole : userRoles) {
58
                if (role.getRoleId().longValue() == userRole.getRoleId().longValue()) {
59
                    role.setFlag(true);
60
                    break;
61
                }
62
            }
63
        }
64
        return new LinkedHashSet<SysRole>(roles);
65
    }
66

67
    /**
68
     * 查询所有角色
69
     */
70
    @Override
71
    public List<SysRole> selectRoleAll() {
72
        return SpringUtils.getAopProxy(this).selectRoleList(new SysRole());
73
    }
74

75
    /**
76
     * 新增保存角色信息
77
     */
78
    @Override
79
    @Transactional
80
    public int insertRole(SysRole role) {
81
        // 新增角色信息
82
        roleMapper.insertRole(role);
83
        return insertRoleMenu(role);
84
    }
85

86
    /**
87
     * 修改保存角色信息
88
     */
89
    @Override
90
    @Transactional
91
    public int updateRole(SysRole role) {
92
        // 修改角色信息
93
        roleMapper.updateRole(role);
94
        // 删除角色与菜单关联
95
        roleMenuMapper.deleteRoleMenuByRoleId(role.getRoleId());
96
        return insertRoleMenu(role);
97
    }
98

99
    /**
100
     * 新增角色菜单信息
101
     */
102
    public int insertRoleMenu(SysRole role) {
103
        int rows = 1;
104
        // 新增用户与角色管理
105
        List<SysRoleMenu> list = new ArrayList<SysRoleMenu>();
106
        for (Long menuId : role.getMenuIds()) {
107
            SysRoleMenu rm = new SysRoleMenu();
108
            rm.setRoleId(role.getRoleId());
109
            rm.setMenuId(menuId);
110
            list.add(rm);
111
        }
112
        if (list.size() > 0) {
113
            rows = roleMenuMapper.batchRoleMenu(list);
114
        }
115
        return rows;
116
    }
117

118
    /**
119
     * 修改数据权限信息
120
     */
121
    @Override
122
    @Transactional
123
    public int authDataScope(SysRole role) {
124
        // 修改角色信息
125
        roleMapper.updateRole(role);
126
        // 删除角色与部门关联
127
        roleDeptMapper.deleteRoleDeptByRoleId(role.getRoleId());
128
        // 新增角色和部门信息（数据权限）
129
        return insertRoleDept(role);
130
    }
131

132
    /**
133
     * 新增角色部门信息（数据权限）
134
     */
135
    public int insertRoleDept(SysRole role) {
136
        int rows = 1;
137
        // 新增角色与部门管理
138
        List<SysRoleDept> list = new ArrayList<SysRoleDept>();
139
        for (Long deptId : role.getDeptIds()) {
140
            SysRoleDept rd = new SysRoleDept();
141
            rd.setRoleId(role.getRoleId());
142
            rd.setDeptId(deptId);
143
            list.add(rd);
144
        }
145
        if (list.size() > 0) {
146
            rows = roleDeptMapper.batchRoleDept(list);
147
        }
148
        return rows;
149
    }
150

151
    /**
152
     * 校验角色名称是否唯一
153
     */
154
    @Override
155
    public String checkRoleNameUnique(SysRole role) {
156
        Long roleId = StringUtils.isNull(role.getRoleId()) ? -1L : role.getRoleId();
157
        SysRole info = roleMapper.checkRoleNameUnique(role.getRoleName());
158
        if (StringUtils.isNotNull(info) && info.getRoleId().longValue() != roleId.longValue()) {
159
            return UserConstants.NOT_UNIQUE;
160
        }
161
        return UserConstants.UNIQUE;
162
    }
163

164
    /**
165
     * 校验角色权限是否唯一
166
     */
167
    @Override
168
    public String checkRoleKeyUnique(SysRole role) {
169
        Long roleId = StringUtils.isNull(role.getRoleId()) ? -1L : role.getRoleId();
170
        SysRole info = roleMapper.checkRoleKeyUnique(role.getRoleKey());
171
        if (StringUtils.isNotNull(info) && info.getRoleId().longValue() != roleId.longValue()) {
172
            return UserConstants.NOT_UNIQUE;
173
        }
174
        return UserConstants.UNIQUE;
175
    }
176

177
    /**
178
     * 校验角色是否允许操作
179
     */
180
    @Override
181
    public void checkRoleAllowed(SysRole role) {
182
        if (StringUtils.isNotNull(role.getRoleId()) && role.isAdmin()) {
183
            throw new ServiceException("不允许操作超级管理员角色");
184
        }
185
    }
186

187
    /**
188
     * 批量删除角色信息
189
     */
190
    @Override
191
    public int deleteRoleByIds(String ids) {
192
        Long[] roleIds = Convert.toLongArray(ids);
193
        for (Long roleId : roleIds) {
194
            checkRoleAllowed(new SysRole(roleId));
195
            SysRole role = selectRoleById(roleId);
196
            if (countUserRoleByRoleId(roleId) > 0) {
197
                throw new ServiceException(String.format("%1$s已分配,不能删除", role.getRoleName()));
198
            }
199
        }
200
        // 删除角色与菜单关联
201
        roleMenuMapper.deleteRoleMenu(roleIds);
202
        // 删除角色与部门关联
203
        roleDeptMapper.deleteRoleDept(roleIds);
204
        return roleMapper.deleteRoleByIds(roleIds);
205
    }
206

207
    /**
208
     * 查询角色绑定用户数
209
     */
210
    public int countUserRoleByRoleId(Long roleId) {
211
        return userRoleMapper.countUserRoleByRoleId(roleId);
212
    }
213
}

菜单 Service 实现#

接口定义#

1
package com.ruoyi.system.service;
2

3
import java.util.List;
4
import java.util.Map;
5
import java.util.Set;
6
import com.ruoyi.common.core.domain.Ztree;
7
import com.ruoyi.system.domain.SysMenu;
8

9
/**
10
 * 菜单 业务层
11
 *
12
 * @author ruoyi
13
 */
14
public interface ISysMenuService {
15
    /**
16
     * 根据用户查询系统菜单列表
17
     */
18
    public List<SysMenu> selectMenusByUser(SysUser user);
19

20
    /**
21
     * 查询系统菜单列表
22
     */
23
    public List<SysMenu> selectMenuList(SysMenu menu);
24

25
    /**
26
     * 查询菜单集合
27
     */
28
    public List<SysMenu> selectMenuAll();
29

30
    /**
31
     * 根据用户ID查询权限
32
     */
33
    public Set<String> selectPermsByUserId(Long userId);
34

35
    /**
36
     * 根据角色ID查询菜单
37
     */
38
    public List<Ztree> roleMenuTreeData(Long roleId);
39

40
    /**
41
     * 查询所有菜单信息
42
     */
43
    public List<Ztree> menuTreeData();
44

45
    /**
46
     * 根据菜单ID查询信息
47
     */
48
    public SysMenu selectMenuById(Long menuId);
49

50
    /**
51
     * 删除菜单信息
52
     */
53
    public int deleteMenuById(Long menuId);
54

55
    /**
56
     * 新增保存菜单信息
57
     */
58
    public int insertMenu(SysMenu menu);
59

60
    /**
61
     * 修改保存菜单信息
62
     */
63
    public int updateMenu(SysMenu menu);
64

65
    /**
66
     * 校验菜单名称是否唯一
67
     */
68
    public String checkMenuNameUnique(SysMenu menu);
69
}

构建菜单树#

1
/**
2
 * 构建前端需要的树结构
3
 */
4
public List<Ztree> initZtree(List<SysMenu> menus) {
5
    List<Ztree> ztrees = new ArrayList<Ztree>();
6
    boolean isChild = true;
7
    for (SysMenu menu : menus) {
8
        Ztree ztree = new Ztree();
9
        ztree.setId(menu.getMenuId());
10
        ztree.setpId(menu.getParentId());
11
        ztree.setName(transMenuName(menu, isChild));
12
        ztree.setTitle(menu.getMenuName());
13
        ztree.setChecked(menu.isVisible());
14
        ztree.setOpen(menu.isOpen());
15
        ztrees.add(ztree);
16
    }
17
    return ztrees;
18
}
19

20
/**
21
 * 转换菜单名称
22
 */
23
public String transMenuName(SysMenu menu, boolean isChild) {
24
    if (isChild) {
25
        return menu.getMenuName();
26
    }
27
    return menu.getMenuName() + "/" + menu.getPerms();
28
}
29

30
/**
31
 * 递归构建菜单树
32
 */
33
public List<SysMenu> getChildPerms(List<SysMenu> list, int parentId) {
34
    List<SysMenu> returnList = new ArrayList<SysMenu>();
35
    for (Iterator<SysMenu> iterator = list.iterator(); iterator.hasNext();) {
36
        SysMenu t = iterator.next();
37
        // 根据传入的parentId进行筛选
38
        if (t.getParentId() == parentId) {
39
            recursionFn(list, t);
40
            returnList.add(t);
41
        }
42
    }
43
    return returnList;
44
}
45

46
/**
47
 * 递归列表
48
 */
49
private void recursionFn(List<SysMenu> list, SysMenu t) {
50
    // 得到子节点列表
51
    List<SysMenu> childList = getChildList(list, t);
52
    t.setChildren(childList);
53
    for (SysMenu tChild : childList) {
54
        if (hasChild(list, tChild)) {
55
            // 判断子节点是否有下级
56
            recursionFn(list, tChild);
57
        }
58
    }
59
}
60

61
/**
62
 * 得到子节点列表
63
 */
64
private List<SysMenu> getChildList(List<SysMenu> list, SysMenu t) {
65
    List<SysMenu> tlist = new ArrayList<SysMenu>();
66
    Iterator<SysMenu> it = list.iterator();
67
    while (it.hasNext()) {
68
        SysMenu n = it.next();
69
        if (n.getParentId().longValue() == t.getMenuId().longValue()) {
70
            tlist.add(n);
71
        }
72
    }
73
    return tlist;
74
}
75

76
/**
77
 * 判断是否有子节点
78
 */
79
private boolean hasChild(List<SysMenu> list, SysMenu t) {
80
    return getChildList(list, t).size() > 0;
81
}

数据库表结构#

角色表#

1
CREATE TABLE sys_role (
2
  role_id           BIGINT(20)      NOT NULL AUTO_INCREMENT    COMMENT '角色ID',
3
  role_name         VARCHAR(30)     NOT NULL                   COMMENT '角色名称',
4
  role_key          VARCHAR(100)    NOT NULL                   COMMENT '角色权限字符串',
5
  role_sort         INT(4)          NOT NULL                   COMMENT '显示顺序',
6
  data_scope        CHAR(1)         DEFAULT '1'                COMMENT '数据范围',
7
  status            CHAR(1)         NOT NULL                   COMMENT '角色状态（0正常 1停用）',
8
  del_flag          CHAR(1)         DEFAULT '0'                COMMENT '删除标志',
9
  create_by         VARCHAR(64)     DEFAULT ''                 COMMENT '创建者',
10
  create_time       DATETIME                                   COMMENT '创建时间',
11
  update_by         VARCHAR(64)     DEFAULT ''                 COMMENT '更新者',
12
  update_time       DATETIME                                   COMMENT '更新时间',
13
  remark            VARCHAR(500)    DEFAULT NULL               COMMENT '备注',
14
  PRIMARY KEY (role_id)
15
) ENGINE=InnoDB AUTO_INCREMENT=100 COMMENT = '角色信息表';

菜单表#

1
CREATE TABLE sys_menu (
2
  menu_id           BIGINT(20)      NOT NULL AUTO_INCREMENT    COMMENT '菜单ID',
3
  menu_name         VARCHAR(50)     NOT NULL                   COMMENT '菜单名称',
4
  parent_id         BIGINT(20)      DEFAULT 0                  COMMENT '父菜单ID',
5
  order_num         INT(4)          DEFAULT 0                  COMMENT '显示顺序',
6
  url               VARCHAR(200)    DEFAULT '#'                COMMENT '请求地址',
7
  target            VARCHAR(20)     DEFAULT ''                 COMMENT '打开方式',
8
  menu_type         CHAR(1)         DEFAULT ''                 COMMENT '菜单类型（M目录 C菜单 F按钮）',
9
  visible           CHAR(1)         DEFAULT 0                  COMMENT '菜单状态（0显示 1隐藏）',
10
  is_refresh        CHAR(1)         DEFAULT 1                  COMMENT '是否刷新',
11
  perms             VARCHAR(100)    DEFAULT NULL               COMMENT '权限标识',
12
  icon              VARCHAR(100)    DEFAULT '#'                COMMENT '菜单图标',
13
  create_by         VARCHAR(64)     DEFAULT ''                 COMMENT '创建者',
14
  create_time       DATETIME                                   COMMENT '创建时间',
15
  update_by         VARCHAR(64)     DEFAULT ''                 COMMENT '更新者',
16
  update_time       DATETIME                                   COMMENT '更新时间',
17
  remark            VARCHAR(500)    DEFAULT ''                 COMMENT '备注',
18
  PRIMARY KEY (menu_id)
19
) ENGINE=InnoDB AUTO_INCREMENT=2000 COMMENT = '菜单权限表';

角色菜单关联表#

1
CREATE TABLE sys_role_menu (
2
  role_id           BIGINT(20) NOT NULL COMMENT '角色ID',
3
  menu_id           BIGINT(20) NOT NULL COMMENT '菜单ID',
4
  PRIMARY KEY(role_id, menu_id)
5
) ENGINE=InnoDB COMMENT = '角色和菜单关联表';

权限标识规范#

RuoYi 采用模块化的权限标识命名规范：

1
模块:功能:操作

示例#

权限标识	说明
`system:user:list`	用户列表查询
`system:user:add`	用户新增
`system:user:edit`	用户修改
`system:user:remove`	用户删除
`system:user:export`	用户导出
`system:role:list`	角色列表查询
`system:menu:add`	菜单新增

复习卡片#

1
// RBAC 核心关系
2
// 用户 → 用户角色关联 → 角色 → 角色菜单关联 → 菜单
3

4
// 1. 角色分配菜单
5
List<SysRoleMenu> list = new ArrayList<>();
6
for (Long menuId : role.getMenuIds()) {
7
    SysRoleMenu rm = new SysRoleMenu();
8
    rm.setRoleId(role.getRoleId());
9
    rm.setMenuId(menuId);
10
    list.add(rm);
11
}
12
roleMenuMapper.batchRoleMenu(list);
13

14
// 2. 查询用户角色
15
Set<SysRole> roles = roleService.selectRolesByUserId(userId);
16

17
// 3. 构建菜单树
18
List<Ztree> ztrees = menuService.roleMenuTreeData(roleId);
19

20
// 4. 菜单类型
21
// M = 目录
22
// C = 菜单
23
// F = 按钮
24

25
// 5. 数据权限
26
// 1 = 全部数据
27
// 2 = 自定义
28
// 3 = 本部门
29
// 4 = 本部门及以下
30
// 5 = 仅本人

类名	职责
`SysRole`	角色实体类
`SysMenu`	菜单实体类
`SysRoleMenu`	角色菜单关联
`SysUserRole`	用户角色关联
`ISysRoleService`	角色服务接口
`ISysMenuService`	菜单服务接口
`Ztree`	树形结构数据

TIP
下一步：阶段七：部门与岗位管理
在阶段七中，我们将学习组织架构管理，包括部门树和岗位配置。