十一、后台模块-菜单列表
菜单指的是权限菜单，也就是一堆权限字符串
1. 查询菜单
1.1 接口分析
需要展示菜单列表，不需要分页。可以针对菜单名进行模糊查询。也可以针对菜单的状态进行查询。菜单要按照父菜单id和orderNum进行排序
| 请求方式 | 请求路径 | 是否需求token头 |
| GET | system/menu/list | 是 |
请求参数是query格式的：
{
status : 状态
menuName： 菜单名
}响应格式:
{
"code":200,
"data":[
{
"component":"组件路径",
"icon":"build",
"id":"2023",
"isFrame":1,
"menuName":"菜单名称",
"menuType":"C",
"orderNum":0,
"parentId":"0",
"path":"write",
"perms":"权限字符串",
"remark":"备注信息",
"status":"0",
"visible":"0"
},
{
"icon":"system",
"id":"1",
"isFrame":1,
"menuName":"菜单名称",
"menuType":"M",
"orderNum":1,
"parentId":"0",
"path":"system",
"perms":"权限字符串",
"remark":"备注信息",
"status":"0",
"visible":"0"
}
],
"msg":"操作成功"
}2.2 代码实现
第一步: 在keke-framework工程的Vo目录新建MenuVo类，写入如下，用于把指定字段返回给前端
package com.keke.domain.vo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class AdminMenuVo {
//菜单ID
private Long id;
//菜单名称
private String menuName;
//父菜单ID
private Long parentId;
//显示顺序
private Integer orderNum;
//路由地址
private String path;
//组件路径
private String component;
//是否为外链（0是 1否）
private Integer isFrame;
//菜单类型（M目录 C菜单 F按钮）
private String menuType;
//菜单状态（0显示 1隐藏）
private String visible;
//菜单状态（0正常 1停用）
private String status;
//权限标识
private String perms;
//菜单图标
private String icon;
//备注
private String remark;
}
第二步: 在keke-admin工程的controller目录新建MenuController类，写入如下，是查询菜单列表的访问接口
package com.keke.controller;
import com.keke.domain.ResponseResult;
import com.keke.domain.entity.Menu;
import com.keke.service.MenuService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/system/menu")
public class MenuController {
@Autowired
private MenuService menuService;
//查询菜单列表
@GetMapping("/list")
public ResponseResult selectAllMenu(Menu menu){
List<AdminMenuVo> adminMenuVos = menuService.selectAllMenu(menu);
return ResponseResult.okResult(adminMenuVos);
}
}
第三步：把keke-framework工程的MenuService接口修改为如下，增加了查询菜单列表的接口
package com.keke.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.keke.domain.ResponseResult;
import com.keke.domain.entity.Menu;
import java.util.List;
/**
* 菜单权限表(Menu)表服务接口
*
* @author makejava
* @since 2023-10-18 20:55:48
*/
public interface MenuService extends IService<Menu> {
//查询用户权限信息
List<String> selectPermsByUserId(Long userId);
//查询用户的路由信息，也就是权限菜单
List<Menu> selectRouterMenuTreeByUserId(Long userId);
List<AdminMenuVo> selectAllMenu(Menu menu);
}
第四步: 把keke-framework工程的MenuServiceImpl类修改为如下，增加了查询菜单列表的具体代码实现
package com.keke.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.keke.constants.SystemConstants;
import com.keke.domain.ResponseResult;
import com.keke.domain.entity.Menu;
import com.keke.domain.vo.AdminMenuVo;
import com.keke.mapper.MenuMapper;
import com.keke.service.MenuService;
import com.keke.utils.BeanCopyUtils;
import com.keke.utils.SecurityUtils;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;
/**
* 菜单权限表(Menu)表服务实现类
*
* @author makejava
* @since 2023-10-18 20:55:48
*/
@Service("menuService")
public class MenuServiceImpl extends ServiceImpl<MenuMapper, Menu> implements MenuService {
//根据用户id查询权限关键字
@Override
public List<String> selectPermsByUserId(Long userId) {
//如果用户id为1代表管理员，roles 中只需要有admin，
// permissions中需要有所有菜单类型为C(菜单)或者F(按钮)的，状态为正常的，未被删除的权限
if(SecurityUtils.isAdmin()) {
LambdaQueryWrapper<Menu> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.in(Menu::getMenuType, SystemConstants.MENU, SystemConstants.BUTTON);
lambdaQueryWrapper.eq(Menu::getStatus, SystemConstants.STATUS_NORMAL);
//由于我们的逻辑删除字段已经配置了，所以无需封装lambdaQueryWrapper
List<Menu> menuList = list(lambdaQueryWrapper);
//我们需要的是String类型的集合，这里我们要进行数据的处理，这里采用流的方式
List<String> permissions = menuList.stream()
.map(new Function<Menu, String>() {
@Override
public String apply(Menu menu) {
String perms = menu.getPerms();
return perms;
}
})
.collect(Collectors.toList());
return permissions;
}
//否则返回这个用户所具有的权限
//这里我们需要进行连表查询，因为我们的用户先和角色关联，然后角色才跟权限关联
MenuMapper menuMapper = getBaseMapper();
//我们期望menuMapper中有一个方法可以直接帮我们去实现这个复杂的逻辑，这里直接返回
return menuMapper.selectPermsByUserId(userId);
}
@Override
public List<Menu> selectRouterMenuTreeByUserId(Long userId) {
MenuMapper menuMapper = getBaseMapper();
List<Menu> menus = null;
//如果是管理员，返回所有
if(SecurityUtils.isAdmin()){
menus = menuMapper.selectAllRoutersMenu();
}else {
//如果不是管理员，返回对应用户的菜单
menus = menuMapper.selectRoutersMenuTreeByUserId(userId);
}
//因为上面的查询都是从数据库进行查询，所以无法封装children，这里构建Tree
List<Menu> menuTree = buildMenuTree(menus,0L);
return menuTree;
}
@Override
public ResponseResult selectAllMenu(Menu menu) {
//可以针对菜单名进行模糊查询。也可以针对菜单的状态进行查询
LambdaQueryWrapper<Menu> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.like(StringUtils.hasText(menu.getMenuName()),Menu::getMenuName,menu.getMenuName());
lambdaQueryWrapper.eq(StringUtils.hasText(menu.getStatus()),Menu::getStatus,menu.getStatus());
//排序 parent_id和order_num
lambdaQueryWrapper.orderByAsc(Menu::getParentId,Menu::getOrderNum);
List<Menu> menus = list(lambdaQueryWrapper);
List<AdminMenuVo> adminMenuVos = BeanCopyUtils.copyBeanList(menus, AdminMenuVo.class);
return adminMenuVos;
}
/**
* 构建MenuTree
* 思路先找第一层级的菜单，就是找到id于parentId的对应关系，然后把parentId设置为Id的children
* @param menus
* @return
*/
private List<Menu> buildMenuTree(List<Menu> menus,Long parentId) {
//转化流处理
List<Menu> menuTree = menus.stream()
//过滤掉除一级菜单之外的菜单
.filter(menu -> menu.getParentId().equals(parentId))
//然后将获取其子菜单设置到children字段，并返回
.map(m -> m.setChildren(gerChildren(m, menus)))
.collect(Collectors.toList());
return menuTree;
}
//获取当前菜单的子菜单
private List<Menu> gerChildren(Menu menu, List<Menu> menus) {
//流处理，遍历每一个流对象，筛选出流对象的parentId=menu的id，即过滤
List<Menu> children = menus.stream()
.filter(m -> m.getParentId().equals(menu.getId()))
//这里其实不必要写，这一步的逻辑是如果有三级，
//可以把流对象中再过筛选出子菜单设置给对应的children并返回
.map(m -> m.setChildren(gerChildren(m,menus)))
.collect(Collectors.toList());
return children;
}
}
2.3 测试
运行前端工程，打开redis，打开菜单管理
2. 新增菜单
2.1 接口分析
新增权限菜单
| 请求方式 | 请求路径 | 是否需求token头 |
| POST | system/menu | 是 |
请求体参数:
Menu类对应的json格式响应格式:
{
"code":200,
"msg":"操作成功"
}2.2 代码实现
第一步: 把keke-framework工程的Menu类修改为如下，注意有四个字段使用了mybatisplus的字段自增
package com.keke.domain.entity;
import java.util.Date;
import java.util.List;
import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.TableField;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.experimental.Accessors;
/**
* 菜单权限表(Menu)表实体类
*
* @author makejava
* @since 2023-10-18 20:55:24
*/
@SuppressWarnings("serial")
@Data
@NoArgsConstructor
@AllArgsConstructor
@Accessors(chain = true)
@TableName("sys_menu")
public class Menu {
//菜单ID
private Long id;
//菜单名称
private String menuName;
//父菜单ID
private Long parentId;
//显示顺序
private Integer orderNum;
//路由地址
private String path;
//组件路径
private String component;
//是否为外链（0是 1否）
private Integer isFrame;
//菜单类型（M目录 C菜单 F按钮）
private String menuType;
//菜单状态（0显示 1隐藏）
private String visible;
//菜单状态（0正常 1停用）
private String status;
//权限标识
private String perms;
//菜单图标
private String icon;
//创建者
@TableField(fill = FieldFill.INSERT)
private Long createBy;
//创建时间
@TableField(fill = FieldFill.INSERT)
private Date createTime;
//更新者
@TableField(fill = FieldFill.INSERT_UPDATE)
private Long updateBy;
//更新时间
@TableField(fill = FieldFill.INSERT_UPDATE)
private Date updateTime;
//备注
private String remark;
private String delFlag;
//由于数据库没有children字段，所以我们要添加@TableField(exist = false)注解
// 让mybatis在查表时不查询这个字段
@TableField(exist = false)
private List<Menu> children;
}
第二步: 把huanf-framework工程的MenuController类修改为如下，增加了新增菜单的具体代码实现
package com.keke.controller;
import com.keke.domain.ResponseResult;
import com.keke.domain.entity.Menu;
import com.keke.service.MenuService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/system/menu")
public class MenuController {
@Autowired
private MenuService menuService;
//查询菜单列表
@GetMapping("/list")
public ResponseResult selectAllMenu(Menu menu){
return menuService.selectAllMenu(menu);
}
//新增菜单
@PostMapping
public ResponseResult add(@RequestBody Menu menu) {
menuService.save(menu);
return ResponseResult.okResult();
}
}
2.3 测试
启动工程，打开前端工程，redis
测试在 '系统管理' 页面，点击 '新增'，能否可以添加"测试目录"类型的菜单
3. 修改菜单
能够修改菜单，但是修改的时候不能把父菜单设置为当前菜单，如果设置了需要给出相应的提示。并且修改失败。
修改菜单包含两个接口，一个是点击修改回显出菜单的详情信息，一个是点击确定后菜单修改成功
3.1 菜单详情
3.1.1菜单详情接口分析
| 请求方式 | 请求路径 | 是否需求token头 |
|---|---|---|
| Get | system/menu/{id} | 是 |
请求参数PathVariable格式：
id: 菜单id响应格式：
{
"code":200,
"data":{
"icon":"table",
"id":"2017",
"menuName":"内容管理",
"menuType":"M",
"orderNum":"4",
"parentId":"0",
"path":"content",
"remark":"",
"status":"0",
"visible":"0"
},
"msg":"操作成功"
}3.1.2 代码实现
controller层新增
package com.keke.controller;
import com.keke.domain.ResponseResult;
import com.keke.domain.entity.Menu;
import com.keke.service.MenuService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/system/menu")
public class MenuController {
@Autowired
private MenuService menuService;
//查询菜单列表
@GetMapping("/list")
public ResponseResult selectAllMenu(Menu menu){
return menuService.selectAllMenu(menu);
}
//新增菜单
@PostMapping
public ResponseResult add(@RequestBody Menu menu) {
menuService.save(menu);
return ResponseResult.okResult();
}
@GetMapping("/{menuId}")
public ResponseResult getInfoById(@PathVariable("menuId") Long menuId){
Menu menu = menuService.getById(menuId);
return ResponseResult.okResult(menu);
}
}
3.1.3 测试
点击修改按钮后，回显出菜单的详情信息
3.2 修改菜单
3.2.1 修改菜单接口分析
| 请求方式 | 请求路径 | 是否需求token头 |
|---|---|---|
| PUT | system/menu | 是 |
请求体参数：
Menu类对应的json格式
响应格式：
{
"code":200,
"msg":"操作成功"
}如果把父菜单设置为当前菜单:
{
"code":500,
"msg":"修改菜单'写博文'失败，上级菜单不能选择自己"
}3.2.2 代码实现
第一步：Controller层新增
package com.keke.controller;
import com.keke.domain.ResponseResult;
import com.keke.domain.entity.Menu;
import com.keke.service.MenuService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/system/menu")
public class MenuController {
@Autowired
private MenuService menuService;
//查询菜单列表
@GetMapping("/list")
public ResponseResult selectAllMenu(Menu menu){
return menuService.selectAllMenu(menu);
}
//新增菜单
@PostMapping
public ResponseResult add(@RequestBody Menu menu) {
menuService.save(menu);
return ResponseResult.okResult();
}
@GetMapping("/{menuId}")
public ResponseResult getInfoById(@PathVariable("menuId") Long menuId){
Menu menu = menuService.getById(menuId);
return ResponseResult.okResult(menu);
}
@PutMapping
public ResponseResult editMenu(@RequestBody Menu menu){
return menuService.editMenu(menu);
}
}
第二步：domain/entity的Menu实体类修改四个字段，设置为mp自动填充
package com.keke.domain.entity;
import java.util.Date;
import java.util.List;
import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.TableField;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.experimental.Accessors;
/**
* 菜单权限表(Menu)表实体类
*
* @author makejava
* @since 2023-10-18 20:55:24
*/
@SuppressWarnings("serial")
@Data
@NoArgsConstructor
@AllArgsConstructor
@Accessors(chain = true)
@TableName("sys_menu")
public class Menu {
//菜单ID
private Long id;
//菜单名称
private String menuName;
//父菜单ID
private Long parentId;
//显示顺序
private Integer orderNum;
//路由地址
private String path;
//组件路径
private String component;
//是否为外链（0是 1否）
private Integer isFrame;
//菜单类型（M目录 C菜单 F按钮）
private String menuType;
//菜单状态（0显示 1隐藏）
private String visible;
//菜单状态（0正常 1停用）
private String status;
//权限标识
private String perms;
//菜单图标
private String icon;
//创建者
@TableField(fill = FieldFill.INSERT)
private Long createBy;
//创建时间
@TableField(fill = FieldFill.INSERT)
private Date createTime;
//更新者
@TableField(fill = FieldFill.INSERT_UPDATE)
private Long updateBy;
//更新时间
@TableField(fill = FieldFill.INSERT_UPDATE)
private Date updateTime;
//备注
private String remark;
private String delFlag;
//由于数据库没有children字段，所以我们要添加@TableField(exist = false)注解
// 让mybatis在查表时不查询这个字段
@TableField(exist = false)
private List<Menu> children;
}
第三步：service层新增
package com.keke.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.keke.domain.ResponseResult;
import com.keke.domain.entity.Menu;
import java.util.List;
/**
* 菜单权限表(Menu)表服务接口
*
* @author makejava
* @since 2023-10-18 20:55:48
*/
public interface MenuService extends IService<Menu> {
//查询用户权限信息
List<String> selectPermsByUserId(Long userId);
//查询用户的路由信息，也就是权限菜单
List<Menu> selectRouterMenuTreeByUserId(Long userId);
ResponseResult selectAllMenu(Menu menu);
ResponseResult editMenu(Menu menu);
}
第四步：impl层新增
package com.keke.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.keke.constants.SystemConstants;
import com.keke.domain.ResponseResult;
import com.keke.domain.entity.Menu;
import com.keke.domain.vo.AdminMenuVo;
import com.keke.mapper.MenuMapper;
import com.keke.service.MenuService;
import com.keke.utils.BeanCopyUtils;
import com.keke.utils.SecurityUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;
/**
* 菜单权限表(Menu)表服务实现类
*
* @author makejava
* @since 2023-10-18 20:55:48
*/
@Service("menuService")
public class MenuServiceImpl extends ServiceImpl<MenuMapper, Menu> implements MenuService {
@Autowired
private MenuService menuService;
//根据用户id查询权限关键字
@Override
public List<String> selectPermsByUserId(Long userId) {
//如果用户id为1代表管理员，roles 中只需要有admin，
// permissions中需要有所有菜单类型为C(菜单)或者F(按钮)的，状态为正常的，未被删除的权限
if(SecurityUtils.isAdmin()) {
LambdaQueryWrapper<Menu> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.in(Menu::getMenuType, SystemConstants.MENU, SystemConstants.BUTTON);
lambdaQueryWrapper.eq(Menu::getStatus, SystemConstants.STATUS_NORMAL);
//由于我们的逻辑删除字段已经配置了，所以无需封装lambdaQueryWrapper
List<Menu> menuList = list(lambdaQueryWrapper);
//我们需要的是String类型的集合，这里我们要进行数据的处理，这里采用流的方式
List<String> permissions = menuList.stream()
.map(new Function<Menu, String>() {
@Override
public String apply(Menu menu) {
String perms = menu.getPerms();
return perms;
}
})
.collect(Collectors.toList());
return permissions;
}
//否则返回这个用户所具有的权限
//这里我们需要进行连表查询，因为我们的用户先和角色关联，然后角色才跟权限关联
MenuMapper menuMapper = getBaseMapper();
//我们期望menuMapper中有一个方法可以直接帮我们去实现这个复杂的逻辑，这里直接返回
return menuMapper.selectPermsByUserId(userId);
}
@Override
public List<Menu> selectRouterMenuTreeByUserId(Long userId) {
MenuMapper menuMapper = getBaseMapper();
List<Menu> menus = null;
//如果是管理员，返回所有
if(SecurityUtils.isAdmin()){
menus = menuMapper.selectAllRoutersMenu();
}else {
//如果不是管理员，返回对应用户的菜单
menus = menuMapper.selectRoutersMenuTreeByUserId(userId);
}
//因为上面的查询都是从数据库进行查询，所以无法封装children，这里构建Tree
List<Menu> menuTree = buildMenuTree(menus,0L);
return menuTree;
}
@Override
public ResponseResult selectAllMenu(Menu menu) {
//可以针对菜单名进行模糊查询。也可以针对菜单的状态进行查询
LambdaQueryWrapper<Menu> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.like(StringUtils.hasText(menu.getMenuName()),Menu::getMenuName,menu.getMenuName());
lambdaQueryWrapper.eq(StringUtils.hasText(menu.getStatus()),Menu::getStatus,menu.getStatus());
//排序 parent_id和order_num
lambdaQueryWrapper.orderByAsc(Menu::getParentId,Menu::getOrderNum);
List<Menu> menus = list(lambdaQueryWrapper);
List<AdminMenuVo> adminMenuVos = BeanCopyUtils.copyBeanList(menus, AdminMenuVo.class);
return ResponseResult.okResult(adminMenuVos);
}
@Override
public ResponseResult editMenu(Menu menu) {
if(menu.getParentId().equals(menu.getId())){
return ResponseResult.okResult(500,"修改菜单" + "'" + menu.getMenuName() + "'" + "失败，上级菜单不能选择自己");
}
updateById(menu);
return ResponseResult.okResult();
}
/**
* 构建MenuTree
* 思路先找第一层级的菜单，就是找到id于parentId的对应关系，然后把parentId设置为Id的children
* @param menus
* @return
*/
private List<Menu> buildMenuTree(List<Menu> menus,Long parentId) {
//转化流处理
List<Menu> menuTree = menus.stream()
//过滤掉除一级菜单之外的菜单
.filter(menu -> menu.getParentId().equals(parentId))
//然后将获取其子菜单设置到children字段，并返回
.map(m -> m.setChildren(gerChildren(m, menus)))
.collect(Collectors.toList());
return menuTree;
}
//获取当前菜单的子菜单
private List<Menu> gerChildren(Menu menu, List<Menu> menus) {
//流处理，遍历每一个流对象，筛选出流对象的parentId=menu的id，即过滤
List<Menu> children = menus.stream()
.filter(m -> m.getParentId().equals(menu.getId()))
//这里其实不必要写，这一步的逻辑是如果有三级，
//可以把流对象中再过筛选出子菜单设置给对应的children并返回
.map(m -> m.setChildren(gerChildren(m,menus)))
.collect(Collectors.toList());
return children;
}
}
3.2.3 测试
4. 删除菜单
能够删除菜单，但是如果要删除的菜单有子菜单则提示：存在子菜单不允许删除 并且删除失败
4.1 接口分析
| 请求方式 | 请求路径 | 是否需求token头 |
|---|---|---|
| DELETE | content/article/{menuId} | 是 |
请求参数PathVariable参数：
menuId：要删除菜单的id响应格式：
{
"code":200,
"msg":"操作成功"
}如果有子菜单
{
"code":500,
"msg":"存在子菜单不允许删除"
}4.2 代码实现
第一步：controller层新增
package com.keke.controller;
import com.keke.domain.ResponseResult;
import com.keke.domain.entity.Menu;
import com.keke.service.MenuService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/system/menu")
public class MenuController {
@Autowired
private MenuService menuService;
//查询菜单列表
@GetMapping("/list")
public ResponseResult selectAllMenu(Menu menu){
return menuService.selectAllMenu(menu);
}
//新增菜单
@PostMapping
public ResponseResult add(@RequestBody Menu menu) {
menuService.save(menu);
return ResponseResult.okResult();
}
@GetMapping("/{menuId}")
public ResponseResult getInfoById(@PathVariable("menuId") Long menuId){
Menu menu = menuService.getById(menuId);
return ResponseResult.okResult(menu);
}
@PutMapping
public ResponseResult editMenu(@RequestBody Menu menu){
return menuService.editMenu(menu);
}
@DeleteMapping("/{menuId}")
public ResponseResult deleteMenu(@PathVariable("menuId") Long menuId){
return menuService.deleteMenu(menuId);
}
}
第二步：service层新增
package com.keke.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.keke.domain.ResponseResult;
import com.keke.domain.entity.Menu;
import java.util.List;
/**
* 菜单权限表(Menu)表服务接口
*
* @author makejava
* @since 2023-10-18 20:55:48
*/
public interface MenuService extends IService<Menu> {
//查询用户权限信息
List<String> selectPermsByUserId(Long userId);
//查询用户的路由信息，也就是权限菜单
List<Menu> selectRouterMenuTreeByUserId(Long userId);
ResponseResult selectAllMenu(Menu menu);
ResponseResult editMenu(Menu menu);
ResponseResult deleteMenu(Long menuId);
}
第三步：impl层新增
package com.keke.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.keke.constants.SystemConstants;
import com.keke.domain.ResponseResult;
import com.keke.domain.entity.Menu;
import com.keke.domain.vo.AdminMenuVo;
import com.keke.mapper.MenuMapper;
import com.keke.service.MenuService;
import com.keke.utils.BeanCopyUtils;
import com.keke.utils.SecurityUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;
/**
* 菜单权限表(Menu)表服务实现类
*
* @author makejava
* @since 2023-10-18 20:55:48
*/
@Service("menuService")
public class MenuServiceImpl extends ServiceImpl<MenuMapper, Menu> implements MenuService {
@Autowired
private MenuService menuService;
//根据用户id查询权限关键字
@Override
public List<String> selectPermsByUserId(Long userId) {
//如果用户id为1代表管理员，roles 中只需要有admin，
// permissions中需要有所有菜单类型为C(菜单)或者F(按钮)的，状态为正常的，未被删除的权限
if(SecurityUtils.isAdmin()) {
LambdaQueryWrapper<Menu> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.in(Menu::getMenuType, SystemConstants.MENU, SystemConstants.BUTTON);
lambdaQueryWrapper.eq(Menu::getStatus, SystemConstants.STATUS_NORMAL);
//由于我们的逻辑删除字段已经配置了，所以无需封装lambdaQueryWrapper
List<Menu> menuList = list(lambdaQueryWrapper);
//我们需要的是String类型的集合，这里我们要进行数据的处理，这里采用流的方式
List<String> permissions = menuList.stream()
.map(new Function<Menu, String>() {
@Override
public String apply(Menu menu) {
String perms = menu.getPerms();
return perms;
}
})
.collect(Collectors.toList());
return permissions;
}
//否则返回这个用户所具有的权限
//这里我们需要进行连表查询，因为我们的用户先和角色关联，然后角色才跟权限关联
MenuMapper menuMapper = getBaseMapper();
//我们期望menuMapper中有一个方法可以直接帮我们去实现这个复杂的逻辑，这里直接返回
return menuMapper.selectPermsByUserId(userId);
}
@Override
public List<Menu> selectRouterMenuTreeByUserId(Long userId) {
MenuMapper menuMapper = getBaseMapper();
List<Menu> menus = null;
//如果是管理员，返回所有
if(SecurityUtils.isAdmin()){
menus = menuMapper.selectAllRoutersMenu();
}else {
//如果不是管理员，返回对应用户的菜单
menus = menuMapper.selectRoutersMenuTreeByUserId(userId);
}
//因为上面的查询都是从数据库进行查询，所以无法封装children，这里构建Tree
List<Menu> menuTree = buildMenuTree(menus,0L);
return menuTree;
}
@Override
public ResponseResult selectAllMenu(Menu menu) {
//可以针对菜单名进行模糊查询。也可以针对菜单的状态进行查询
LambdaQueryWrapper<Menu> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.like(StringUtils.hasText(menu.getMenuName()),Menu::getMenuName,menu.getMenuName());
lambdaQueryWrapper.eq(StringUtils.hasText(menu.getStatus()),Menu::getStatus,menu.getStatus());
//排序 parent_id和order_num
lambdaQueryWrapper.orderByAsc(Menu::getParentId,Menu::getOrderNum);
List<Menu> menus = list(lambdaQueryWrapper);
List<AdminMenuVo> adminMenuVos = BeanCopyUtils.copyBeanList(menus, AdminMenuVo.class);
return ResponseResult.okResult(adminMenuVos);
}
@Override
public ResponseResult editMenu(Menu menu) {
if(menu.getParentId().equals(menu.getId())){
return ResponseResult.okResult(500,"修改菜单" + "'" + menu.getMenuName() + "'" + "失败，上级菜单不能选择自己");
}
updateById(menu);
return ResponseResult.okResult();
}
@Override
public ResponseResult deleteMenu(Long menuId) {
Menu menu = menuService.getById(menuId);
//如果该菜单有子菜单，那么就提示不能删除，逻辑就是查询菜单表中是否有父菜单id是当前菜单id
LambdaQueryWrapper<Menu> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.eq(Menu::getParentId,menuId);
List<Menu> menus = list(lambdaQueryWrapper);
if(!menus.isEmpty()) {
return ResponseResult.okResult(500, "存在子菜单不允许删除");
}
removeById(menuId);
return ResponseResult.okResult();
}
/**
* 构建MenuTree
* 思路先找第一层级的菜单，就是找到id于parentId的对应关系，然后把parentId设置为Id的children
* @param menus
* @return
*/
private List<Menu> buildMenuTree(List<Menu> menus,Long parentId) {
//转化流处理
List<Menu> menuTree = menus.stream()
//过滤掉除一级菜单之外的菜单
.filter(menu -> menu.getParentId().equals(parentId))
//然后将获取其子菜单设置到children字段，并返回
.map(m -> m.setChildren(gerChildren(m, menus)))
.collect(Collectors.toList());
return menuTree;
}
//获取当前菜单的子菜单
private List<Menu> gerChildren(Menu menu, List<Menu> menus) {
//流处理，遍历每一个流对象，筛选出流对象的parentId=menu的id，即过滤
List<Menu> children = menus.stream()
.filter(m -> m.getParentId().equals(menu.getId()))
//这里其实不必要写，这一步的逻辑是如果有三级，
//可以把流对象中再过筛选出子菜单设置给对应的children并返回
.map(m -> m.setChildren(gerChildren(m,menus)))
.collect(Collectors.toList());
return children;
}
}
4.3 测试
十二、后台模块-角色列表
1. 查询角色
需要有角色列表分页查询的功能。
要求能够针对角色名称进行模糊查询。
要求能够针对状态进行查询。
要求按照role_sort进行升序排列。
1.1 接口分析
| 请求方式 | 请求路径 | 是否需求token头 |
|---|---|---|
| GET | system/role/list | 是 |
Query格式请求参数：
pageNum: 页码
pageSize: 每页条数
roleName：角色名称
status：状态响应格式：
{
"code":200,
"data":{
"rows":[
{
"id":"12",
"roleKey":"link",
"roleName":"友链审核员",
"roleSort":"1",
"status":"0"
}
],
"total":"1"
},
"msg":"操作成功"
}1.2 代码实现
第一步：新建RoleController新增
package com.keke.controller;
import com.keke.domain.ResponseResult;
import com.keke.domain.dto.ChangeRoleStatusDto;
import com.keke.domain.entity.Role;
import com.keke.service.RoleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/system/role")
public class RoleController {
@Autowired
private RoleService roleService;
@GetMapping("/list")
public ResponseResult selectPageRole(Role role,Integer pageNum,Integer pageSize){
return roleService.selectPageRole(role,pageNum,pageSize);
}
}
第二步：service层新增
package com.keke.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.keke.domain.ResponseResult;
import com.keke.domain.dto.ChangeRoleStatusDto;
import com.keke.domain.entity.Role;
import java.util.List;
/**
* 角色信息表(Role)表服务接口
*
* @author makejava
* @since 2023-10-18 21:04:06
*/
public interface RoleService extends IService<Role> {
List<String> selectRoleKeyByUserId(Long userId);
ResponseResult selectPageRole(Role role, Integer pageNum, Integer pageSize);
}
第三步：impl层新增
package com.keke.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.keke.domain.ResponseResult;
import com.keke.domain.dto.ChangeRoleStatusDto;
import com.keke.domain.entity.Role;
import com.keke.domain.vo.PageVo;
import com.keke.mapper.RoleMapper;
import com.keke.service.RoleService;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import java.util.ArrayList;
import java.util.List;
/**
* 角色信息表(Role)表服务实现类
*
* @author makejava
* @since 2023-10-18 21:04:06
*/
@Service("roleService")
public class RoleServiceImpl extends ServiceImpl<RoleMapper, Role> implements RoleService {
//根据用户id查询角色信息
@Override
public List<String> selectRoleKeyByUserId(Long userId) {
//如果userId为1，那么角色权限字符串就只需要返回一个admin
if(userId==1L){
List<String> roles = new ArrayList<>();
roles.add("admin");
return roles;
}
//如果用户id不为1，那么需要根据userId连表查询对应的roleId，然后再去角色表中去查询
//对应的角色权限字符串
//这里我们期望RoleMapper中封装一个方法去帮我们实现这个复杂的操作
RoleMapper roleMapper = getBaseMapper();
return roleMapper.selectRoleKeyByUserId(userId);
}
@Override
public ResponseResult selectPageRole(Role role, Integer pageNum, Integer pageSize) {
LambdaQueryWrapper<Role> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.like(StringUtils.hasText(role.getRoleName()),Role::getRoleName,role.getRoleName());
lambdaQueryWrapper.eq(StringUtils.hasText(role.getStatus()),Role::getStatus,role.getStatus());
lambdaQueryWrapper.orderByAsc(Role::getRoleSort);
Page<Role> page = new Page<>(pageNum,pageSize);
page(page,lambdaQueryWrapper);
PageVo pageVo = new PageVo(page.getRecords(),page.getTotal());
return ResponseResult.okResult(pageVo);
}
}
1.3 测试
2. 改变角色状态
要求能够修改角色的停启用状态
2.1 接口分析
| 请求方式 | 请求路径 | 是否需求token头 |
|---|---|---|
| PUT | system/role/changeStatus | 是 |
请求体：
{
"roleId":"11",
"status":"1"
}响应格式：
{
"code":200,
"msg":"操作成功"
}2.2 代码实现
第一步：controller层新增
package com.keke.controller;
import com.keke.domain.ResponseResult;
import com.keke.domain.dto.ChangeRoleStatusDto;
import com.keke.domain.entity.Role;
import com.keke.service.RoleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/system/role")
public class RoleController {
@Autowired
private RoleService roleService;
@GetMapping("/list")
public ResponseResult selectPageRole(Role role,Integer pageNum,Integer pageSize){
return roleService.selectPageRole(role,pageNum,pageSize);
}
@PutMapping("/changeStatus")
public ResponseResult changeRoleStatus(@RequestBody ChangeRoleStatusDto changeRoleStatusDto){
return roleService.changeRoleStatus(changeRoleStatusDto);
}
}
第二步：domain/dto新增
package com.keke.domain.dto;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class ChangeRoleStatusDto {
private Long roleId;
//角色状态（0正常 1停用）
private String status;
}
第三步：service层新增
package com.keke.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.keke.domain.ResponseResult;
import com.keke.domain.dto.ChangeRoleStatusDto;
import com.keke.domain.entity.Role;
import java.util.List;
/**
* 角色信息表(Role)表服务接口
*
* @author makejava
* @since 2023-10-18 21:04:06
*/
public interface RoleService extends IService<Role> {
List<String> selectRoleKeyByUserId(Long userId);
ResponseResult selectPageRole(Role role, Integer pageNum, Integer pageSize);
ResponseResult changeRoleStatus(ChangeRoleStatusDto changeRoleStatusDto);
}
第四步：impl层新增
package com.keke.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.keke.domain.ResponseResult;
import com.keke.domain.dto.ChangeRoleStatusDto;
import com.keke.domain.entity.Role;
import com.keke.domain.vo.PageVo;
import com.keke.mapper.RoleMapper;
import com.keke.service.RoleService;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import java.util.ArrayList;
import java.util.List;
/**
* 角色信息表(Role)表服务实现类
*
* @author makejava
* @since 2023-10-18 21:04:06
*/
@Service("roleService")
public class RoleServiceImpl extends ServiceImpl<RoleMapper, Role> implements RoleService {
//根据用户id查询角色信息
@Override
public List<String> selectRoleKeyByUserId(Long userId) {
//如果userId为1，那么角色权限字符串就只需要返回一个admin
if(userId==1L){
List<String> roles = new ArrayList<>();
roles.add("admin");
return roles;
}
//如果用户id不为1，那么需要根据userId连表查询对应的roleId，然后再去角色表中去查询
//对应的角色权限字符串
//这里我们期望RoleMapper中封装一个方法去帮我们实现这个复杂的操作
RoleMapper roleMapper = getBaseMapper();
return roleMapper.selectRoleKeyByUserId(userId);
}
@Override
public ResponseResult selectPageRole(Role role, Integer pageNum, Integer pageSize) {
LambdaQueryWrapper<Role> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.like(StringUtils.hasText(role.getRoleName()),Role::getRoleName,role.getRoleName());
lambdaQueryWrapper.eq(StringUtils.hasText(role.getStatus()),Role::getStatus,role.getStatus());
lambdaQueryWrapper.orderByAsc(Role::getRoleSort);
Page<Role> page = new Page<>(pageNum,pageSize);
page(page,lambdaQueryWrapper);
PageVo pageVo = new PageVo(page.getRecords(),page.getTotal());
return ResponseResult.okResult(pageVo);
}
@Override
public ResponseResult changeRoleStatus(ChangeRoleStatusDto changeRoleStatusDto) {
Long roleId = changeRoleStatusDto.getRoleId();
Role role = getById(roleId);
role.setStatus(changeRoleStatusDto.getStatus());
updateById(role);
return ResponseResult.okResult();
}
}
2.3 测试
把该用户启用
数据库中状态正常
3. 新增角色
需要提供新增角色的功能。新增角色时能够直接设置角色所关联的菜单权限
首先应该获取权限菜单数，勾选，然后才能新增
分析下来，有两个接口需要实现
3.1 获取菜单权限树接口
3.1.1 接口分析
| 请求方式 | 请求路径 | 是否需求token头 |
|---|---|---|
| GET | /system/menu/treeselect | 是 |
无需请求参数
响应格式：
{
"code":200,
"data":[
{
"children":[],
"id":"2023",
"label":"写博文",
"parentId":"0"
},
{
"children":[
{
"children":[
{
"children":[],
"id":"1001",
"label":"用户查询",
"parentId":"100"
},
{
"children":[],
"id":"1007",
"label":"重置密码",
"parentId":"100"
}
],
"id":"100",
"label":"用户管理",
"parentId":"1"
},
{
"children":[
{
"children":[],
"id":"2024",
"label":"友链新增",
"parentId":"2022"
},
{
"children":[],
"id":"2025",
"label":"友链修改",
"parentId":"2022"
},
{
"children":[],
"id":"2026",
"label":"友链删除",
"parentId":"2022"
},
{
"children":[],
"id":"2027",
"label":"友链查询",
"parentId":"2022"
}
],
"id":"2022",
"label":"友链管理",
"parentId":"2017"
},
{
"children":[],
"id":"2021",
"label":"标签管理",
"parentId":"2017"
}
],
"id":"2017",
"label":"内容管理",
"parentId":"0"
}
],
"msg":"操作成功"
}3.1.2 代码实现
第一步：keke-framework的domain/entity Role实体类修改如下，加上mp自填充，并且加上menuIds字段
package com.keke.domain.entity;
import java.util.Date;
import java.io.Serializable;
import java.util.List;
import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.TableField;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import com.baomidou.mybatisplus.annotation.TableName;
/**
* 角色信息表(Role)表实体类
*
* @author makejava
* @since 2023-10-18 21:03:52
*/
@SuppressWarnings("serial")
@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("sys_role")
public class Role {
//角色ID
private Long id;
//角色名称
private String roleName;
//角色权限字符串
private String roleKey;
//显示顺序
private Integer roleSort;
//角色状态（0正常 1停用）
private String status;
//删除标志（0代表存在 1代表删除）
private String delFlag;
//创建者
@TableField(fill = FieldFill.INSERT)
private Long createBy;
//创建时间
@TableField(fill = FieldFill.INSERT)
private Date createTime;
//更新者
@TableField(fill = FieldFill.INSERT_UPDATE)
private Long updateBy;
//更新时间
@TableField(fill = FieldFill.INSERT_UPDATE)
private Date updateTime;
//备注
private String remark;
//角色关联的menuIds
List<Long> menuIds;
}
第二步：vo层创建MenuTreeVo
package com.keke.domain.vo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
import java.util.List;
@Data
@NoArgsConstructor
@AllArgsConstructor
@Accessors(chain = true)
//新增角色-获取菜单下拉树列表
public class MenuTreeVo {
private static final long serialVersionUID = 1L;
/** 节点ID */
private Long id;
/** 节点名称 */
private String label;
private Long parentId;
/** 子节点 */
private List<MenuTreeVo> children;
}第三步：entity层新增RoleMenu实体类
package com.keke.domain.entity;
import java.io.Serializable;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import com.baomidou.mybatisplus.annotation.TableName;
/**
* 角色和菜单关联表(RoleMenu)表实体类
*
* @author makejava
* @since 2023-10-23 17:00:27
*/
@SuppressWarnings("serial")
@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("sys_role_menu")
public class RoleMenu {
//角色ID
private Long roleId;
//菜单ID
private Long menuId;
}
第四步：mapper层新增RoleMenuMapper
package com.keke.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.keke.domain.entity.RoleMenu;
/**
* 角色和菜单关联表(RoleMenu)表数据库访问层
*
* @author makejava
* @since 2023-10-23 17:01:09
*/
public interface RoleMenuMapper extends BaseMapper<RoleMenu> {
}
第五步：service层新增RoleMenuService
package com.keke.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.keke.domain.entity.RoleMenu;
/**
* 角色和菜单关联表(RoleMenu)表服务接口
*
* @author makejava
* @since 2023-10-23 17:01:09
*/
public interface RoleMenuService extends IService<RoleMenu> {
}
第六步：impl层新增RoleMenuServiceImpl
package com.keke.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.keke.domain.entity.RoleMenu;
import com.keke.mapper.RoleMenuMapper;
import com.keke.service.RoleMenuService;
import org.springframework.stereotype.Service;
/**
* 角色和菜单关联表(RoleMenu)表服务实现类
*
* @author makejava
* @since 2023-10-23 17:01:09
*/
@Service("roleMenuService")
public class RoleMenuServiceImpl extends ServiceImpl<RoleMenuMapper, RoleMenu> implements RoleMenuService {
}
第七步：在keke-framework工程的utils目录新建SystemConverter类，写入如下，是一个获取菜单下拉树工具类
package com.keke.utils;
import com.keke.domain.entity.Menu;
import com.keke.domain.vo.MenuTreeVo;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
public class SystemConverter {
private SystemConverter() {}
public static List<MenuTreeVo> buildMenuSelectTree(List<Menu> menus) {
List<MenuTreeVo> MenuTreeVos = menus.stream()
.map(m -> new MenuTreeVo(m.getId(), m.getMenuName(), m.getParentId(), null))
.collect(Collectors.toList());
List<MenuTreeVo> options = MenuTreeVos.stream()
.filter(o -> o.getParentId().equals(0L))
.map(o -> o.setChildren(getChildList(MenuTreeVos, o)))
.collect(Collectors.toList());
return options;
}
/**
* 得到子节点列表
*/
private static List<MenuTreeVo> getChildList(List<MenuTreeVo> list, MenuTreeVo option) {
List<MenuTreeVo> options = list.stream()
.filter(o -> Objects.equals(o.getParentId(), option.getId()))
.map(o -> o.setChildren(getChildList(list, o)))
.collect(Collectors.toList());
return options;
}
}
第八步：keke-admin的MenuController中写接口
package com.keke.controller;
import com.keke.domain.ResponseResult;
import com.keke.domain.entity.Menu;
import com.keke.domain.vo.AdminMenuVo;
import com.keke.domain.vo.MenuTreeVo;
import com.keke.service.MenuService;
import com.keke.utils.BeanCopyUtils;
import com.keke.utils.SystemConverter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RestController
@RequestMapping("/system/menu")
public class MenuController {
@Autowired
private MenuService menuService;
//查询菜单列表
@GetMapping("/list")
public ResponseResult selectAllMenu(Menu menu){
List<AdminMenuVo> adminMenuVos = menuService.selectAllMenu(menu);
return ResponseResult.okResult(adminMenuVos);
}
//新增菜单
@PostMapping
public ResponseResult add(@RequestBody Menu menu) {
menuService.save(menu);
return ResponseResult.okResult();
}
@GetMapping("/{menuId}")
public ResponseResult getInfoById(@PathVariable("menuId") Long menuId){
Menu menu = menuService.getById(menuId);
return ResponseResult.okResult(menu);
}
@PutMapping
public ResponseResult editMenu(@RequestBody Menu menu){
return menuService.editMenu(menu);
}
@DeleteMapping("/{menuId}")
public ResponseResult deleteMenu(@PathVariable("menuId") Long menuId){
return menuService.deleteMenu(menuId);
}
@GetMapping("/treeselect")
public ResponseResult treeSelect(){
//复用之前的selectMenuList方法。方法需要参数，参数可以用来进行条件查询，而这个方法不需要条件，所以直接new Menu()传入
//这样就可以获取所有的菜单了
List<AdminMenuVo> adminMenuVos = menuService.selectAllMenu(new Menu());
List<Menu> menus = BeanCopyUtils.copyBeanList(adminMenuVos, Menu.class);
List<MenuTreeVo> options = SystemConverter.buildMenuSelectTree(menus);
return ResponseResult.okResult(options);
}
}
3.1.3 测试
3.2 新增角色接口
3.2.1 接口分析
| 请求方式 | 请求路径 | 是否需求token头 |
|---|---|---|
| POST | system/role | 是 |
请求体：
{
"roleName":"测试新增角色",
"roleKey":"wds",
"roleSort":0,
"status":"0",
"menuIds":[
"1",
"100"
],
"remark":"我是角色备注"
}响应格式：
{
"code":200,
"msg":"操作成功"
}3.2.2 代码实现
第一步：domain/dto层新增
package com.keke.domain.dto;
import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.TableField;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
import java.util.List;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class AdminAddRoleDto {
//角色名称
private String roleName;
//角色权限字符串
private String roleKey;
//显示顺序
private Integer roleSort;
//角色状态（0正常 1停用）
private String status;
//备注
private String remark;
//关联的menuId
List<Long> menuIds;
}
第二步：domain/entity层新增
package com.keke.domain.entity;
import java.io.Serializable;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import com.baomidou.mybatisplus.annotation.TableName;
/**
* 角色和菜单关联表(RoleMenu)表实体类
*
* @author makejava
* @since 2023-10-23 17:00:27
*/
@SuppressWarnings("serial")
@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("sys_role_menu")
public class RoleMenu {
//角色ID
private Long roleId;
//菜单ID
private Long menuId;
}
第三步：mapper层新增RoleMenuMapper
package com.keke.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.keke.domain.entity.RoleMenu;
/**
* 角色和菜单关联表(RoleMenu)表数据库访问层
*
* @author makejava
* @since 2023-10-23 17:01:09
*/
public interface RoleMenuMapper extends BaseMapper<RoleMenu> {
}
第四步：service新增RoleMenuService
package com.keke.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.keke.domain.entity.RoleMenu;
/**
* 角色和菜单关联表(RoleMenu)表服务接口
*
* @author makejava
* @since 2023-10-23 17:01:09
*/
public interface RoleMenuService extends IService<RoleMenu> {
}
第五步：impl层新增RoleMenuServiceImpl
package com.keke.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.keke.domain.entity.RoleMenu;
import com.keke.mapper.RoleMenuMapper;
import com.keke.service.RoleMenuService;
import org.springframework.stereotype.Service;
/**
* 角色和菜单关联表(RoleMenu)表服务实现类
*
* @author makejava
* @since 2023-10-23 17:01:09
*/
@Service("roleMenuService")
public class RoleMenuServiceImpl extends ServiceImpl<RoleMenuMapper, RoleMenu> implements RoleMenuService {
}
第六步：controller的RoleController新增
package com.keke.controller;
import com.keke.domain.ResponseResult;
import com.keke.domain.dto.AdminAddRoleDto;
import com.keke.domain.dto.ChangeRoleStatusDto;
import com.keke.domain.entity.Role;
import com.keke.service.RoleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/system/role")
public class RoleController {
@Autowired
private RoleService roleService;
@GetMapping("/list")
public ResponseResult selectPageRole(Role role,Integer pageNum,Integer pageSize){
return roleService.selectPageRole(role,pageNum,pageSize);
}
@PutMapping("/changeStatus")
public ResponseResult changeRoleStatus(@RequestBody ChangeRoleStatusDto changeRoleStatusDto){
return roleService.changeRoleStatus(changeRoleStatusDto);
}
@PostMapping
public ResponseResult addRole(@RequestBody AdminAddRoleDto adminAddRoleDto){
return roleService.addRole(adminAddRoleDto);
}
}
第七步：service层的RoleService新增
package com.keke.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.keke.domain.ResponseResult;
import com.keke.domain.dto.AdminAddRoleDto;
import com.keke.domain.dto.ChangeRoleStatusDto;
import com.keke.domain.entity.Role;
import java.util.List;
/**
* 角色信息表(Role)表服务接口
*
* @author makejava
* @since 2023-10-18 21:04:06
*/
public interface RoleService extends IService<Role> {
List<String> selectRoleKeyByUserId(Long userId);
ResponseResult selectPageRole(Role role, Integer pageNum, Integer pageSize);
ResponseResult changeRoleStatus(ChangeRoleStatusDto changeRoleStatusDto);
ResponseResult addRole(AdminAddRoleDto adminAddRoleDto);
}
第八步：impl层的RoleServiceImpl新增，记得方法加上@Transactional注解
package com.keke.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.keke.domain.ResponseResult;
import com.keke.domain.dto.AdminAddRoleDto;
import com.keke.domain.dto.ChangeRoleStatusDto;
import com.keke.domain.entity.Role;
import com.keke.domain.entity.RoleMenu;
import com.keke.domain.vo.PageVo;
import com.keke.mapper.RoleMapper;
import com.keke.service.RoleMenuService;
import com.keke.service.RoleService;
import com.keke.utils.BeanCopyUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;
/**
* 角色信息表(Role)表服务实现类
*
* @author makejava
* @since 2023-10-18 21:04:06
*/
@Service("roleService")
public class RoleServiceImpl extends ServiceImpl<RoleMapper, Role> implements RoleService {
@Autowired
private RoleMenuService roleMenuService;
//根据用户id查询角色信息
@Override
public List<String> selectRoleKeyByUserId(Long userId) {
//如果userId为1，那么角色权限字符串就只需要返回一个admin
if(userId==1L){
List<String> roles = new ArrayList<>();
roles.add("admin");
return roles;
}
//如果用户id不为1，那么需要根据userId连表查询对应的roleId，然后再去角色表中去查询
//对应的角色权限字符串
//这里我们期望RoleMapper中封装一个方法去帮我们实现这个复杂的操作
RoleMapper roleMapper = getBaseMapper();
return roleMapper.selectRoleKeyByUserId(userId);
}
@Override
public ResponseResult selectPageRole(Role role, Integer pageNum, Integer pageSize) {
LambdaQueryWrapper<Role> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.like(StringUtils.hasText(role.getRoleName()),Role::getRoleName,role.getRoleName());
lambdaQueryWrapper.eq(StringUtils.hasText(role.getStatus()),Role::getStatus,role.getStatus());
lambdaQueryWrapper.orderByAsc(Role::getRoleSort);
Page<Role> page = new Page<>(pageNum,pageSize);
page(page,lambdaQueryWrapper);
PageVo pageVo = new PageVo(page.getRecords(),page.getTotal());
return ResponseResult.okResult(pageVo);
}
@Override
public ResponseResult changeRoleStatus(ChangeRoleStatusDto changeRoleStatusDto) {
Long roleId = changeRoleStatusDto.getRoleId();
Role role = getById(roleId);
role.setStatus(changeRoleStatusDto.getStatus());
updateById(role);
return ResponseResult.okResult();
}
@Transactional
@Override
public ResponseResult addRole(AdminAddRoleDto adminAddRoleDto) {
//Bean拷贝
Role role = BeanCopyUtils.copyBean(adminAddRoleDto, Role.class);
//拿到菜单权限id集合
List<Long> menuIds = adminAddRoleDto.getMenuIds();
//流式处理转化，把每一个menuId都设置到该roleId下
List<RoleMenu> roleMenuList = menuIds.stream()
.map(new Function<Long, RoleMenu>() {
@Override
public RoleMenu apply(Long menuId) {
RoleMenu roleMenu = new RoleMenu();
roleMenu.setRoleId(role.getId());
roleMenu.setMenuId(menuId);
return roleMenu;
}
}).collect(Collectors.toList());
//mp批量保存到数据库中
roleMenuService.saveBatch(roleMenuList);
//封装返回
return ResponseResult.okResult();
}
}
第九步：domain/entity的Role实体类修改四个字段为mp自动填充
package com.keke.domain.entity;
import java.util.Date;
import java.io.Serializable;
import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.TableField;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import com.baomidou.mybatisplus.annotation.TableName;
/**
* 角色信息表(Role)表实体类
*
* @author makejava
* @since 2023-10-18 21:03:52
*/
@SuppressWarnings("serial")
@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("sys_role")
public class Role {
//角色ID
private Long id;
//角色名称
private String roleName;
//角色权限字符串
private String roleKey;
//显示顺序
private Integer roleSort;
//角色状态（0正常 1停用）
private String status;
//删除标志（0代表存在 1代表删除）
private String delFlag;
//创建者
@TableField(fill = FieldFill.INSERT)
private Long createBy;
//创建时间
@TableField(fill = FieldFill.INSERT)
private Date createTime;
//更新者
@TableField(fill = FieldFill.INSERT_UPDATE)
private Long updateBy;
//更新时间
@TableField(fill = FieldFill.INSERT_UPDATE)
private Date updateTime;
//备注
private String remark;
}
3.2.3 测试
4. 修改角色
需要提供修改角色的功能。修改角色时可以修改角色所关联的菜单权限
这里可以分析到修改角色有三个接口，一个点击是修改角色后，角色信息的回显接口，回显中有一个菜单权限树接口，另一个是修改角色的接口
4.1 角色信息回显接口
4.1.1接口分析
| 请求路径 | 请求方式 | 是否需求token头 |
|---|---|---|
| system/role/{id} | Get | 是 |
请求参数PathVariable格式：
id: 角色id响应格式：
{
"code":200,
"data":{
"id":"11",
"remark":"嘎嘎嘎",
"roleKey":"aggag",
"roleName":"嘎嘎嘎",
"roleSort":"5",
"status":"0"
},
"msg":"操作成功"
}4.1.2 代码实现
第一步：controller层
package com.keke.controller;
import com.keke.domain.ResponseResult;
import com.keke.domain.dto.AdminAddRoleDto;
import com.keke.domain.dto.ChangeRoleStatusDto;
import com.keke.domain.entity.Role;
import com.keke.service.RoleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/system/role")
public class RoleController {
@Autowired
private RoleService roleService;
@GetMapping("/list")
public ResponseResult selectPageRole(Role role,Integer pageNum,Integer pageSize){
return roleService.selectPageRole(role,pageNum,pageSize);
}
@PutMapping("/changeStatus")
public ResponseResult changeRoleStatus(@RequestBody ChangeRoleStatusDto changeRoleStatusDto){
return roleService.changeRoleStatus(changeRoleStatusDto);
}
@PostMapping
public ResponseResult addRole(@RequestBody AdminAddRoleDto adminAddRoleDto){
return roleService.addRole(adminAddRoleDto);
}
@GetMapping("/{id}")
public ResponseResult getRoleInfo(@PathVariable("id") Long id){
return roleService.getRoleInfo(id);
}
}
第二步：domain/vo层新增
package com.keke.domain.vo;
import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.TableField;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class AdminRoleVo {
//角色ID
private Long id;
//角色名称
private String roleName;
//角色权限字符串
private String roleKey;
//显示顺序
private Integer roleSort;
//角色状态（0正常 1停用）
private String status;
//备注
private String remark;
}
第三步：service层
package com.keke.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.keke.domain.ResponseResult;
import com.keke.domain.dto.AdminAddRoleDto;
import com.keke.domain.dto.ChangeRoleStatusDto;
import com.keke.domain.entity.Role;
import java.util.List;
/**
* 角色信息表(Role)表服务接口
*
* @author makejava
* @since 2023-10-18 21:04:06
*/
public interface RoleService extends IService<Role> {
List<String> selectRoleKeyByUserId(Long userId);
ResponseResult selectPageRole(Role role, Integer pageNum, Integer pageSize);
ResponseResult changeRoleStatus(ChangeRoleStatusDto changeRoleStatusDto);
ResponseResult addRole(AdminAddRoleDto adminAddRoleDto);
ResponseResult getRoleInfo(Long id);
}
第四步：impl层新增
package com.keke.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.keke.domain.ResponseResult;
import com.keke.domain.dto.AdminAddRoleDto;
import com.keke.domain.dto.ChangeRoleStatusDto;
import com.keke.domain.entity.Role;
import com.keke.domain.entity.RoleMenu;
import com.keke.domain.vo.AdminRoleVo;
import com.keke.domain.vo.PageVo;
import com.keke.mapper.RoleMapper;
import com.keke.service.RoleMenuService;
import com.keke.service.RoleService;
import com.keke.utils.BeanCopyUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;
/**
* 角色信息表(Role)表服务实现类
*
* @author makejava
* @since 2023-10-18 21:04:06
*/
@Service("roleService")
public class RoleServiceImpl extends ServiceImpl<RoleMapper, Role> implements RoleService {
@Autowired
private RoleMenuService roleMenuService;
//根据用户id查询角色信息
@Override
public List<String> selectRoleKeyByUserId(Long userId) {
//如果userId为1，那么角色权限字符串就只需要返回一个admin
if(userId==1L){
List<String> roles = new ArrayList<>();
roles.add("admin");
return roles;
}
//如果用户id不为1，那么需要根据userId连表查询对应的roleId，然后再去角色表中去查询
//对应的角色权限字符串
//这里我们期望RoleMapper中封装一个方法去帮我们实现这个复杂的操作
RoleMapper roleMapper = getBaseMapper();
return roleMapper.selectRoleKeyByUserId(userId);
}
@Override
public ResponseResult selectPageRole(Role role, Integer pageNum, Integer pageSize) {
LambdaQueryWrapper<Role> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.like(StringUtils.hasText(role.getRoleName()),Role::getRoleName,role.getRoleName());
lambdaQueryWrapper.eq(StringUtils.hasText(role.getStatus()),Role::getStatus,role.getStatus());
lambdaQueryWrapper.orderByAsc(Role::getRoleSort);
Page<Role> page = new Page<>(pageNum,pageSize);
page(page,lambdaQueryWrapper);
PageVo pageVo = new PageVo(page.getRecords(),page.getTotal());
return ResponseResult.okResult(pageVo);
}
@Override
public ResponseResult changeRoleStatus(ChangeRoleStatusDto changeRoleStatusDto) {
Long roleId = changeRoleStatusDto.getRoleId();
Role role = getById(roleId);
role.setStatus(changeRoleStatusDto.getStatus());
updateById(role);
return ResponseResult.okResult();
}
@Transactional
@Override
public ResponseResult addRole(AdminAddRoleDto adminAddRoleDto) {
//Bean拷贝
Role role = BeanCopyUtils.copyBean(adminAddRoleDto, Role.class);
//拿到菜单权限id集合
List<Long> menuIds = adminAddRoleDto.getMenuIds();
//流式处理转化，把每一个menuId都设置到该roleId下
List<RoleMenu> roleMenuList = menuIds.stream()
.map(new Function<Long, RoleMenu>() {
@Override
public RoleMenu apply(Long menuId) {
RoleMenu roleMenu = new RoleMenu();
roleMenu.setRoleId(role.getId());
roleMenu.setMenuId(menuId);
return roleMenu;
}
}).collect(Collectors.toList());
//mp批量保存到数据库中
roleMenuService.saveBatch(roleMenuList);
//封装返回
return ResponseResult.okResult();
}
@Override
public ResponseResult getRoleInfo(Long id) {
Role role = getById(id);
AdminRoleVo adminRoleVo = BeanCopyUtils.copyBean(role, AdminRoleVo.class);
return ResponseResult.okResult(adminRoleVo);
}
}
4.1.3 测试
回显成功
4.2 对应角色菜单权限树接口
4.2.1 接口分析
| 请求方式 | 请求路径 | 是否需求token头 |
|---|---|---|
| Get | /system/menu/roleMenuTreeselect/{id} | 是 |
请求参数PathVariable格式：
id: 角色id响应格式：
字段介绍
menus：菜单树
checkedKeys：角色所关联的菜单权限id列表
{
"code":200,
"data":{
"menus":[
{
"children":[],
"id":"2023",
"label":"写博文",
"parentId":"0"
},
{
"children":[
{
"children":[
{
"children":[],
"id":"1001",
"label":"用户查询",
"parentId":"100"
},
{
"children":[],
"id":"1002",
"label":"用户新增",
"parentId":"100"
},
{
"children":[],
"id":"1003",
"label":"用户修改",
"parentId":"100"
},
{
"children":[],
"id":"1004",
"label":"用户删除",
"parentId":"100"
},
{
"children":[],
"id":"1005",
"label":"用户导出",
"parentId":"100"
},
{
"children":[],
"id":"1006",
"label":"用户导入",
"parentId":"100"
},
{
"children":[],
"id":"1007",
"label":"重置密码",
"parentId":"100"
}
],
"id":"100",
"label":"用户管理",
"parentId":"1"
},
{
"children":[
{
"children":[],
"id":"1008",
"label":"角色查询",
"parentId":"101"
},
{
"children":[],
"id":"1009",
"label":"角色新增",
"parentId":"101"
},
{
"children":[],
"id":"1010",
"label":"角色修改",
"parentId":"101"
},
{
"children":[],
"id":"1011",
"label":"角色删除",
"parentId":"101"
},
{
"children":[],
"id":"1012",
"label":"角色导出",
"parentId":"101"
}
],
"id":"101",
"label":"角色管理",
"parentId":"1"
},
{
"children":[
{
"children":[],
"id":"1013",
"label":"菜单查询",
"parentId":"102"
},
{
"children":[],
"id":"1014",
"label":"菜单新增",
"parentId":"102"
},
{
"children":[],
"id":"1015",
"label":"菜单修改",
"parentId":"102"
},
{
"children":[],
"id":"1016",
"label":"菜单删除",
"parentId":"102"
}
],
"id":"102",
"label":"菜单管理",
"parentId":"1"
}
],
"id":"1",
"label":"系统管理",
"parentId":"0"
},
{
"children":[
{
"children":[],
"id":"2019",
"label":"文章管理",
"parentId":"2017"
},
{
"children":[
{
"children":[],
"id":"2028",
"label":"导出分类",
"parentId":"2018"
}
],
"id":"2018",
"label":"分类管理",
"parentId":"2017"
},
{
"children":[
{
"children":[],
"id":"2024",
"label":"友链新增",
"parentId":"2022"
},
{
"children":[],
"id":"2025",
"label":"友链修改",
"parentId":"2022"
},
{
"children":[],
"id":"2026",
"label":"友链删除",
"parentId":"2022"
},
{
"children":[],
"id":"2027",
"label":"友链查询",
"parentId":"2022"
}
],
"id":"2022",
"label":"友链管理",
"parentId":"2017"
},
{
"children":[],
"id":"2021",
"label":"标签管理",
"parentId":"2017"
}
],
"id":"2017",
"label":"内容管理",
"parentId":"0"
}
],
"checkedKeys":[
"1001"
]
},
"msg":"操作成功"
}4.2.2 代码实现
第一步：vo层新建RoleMenuTreeSelectVo，用于响应返回
package com.keke.domain.vo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.List;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class RoleMenuTreeSelectVo {
private List<MenuTreeVo> menus;
private List<Long> checkedKeys;
}
第二步: 把keke-framework工程的MenuService接口修改为如下，增加了 '根据角色id查询对应角色菜单列表树' 的接口
package com.keke.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.keke.domain.ResponseResult;
import com.keke.domain.entity.Menu;
import com.keke.domain.vo.AdminMenuVo;
import java.util.List;
/**
* 菜单权限表(Menu)表服务接口
*
* @author makejava
* @since 2023-10-18 20:55:48
*/
public interface MenuService extends IService<Menu> {
//查询用户权限信息
List<String> selectPermsByUserId(Long userId);
//查询用户的路由信息，也就是权限菜单
List<Menu> selectRouterMenuTreeByUserId(Long userId);
List<AdminMenuVo> selectAllMenu(Menu menu);
ResponseResult editMenu(Menu menu);
ResponseResult deleteMenu(Long menuId);
List<Long> selectMenuListByRoleId(Long roleId);
}
第三步：MenuServiceImpl
package com.keke.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.keke.constants.SystemConstants;
import com.keke.domain.ResponseResult;
import com.keke.domain.entity.Menu;
import com.keke.domain.vo.AdminMenuVo;
import com.keke.mapper.MenuMapper;
import com.keke.service.MenuService;
import com.keke.utils.BeanCopyUtils;
import com.keke.utils.SecurityUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;
/**
* 菜单权限表(Menu)表服务实现类
*
* @author makejava
* @since 2023-10-18 20:55:48
*/
@Service("menuService")
public class MenuServiceImpl extends ServiceImpl<MenuMapper, Menu> implements MenuService {
@Autowired
private MenuService menuService;
//根据用户id查询权限关键字
@Override
public List<String> selectPermsByUserId(Long userId) {
//如果用户id为1代表管理员，roles 中只需要有admin，
// permissions中需要有所有菜单类型为C(菜单)或者F(按钮)的，状态为正常的，未被删除的权限
if(SecurityUtils.isAdmin()) {
LambdaQueryWrapper<Menu> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.in(Menu::getMenuType, SystemConstants.MENU, SystemConstants.BUTTON);
lambdaQueryWrapper.eq(Menu::getStatus, SystemConstants.STATUS_NORMAL);
//由于我们的逻辑删除字段已经配置了，所以无需封装lambdaQueryWrapper
List<Menu> menuList = list(lambdaQueryWrapper);
//我们需要的是String类型的集合，这里我们要进行数据的处理，这里采用流的方式
List<String> permissions = menuList.stream()
.map(new Function<Menu, String>() {
@Override
public String apply(Menu menu) {
String perms = menu.getPerms();
return perms;
}
})
.collect(Collectors.toList());
return permissions;
}
//否则返回这个用户所具有的权限
//这里我们需要进行连表查询，因为我们的用户先和角色关联，然后角色才跟权限关联
MenuMapper menuMapper = getBaseMapper();
//我们期望menuMapper中有一个方法可以直接帮我们去实现这个复杂的逻辑，这里直接返回
return menuMapper.selectPermsByUserId(userId);
}
@Override
public List<Menu> selectRouterMenuTreeByUserId(Long userId) {
MenuMapper menuMapper = getBaseMapper();
List<Menu> menus = null;
//如果是管理员，返回所有
if(SecurityUtils.isAdmin()){
menus = menuMapper.selectAllRoutersMenu();
}else {
//如果不是管理员，返回对应用户的菜单
menus = menuMapper.selectRoutersMenuTreeByUserId(userId);
}
//因为上面的查询都是从数据库进行查询，所以无法封装children，这里构建Tree
List<Menu> menuTree = buildMenuTree(menus,0L);
return menuTree;
}
@Override
public List<AdminMenuVo> selectAllMenu(Menu menu) {
//可以针对菜单名进行模糊查询。也可以针对菜单的状态进行查询
LambdaQueryWrapper<Menu> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.like(StringUtils.hasText(menu.getMenuName()),Menu::getMenuName,menu.getMenuName());
lambdaQueryWrapper.eq(StringUtils.hasText(menu.getStatus()),Menu::getStatus,menu.getStatus());
//排序 parent_id和order_num
lambdaQueryWrapper.orderByAsc(Menu::getParentId,Menu::getOrderNum);
List<Menu> menus = list(lambdaQueryWrapper);
List<AdminMenuVo> adminMenuVos = BeanCopyUtils.copyBeanList(menus, AdminMenuVo.class);
return adminMenuVos;
}
@Override
public ResponseResult editMenu(Menu menu) {
if(menu.getParentId().equals(menu.getId())){
return ResponseResult.okResult(500,"修改菜单" + "'" + menu.getMenuName() + "'" + "失败，上级菜单不能选择自己");
}
updateById(menu);
return ResponseResult.okResult();
}
@Override
public ResponseResult deleteMenu(Long menuId) {
Menu menu = menuService.getById(menuId);
//如果该菜单有子菜单，那么就提示不能删除，逻辑就是查询菜单表中是否有父菜单id是当前菜单id
LambdaQueryWrapper<Menu> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.eq(Menu::getParentId,menuId);
List<Menu> menus = list(lambdaQueryWrapper);
if(!menus.isEmpty()) {
return ResponseResult.okResult(500, "存在子菜单不允许删除");
}
removeById(menuId);
return ResponseResult.okResult();
}
@Override
public List<Long> selectMenuListByRoleId(Long roleId) {
return getBaseMapper().selectMenuListByRoleId(roleId);
}
/**
* 构建MenuTree
* 思路先找第一层级的菜单，就是找到id于parentId的对应关系，然后把parentId设置为Id的children
* @param menus
* @return
*/
private List<Menu> buildMenuTree(List<Menu> menus,Long parentId) {
//转化流处理
List<Menu> menuTree = menus.stream()
//过滤掉除一级菜单之外的菜单
.filter(menu -> menu.getParentId().equals(parentId))
//然后将获取其子菜单设置到children字段，并返回
.map(m -> m.setChildren(gerChildren(m, menus)))
.collect(Collectors.toList());
return menuTree;
}
//获取当前菜单的子菜单
private List<Menu> gerChildren(Menu menu, List<Menu> menus) {
//流处理，遍历每一个流对象，筛选出流对象的parentId=menu的id，即过滤
List<Menu> children = menus.stream()
.filter(m -> m.getParentId().equals(menu.getId()))
//这里其实不必要写，这一步的逻辑是如果有三级，
//可以把流对象中再过筛选出子菜单设置给对应的children并返回
.map(m -> m.setChildren(gerChildren(m,menus)))
.collect(Collectors.toList());
return children;
}
}
第四步：MenuMapper新增
package com.keke.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.keke.domain.entity.Menu;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;
/**
* 菜单权限表(Menu)表数据库访问层
*
* @author makejava
* @since 2023-10-18 20:55:48
*/
@Mapper
public interface MenuMapper extends BaseMapper<Menu> {
//Mapper的实现类对应xml映射文件
List<String> selectPermsByUserId(Long userId);
List<Menu> selectAllRoutersMenu();
List<Menu> selectRoutersMenuTreeByUserId(Long userId);
List<Long> selectMenuListByRoleId(Long roleId);
}
第五步: 把keke-framework工程的resources/mapper目录的MenuMapper.xml修改为如下，增加了 '根据角色id查询对应角色菜单列表树' 的具体实现代码
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.keke.mapper.MenuMapper">
<select id="selectPermsByUserId" resultType="java.lang.String">
-- 这里的逻辑是先用userId连表查询roleId，再用roleId连表查询menuId，再根据menuId
-- 查询对应的用户权限
select
DISTINCT m.`perms`
from `sys_user_role` ur
left join `sys_role_menu` rm on ur.`role_id`=rm.`role_id`
left join `sys_menu` m on m.`id`=rm.`menu_id`
where
ur.`user_id`=#{userId} and
m.`menu_type` in ('C','F') and
m.`status`=0 and
m.`del_flag`=0
</select>
<select id="selectAllRoutersMenu" resultType="com.keke.domain.entity.Menu">
-- 这里与上面的sql差不多，只是menu_type有差别，还有查询的字段个数
SELECT
DISTINCT m.id, m.parent_id, m.menu_name, m.path, m.component, m.visible, m.status,
IFNULL(m.perms,'') AS perms, m.is_frame, m.menu_type, m.icon, m.order_num, m.create_time
FROM
`sys_menu` m
WHERE
-- 查询所有的，所以不需要加userId的条件
m.`menu_type` IN ('C','M') AND
m.`status` = 0 AND
m.`del_flag` = 0
ORDER BY
m.parent_id,m.order_num
</select>
<select id="selectRoutersMenuTreeByUserId" resultType="com.keke.domain.entity.Menu">
-- 这里与上面的sql差不多
SELECT
DISTINCT m.id, m.parent_id, m.menu_name, m.path, m.component, m.visible, m.status,
IFNULL(m.perms,'') AS perms, m.is_frame, m.menu_type, m.icon, m.order_num, m.create_time
FROM
`sys_user_role` ur
LEFT JOIN `sys_role_menu` rm ON ur.`role_id` = rm.`role_id`
LEFT JOIN `sys_menu` m ON m.`id` = rm.`menu_id`
WHERE
ur.`user_id` = #{userId} AND
m.`menu_type` IN ('C','M') AND
m.`status` = 0 AND
m.`del_flag` = 0
ORDER BY
m.parent_id,m.order_num
</select>
<select id="selectMenuListByRoleId" resultType="java.lang.Long">
select m.id
from sys_menu m
left join sys_role_menu rm on m.id = rm.menu_id
where rm.role_id = #{roleId}
order by m.parent_id, m.order_num
</select>
</mapper>第六步：MenuController
package com.keke.controller;
import com.keke.domain.ResponseResult;
import com.keke.domain.entity.Menu;
import com.keke.domain.vo.AdminMenuVo;
import com.keke.domain.vo.MenuTreeVo;
import com.keke.domain.vo.RoleMenuTreeSelectVo;
import com.keke.service.MenuService;
import com.keke.utils.BeanCopyUtils;
import com.keke.utils.SystemConverter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.parameters.P;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RestController
@RequestMapping("/system/menu")
public class MenuController {
@Autowired
private MenuService menuService;
//查询菜单列表
@GetMapping("/list")
public ResponseResult selectAllMenu(Menu menu){
List<AdminMenuVo> adminMenuVos = menuService.selectAllMenu(menu);
return ResponseResult.okResult(adminMenuVos);
}
//新增菜单
@PostMapping
public ResponseResult add(@RequestBody Menu menu) {
menuService.save(menu);
return ResponseResult.okResult();
}
@GetMapping("/{menuId}")
public ResponseResult getInfoById(@PathVariable("menuId") Long menuId){
Menu menu = menuService.getById(menuId);
return ResponseResult.okResult(menu);
}
@GetMapping("/roleMenuTreeselect/{id}")
public ResponseResult selectMenuListByRoleId(@PathVariable("id") Long roleId){
List<AdminMenuVo> adminMenuVos = menuService.selectAllMenu(new Menu());
List<Menu> menus = BeanCopyUtils.copyBeanList(adminMenuVos, Menu.class);
List<Long> checkedKeys = menuService.selectMenuListByRoleId(roleId);
List<MenuTreeVo> menuTreeVos = SystemConverter.buildMenuSelectTree(menus);
RoleMenuTreeSelectVo roleMenuTreeSelectVo = new RoleMenuTreeSelectVo(menuTreeVos,checkedKeys);
return ResponseResult.okResult(roleMenuTreeSelectVo);
}
@PutMapping
public ResponseResult editMenu(@RequestBody Menu menu){
return menuService.editMenu(menu);
}
@DeleteMapping("/{menuId}")
public ResponseResult deleteMenu(@PathVariable("menuId") Long menuId){
return menuService.deleteMenu(menuId);
}
@GetMapping("/treeselect")
public ResponseResult treeSelect(){
//复用之前的selectMenuList方法。方法需要参数，参数可以用来进行条件查询，而这个方法不需要条件，所以直接new Menu()传入
//这样就可以获取所有的菜单了
List<AdminMenuVo> adminMenuVos = menuService.selectAllMenu(new Menu());
List<Menu> menus = BeanCopyUtils.copyBeanList(adminMenuVos, Menu.class);
List<MenuTreeVo> options = SystemConverter.buildMenuSelectTree(menus);
return ResponseResult.okResult(options);
}
}
4.2.3 测试
可用看到回显出了对应角色的权限信息
4.3 修改角色接口
4.3.1 接口分析
| 请求方式 | 请求路径 | 是否需求token头 |
|---|---|---|
| PUT | system/role | 是 |
请求体：
{
"id":"13",
"remark":"我是角色备注",
"roleKey":"wds",
"roleName":"测试新增角色",
"roleSort":0,
"status":"0",
"menuIds":[
"1",
"100",
"1001"
]
}响应体
{
"code":200,
"msg":"操作成功"
}4.3.2 代码实现
第一步：domain/dto层新增
package com.keke.domain.dto;
import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.TableField;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
import java.util.List;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class EditRoleDto {
//角色ID
private Long id;
//角色名称
private String roleName;
//角色权限字符串
private String roleKey;
//显示顺序
private Integer roleSort;
//角色状态（0正常 1停用）
private String status;
//备注
private String remark;
//权限id
private List<Long> menuIds;
}
第二步：controller层新增EditRole接口
package com.keke.controller;
import com.keke.domain.ResponseResult;
import com.keke.domain.dto.AdminAddRoleDto;
import com.keke.domain.dto.ChangeRoleStatusDto;
import com.keke.domain.dto.EditRoleDto;
import com.keke.domain.entity.Role;
import com.keke.service.RoleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/system/role")
public class RoleController {
@Autowired
private RoleService roleService;
@GetMapping("/list")
public ResponseResult selectPageRole(Role role,Integer pageNum,Integer pageSize){
return roleService.selectPageRole(role,pageNum,pageSize);
}
@PutMapping("/changeStatus")
public ResponseResult changeRoleStatus(@RequestBody ChangeRoleStatusDto changeRoleStatusDto){
return roleService.changeRoleStatus(changeRoleStatusDto);
}
@PostMapping
public ResponseResult addRole(@RequestBody AdminAddRoleDto adminAddRoleDto){
return roleService.addRole(adminAddRoleDto);
}
@GetMapping("/{id}")
public ResponseResult getRoleInfo(@PathVariable("id") Long id){
return roleService.getRoleInfo(id);
}
@PutMapping
public ResponseResult editRole(@RequestBody EditRoleDto editRoleDto){
return roleService.editRole(editRoleDto);
}
}
第二步：service新增
package com.keke.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.keke.domain.ResponseResult;
import com.keke.domain.dto.AdminAddRoleDto;
import com.keke.domain.dto.ChangeRoleStatusDto;
import com.keke.domain.dto.EditRoleDto;
import com.keke.domain.entity.Role;
import java.util.List;
/**
* 角色信息表(Role)表服务接口
*
* @author makejava
* @since 2023-10-18 21:04:06
*/
public interface RoleService extends IService<Role> {
List<String> selectRoleKeyByUserId(Long userId);
ResponseResult selectPageRole(Role role, Integer pageNum, Integer pageSize);
ResponseResult changeRoleStatus(ChangeRoleStatusDto changeRoleStatusDto);
ResponseResult addRole(AdminAddRoleDto adminAddRoleDto);
ResponseResult getRoleInfo(Long id);
ResponseResult editRole(EditRoleDto editRoleDto);
}
第三步：impl新增，逻辑和添加用户一样
package com.keke.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.keke.domain.ResponseResult;
import com.keke.domain.dto.AdminAddRoleDto;
import com.keke.domain.dto.ChangeRoleStatusDto;
import com.keke.domain.dto.EditRoleDto;
import com.keke.domain.entity.Role;
import com.keke.domain.entity.RoleMenu;
import com.keke.domain.vo.AdminRoleVo;
import com.keke.domain.vo.PageVo;
import com.keke.mapper.RoleMapper;
import com.keke.service.RoleMenuService;
import com.keke.service.RoleService;
import com.keke.utils.BeanCopyUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;
/**
* 角色信息表(Role)表服务实现类
*
* @author makejava
* @since 2023-10-18 21:04:06
*/
@Service("roleService")
public class RoleServiceImpl extends ServiceImpl<RoleMapper, Role> implements RoleService {
@Autowired
private RoleMenuService roleMenuService;
//根据用户id查询角色信息
@Override
public List<String> selectRoleKeyByUserId(Long userId) {
//如果userId为1，那么角色权限字符串就只需要返回一个admin
if(userId==1L){
List<String> roles = new ArrayList<>();
roles.add("admin");
return roles;
}
//如果用户id不为1，那么需要根据userId连表查询对应的roleId，然后再去角色表中去查询
//对应的角色权限字符串
//这里我们期望RoleMapper中封装一个方法去帮我们实现这个复杂的操作
RoleMapper roleMapper = getBaseMapper();
return roleMapper.selectRoleKeyByUserId(userId);
}
@Override
public ResponseResult selectPageRole(Role role, Integer pageNum, Integer pageSize) {
LambdaQueryWrapper<Role> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.like(StringUtils.hasText(role.getRoleName()),Role::getRoleName,role.getRoleName());
lambdaQueryWrapper.eq(StringUtils.hasText(role.getStatus()),Role::getStatus,role.getStatus());
lambdaQueryWrapper.orderByAsc(Role::getRoleSort);
Page<Role> page = new Page<>(pageNum,pageSize);
page(page,lambdaQueryWrapper);
PageVo pageVo = new PageVo(page.getRecords(),page.getTotal());
return ResponseResult.okResult(pageVo);
}
@Override
public ResponseResult changeRoleStatus(ChangeRoleStatusDto changeRoleStatusDto) {
Long roleId = changeRoleStatusDto.getRoleId();
Role role = getById(roleId);
role.setStatus(changeRoleStatusDto.getStatus());
updateById(role);
return ResponseResult.okResult();
}
@Transactional
@Override
public ResponseResult addRole(AdminAddRoleDto adminAddRoleDto) {
//Bean拷贝
Role role = BeanCopyUtils.copyBean(adminAddRoleDto, Role.class);
//拿到菜单权限id集合
List<Long> menuIds = adminAddRoleDto.getMenuIds();
//流式处理转化，把每一个menuId都设置到该roleId下
List<RoleMenu> roleMenuList = menuIds.stream()
.map(new Function<Long, RoleMenu>() {
@Override
public RoleMenu apply(Long menuId) {
RoleMenu roleMenu = new RoleMenu();
roleMenu.setRoleId(role.getId());
roleMenu.setMenuId(menuId);
return roleMenu;
}
}).collect(Collectors.toList());
//mp批量保存到数据库中
roleMenuService.saveBatch(roleMenuList);
//封装返回
return ResponseResult.okResult();
}
@Override
public ResponseResult getRoleInfo(Long id) {
Role role = getById(id);
AdminRoleVo adminRoleVo = BeanCopyUtils.copyBean(role, AdminRoleVo.class);
return ResponseResult.okResult(adminRoleVo);
}
@Override
public ResponseResult editRole(EditRoleDto editRoleDto) {
Role role = BeanCopyUtils.copyBean(editRoleDto, Role.class);
List<Long> menuIds = editRoleDto.getMenuIds();
List<RoleMenu> roleMenuList = menuIds.stream()
.map(new Function<Long, RoleMenu>() {
@Override
public RoleMenu apply(Long menuId) {
RoleMenu roleMenu = new RoleMenu();
roleMenu.setRoleId(role.getId());
roleMenu.setMenuId(menuId);
return roleMenu;
}
}).collect(Collectors.toList());
roleMenuService.saveBatch(roleMenuList);
return ResponseResult.okResult();
}
}
4.3.3 测试
可用新增角色，并且赋予其相应的菜单权限
5. 删除角色
删除固定的某个角色（逻辑删除）
5.1 接口分析
| 请求方式 | 请求路径 | 是否需求token头 |
|---|---|---|
| DELETE | system/role/{id} | 是 |
请求参数PathVariable格式：
id：要删除的角色id响应格式：
{
"code":200,
"msg":"操作成功"
}5.2 代码实现
controller层新增接口，逻辑较少直接写
package com.keke.controller;
import com.keke.domain.ResponseResult;
import com.keke.domain.dto.AdminAddRoleDto;
import com.keke.domain.dto.ChangeRoleStatusDto;
import com.keke.domain.dto.EditRoleDto;
import com.keke.domain.entity.Role;
import com.keke.service.RoleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/system/role")
public class RoleController {
@Autowired
private RoleService roleService;
@GetMapping("/list")
public ResponseResult selectPageRole(Role role,Integer pageNum,Integer pageSize){
return roleService.selectPageRole(role,pageNum,pageSize);
}
@PutMapping("/changeStatus")
public ResponseResult changeRoleStatus(@RequestBody ChangeRoleStatusDto changeRoleStatusDto){
return roleService.changeRoleStatus(changeRoleStatusDto);
}
@PostMapping
public ResponseResult addRole(@RequestBody AdminAddRoleDto adminAddRoleDto){
return roleService.addRole(adminAddRoleDto);
}
@GetMapping("/{id}")
public ResponseResult getRoleInfo(@PathVariable("id") Long id){
return roleService.getRoleInfo(id);
}
@PutMapping
public ResponseResult editRole(@RequestBody EditRoleDto editRoleDto){
return roleService.editRole(editRoleDto);
}
@DeleteMapping("/{id}")
public ResponseResult deleteRoleById(@PathVariable("id") Long id){
roleService.removeById(id);
return ResponseResult.okResult();
}
}
5.3 测试
只是逻辑删除
十三、后台模块-用户列表
1. 查询用户
需要用户分页列表接口。
可以根据用户名模糊搜索。
可以进行手机号的搜索。
可以进行状态的查询。
1.1 接口分析
| 请求方式 | 请求路径 | 是否需求token头 |
|---|---|---|
| GET | system/user/list | 是 |
请求参数query格式：
pageNum: 页码
pageSize: 每页条数
userName：用户名
phonenumber：手机号
status:状态响应格式：
{
"code":200,
"data":{
"rows":[
{
"avatar":"http://r7yxkqloa.bkt.clouddn.com/2022/03/05/75fd15587811443a9a9a771f24da458d.png",
"createTime":"2022-01-05 17:01:56",
"email":"23412332@qq.com",
"id":"1",
"nickName":"sg3334",
"phonenumber":"18888888888",
"sex":"1",
"status":"0",
"updateBy":"1",
"updateTime":"2022-03-13 21:36:22",
"userName":"sg"
}
],
"total":"1"
},
"msg":"操作成功"
}1.2 代码实现
第一步：keke-admin的controller层新建UserController
package com.keke.controller;
import com.keke.domain.ResponseResult;
import com.keke.domain.entity.User;
import com.keke.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/system/user")
public class UserController {
@Autowired
private UserService userService;
@GetMapping("/list")
public ResponseResult selectPageUser(User user, Integer pageNum, Integer pageSize){
return userService.selectPageUser(user,pageNum,pageSize);
}
}
第二步：service层
package com.keke.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.keke.domain.ResponseResult;
import com.keke.domain.dto.RegisterUserDto;
import com.keke.domain.dto.UserInfoDto;
import com.keke.domain.entity.User;
import org.springframework.stereotype.Service;
/**
* 用户表(User)表服务接口
*
* @author makejava
* @since 2023-10-13 09:08:38
*/
public interface UserService extends IService<User> {
ResponseResult userInfo();
ResponseResult updateUserInfo(UserInfoDto userInfoDto);
ResponseResult register(RegisterUserDto registerUserDto);
//后台接口分页查询用户
ResponseResult selectPageUser(User user, Integer pageNum, Integer pageSize);
}
第三步：impl层
package com.keke.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.keke.domain.ResponseResult;
import com.keke.domain.dto.RegisterUserDto;
import com.keke.domain.dto.UserInfoDto;
import com.keke.domain.entity.User;
import com.keke.domain.vo.PageVo;
import com.keke.domain.vo.UserInfoVo;
import com.keke.enums.AppHttpCodeEnum;
import com.keke.handler.exception.exception.SystemException;
import com.keke.mapper.UserMapper;
import com.keke.service.UserService;
import com.keke.utils.BeanCopyUtils;
import com.keke.utils.SecurityUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
/**
* 用户表(User)表服务实现类
*
* @author makejava
* @since 2023-10-13 10:12:51
*/
@Service("userService")
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
@Autowired
private PasswordEncoder passwordEncoder;
@Override
public ResponseResult userInfo() {
Long userId = SecurityUtils.getUserId();
User user = getById(userId);
UserInfoVo userInfoVo = BeanCopyUtils.copyBean(user, UserInfoVo.class);
return ResponseResult.okResult(userInfoVo);
}
@Override
public ResponseResult updateUserInfo(UserInfoDto userInfoDto) {
User user = BeanCopyUtils.copyBean(userInfoDto, User.class);
updateById(user);
return ResponseResult.okResult();
}
@Override
public ResponseResult register(RegisterUserDto registerUserDto) {
//对前端传过来的用户名进行非空判断，例如null、""，就抛出异常
if(!StringUtils.hasText(registerUserDto.getUserName())){
//SystemException是我们写的异常类、AppHttpCodeEnum是我们写的枚举类
throw new SystemException(AppHttpCodeEnum.USERNAME_NOT_NULL);
}
//密码
if(!StringUtils.hasText(registerUserDto.getPassword())){
throw new SystemException(AppHttpCodeEnum.PASSWORD_NOT_NULL);
}
//邮箱
if(!StringUtils.hasText(registerUserDto.getEmail())){
throw new SystemException(AppHttpCodeEnum.EMAIL_NOT_NULL);
}
//昵称
if(!StringUtils.hasText(registerUserDto.getNickName())){
throw new SystemException(AppHttpCodeEnum.NICKNAME_NOT_NULL);
}
//判断用户传给我们的用户名是否在数据库已经存在。userNameExist方法是下面定义的
if(userNameExist(registerUserDto.getUserName())){
//SystemException是我们写的异常类、AppHttpCodeEnum是我们写的枚举类
throw new SystemException(AppHttpCodeEnum.USERNAME_EXIST);
}
//判断用户传给我们的昵称是否在数据库已经存在。NickNameExist方法是下面定义的
if(nickNameExist(registerUserDto.getNickName())){
//SystemException是我们写的异常类、AppHttpCodeEnum是我们写的枚举类
throw new SystemException(AppHttpCodeEnum.NICKNAME_EXIST);
}
//判断用户传给我们的邮箱是否在数据库已经存在。NickNameExist方法是下面定义的
if(emailExist(registerUserDto.getEmail())){
//SystemException是我们写的异常类、AppHttpCodeEnum是我们写的枚举类
throw new SystemException(AppHttpCodeEnum.EMAIL_EXIST);
}
//经过上面的判断，可以确保用户传给我们的用户名和昵称是数据库不存在的，且相关字段都不为空。就可以存入数据库
//注意用户传给我们的密码是明文，对于密码我们要转成密文之后再存入数据库。注意加密要和解密用同一套算法
//keke-blog工程的securityConfig类里面有解密算法，当时我们写了一个passwordEncoder方法，并且注入到了spring容器
//解密
String encodePassword = passwordEncoder.encode(registerUserDto.getPassword());
//封装成user存数据库中
User user = BeanCopyUtils.copyBean(registerUserDto, User.class);
//设置密码为加密的密码
user.setPassword(encodePassword);
//存入数据库中
save(user);
//封装返回
return ResponseResult.okResult();
}
@Override
public ResponseResult selectPageUser(User user, Integer pageNum, Integer pageSize) {
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
//可以根据用户名模糊搜索
lambdaQueryWrapper.like(StringUtils.hasText(user.getUserName()),User::getUserName,user.getUserName());
//可以进行手机号的搜索
lambdaQueryWrapper.eq(StringUtils.hasText(user.getPhonenumber()),User::getPhonenumber,user.getPhonenumber());
//可以根据状态进行搜索
lambdaQueryWrapper.eq(StringUtils.hasText(user.getStatus()),User::getStatus,user.getStatus());
//mp分页器
Page<User> page = new Page<>(pageNum,pageSize);
page(page,lambdaQueryWrapper);
//封装vo
PageVo pageVo = new PageVo(page.getRecords(),page.getTotal());
//响应返回
return ResponseResult.okResult(pageVo);
}
//'判断用户传给我们的用户名是否在数据库已经存在' 的方法
public boolean userNameExist(String userName){
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
//查询数据库中有用户名相同的数据没有
lambdaQueryWrapper.eq(User::getUserName,userName);
//如果查出来有，就说明存在，返回true
int count = count(lambdaQueryWrapper);
return count>0;
}
//'判断用户传给我们的昵称是否在数据库已经存在' 的方法
public boolean nickNameExist(String nickName){
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
//查询数据库中有用户名相同的数据没有
lambdaQueryWrapper.eq(User::getNickName,nickName);
//如果查出来有，就说明存在，返回true
int count = count(lambdaQueryWrapper);
return count>0;
}
//'判断用户传给我们的邮箱是否在数据库已经存在' 的方法
public boolean emailExist(String email){
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
//查询数据库中有用户名相同的数据没有
lambdaQueryWrapper.eq(User::getEmail,email);
//如果查出来有，就说明存在，返回true
int count = count(lambdaQueryWrapper);
return count>0;
}
}
1.3 测试
2. 新增用户
需要新增用户功能。新增用户时可以直接关联角色。
注意：新增用户时注意密码加密存储。
用户名不能为空，否则提示：必需填写用户名
用户名必须之前未存在，否则提示：用户名已存在
手机号必须之前未存在，否则提示：手机号已存在
邮箱必须之前未存在，否则提示：邮箱已存在
2.1 查询角色列表接口
注意：查询的是所有状态正常的角色
2.1.1 接口分析
| 请求方式 | 请求路径 | 是否需求token头 |
|---|---|---|
| GET | /system/role/listAllRole | 是 |
响应格式：
{
"code":200,
"data":[
{
"createBy":"0",
"createTime":"2021-11-12 18:46:19",
"delFlag":"0",
"id":"1",
"remark":"超级管理员",
"roleKey":"admin",
"roleName":"超级管理员",
"roleSort":"1",
"status":"0",
"updateBy":"0"
},
{
"createBy":"0",
"createTime":"2021-11-12 18:46:19",
"delFlag":"0",
"id":"2",
"remark":"普通角色",
"roleKey":"common",
"roleName":"普通角色",
"roleSort":"2",
"status":"0",
"updateBy":"0",
"updateTime":"2022-01-02 06:32:58"
},
{
"createTime":"2022-01-06 22:07:40",
"delFlag":"0",
"id":"11",
"remark":"嘎嘎嘎",
"roleKey":"aggag",
"roleName":"嘎嘎嘎",
"roleSort":"5",
"status":"0",
"updateBy":"1",
"updateTime":"2022-09-12 10:00:25"
},
{
"createTime":"2022-01-16 14:49:30",
"delFlag":"0",
"id":"12",
"roleKey":"link",
"roleName":"友链审核员",
"roleSort":"1",
"status":"0",
"updateTime":"2022-01-16 16:05:09"
}
],
"msg":"操作成功"
}2.1.2 代码实现
第一步：在keke-admin的controller层的RoleController新增查询状态正常角色的接口
package com.keke.controller;
import com.keke.domain.ResponseResult;
import com.keke.domain.dto.AdminAddRoleDto;
import com.keke.domain.dto.ChangeRoleStatusDto;
import com.keke.domain.dto.EditRoleDto;
import com.keke.domain.entity.Role;
import com.keke.service.RoleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/system/role")
public class RoleController {
@Autowired
private RoleService roleService;
@GetMapping("/list")
public ResponseResult selectPageRole(Role role,Integer pageNum,Integer pageSize){
return roleService.selectPageRole(role,pageNum,pageSize);
}
@PutMapping("/changeStatus")
public ResponseResult changeRoleStatus(@RequestBody ChangeRoleStatusDto changeRoleStatusDto){
return roleService.changeRoleStatus(changeRoleStatusDto);
}
@PostMapping
public ResponseResult addRole(@RequestBody AdminAddRoleDto adminAddRoleDto){
return roleService.addRole(adminAddRoleDto);
}
@GetMapping("/{id}")
public ResponseResult getRoleInfo(@PathVariable("id") Long id){
return roleService.getRoleInfo(id);
}
@PutMapping
public ResponseResult editRole(@RequestBody EditRoleDto editRoleDto){
return roleService.editRole(editRoleDto);
}
@DeleteMapping("/{id}")
public ResponseResult deleteRoleById(@PathVariable("id") Long id){
roleService.removeById(id);
return ResponseResult.okResult();
}
@GetMapping("/listAllRole")
public ResponseResult listAllRole(){
return roleService.listAllRole();
}
}
第二步：service层新增
package com.keke.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.keke.domain.ResponseResult;
import com.keke.domain.dto.AdminAddRoleDto;
import com.keke.domain.dto.ChangeRoleStatusDto;
import com.keke.domain.dto.EditRoleDto;
import com.keke.domain.entity.Role;
import java.util.List;
/**
* 角色信息表(Role)表服务接口
*
* @author makejava
* @since 2023-10-18 21:04:06
*/
public interface RoleService extends IService<Role> {
List<String> selectRoleKeyByUserId(Long userId);
ResponseResult selectPageRole(Role role, Integer pageNum, Integer pageSize);
ResponseResult changeRoleStatus(ChangeRoleStatusDto changeRoleStatusDto);
ResponseResult addRole(AdminAddRoleDto adminAddRoleDto);
ResponseResult getRoleInfo(Long id);
ResponseResult editRole(EditRoleDto editRoleDto);
ResponseResult listAllRole();
}
第三步：impl层新增
package com.keke.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.keke.constants.SystemConstants;
import com.keke.domain.ResponseResult;
import com.keke.domain.dto.AdminAddRoleDto;
import com.keke.domain.dto.ChangeRoleStatusDto;
import com.keke.domain.dto.EditRoleDto;
import com.keke.domain.entity.Role;
import com.keke.domain.entity.RoleMenu;
import com.keke.domain.vo.AdminRoleVo;
import com.keke.domain.vo.PageVo;
import com.keke.mapper.RoleMapper;
import com.keke.service.RoleMenuService;
import com.keke.service.RoleService;
import com.keke.utils.BeanCopyUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;
/**
* 角色信息表(Role)表服务实现类
*
* @author makejava
* @since 2023-10-18 21:04:06
*/
@Service("roleService")
public class RoleServiceImpl extends ServiceImpl<RoleMapper, Role> implements RoleService {
@Autowired
private RoleMenuService roleMenuService;
//根据用户id查询角色信息
@Override
public List<String> selectRoleKeyByUserId(Long userId) {
//如果userId为1，那么角色权限字符串就只需要返回一个admin
if(userId==1L){
List<String> roles = new ArrayList<>();
roles.add("admin");
return roles;
}
//如果用户id不为1，那么需要根据userId连表查询对应的roleId，然后再去角色表中去查询
//对应的角色权限字符串
//这里我们期望RoleMapper中封装一个方法去帮我们实现这个复杂的操作
RoleMapper roleMapper = getBaseMapper();
return roleMapper.selectRoleKeyByUserId(userId);
}
@Override
public ResponseResult selectPageRole(Role role, Integer pageNum, Integer pageSize) {
LambdaQueryWrapper<Role> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.like(StringUtils.hasText(role.getRoleName()),Role::getRoleName,role.getRoleName());
lambdaQueryWrapper.eq(StringUtils.hasText(role.getStatus()),Role::getStatus,role.getStatus());
lambdaQueryWrapper.orderByAsc(Role::getRoleSort);
Page<Role> page = new Page<>(pageNum,pageSize);
page(page,lambdaQueryWrapper);
PageVo pageVo = new PageVo(page.getRecords(),page.getTotal());
return ResponseResult.okResult(pageVo);
}
@Override
public ResponseResult changeRoleStatus(ChangeRoleStatusDto changeRoleStatusDto) {
Long roleId = changeRoleStatusDto.getRoleId();
Role role = getById(roleId);
role.setStatus(changeRoleStatusDto.getStatus());
updateById(role);
return ResponseResult.okResult();
}
@Transactional
@Override
public ResponseResult addRole(AdminAddRoleDto adminAddRoleDto) {
//Bean拷贝
Role role = BeanCopyUtils.copyBean(adminAddRoleDto, Role.class);
//拿到菜单权限id集合
List<Long> menuIds = adminAddRoleDto.getMenuIds();
//流式处理转化，把每一个menuId都设置到该roleId下
List<RoleMenu> roleMenuList = menuIds.stream()
.map(new Function<Long, RoleMenu>() {
@Override
public RoleMenu apply(Long menuId) {
RoleMenu roleMenu = new RoleMenu();
roleMenu.setRoleId(role.getId());
roleMenu.setMenuId(menuId);
return roleMenu;
}
}).collect(Collectors.toList());
//mp批量保存到数据库中
roleMenuService.saveBatch(roleMenuList);
//封装返回
return ResponseResult.okResult();
}
@Override
public ResponseResult getRoleInfo(Long id) {
Role role = getById(id);
AdminRoleVo adminRoleVo = BeanCopyUtils.copyBean(role, AdminRoleVo.class);
return ResponseResult.okResult(adminRoleVo);
}
@Override
public ResponseResult editRole(EditRoleDto editRoleDto) {
Role role = BeanCopyUtils.copyBean(editRoleDto, Role.class);
List<Long> menuIds = editRoleDto.getMenuIds();
List<RoleMenu> roleMenuList = menuIds.stream()
.map(new Function<Long, RoleMenu>() {
@Override
public RoleMenu apply(Long menuId) {
RoleMenu roleMenu = new RoleMenu();
roleMenu.setRoleId(role.getId());
roleMenu.setMenuId(menuId);
return roleMenu;
}
}).collect(Collectors.toList());
roleMenuService.saveBatch(roleMenuList);
return ResponseResult.okResult();
}
@Override
public ResponseResult listAllRole() {
LambdaQueryWrapper<Role> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.eq(Role::getStatus, SystemConstants.STATUS_NORMAL);
List<Role> roleList = list(lambdaQueryWrapper);
return ResponseResult.okResult(roleList);
}
}
2.1.3 测试
2.2 新增用户接口
2.2.1 接口分析
| 请求方式 | 请求路径 | 是否需求token头 |
|---|---|---|
| POST | system/user | 是 |
请求体：
{
"userName":"wqeree",
"nickName":"测试新增用户",
"password":"1234343",
"phonenumber":"18889778907",
"email":"233@sq.com",
"sex":"0",
"status":"0",
"roleIds":[
"2"
]
}响应格式：
{
"code":200,
"msg":"操作成功"
}2.2.2 代码实现
第一步：keke-framework的domain/entity新增
package com.keke.domain.entity;
import java.io.Serializable;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import com.baomidou.mybatisplus.annotation.TableName;
/**
* 用户和角色关联表(UserRole)表实体类
*
* @author makejava
* @since 2023-10-23 21:17:14
*/
@SuppressWarnings("serial")
@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("sys_user_role")
public class UserRole {
//用户ID
private Long userId;
//角色ID
private Long roleId;
}
第二步：keke-framework的service新增
package com.keke.service;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* 用户和角色关联表(UserRole)表服务接口
*
* @author makejava
* @since 2023-10-23 21:17:32
*/
public interface UserRoleService extends IService<UserRole> {
}
第三步：keke-framework的service/impl新增
package com.keke.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.keke.domain.entity.UserRole;
import com.keke.mapper.UserRoleMapper;
import com.keke.service.UserRoleService;
import org.springframework.stereotype.Service;
/**
* 用户和角色关联表(UserRole)表服务实现类
*
* @author makejava
* @since 2023-10-23 21:17:32
*/
@Service("userRoleService")
public class UserRoleServiceImpl extends ServiceImpl<UserRoleMapper, UserRole> implements UserRoleService {
}
第四步：keke-framework的mapper新增
package com.keke.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.keke.domain.entity.User;
import org.apache.ibatis.annotations.Mapper;
/**
* 用户表(User)表数据库访问层
*
* @author makejava
* @since 2023-10-11 20:26:26
*/
@Mapper
public interface UserMapper extends BaseMapper<User> {
}
第五步：keke-framework的domain/dto新增
package com.keke.domain.dto;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.List;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class AdminAddUserDto {
//用户名
private String userName;
//昵称
private String nickName;
//密码
private String password;
//账号状态（0正常 1停用）
private String status;
//邮箱
private String email;
//手机号
private String phonenumber;
//用户性别（0男，1女，2未知）
private String sex;
//roleId
List<Long> roleIds;
}
第六步：keke-admin的controller层UserController新增
package com.keke.controller;
import com.keke.domain.ResponseResult;
import com.keke.domain.dto.AdminAddUserDto;
import com.keke.domain.entity.User;
import com.keke.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/system/user")
public class UserController {
@Autowired
private UserService userService;
@GetMapping("/list")
public ResponseResult selectPageUser(User user, Integer pageNum, Integer pageSize){
return userService.selectPageUser(user,pageNum,pageSize);
}
@PostMapping
public ResponseResult addUser(@RequestBody AdminAddUserDto adminAddUserDto){
return userService.addUser(adminAddUserDto);
}
}
第七步：service层UserService新增
package com.keke.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.keke.domain.ResponseResult;
import com.keke.domain.dto.AdminAddUserDto;
import com.keke.domain.dto.RegisterUserDto;
import com.keke.domain.dto.UserInfoDto;
import com.keke.domain.entity.User;
import org.springframework.stereotype.Service;
/**
* 用户表(User)表服务接口
*
* @author makejava
* @since 2023-10-13 09:08:38
*/
public interface UserService extends IService<User> {
ResponseResult userInfo();
ResponseResult updateUserInfo(UserInfoDto userInfoDto);
ResponseResult register(RegisterUserDto registerUserDto);
//后台接口分页查询用户
ResponseResult selectPageUser(User user, Integer pageNum, Integer pageSize);
ResponseResult addUser(AdminAddUserDto adminAddUserDto);
}
第八步：impl层实现方法
package com.keke.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.keke.domain.ResponseResult;
import com.keke.domain.dto.AdminAddUserDto;
import com.keke.domain.dto.RegisterUserDto;
import com.keke.domain.dto.UserInfoDto;
import com.keke.domain.entity.User;
import com.keke.domain.entity.UserRole;
import com.keke.domain.vo.PageVo;
import com.keke.domain.vo.UserInfoVo;
import com.keke.enums.AppHttpCodeEnum;
import com.keke.handler.exception.exception.SystemException;
import com.keke.mapper.UserMapper;
import com.keke.service.UserRoleService;
import com.keke.service.UserService;
import com.keke.utils.BeanCopyUtils;
import com.keke.utils.SecurityUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;
/**
* 用户表(User)表服务实现类
*
* @author makejava
* @since 2023-10-13 10:12:51
*/
@Service("userService")
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
@Autowired
private PasswordEncoder passwordEncoder;
@Autowired
private UserRoleService userRoleService;
@Override
public ResponseResult userInfo() {
Long userId = SecurityUtils.getUserId();
User user = getById(userId);
UserInfoVo userInfoVo = BeanCopyUtils.copyBean(user, UserInfoVo.class);
return ResponseResult.okResult(userInfoVo);
}
@Override
public ResponseResult updateUserInfo(UserInfoDto userInfoDto) {
User user = BeanCopyUtils.copyBean(userInfoDto, User.class);
updateById(user);
return ResponseResult.okResult();
}
@Override
public ResponseResult register(RegisterUserDto registerUserDto) {
//对前端传过来的用户名进行非空判断，例如null、""，就抛出异常
if(!StringUtils.hasText(registerUserDto.getUserName())){
//SystemException是我们写的异常类、AppHttpCodeEnum是我们写的枚举类
throw new SystemException(AppHttpCodeEnum.USERNAME_NOT_NULL);
}
//密码
if(!StringUtils.hasText(registerUserDto.getPassword())){
throw new SystemException(AppHttpCodeEnum.PASSWORD_NOT_NULL);
}
//邮箱
if(!StringUtils.hasText(registerUserDto.getEmail())){
throw new SystemException(AppHttpCodeEnum.EMAIL_NOT_NULL);
}
//昵称
if(!StringUtils.hasText(registerUserDto.getNickName())){
throw new SystemException(AppHttpCodeEnum.NICKNAME_NOT_NULL);
}
//判断用户传给我们的用户名是否在数据库已经存在。userNameExist方法是下面定义的
if(userNameExist(registerUserDto.getUserName())){
//SystemException是我们写的异常类、AppHttpCodeEnum是我们写的枚举类
throw new SystemException(AppHttpCodeEnum.USERNAME_EXIST);
}
//判断用户传给我们的昵称是否在数据库已经存在。NickNameExist方法是下面定义的
if(nickNameExist(registerUserDto.getNickName())){
//SystemException是我们写的异常类、AppHttpCodeEnum是我们写的枚举类
throw new SystemException(AppHttpCodeEnum.NICKNAME_EXIST);
}
//判断用户传给我们的邮箱是否在数据库已经存在。NickNameExist方法是下面定义的
if(emailExist(registerUserDto.getEmail())){
//SystemException是我们写的异常类、AppHttpCodeEnum是我们写的枚举类
throw new SystemException(AppHttpCodeEnum.EMAIL_EXIST);
}
//经过上面的判断，可以确保用户传给我们的用户名和昵称是数据库不存在的，且相关字段都不为空。就可以存入数据库
//注意用户传给我们的密码是明文，对于密码我们要转成密文之后再存入数据库。注意加密要和解密用同一套算法
//keke-blog工程的securityConfig类里面有解密算法，当时我们写了一个passwordEncoder方法，并且注入到了spring容器
//解密
String encodePassword = passwordEncoder.encode(registerUserDto.getPassword());
//封装成user存数据库中
User user = BeanCopyUtils.copyBean(registerUserDto, User.class);
//设置密码为加密的密码
user.setPassword(encodePassword);
//存入数据库中
save(user);
//封装返回
return ResponseResult.okResult();
}
@Override
public ResponseResult selectPageUser(User user, Integer pageNum, Integer pageSize) {
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
//可以根据用户名模糊搜索
lambdaQueryWrapper.like(StringUtils.hasText(user.getUserName()),User::getUserName,user.getUserName());
//可以进行手机号的搜索
lambdaQueryWrapper.eq(StringUtils.hasText(user.getPhonenumber()),User::getPhonenumber,user.getPhonenumber());
//可以根据状态进行搜索
lambdaQueryWrapper.eq(StringUtils.hasText(user.getStatus()),User::getStatus,user.getStatus());
//mp分页器
Page<User> page = new Page<>(pageNum,pageSize);
page(page,lambdaQueryWrapper);
//封装vo
PageVo pageVo = new PageVo(page.getRecords(),page.getTotal());
//响应返回
return ResponseResult.okResult(pageVo);
}
@Override
public ResponseResult addUser(AdminAddUserDto adminAddUserDto) {
User user = BeanCopyUtils.copyBean(adminAddUserDto, User.class);
List<Long> roleIds = adminAddUserDto.getRoleIds();
List<UserRole> userRoleList = roleIds.stream()
.map(new Function<Long, UserRole>() {
@Override
public UserRole apply(Long roleId) {
UserRole userRole = new UserRole();
userRole.setUserId(user.getId());
userRole.setRoleId(roleId);
return userRole;
}
}).collect(Collectors.toList());
userRoleService.saveBatch(userRoleList);
return ResponseResult.okResult();
}
//'判断用户传给我们的用户名是否在数据库已经存在' 的方法
public boolean userNameExist(String userName){
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
//查询数据库中有用户名相同的数据没有
lambdaQueryWrapper.eq(User::getUserName,userName);
//如果查出来有，就说明存在，返回true
int count = count(lambdaQueryWrapper);
return count>0;
}
//'判断用户传给我们的昵称是否在数据库已经存在' 的方法
public boolean nickNameExist(String nickName){
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
//查询数据库中有用户名相同的数据没有
lambdaQueryWrapper.eq(User::getNickName,nickName);
//如果查出来有，就说明存在，返回true
int count = count(lambdaQueryWrapper);
return count>0;
}
//'判断用户传给我们的邮箱是否在数据库已经存在' 的方法
public boolean emailExist(String email){
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
//查询数据库中有用户名相同的数据没有
lambdaQueryWrapper.eq(User::getEmail,email);
//如果查出来有，就说明存在，返回true
int count = count(lambdaQueryWrapper);
return count>0;
}
}
2.2.3 测试
十四、后台模块-分类列表
1. 查询分类
需要分页查询分类列表。
能根据分类名称进行模糊查询。
能根据状态进行查询。
1.1 接口分析
| 请求方式 | 请求路径 | 是否需求token头 |
|---|---|---|
| GET | content/category/list | 是 |
Query格式请求参数：
pageNum: 页码
pageSize: 每页条数
name：分类名
status: 状态响应格式：
{
"code":200,
"data":{
"rows":[
{
"description":"wsd",
"id":"1",
"name":"java",
"status":"0"
},
{
"description":"wsd",
"id":"2",
"name":"PHP",
"status":"0"
}
],
"total":"2"
},
"msg":"操作成功"
}1.2 代码实现
第一步：keke-admin controller层
package com.keke.controller;
import com.alibaba.excel.EasyExcel;
import com.alibaba.fastjson.JSON;
import com.keke.domain.ResponseResult;
import com.keke.domain.entity.Category;
import com.keke.domain.vo.ExcelCategoryVo;
import com.keke.enums.AppHttpCodeEnum;
import com.keke.service.CategoryService;
import com.keke.utils.BeanCopyUtils;
import com.keke.utils.WebUtils;
import io.swagger.annotations.Api;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletResponse;
import java.io.UnsupportedEncodingException;
import java.util.List;
@RestController
@RequestMapping("/content/category")
@Api(tags = "后台标签相关接口")
public class CategoryController {
@Autowired
private CategoryService categoryService;
@GetMapping("/listAllCategory")
public ResponseResult listAllCategory(){
return categoryService.listAllCategory();
}
//权限控制，ps是PermissionService类的bean名称
@PreAuthorize("@ps.hasPermission('content:category:export')")
@GetMapping("/export")
public void export(HttpServletResponse response){
try {
//设置下载文件的请求头
WebUtils.setDownLoadHeader("分类.xlsx",response);
//获取需要导出的数据
List<Category> categoryList = categoryService.list();
List<ExcelCategoryVo> excelCategoryVos = BeanCopyUtils.copyBeanList(categoryList, ExcelCategoryVo.class);
//把数据写入Excel中
EasyExcel.write(response.getOutputStream(), ExcelCategoryVo.class).autoCloseStream(Boolean.FALSE).sheet("分类导出")
.doWrite(excelCategoryVos);
} catch (Exception e) {
//如果出现异常,就返回失败的json数据给前端
ResponseResult result = ResponseResult.errorResult(AppHttpCodeEnum.SYSTEM_ERROR);
//WebUtils是我们在keke-framework工程写的类，里面的renderString方法是将json字符串写入到请求体，然后返回给前端
WebUtils.renderString(response, JSON.toJSONString(result));
}
}
@GetMapping("/list")
public ResponseResult selectPageCategory(Category category,Integer pageNum,Integer pageSize){
return categoryService.selectPageCategory(category,pageNum,pageSize);
}
}
第二步：keke-framework service层
package com.keke.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.keke.domain.ResponseResult;
import com.keke.domain.entity.Category;
import org.springframework.web.bind.annotation.RequestMapping;
/**
* 分类表(Category)表服务接口
*
* @author makejava
* @since 2023-10-10 20:42:22
*/
public interface CategoryService extends IService<Category> {
ResponseResult getCategoryList();
//后台接口，查询所有文章分类
ResponseResult listAllCategory();
ResponseResult selectPageCategory(Category category, Integer pageNum, Integer pageSize);
}
第三步：keke-framework impl层 实现selectPageCategory
package com.keke.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.keke.constants.SystemConstants;
import com.keke.domain.ResponseResult;
import com.keke.domain.entity.Article;
import com.keke.domain.entity.Category;
import com.keke.domain.vo.AdminCategoryVo;
import com.keke.domain.vo.CategoryVo;
import com.keke.domain.vo.PageVo;
import com.keke.mapper.CategoryMapper;
import com.keke.service.ArticleService;
import com.keke.service.CategoryService;
import com.keke.utils.BeanCopyUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.RequestMapping;
import java.util.List;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;
/**
* 分类表(Category)表服务实现类
*
* @author makejava
* @since 2023-10-10 20:42:22
*/
@Service("categoryService")
public class CategoryServiceImpl extends ServiceImpl<CategoryMapper, Category> implements CategoryService {
@Autowired
private ArticleService articleService;
@Override
public ResponseResult getCategoryList() {
//查询文章表，状态已发布的文章，但是在CategoryService下，查询文章表，就要注入ArticleService
LambdaQueryWrapper<Article> articleWrapper = new LambdaQueryWrapper<>();
articleWrapper.eq(Article::getStatus, SystemConstants.ARTICLE_STATUS_NORMAL);
List<Article> articleList = articleService.list(articleWrapper);
//获取文章的分类id，并去重
Set<Long> categoryIds = articleList.stream()
.map(article -> article.getCategoryId())
//toSet可以去除重复的id
.collect(Collectors.toSet());
//查询分类表
List<Category> categories = listByIds(categoryIds);
//分类表中只获取正常状态非禁用的分类，用stream流过滤
categories = categories.stream()
.filter(category -> SystemConstants.STATUS_NORMAL.equals(category.getStatus()))
.collect(Collectors.toList());
//封装Vo
List<CategoryVo> categoryVos = BeanCopyUtils.copyBeanList(categories, CategoryVo.class);
//封装到响应体中，因为有数据，所以要调用有参okResult()，把参数传进去
return ResponseResult.okResult(categoryVos);
}
@Override
public ResponseResult listAllCategory() {
LambdaQueryWrapper<Category> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.eq(Category::getStatus,SystemConstants.STATUS_NORMAL);
List<Category> categoryList = list(lambdaQueryWrapper);
List<AdminCategoryVo> adminCategoryVos = BeanCopyUtils.copyBeanList(categoryList, AdminCategoryVo.class);
return ResponseResult.okResult(adminCategoryVos);
}
@Override
public ResponseResult selectPageCategory(Category category, Integer pageNum, Integer pageSize) {
LambdaQueryWrapper<Category> lambdaQueryWrapper = new LambdaQueryWrapper<>();
//根据分类名进行模糊查询
lambdaQueryWrapper.like(StringUtils.hasText(category.getName()),Category::getName,category.getName());
lambdaQueryWrapper.eq(StringUtils.hasText(category.getStatus()),Category::getStatus,category.getStatus());
//构造分页器
Page<Category> page = new Page<>(pageNum,pageSize);
page(page,lambdaQueryWrapper);
//封装Vo
PageVo pageVo = new PageVo(page.getRecords(),page.getTotal());
return ResponseResult.okResult(pageVo);
}
}
1.3 测试
2. 新增分类
需要新增分类功能
2.1 接口分析
| 请求方式 | 请求路径 | 是否需求token头 |
|---|---|---|
| POST | /content/category | 是 |
请求体：
{
"name":"威威",
"description":"是的",
"status":"0"
}响应格式：
{
"code":200,
"msg":"操作成功"
}2.2 代码实现
第一步：新增dto，接受前端传来的参数
package com.keke.domain.dto;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class AdminCategoryDto {
//分类名
private String name;
//描述
private String description;
//状态0:正常,1禁用
private String status;
}
第二步：entity层Category修改mp自填充
package com.keke.domain.entity;
import java.util.Date;
import java.io.Serializable;
import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* 分类表(Category)表实体类
*
* @author makejava
* @since 2023-10-10 20:42:21
*/
@SuppressWarnings("serial")
@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("ke_category")
public class Category {
@TableId
private Long id;
//分类名
private String name;
//父分类id，如果没有父分类为-1
private Long pid;
//描述
private String description;
//状态0:正常,1禁用
private String status;
//创建者
@TableField(fill = FieldFill.INSERT)
private Long createBy;
//创建时间
@TableField(fill = FieldFill.INSERT)
private Date createTime;
//更新者
@TableField(fill = FieldFill.INSERT_UPDATE)
private Long updateBy;
//更新时间
@TableField(fill = FieldFill.INSERT_UPDATE)
private Date updateTime;
//删除标志（0代表未删除，1代表已删除）
private Integer delFlag;
}
第三步： keke-admin的Controller层
package com.keke.controller;
import com.alibaba.excel.EasyExcel;
import com.alibaba.fastjson.JSON;
import com.keke.domain.ResponseResult;
import com.keke.domain.dto.AdminCategoryDto;
import com.keke.domain.entity.Category;
import com.keke.domain.vo.ExcelCategoryVo;
import com.keke.enums.AppHttpCodeEnum;
import com.keke.service.CategoryService;
import com.keke.utils.BeanCopyUtils;
import com.keke.utils.WebUtils;
import io.swagger.annotations.Api;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.io.UnsupportedEncodingException;
import java.util.List;
@RestController
@RequestMapping("/content/category")
@Api(tags = "后台标签相关接口")
public class CategoryController {
@Autowired
private CategoryService categoryService;
@GetMapping("/listAllCategory")
public ResponseResult listAllCategory(){
return categoryService.listAllCategory();
}
//权限控制，ps是PermissionService类的bean名称
@PreAuthorize("@ps.hasPermission('content:category:export')")
@GetMapping("/export")
public void export(HttpServletResponse response){
try {
//设置下载文件的请求头
WebUtils.setDownLoadHeader("分类.xlsx",response);
//获取需要导出的数据
List<Category> categoryList = categoryService.list();
List<ExcelCategoryVo> excelCategoryVos = BeanCopyUtils.copyBeanList(categoryList, ExcelCategoryVo.class);
//把数据写入Excel中
EasyExcel.write(response.getOutputStream(), ExcelCategoryVo.class).autoCloseStream(Boolean.FALSE).sheet("分类导出")
.doWrite(excelCategoryVos);
} catch (Exception e) {
//如果出现异常,就返回失败的json数据给前端
ResponseResult result = ResponseResult.errorResult(AppHttpCodeEnum.SYSTEM_ERROR);
//WebUtils是我们在keke-framework工程写的类，里面的renderString方法是将json字符串写入到请求体，然后返回给前端
WebUtils.renderString(response, JSON.toJSONString(result));
}
}
@GetMapping("/list")
public ResponseResult selectPageCategory(Category category,Integer pageNum,Integer pageSize){
return categoryService.selectPageCategory(category,pageNum,pageSize);
}
@PostMapping
public ResponseResult addCategory(@RequestBody AdminCategoryDto adminCategoryDto){
return categoryService.addCategory(adminCategoryDto);
}
}
第四步：keke-framework的service层
package com.keke.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.keke.domain.ResponseResult;
import com.keke.domain.dto.AdminCategoryDto;
import com.keke.domain.entity.Category;
import org.springframework.web.bind.annotation.RequestMapping;
/**
* 分类表(Category)表服务接口
*
* @author makejava
* @since 2023-10-10 20:42:22
*/
public interface CategoryService extends IService<Category> {
ResponseResult getCategoryList();
//后台接口，查询所有文章分类
ResponseResult listAllCategory();
ResponseResult selectPageCategory(Category category, Integer pageNum, Integer pageSize);
ResponseResult addCategory(AdminCategoryDto adminCategoryDto);
}
第五步：keke-framework的impl层
package com.keke.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.keke.constants.SystemConstants;
import com.keke.domain.ResponseResult;
import com.keke.domain.dto.AdminCategoryDto;
import com.keke.domain.entity.Article;
import com.keke.domain.entity.Category;
import com.keke.domain.vo.AdminCategoryVo;
import com.keke.domain.vo.CategoryVo;
import com.keke.domain.vo.PageVo;
import com.keke.mapper.CategoryMapper;
import com.keke.service.ArticleService;
import com.keke.service.CategoryService;
import com.keke.utils.BeanCopyUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.RequestMapping;
import java.util.List;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;
/**
* 分类表(Category)表服务实现类
*
* @author makejava
* @since 2023-10-10 20:42:22
*/
@Service("categoryService")
public class CategoryServiceImpl extends ServiceImpl<CategoryMapper, Category> implements CategoryService {
@Autowired
private ArticleService articleService;
@Override
public ResponseResult getCategoryList() {
//查询文章表，状态已发布的文章，但是在CategoryService下，查询文章表，就要注入ArticleService
LambdaQueryWrapper<Article> articleWrapper = new LambdaQueryWrapper<>();
articleWrapper.eq(Article::getStatus, SystemConstants.ARTICLE_STATUS_NORMAL);
List<Article> articleList = articleService.list(articleWrapper);
//获取文章的分类id，并去重
Set<Long> categoryIds = articleList.stream()
.map(article -> article.getCategoryId())
//toSet可以去除重复的id
.collect(Collectors.toSet());
//查询分类表
List<Category> categories = listByIds(categoryIds);
//分类表中只获取正常状态非禁用的分类，用stream流过滤
categories = categories.stream()
.filter(category -> SystemConstants.STATUS_NORMAL.equals(category.getStatus()))
.collect(Collectors.toList());
//封装Vo
List<CategoryVo> categoryVos = BeanCopyUtils.copyBeanList(categories, CategoryVo.class);
//封装到响应体中，因为有数据，所以要调用有参okResult()，把参数传进去
return ResponseResult.okResult(categoryVos);
}
@Override
public ResponseResult listAllCategory() {
LambdaQueryWrapper<Category> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.eq(Category::getStatus,SystemConstants.STATUS_NORMAL);
List<Category> categoryList = list(lambdaQueryWrapper);
List<AdminCategoryVo> adminCategoryVos = BeanCopyUtils.copyBeanList(categoryList, AdminCategoryVo.class);
return ResponseResult.okResult(adminCategoryVos);
}
@Override
public ResponseResult selectPageCategory(Category category, Integer pageNum, Integer pageSize) {
LambdaQueryWrapper<Category> lambdaQueryWrapper = new LambdaQueryWrapper<>();
//根据分类名进行模糊查询
lambdaQueryWrapper.like(StringUtils.hasText(category.getName()),Category::getName,category.getName());
lambdaQueryWrapper.eq(StringUtils.hasText(category.getStatus()),Category::getStatus,category.getStatus());
//构造分页器
Page<Category> page = new Page<>(pageNum,pageSize);
page(page,lambdaQueryWrapper);
//封装Vo
PageVo pageVo = new PageVo(page.getRecords(),page.getTotal());
return ResponseResult.okResult(pageVo);
}
@Override
public ResponseResult addCategory(AdminCategoryDto adminCategoryDto) {
Category category = BeanCopyUtils.copyBean(adminCategoryDto, Category.class);
save(category);
return ResponseResult.okResult();
}
}
2.3 测试
3. 修改分类
需要提供修改分类的功能
分析：点击修改按钮，需要回显出分类的相关信息
点击确定按钮，修改成功
所以这里需要实现两个接口
3.1 回显分类信息接口
3.1.1 接口分析
根据id查询分类
| 请求方式 | 请求路径 | 是否需求token头 |
|---|---|---|
| Get | content/category/{id} | 是 |
3.1.2 代码实现
逻辑较少，直接在Controller层写逻辑
package com.keke.controller;
import com.alibaba.excel.EasyExcel;
import com.alibaba.fastjson.JSON;
import com.keke.domain.ResponseResult;
import com.keke.domain.dto.AdminCategoryDto;
import com.keke.domain.entity.Category;
import com.keke.domain.vo.ExcelCategoryVo;
import com.keke.enums.AppHttpCodeEnum;
import com.keke.service.CategoryService;
import com.keke.utils.BeanCopyUtils;
import com.keke.utils.WebUtils;
import io.swagger.annotations.Api;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.io.UnsupportedEncodingException;
import java.util.List;
@RestController
@RequestMapping("/content/category")
@Api(tags = "后台标签相关接口")
public class CategoryController {
@Autowired
private CategoryService categoryService;
@GetMapping("/listAllCategory")
public ResponseResult listAllCategory(){
return categoryService.listAllCategory();
}
//权限控制，ps是PermissionService类的bean名称
@PreAuthorize("@ps.hasPermission('content:category:export')")
@GetMapping("/export")
public void export(HttpServletResponse response){
try {
//设置下载文件的请求头
WebUtils.setDownLoadHeader("分类.xlsx",response);
//获取需要导出的数据
List<Category> categoryList = categoryService.list();
List<ExcelCategoryVo> excelCategoryVos = BeanCopyUtils.copyBeanList(categoryList, ExcelCategoryVo.class);
//把数据写入Excel中
EasyExcel.write(response.getOutputStream(), ExcelCategoryVo.class).autoCloseStream(Boolean.FALSE).sheet("分类导出")
.doWrite(excelCategoryVos);
} catch (Exception e) {
//如果出现异常,就返回失败的json数据给前端
ResponseResult result = ResponseResult.errorResult(AppHttpCodeEnum.SYSTEM_ERROR);
//WebUtils是我们在keke-framework工程写的类，里面的renderString方法是将json字符串写入到请求体，然后返回给前端
WebUtils.renderString(response, JSON.toJSONString(result));
}
}
@GetMapping("/list")
public ResponseResult selectPageCategory(Category category,Integer pageNum,Integer pageSize){
return categoryService.selectPageCategory(category,pageNum,pageSize);
}
@PostMapping
public ResponseResult addCategory(@RequestBody AdminCategoryDto adminCategoryDto){
return categoryService.addCategory(adminCategoryDto);
}
@GetMapping("/{id}")
public ResponseResult getInfoById(@PathVariable("id") Long id){
Category category = categoryService.getById(id);
return ResponseResult.okResult(category);
}
}
3.1.3 测试
成功回显出分类信息
3.2 修改分类接口
3.2.1 接口分析
| 请求方式 | 请求路径 | 是否需求token头 |
|---|---|---|
| PUT | /content/category | 是 |
请求体：
{
"description":"是的",
"id":"3",
"name":"威威2",
"status":"0"
}响应格式：
{
"code":200,
"msg":"操作成功"
}3.2.2 代码实现
逻辑较少，直接在controller层实现
@PutMapping
public ResponseResult editCategory(@RequestBody Category category){
categoryService.updateById(category);
return ResponseResult.okResult();
}
3.2.3 测试
4. 删除分类
删除某个分类（逻辑删除）
4.1 接口分析
| 请求方式 | 请求路径 | 是否需求token头 |
|---|---|---|
| DELETE | /content/category/{id} | 是 |
请求参数PathVariable格式：
id：要删除的分类id响应格式：
{
"code":200,
"msg":"操作成功"
}4.2 代码实现
逻辑较少，直接在controller层实现
@DeleteMapping("/{id}")
public ResponseResult deleteCategory(@PathVariable("/id") Long id){
categoryService.removeById(id);
return ResponseResult.okResult();
}
4.3 测试
十五、后台模块-友链列表
1. 查询友链
需要分页查询友链列表。
能根据友链名称进行模糊查询。
能根据状态进行查询。
1.1 接口分析
| 请求方式 | 请求路径 | 是否需求token头 |
|---|---|---|
| GET | /content/link/list | 是 |
Query格式请求参数：
pageNum: 页码
pageSize: 每页条数
name：友链名
status:状态响应格式：
{
"code":200,
"data":{
"rows":[
{
"address":"https://www.baidu.com",
"description":"sda",
"id":"1",
"logo":"图片URL",
"name":"sda",
"status":"0"
}
],
"total":"1"
},
"msg":"操作成功"
}1.2 代码实现
第一步：keke-admin的controller层新建LinkController
package com.keke.controller;
import com.keke.domain.ResponseResult;
import com.keke.domain.entity.Link;
import com.keke.service.LinkService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/system/link")
public class LinkController {
@Autowired
private LinkService linkService;
@GetMapping("/list")
public ResponseResult selectPageLink(Link link, Integer pageNum, Integer pageSize){
return linkService.selectPageLink(link,pageNum,pageSize);
}
}
第二步：keke-framework的service层新增方法
package com.keke.service;
import com.keke.domain.ResponseResult;
import com.keke.domain.entity.Link;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* 友链(Link)表服务接口
*
* @author makejava
* @since 2023-10-11 15:46:23
*/
public interface LinkService extends IService<Link> {
ResponseResult getAllLink();
ResponseResult selectPageLink(Link link, Integer pageNum, Integer pageSize);
}
第三步：keke-framework的impl层实现方法
package com.keke.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.keke.constants.SystemConstants;
import com.keke.domain.ResponseResult;
import com.keke.domain.entity.Link;
import com.keke.domain.vo.LinkVo;
import com.keke.domain.vo.PageVo;
import com.keke.mapper.LinkMapper;
import com.keke.service.LinkService;
import com.keke.utils.BeanCopyUtils;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import java.util.List;
/**
* 友链(Link)表服务实现类
*
* @author makejava
* @since 2023-10-11 16:53:47
*/
@Service("linkService")
public class LinkServiceImpl extends ServiceImpl<LinkMapper, Link> implements LinkService {
@Override
public ResponseResult getAllLink() {
//查询所有审核通过的
LambdaQueryWrapper<Link> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.eq(Link::getStatus, SystemConstants.Link_STATUS_NORMAL);
List<Link> links = list(lambdaQueryWrapper);
//转换Vo
List<LinkVo> linkVos = BeanCopyUtils.copyBeanList(links, LinkVo.class);
//封装响应体
return ResponseResult.okResult(linkVos);
}
@Override
public ResponseResult selectPageLink(Link link, Integer pageNum, Integer pageSize) {
LambdaQueryWrapper<Link> lambdaQueryWrapper = new LambdaQueryWrapper<>();
//根据友链名进行模糊查询
lambdaQueryWrapper.like(StringUtils.hasText(link.getName()),Link::getName,link.getName());
//根据状态进行查询
lambdaQueryWrapper.eq(StringUtils.hasText(link.getStatus()),Link::getStatus,link.getStatus());
//构造分页器
Page<Link> page = new Page<>(pageNum,pageSize);
page(page,lambdaQueryWrapper);
//封装Vo
PageVo pageVo = new PageVo(page.getRecords(),page.getTotal());
//封装响应体返回
return ResponseResult.okResult(pageVo);
}
}
1.3 测试
2. 新增友链
需要新增友链功能
2.1 接口分析
| 请求方式 | 请求路径 | 是否需求token头 |
|---|---|---|
| POST | /content/link | 是 |
请求体：
{
"name":"sda",
"description":"weqw",
"address":"wewe",
"logo":"weqe",
"status":"2"
}响应格式：
{
"code":200,
"msg":"操作成功"
}2.2 代码实现
第一步：修改entity层Link实体类，修改四字段为mp自动填充
package com.keke.domain.entity;
import java.util.Date;
import java.io.Serializable;
import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.TableField;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import com.baomidou.mybatisplus.annotation.TableName;
/**
* 友链(Link)表实体类
*
* @author makejava
* @since 2023-10-11 15:45:54
*/
@SuppressWarnings("serial")
@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("ke_link")
public class Link {
private Long id;
private String name;
private String logo;
private String description;
//网站地址
private String address;
//审核状态 (0代表审核通过，1代表审核未通过，2代表未审核)
private String status;
//创建者
@TableField(fill = FieldFill.INSERT)
private Long createBy;
//创建时间
@TableField(fill = FieldFill.INSERT)
private Date createTime;
//更新者
@TableField(fill = FieldFill.INSERT_UPDATE)
private Long updateBy;
//更新时间
@TableField(fill = FieldFill.INSERT_UPDATE)
private Date updateTime;
//删除标志（0代表未删除，1代表已删除）
private Integer delFlag;
}
第二步：keke-admin的controller层新增添加友链的接口
package com.keke.controller;
import com.keke.domain.ResponseResult;
import com.keke.domain.entity.Link;
import com.keke.service.LinkService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/content/link")
public class LinkController {
@Autowired
private LinkService linkService;
//分页查询友链
@GetMapping("/list")
public ResponseResult selectPageLink(Link link, Integer pageNum, Integer pageSize){
return linkService.selectPageLink(link,pageNum,pageSize);
}
//新增友链
@PostMapping
public ResponseResult addLink(@RequestBody Link link){
linkService.save(link);
return ResponseResult.okResult();
}
}
2.3 测试
3. 修改友链
需要提供修改友链的功能
3.1 回显友链信息接口
3.1.1 接口分析
根据id查询友链
| 请求方式 | 请求路径 | 是否需求token头 |
|---|---|---|
| Get | content/link/{id} | 是 |
请求PathVariable格式参数：
id: 友链id响应格式：
{
"code":200,
"data":{
"address":"wewe",
"description":"weqw",
"id":"4",
"logo":"weqe",
"name":"sda",
"status":"2"
},
"msg":"操作成功"
}3.1.2 代码实现
逻辑较少，直接在controller层写
//回显友链信息
@GetMapping("/{id}")
public ResponseResult getInfoById(@PathVariable("id") Long id){
Link link = linkService.getById(id);
return ResponseResult.okResult(link);
}3.1.3 测试
3.2 修改友链接口
3.2.1 接口分析
| 请求方式 | 请求路径 | 是否需求token头 |
|---|---|---|
| PUT | /content/link | 是 |
请求头：
{
"address":"https://www.qq.com",
"description":"dada2",
"id":"2",
"logo":"https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fn1.itc.cn%2Fimg8%2Fwb%2Frecom%2F2016%2F05%2F10%2F146286696706220328.PNG&refer=http%3A%2F%2Fn1.itc.cn&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg?sec=1646205529&t=f942665181eb9b0685db7a6f59d59975",
"name":"sda",
"status":"0"
}响应体：
{
"code":200,
"msg":"操作成功"
}3.2.2 代码实现
//修改友链
@PutMapping
public ResponseResult editLink(@RequestBody Link link){
linkService.updateById(link);
return ResponseResult.okResult();
}3.2.3 测试
我们把刚才新增的友链LOG修改成猴子图标
4. 删除友链
删除某个友链（逻辑删除）
4.1 接口分析
| 请求方式 | 请求路径 | 是否需求token头 |
|---|---|---|
| DELETE | /content/link/{id} | 是 |
请求参数PathVariable格式：
id：要删除的友链id响应格式：
{
"code":200,
"msg":"操作成功"
}4.2 代码实现
package com.keke.controller;
import com.keke.domain.ResponseResult;
import com.keke.domain.entity.Link;
import com.keke.service.LinkService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/content/link")
public class LinkController {
@Autowired
private LinkService linkService;
//分页查询友链
@GetMapping("/list")
public ResponseResult selectPageLink(Link link, Integer pageNum, Integer pageSize){
return linkService.selectPageLink(link,pageNum,pageSize);
}
//新增友链
@PostMapping
public ResponseResult addLink(@RequestBody Link link){
linkService.save(link);
return ResponseResult.okResult();
}
//回显友链信息
@GetMapping("/{id}")
public ResponseResult getInfoById(@PathVariable("id") Long id){
Link link = linkService.getById(id);
return ResponseResult.okResult(link);
}
//修改友链
@PutMapping
public ResponseResult editLink(@RequestBody Link link){
linkService.updateById(link);
return ResponseResult.okResult();
}
//根据id删除友链
@DeleteMapping("/{id}")
public ResponseResult deleteLink(@PathVariable("id") Long id){
linkService.removeById(id);
return ResponseResult.okResult();
}
}
4.3 测试
至此，KekeBlog的后台模块开发全部结束
