那现在就来到了角色和权限菜单关联了，道理是一样的，在编辑角色中，编辑角色可以访问的权限菜单就可以了，例如：

这个是编辑角色中对应的权限菜单的form

<code><el-form-item label="权限菜单" prop="checkedMenus">code>

<el-tree

:data="menuList"code>

:props="defaultProps"code>

node-key="value"code>

show-checkbox

:check-on-click-node="true"code>

:default-checked-keys="defaultCheckedKeys"code>

:default-expanded-keys="defaultCheckedKeys"code>

@check="handleCheck"code>

ref="menuTree"code>

>

</el-tree>

</el-form-item>

defaultProps: {

children: 'children',

label: 'label'

},

这个部分其实还是比较复杂的，你要在后端处理树结构，网上也有很多教程，大家可以自行搜索，本篇我们主要理清思路

sysRole对应的sys_role的字段

sysRightMenu对应的sys_right_menu中的字段

我下面的处理其实是很复杂的，大体看一下就可以

@Transactional(rollbackFor = Exception.class)

@Override

public void updateRole(RoleVO roleVO) {

// 获取当前时间

Date now = DateUtil.getNow();

// 创建SysRole对象

SysRole sysRole = new SysRole();

// 设置角色ID

sysRole.setId(roleVO.getId());

// 设置角色编码

sysRole.setRoleCode(roleVO.getRoleCode());

// 设置角色名称

sysRole.setRoleName(roleVO.getRoleName());

// 设置角色状态

sysRole.setRoleStatus(roleVO.getRoleStatus());

// 设置角色类型

sysRole.setRoleType(roleVO.getRoleType());

// 设置编辑人

sysRole.setEditBy(Constant.CREATE_BY);

// 设置编辑时间

sysRole.setEditTime(DateUtil.formatDate(now));

// 更新角色信息

this.baseMapper.updateById(sysRole);

// 获取角色对应的菜单列表

List<CommonTree> commonTreeList = roleVO.getCommonTreeList();

// 初始化要插入的菜单列表

List<SysRightMenu> sysRightMenuList = new ArrayList<>();

// 初始化要删除的菜单列表

List<CommonTree> sysRightMenusToDelete = new ArrayList<>();

if (commonTreeList != null && commonTreeList.size() > 0) {

// 获取当前角色已关联的菜单ID集合

Set<String> currentSysRightMenusIds = new HashSet<>();

List<CommonTree> currentSysRightMenus = sysRightMenuService.listByRoleId(sysRole.getId());

for (CommonTree currentSysRightMenu : currentSysRightMenus) {

currentSysRightMenusIds.add(currentSysRightMenu.getValue());

}

// 遍历传入的菜单列表

for (CommonTree tree : commonTreeList) {

// 如果菜单已存在，则跳过

if (currentSysRightMenusIds.contains(tree.getValue())) {

continue;

}

// 创建SysRightMenu对象

SysRightMenu sysRightMenu = new SysRightMenu();

// 设置菜单ID

sysRightMenu.setId(IdWorker.get32UUID());

// 设置角色ID

sysRightMenu.setRoleId(sysRole.getId());

// 设置角色编码

sysRightMenu.setRoleCode(sysRole.getRoleCode());

// 设置菜单ID

sysRightMenu.setMenuId(tree.getValue());

// 设置创建时间

sysRightMenu.setCreateTime(DateUtil.formatDate(now));

// 设置创建人

sysRightMenu.setCreateBy(Constant.CREATE_BY);

// 将菜单添加到要插入的列表

sysRightMenuList.add(sysRightMenu);

}

// 遍历当前角色已关联的菜单列表

for (CommonTree currentSysRightMenu : currentSysRightMenus) {

// 如果菜单不在传入的菜单列表中，则添加到要删除的列表

if (!commonTreeList.contains(currentSysRightMenu)) {

sysRightMenusToDelete.add(currentSysRightMenu);

}

}

}

// 批量插入菜单

sysRightMenuService.saveBatch(sysRightMenuList);

// 批量删除菜单

sysRightMenuService.deleteRoleMenu(sysRightMenusToDelete, roleVO.getId());

}

那么现在其实用户有了角色，角色有了对应的权限菜单，那怎么根据用户渲染对应的菜单呢？

有很多方式，我这里说一下我的思路

假如现在用户有角色（新注册用户，注册逻辑里一般会给默认角色），登录的时候会经过filter和LoginServlet

在loginServlet中进行登录验证（判断账号密码和验证码等逻辑），如果验证成功，我这里是用的redis存储的，就把用户的用户信息，角色，权限菜单存到redis中，然后登录成功之后会请求其他页面，这个时候会被filter拦截，判断是否登录进而判断权限菜单，最后将存到redis中的权限菜单列表返回给前端请求渲染列表的地方就完成了整个流程

下面是部分代码，可能写的不是很好，因为是手搓出来的，之前刚理清一点点思路写的哈哈，仅供参考仅供参考！

<code>public class LoginServlet extends HttpServlet {

private SysUserServiceImpl sysUserService;

@Override

protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

// 获取请求体中的数据

StringBuilder jsonData = new StringBuilder();

String line;

try (BufferedReader reader = request.getReader()) {

while ((line = reader.readLine()) != null) {

jsonData.append(line);

}

}

try {

// 将请求体中的数据转换为JSON对象

JSONObject jsonObject = new JSONObject(jsonData.toString());

// 从JSON对象中获取用户名

String username = jsonObject.getString("userName");

// 从JSON对象中获取密码

String password = jsonObject.getString("passWord");

// 从JSON对象中获取验证码

String captcha = jsonObject.getString("captcha");

if(captcha != null && captcha.length() > 0){

// 从session中获取验证码

String sessionCaptcha = (String) request.getSession().getAttribute("captcha");

// 比较session中的验证码和请求中的验证码是否一致

if(!sessionCaptcha.equalsIgnoreCase(captcha)){

// 如果验证码错误，则返回状态码401，表示未授权

response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);

response.setContentType("application/json; charset=utf-8");

response.getWriter().write("{\"success\": false, \"message\": \"验证码错误！\"}");

return;

}

}

// 创建UserParam对象，并设置用户名和密码

UserParam userParam = new UserParam();

userParam.setUserName(username);

userParam.setPassWord(password);

// 进行登录验证

Boolean login = sysUserService.login(userParam);

if (login){

// 进行登录成功后的处理

sysUserService.loginSuccess(request,response,userParam);

response.setStatus(HttpServletResponse.SC_OK);

response.setHeader("Content-Type", "application/json");

response.getWriter().write("{\"success\": true, \"message\": \"登录成功！\"}");

}else {

// 登录失败，返回状态码401，表示未授权

response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);

response.setContentType("application/json; charset=utf-8");

response.getWriter().write("{\"success\": false, \"message\": \"用户名或密码错误！\"}");

}

} catch (JSONException e) {

throw new RuntimeException(e);

}

}

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

doPost(request, response);

}

@Override

public void init() throws ServletException {

// 获取WebApplicationContext对象

WebApplicationContext springContext = WebApplicationContextUtils.getWebApplicationContext(getServletContext());

// 从Spring容器中获取SysUserServiceImpl类型的Bean对象，并赋值给sysUserService变量

sysUserService = springContext.getBean(SysUserServiceImpl.class);

}

}

这个是上面出现的登录成功之后处理逻辑loginSuccess方法，当然下面的方法如果角色和角色之间有重复的菜单也会被添加进去，我是在前端取的时候做的处理，其实我写的还是比较复杂的，肯定有更好的方法，大家仅供参考

@Transactional(rollbackFor = Exception.class)

@Override

public Map<String, Object> loginSuccess(HttpServletRequest request, HttpServletResponse response,UserParam userParam) {

// 创建一个存储数据的Map

Map<String, Object> data = new HashMap<>();

// 调用sysUserMapper的userLogin方法，根据用户参数查询用户信息，并将结果赋值给userVO

UserVO userVO = sysUserMapper.userLogin(userParam);

// 调用sysRightUserMapper的queryRightUserByUserId方法，根据用户ID查询用户角色列表，并将结果赋值给roleVOS

ArrayList<RoleVO> roleVOS = sysRightUserMapper.queryRightUserByUserId(userVO.getId());

// 创建一个空的菜单列表

List<CommonTree> menuList = new ArrayList<>();

// 如果角色列表不为空且大小大于0

if(roleVOS != null && roleVOS.size() > 0){

// 遍历角色列表

for (RoleVO roleVO : roleVOS) {

// 调用sysRightMenuMapper的listByRoleId方法，根据角色ID查询菜单列表，并将结果赋值给menus

List<CommonTree> menus = sysRightMenuMapper.listByRoleId(roleVO.getRoleId());

// 遍历菜单列表

for (CommonTree menu : menus) {

// 如果菜单列表中没有包含当前菜单

if (!menuList.contains(menu)) {

// 将当前菜单添加到菜单列表中

menuList.add(menu);

}

}

}

}

// 生成一个随机的ticketId

String ticketId = UUID.randomUUID().toString();

// 拼接ticket的键

String ticket = CacheUtil.PREFIX_TICKET_USER + ticketId;

// 将ticketId存入data中

data.put("ticketId", ticketId);

// 将用户名存入data中

data.put("username", userVO.getUserName());

// 将用户ID存入data中

data.put("userId", userVO.getId());

// 将角色列表存入data中

data.put("roleList", roleVOS);

// 将菜单列表存入data中

data.put("menuList", menuList);

// 将data存入redis中，并设置过期时间为1200秒

redisUtil.set(ticket,data,1200);

// 将ticket存入session中

request.getSession().setAttribute("ticket", ticket);

// 将用户ID存入session中

request.getSession().setAttribute("userID", userVO.getId());

// 返回data

return data;

}

这样一步用户的信息就存进去了，登录之后肯定紧接着会请求到首页，紧接着会被filter拦截

@Component

public class LoginFilter implements Filter {

@Autowired

private RedisUtil redisUtil;

@Override

public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {

HttpServletRequest request = (HttpServletRequest)servletRequest;

HttpServletResponse response = (HttpServletResponse)servletResponse;

String requestURL = request.getRequestURI();

// 过滤不需要处理的请求URL

//根据需要

if(requestURL.contains("/login") || requestURL.contains("/register") || requestURL.contains("/captcha")) {

filterChain.doFilter(request, response);

return;

}

// 检查用户是否已登录

// 用户未登录，跳转到登录页面

try {

if (!isUserLoggedIn(request)) {

response.sendRedirect("/index.html");

return;

}

} catch (Exception e) {

throw new RuntimeException(e);

}

// 用户已登录，放行

filterChain.doFilter(request, response);

}

private boolean isUserLoggedIn(HttpServletRequest request) throws Exception {

// 从Session中获取Ticket

// 刚刚在loginSuccess中存的

String ticket = (String) request.getSession().getAttribute("ticket");

if (ticket != null && !ticket.isEmpty()) {

// 判断Redis中是否存在Ticket

boolean hasKey = redisUtil.hasKey(ticket);

if (hasKey) {

// 从Redis中获取用户信息

Map<String,Object> userMap = (Map<String, Object>) redisUtil.get(ticket);

// 获取用户角色列表

ArrayList<RoleVO> roleList = (ArrayList<RoleVO>) userMap.get("roleList");

// 获取用户菜单列表

ArrayList<CommonTree> menuList = (ArrayList<CommonTree>) userMap.get("menuList");

// 构建树形菜单列表

List<CommonTree> commonTrees = CommonTreeUtil.buildListTree(menuList, "-1");

// 将角色列表和菜单列表设置到request属性中

request.setAttribute("roleList", roleList);

request.setAttribute("commonTrees", commonTrees);

}

return hasKey;

}

return false;

}

}

这样权限列表已经存到request中了，我们只需要在前端请求的时候，返回给他就行了

我前段初始化会调用这个接口 /getCallingTreeByUser

@PostMapping("/getCallingTreeByUser")

public JsonResult<CommonTree> getCallingTreeByUser(HttpServletRequest request) {

//获取到requst中存储的权限菜单列表并进行处理成树结构

List<CommonTree> menuList = (List<CommonTree>) request.getAttribute("commonTrees");

JsonResult<CommonTree> jsonResult = JsonResult.getSuccessResult();

jsonResult.setData(menuList);

return jsonResult;

}

好了，到这基本上就结束了，有没有明白一些呢，我也是最近刚刚理清一点点，所有肯定有很多不是很规范，不严谨的地方，也有很多我还没有涉及到的方面，还请大佬们多多指导！