• KekeBlog项目实战后台模块(二)(已完结)

     十一、后台模块-菜单列表

    菜单指的是权限菜单，也就是一堆权限字符串

    1. 查询菜单

    1.1 接口分析

    需要展示菜单列表，不需要分页。可以针对菜单名进行模糊查询。也可以针对菜单的状态进行查询。菜单要按照父菜单id和orderNum进行排序

    请求方式

    请求路径

    是否需求token头

    GET

    system/menu/list

    是

    请求参数是query格式的： 

    1. {
    2. status  : 状态
    3.  
    4. menuName： 菜单名
    5. }

    响应格式:

    1. {
    2. 	"code":200,
    3. 	"data":[
    4. 		{
    5. 			"component":"组件路径",
    6. 			"icon":"build",
    7. 			"id":"2023",
    8. 			"isFrame":1,
    9. 			"menuName":"菜单名称",
    10. 			"menuType":"C",
    11. 			"orderNum":0,
    12. 			"parentId":"0",
    13. 			"path":"write",
    14. 			"perms":"权限字符串",
    15. 			"remark":"备注信息",
    16. 			"status":"0",
    17. 			"visible":"0"
    18. 		},
    19. 		{
    20. 			"icon":"system",
    21. 			"id":"1",
    22. 			"isFrame":1,
    23. 			"menuName":"菜单名称",
    24. 			"menuType":"M",
    25. 			"orderNum":1,
    26. 			"parentId":"0",
    27. 			"path":"system",
    28. 			"perms":"权限字符串",
    29. 			"remark":"备注信息",
    30. 			"status":"0",
    31. 			"visible":"0"
    32. 		}
    33. 	],
    34. 	"msg":"操作成功"
    35. }

    2.2 代码实现

    第一步: 在keke-framework工程的Vo目录新建MenuVo类，写入如下，用于把指定字段返回给前端

    1. package com.keke.domain.vo;
    2. import lombok.AllArgsConstructor;
    3. import lombok.Data;
    4. import lombok.NoArgsConstructor;
    5.  
    6. @Data
    7. @NoArgsConstructor
    8. @AllArgsConstructor
    9. public class AdminMenuVo {
    10.      //菜单ID
    11.      private Long id;
    12.      //菜单名称
    13.      private String menuName;
    14.      //父菜单ID
    15.      private Long parentId;
    16.      //显示顺序
    17.      private Integer orderNum;
    18.      //路由地址
    19.      private String path;
    20.      //组件路径
    21.      private String component;
    22.      //是否为外链（0是 1否）
    23.      private Integer isFrame;
    24.      //菜单类型（M目录 C菜单 F按钮）
    25.      private String menuType;
    26.      //菜单状态（0显示 1隐藏）
    27.      private String visible;
    28.      //菜单状态（0正常 1停用）
    29.      private String status;
    30.      //权限标识
    31.      private String perms;
    32.      //菜单图标
    33.      private String icon;
    34.      //备注
    35.      private String remark;
    36. }

    第二步: 在keke-admin工程的controller目录新建MenuController类，写入如下，是查询菜单列表的访问接口

    1. package com.keke.controller;
    2.  
    3.  
    4. import com.keke.domain.ResponseResult;
    5. import com.keke.domain.entity.Menu;
    6. import com.keke.service.MenuService;
    7. import org.springframework.beans.factory.annotation.Autowired;
    8. import org.springframework.web.bind.annotation.GetMapping;
    9. import org.springframework.web.bind.annotation.RequestMapping;
    10. import org.springframework.web.bind.annotation.RestController;
    11.  
    12. @RestController
    13. @RequestMapping("/system/menu")
    14. public class MenuController {
    15.  
    16.      @Autowired
    17.      private MenuService menuService;
    18.  
    19.  
    20.      //查询菜单列表
    21.      @GetMapping("/list")
    22.      public ResponseResult selectAllMenu(Menu menu){
    23.           List adminMenuVos = menuService.selectAllMenu(menu);
    24.           return ResponseResult.okResult(adminMenuVos);
    25.      }
    26. }

    第三步：把keke-framework工程的MenuService接口修改为如下，增加了查询菜单列表的接口

    1. package com.keke.service;
    2.  
    3. import com.baomidou.mybatisplus.extension.service.IService;
    4. import com.keke.domain.ResponseResult;
    5. import com.keke.domain.entity.Menu;
    6.  
    7. import java.util.List;
    8.  
    9.  
    10. /**
    11.  * 菜单权限表(Menu)表服务接口
    12.  *
    13.  * @author makejava
    14.  * @since 2023-10-18 20:55:48
    15.  */
    16. public interface MenuService extends IService {
    17.  
    18.  
    19.      //查询用户权限信息
    20.      List selectPermsByUserId(Long userId);
    21.  
    22.      //查询用户的路由信息，也就是权限菜单
    23.      List selectRouterMenuTreeByUserId(Long userId);
    24.  
    25.      List selectAllMenu(Menu menu);
    26.  
    27. }

    第四步: 把keke-framework工程的MenuServiceImpl类修改为如下，增加了查询菜单列表的具体代码实现

    1. package com.keke.service.impl;
    2.  
    3. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
    4. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
    5. import com.keke.constants.SystemConstants;
    6. import com.keke.domain.ResponseResult;
    7. import com.keke.domain.entity.Menu;
    8. import com.keke.domain.vo.AdminMenuVo;
    9. import com.keke.mapper.MenuMapper;
    10. import com.keke.service.MenuService;
    11. import com.keke.utils.BeanCopyUtils;
    12. import com.keke.utils.SecurityUtils;
    13. import org.springframework.stereotype.Service;
    14. import org.springframework.util.StringUtils;
    15.  
    16. import java.util.List;
    17. import java.util.function.Function;
    18. import java.util.stream.Collectors;
    19.  
    20. /**
    21.  * 菜单权限表(Menu)表服务实现类
    22.  *
    23.  * @author makejava
    24.  * @since 2023-10-18 20:55:48
    25.  */
    26. @Service("menuService")
    27. public class MenuServiceImpl extends ServiceImpl implements MenuService {
    28.  
    29.  
    30.  
    31.      //根据用户id查询权限关键字
    32.      @Override
    33.      public List selectPermsByUserId(Long userId) {
    34.           //如果用户id为1代表管理员，roles 中只需要有admin，
    35.           // permissions中需要有所有菜单类型为C(菜单)或者F(按钮)的，状态为正常的，未被删除的权限
    36.           if(SecurityUtils.isAdmin()) {
    37.                LambdaQueryWrapper lambdaQueryWrapper = new LambdaQueryWrapper<>();
    38.                lambdaQueryWrapper.in(Menu::getMenuType, SystemConstants.MENU, SystemConstants.BUTTON);
    39.                lambdaQueryWrapper.eq(Menu::getStatus, SystemConstants.STATUS_NORMAL);
    40.                //由于我们的逻辑删除字段已经配置了，所以无需封装lambdaQueryWrapper
    41.                List menuList = list(lambdaQueryWrapper);
    42.                //我们需要的是String类型的集合，这里我们要进行数据的处理，这里采用流的方式
    43.                List permissions = menuList.stream()
    44.                        .map(new Function() {
    45.                             @Override
    46.                             public String apply(Menu menu) {
    47.                                  String perms = menu.getPerms();
    48.                                  return perms;
    49.                             }
    50.                        })
    51.                        .collect(Collectors.toList());
    52.                return permissions;
    53.           }
    54.           //否则返回这个用户所具有的权限
    55.           //这里我们需要进行连表查询，因为我们的用户先和角色关联，然后角色才跟权限关联
    56.           MenuMapper menuMapper = getBaseMapper();
    57.           //我们期望menuMapper中有一个方法可以直接帮我们去实现这个复杂的逻辑，这里直接返回
    58.           return menuMapper.selectPermsByUserId(userId);
    59.      }
    60.  
    61.      @Override
    62.      public List selectRouterMenuTreeByUserId(Long userId) {
    63.           MenuMapper menuMapper = getBaseMapper();
    64.           List menus = null;
    65.           //如果是管理员，返回所有
    66.           if(SecurityUtils.isAdmin()){
    67.                menus = menuMapper.selectAllRoutersMenu();
    68.           }else {
    69.                //如果不是管理员，返回对应用户的菜单
    70.                menus = menuMapper.selectRoutersMenuTreeByUserId(userId);
    71.           }
    72.           //因为上面的查询都是从数据库进行查询，所以无法封装children，这里构建Tree
    73.  
    74.           List menuTree = buildMenuTree(menus,0L);
    75.           return menuTree;
    76.      }
    77.  
    78.      @Override
    79.      public ResponseResult selectAllMenu(Menu menu) {
    80.            //可以针对菜单名进行模糊查询。也可以针对菜单的状态进行查询
    81.           LambdaQueryWrapper lambdaQueryWrapper = new LambdaQueryWrapper<>();
    82.           lambdaQueryWrapper.like(StringUtils.hasText(menu.getMenuName()),Menu::getMenuName,menu.getMenuName());
    83.           lambdaQueryWrapper.eq(StringUtils.hasText(menu.getStatus()),Menu::getStatus,menu.getStatus());
    84.           //排序 parent_id和order_num
    85.           lambdaQueryWrapper.orderByAsc(Menu::getParentId,Menu::getOrderNum);
    86.           List menus = list(lambdaQueryWrapper);
    87.           List adminMenuVos = BeanCopyUtils.copyBeanList(menus, AdminMenuVo.class);
    88.           return adminMenuVos;
    89.      }
    90.  
    91.  
    92.  
    93.  
    94.  
    95.  
    96.      /**
    97.       * 构建MenuTree
    98.       * 思路先找第一层级的菜单，就是找到id于parentId的对应关系，然后把parentId设置为Id的children
    99.       * @param menus
    100.       * @return
    101.       */
    102.      private List buildMenuTree(List menus,Long parentId) {
    103.           //转化流处理
    104.           List menuTree = menus.stream()
    105.                   //过滤掉除一级菜单之外的菜单
    106.                   .filter(menu -> menu.getParentId().equals(parentId))
    107.                   //然后将获取其子菜单设置到children字段，并返回
    108.                   .map(m -> m.setChildren(gerChildren(m, menus)))
    109.                   .collect(Collectors.toList());
    110.           return menuTree;
    111.      }
    112.  
    113.      //获取当前菜单的子菜单
    114.      private List gerChildren(Menu menu, List menus) {
    115.           //流处理，遍历每一个流对象，筛选出流对象的parentId=menu的id，即过滤
    116.           List children = menus.stream()
    117.                   .filter(m -> m.getParentId().equals(menu.getId()))
    118.                   //这里其实不必要写，这一步的逻辑是如果有三级，
    119.                   //可以把流对象中再过筛选出子菜单设置给对应的children并返回
    120.                   .map(m -> m.setChildren(gerChildren(m,menus)))
    121.                   .collect(Collectors.toList());
    122.           return children;
    123.      }
    124.  
    125. }

    2.3 测试

    运行前端工程，打开redis，打开菜单管理

    2. 新增菜单

    2.1 接口分析

    新增权限菜单

    请求方式

    请求路径

    是否需求token头

    POST

    system/menu

    是

    请求体参数:

    Menu类对应的json格式

    响应格式:

    1. {
    2. 	"code":200,
    3. 	"msg":"操作成功"
    4. }

    2.2 代码实现

    第一步: 把keke-framework工程的Menu类修改为如下，注意有四个字段使用了mybatisplus的字段自增

    1. package com.keke.domain.entity;
    2.  
    3. import java.util.Date;
    4. import java.util.List;
    5.  
    6. import com.baomidou.mybatisplus.annotation.FieldFill;
    7. import com.baomidou.mybatisplus.annotation.TableField;
    8. import lombok.AllArgsConstructor;
    9. import lombok.Data;
    10. import lombok.NoArgsConstructor;
    11. import com.baomidou.mybatisplus.annotation.TableName;
    12. import lombok.experimental.Accessors;
    13.  
    14. /**
    15.  * 菜单权限表(Menu)表实体类
    16.  *
    17.  * @author makejava
    18.  * @since 2023-10-18 20:55:24
    19.  */
    20. @SuppressWarnings("serial")
    21. @Data
    22. @NoArgsConstructor
    23. @AllArgsConstructor
    24. @Accessors(chain = true)
    25. @TableName("sys_menu")
    26. public class Menu {
    27.     //菜单ID
    28.     private Long id;
    29.     //菜单名称
    30.     private String menuName;
    31.     //父菜单ID
    32.     private Long parentId;
    33.     //显示顺序
    34.     private Integer orderNum;
    35.     //路由地址
    36.     private String path;
    37.     //组件路径
    38.     private String component;
    39.     //是否为外链（0是 1否）
    40.     private Integer isFrame;
    41.     //菜单类型（M目录 C菜单 F按钮）
    42.     private String menuType;
    43.     //菜单状态（0显示 1隐藏）
    44.     private String visible;
    45.     //菜单状态（0正常 1停用）
    46.     private String status;
    47.     //权限标识
    48.     private String perms;
    49.     //菜单图标
    50.     private String icon;
    51.     //创建者
    52.     @TableField(fill = FieldFill.INSERT)
    53.     private Long createBy;
    54.     //创建时间
    55.     @TableField(fill = FieldFill.INSERT)
    56.     private Date createTime;
    57.     //更新者
    58.     @TableField(fill = FieldFill.INSERT_UPDATE)
    59.     private Long updateBy;
    60.     //更新时间
    61.     @TableField(fill = FieldFill.INSERT_UPDATE)
    62.     private Date updateTime;
    63.     //备注
    64.     private String remark;
    65.     
    66.     private String delFlag;
    67.  
    68.     //由于数据库没有children字段，所以我们要添加@TableField(exist = false)注解
    69.     // 让mybatis在查表时不查询这个字段
    70.     @TableField(exist = false)
    71.     private List children;
    72. }

    第二步: 把huanf-framework工程的MenuController类修改为如下，增加了新增菜单的具体代码实现

    1. package com.keke.controller;
    2.  
    3.  
    4. import com.keke.domain.ResponseResult;
    5. import com.keke.domain.entity.Menu;
    6. import com.keke.service.MenuService;
    7. import org.springframework.beans.factory.annotation.Autowired;
    8. import org.springframework.web.bind.annotation.*;
    9.  
    10. @RestController
    11. @RequestMapping("/system/menu")
    12. public class MenuController {
    13.  
    14.      @Autowired
    15.      private MenuService menuService;
    16.  
    17.  
    18.      //查询菜单列表
    19.      @GetMapping("/list")
    20.      public ResponseResult selectAllMenu(Menu menu){
    21.           return menuService.selectAllMenu(menu);
    22.      }
    23.  
    24.      //新增菜单
    25.      @PostMapping
    26.      public ResponseResult add(@RequestBody Menu menu) {
    27.           menuService.save(menu);
    28.           return ResponseResult.okResult();
    29.      }
    30.  
    31. }

    2.3 测试

    启动工程，打开前端工程，redis

    测试在 '系统管理' 页面，点击 '新增'，能否可以添加"测试目录"类型的菜单

    3. 修改菜单

    能够修改菜单，但是修改的时候不能把父菜单设置为当前菜单，如果设置了需要给出相应的提示。并且修改失败。

    修改菜单包含两个接口，一个是点击修改回显出菜单的详情信息，一个是点击确定后菜单修改成功

    3.1 菜单详情

    3.1.1菜单详情接口分析
    请求方式请求路径是否需求token头
    Getsystem/menu/{id}是

    请求参数PathVariable格式：

    id: 菜单id

    响应格式：

    1. {
    2. 	"code":200,
    3. 	"data":{
    4. 		"icon":"table",
    5. 		"id":"2017",
    6. 		"menuName":"内容管理",
    7. 		"menuType":"M",
    8. 		"orderNum":"4",
    9. 		"parentId":"0",
    10. 		"path":"content",
    11. 		"remark":"",
    12. 		"status":"0",
    13. 		"visible":"0"
    14. 	},
    15. 	"msg":"操作成功"
    16. }
    3.1.2 代码实现

    controller层新增

    1. package com.keke.controller;
    2.  
    3.  
    4. import com.keke.domain.ResponseResult;
    5. import com.keke.domain.entity.Menu;
    6. import com.keke.service.MenuService;
    7. import org.springframework.beans.factory.annotation.Autowired;
    8. import org.springframework.web.bind.annotation.*;
    9.  
    10. @RestController
    11. @RequestMapping("/system/menu")
    12. public class MenuController {
    13.  
    14.      @Autowired
    15.      private MenuService menuService;
    16.  
    17.  
    18.      //查询菜单列表
    19.      @GetMapping("/list")
    20.      public ResponseResult selectAllMenu(Menu menu){
    21.           return menuService.selectAllMenu(menu);
    22.      }
    23.  
    24.      //新增菜单
    25.      @PostMapping
    26.      public ResponseResult add(@RequestBody Menu menu) {
    27.           menuService.save(menu);
    28.           return ResponseResult.okResult();
    29.      }
    30.  
    31.      @GetMapping("/{menuId}")
    32.      public ResponseResult getInfoById(@PathVariable("menuId") Long menuId){
    33.           Menu menu = menuService.getById(menuId);
    34.           return ResponseResult.okResult(menu);
    35.      }
    36.  
    37. }
    3.1.3 测试

    点击修改按钮后，回显出菜单的详情信息

    3.2 修改菜单

    3.2.1 修改菜单接口分析
    请求方式请求路径是否需求token头
    PUTsystem/menu是

    请求体参数：

    Menu类对应的json格式

    响应格式：

    1. {
    2. 	"code":200,
    3. 	"msg":"操作成功"
    4. }

    如果把父菜单设置为当前菜单:

    1. {
    2. 	"code":500,
    3. 	"msg":"修改菜单'写博文'失败，上级菜单不能选择自己"
    4. }
    3.2.2 代码实现

    第一步：Controller层新增

    1. package com.keke.controller;
    2.  
    3.  
    4. import com.keke.domain.ResponseResult;
    5. import com.keke.domain.entity.Menu;
    6. import com.keke.service.MenuService;
    7. import org.springframework.beans.factory.annotation.Autowired;
    8. import org.springframework.web.bind.annotation.*;
    9.  
    10. @RestController
    11. @RequestMapping("/system/menu")
    12. public class MenuController {
    13.  
    14.      @Autowired
    15.      private MenuService menuService;
    16.  
    17.  
    18.      //查询菜单列表
    19.      @GetMapping("/list")
    20.      public ResponseResult selectAllMenu(Menu menu){
    21.           return menuService.selectAllMenu(menu);
    22.      }
    23.  
    24.      //新增菜单
    25.      @PostMapping
    26.      public ResponseResult add(@RequestBody Menu menu) {
    27.           menuService.save(menu);
    28.           return ResponseResult.okResult();
    29.      }
    30.  
    31.      @GetMapping("/{menuId}")
    32.      public ResponseResult getInfoById(@PathVariable("menuId") Long menuId){
    33.           Menu menu = menuService.getById(menuId);
    34.           return ResponseResult.okResult(menu);
    35.      }
    36.  
    37.      @PutMapping
    38.      public ResponseResult editMenu(@RequestBody Menu menu){
    39.           return menuService.editMenu(menu);
    40.      }
    41.  
    42. }

    第二步：domain/entity的Menu实体类修改四个字段，设置为mp自动填充

    1. package com.keke.domain.entity;
    2.  
    3. import java.util.Date;
    4. import java.util.List;
    5.  
    6. import com.baomidou.mybatisplus.annotation.FieldFill;
    7. import com.baomidou.mybatisplus.annotation.TableField;
    8. import lombok.AllArgsConstructor;
    9. import lombok.Data;
    10. import lombok.NoArgsConstructor;
    11. import com.baomidou.mybatisplus.annotation.TableName;
    12. import lombok.experimental.Accessors;
    13.  
    14. /**
    15.  * 菜单权限表(Menu)表实体类
    16.  *
    17.  * @author makejava
    18.  * @since 2023-10-18 20:55:24
    19.  */
    20. @SuppressWarnings("serial")
    21. @Data
    22. @NoArgsConstructor
    23. @AllArgsConstructor
    24. @Accessors(chain = true)
    25. @TableName("sys_menu")
    26. public class Menu {
    27.     //菜单ID
    28.     private Long id;
    29.     //菜单名称
    30.     private String menuName;
    31.     //父菜单ID
    32.     private Long parentId;
    33.     //显示顺序
    34.     private Integer orderNum;
    35.     //路由地址
    36.     private String path;
    37.     //组件路径
    38.     private String component;
    39.     //是否为外链（0是 1否）
    40.     private Integer isFrame;
    41.     //菜单类型（M目录 C菜单 F按钮）
    42.     private String menuType;
    43.     //菜单状态（0显示 1隐藏）
    44.     private String visible;
    45.     //菜单状态（0正常 1停用）
    46.     private String status;
    47.     //权限标识
    48.     private String perms;
    49.     //菜单图标
    50.     private String icon;
    51.     //创建者
    52.     @TableField(fill = FieldFill.INSERT)
    53.     private Long createBy;
    54.     //创建时间
    55.     @TableField(fill = FieldFill.INSERT)
    56.     private Date createTime;
    57.     //更新者
    58.     @TableField(fill = FieldFill.INSERT_UPDATE)
    59.     private Long updateBy;
    60.     //更新时间
    61.     @TableField(fill = FieldFill.INSERT_UPDATE)
    62.     private Date updateTime;
    63.     //备注
    64.     private String remark;
    65.     
    66.     private String delFlag;
    67.  
    68.     //由于数据库没有children字段，所以我们要添加@TableField(exist = false)注解
    69.     // 让mybatis在查表时不查询这个字段
    70.     @TableField(exist = false)
    71.     private List children;
    72. }

    第三步：service层新增

    1. package com.keke.service;
    2.  
    3. import com.baomidou.mybatisplus.extension.service.IService;
    4. import com.keke.domain.ResponseResult;
    5. import com.keke.domain.entity.Menu;
    6.  
    7. import java.util.List;
    8.  
    9.  
    10. /**
    11.  * 菜单权限表(Menu)表服务接口
    12.  *
    13.  * @author makejava
    14.  * @since 2023-10-18 20:55:48
    15.  */
    16. public interface MenuService extends IService {
    17.  
    18.  
    19.      //查询用户权限信息
    20.      List selectPermsByUserId(Long userId);
    21.  
    22.      //查询用户的路由信息，也就是权限菜单
    23.      List selectRouterMenuTreeByUserId(Long userId);
    24.  
    25.      ResponseResult selectAllMenu(Menu menu);
    26.  
    27.      ResponseResult editMenu(Menu menu);
    28.  
    29. }

    第四步：impl层新增

    1. package com.keke.service.impl;
    2.  
    3. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
    4. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
    5. import com.keke.constants.SystemConstants;
    6. import com.keke.domain.ResponseResult;
    7. import com.keke.domain.entity.Menu;
    8. import com.keke.domain.vo.AdminMenuVo;
    9. import com.keke.mapper.MenuMapper;
    10. import com.keke.service.MenuService;
    11. import com.keke.utils.BeanCopyUtils;
    12. import com.keke.utils.SecurityUtils;
    13. import org.springframework.beans.factory.annotation.Autowired;
    14. import org.springframework.stereotype.Service;
    15. import org.springframework.util.StringUtils;
    16.  
    17. import java.util.List;
    18. import java.util.function.Function;
    19. import java.util.stream.Collectors;
    20.  
    21. /**
    22.  * 菜单权限表(Menu)表服务实现类
    23.  *
    24.  * @author makejava
    25.  * @since 2023-10-18 20:55:48
    26.  */
    27. @Service("menuService")
    28. public class MenuServiceImpl extends ServiceImpl implements MenuService {
    29.  
    30.      @Autowired
    31.      private MenuService menuService;
    32.  
    33.      //根据用户id查询权限关键字
    34.      @Override
    35.      public List selectPermsByUserId(Long userId) {
    36.           //如果用户id为1代表管理员，roles 中只需要有admin，
    37.           // permissions中需要有所有菜单类型为C(菜单)或者F(按钮)的，状态为正常的，未被删除的权限
    38.           if(SecurityUtils.isAdmin()) {
    39.                LambdaQueryWrapper lambdaQueryWrapper = new LambdaQueryWrapper<>();
    40.                lambdaQueryWrapper.in(Menu::getMenuType, SystemConstants.MENU, SystemConstants.BUTTON);
    41.                lambdaQueryWrapper.eq(Menu::getStatus, SystemConstants.STATUS_NORMAL);
    42.                //由于我们的逻辑删除字段已经配置了，所以无需封装lambdaQueryWrapper
    43.                List menuList = list(lambdaQueryWrapper);
    44.                //我们需要的是String类型的集合，这里我们要进行数据的处理，这里采用流的方式
    45.                List permissions = menuList.stream()
    46.                        .map(new Function() {
    47.                             @Override
    48.                             public String apply(Menu menu) {
    49.                                  String perms = menu.getPerms();
    50.                                  return perms;
    51.                             }
    52.                        })
    53.                        .collect(Collectors.toList());
    54.                return permissions;
    55.           }
    56.           //否则返回这个用户所具有的权限
    57.           //这里我们需要进行连表查询，因为我们的用户先和角色关联，然后角色才跟权限关联
    58.           MenuMapper menuMapper = getBaseMapper();
    59.           //我们期望menuMapper中有一个方法可以直接帮我们去实现这个复杂的逻辑，这里直接返回
    60.           return menuMapper.selectPermsByUserId(userId);
    61.      }
    62.  
    63.      @Override
    64.      public List selectRouterMenuTreeByUserId(Long userId) {
    65.           MenuMapper menuMapper = getBaseMapper();
    66.           List menus = null;
    67.           //如果是管理员，返回所有
    68.           if(SecurityUtils.isAdmin()){
    69.                menus = menuMapper.selectAllRoutersMenu();
    70.           }else {
    71.                //如果不是管理员，返回对应用户的菜单
    72.                menus = menuMapper.selectRoutersMenuTreeByUserId(userId);
    73.           }
    74.           //因为上面的查询都是从数据库进行查询，所以无法封装children，这里构建Tree
    75.  
    76.           List menuTree = buildMenuTree(menus,0L);
    77.           return menuTree;
    78.      }
    79.  
    80.      @Override
    81.      public ResponseResult selectAllMenu(Menu menu) {
    82.           //可以针对菜单名进行模糊查询。也可以针对菜单的状态进行查询
    83.           LambdaQueryWrapper lambdaQueryWrapper = new LambdaQueryWrapper<>();
    84.           lambdaQueryWrapper.like(StringUtils.hasText(menu.getMenuName()),Menu::getMenuName,menu.getMenuName());
    85.           lambdaQueryWrapper.eq(StringUtils.hasText(menu.getStatus()),Menu::getStatus,menu.getStatus());
    86.           //排序 parent_id和order_num
    87.           lambdaQueryWrapper.orderByAsc(Menu::getParentId,Menu::getOrderNum);
    88.           List menus = list(lambdaQueryWrapper);
    89.           List adminMenuVos = BeanCopyUtils.copyBeanList(menus, AdminMenuVo.class);
    90.           return ResponseResult.okResult(adminMenuVos);
    91.      }
    92.  
    93.      @Override
    94.      public ResponseResult editMenu(Menu menu) {
    95.           if(menu.getParentId().equals(menu.getId())){
    96.                return ResponseResult.okResult(500,"修改菜单" + "'" + menu.getMenuName() + "'" + "失败，上级菜单不能选择自己");
    97.           }
    98.           updateById(menu);
    99.           return ResponseResult.okResult();
    100.      }
    101.  
    102.  
    103.      /**
    104.       * 构建MenuTree
    105.       * 思路先找第一层级的菜单，就是找到id于parentId的对应关系，然后把parentId设置为Id的children
    106.       * @param menus
    107.       * @return
    108.       */
    109.      private List buildMenuTree(List menus,Long parentId) {
    110.           //转化流处理
    111.           List menuTree = menus.stream()
    112.                   //过滤掉除一级菜单之外的菜单
    113.                   .filter(menu -> menu.getParentId().equals(parentId))
    114.                   //然后将获取其子菜单设置到children字段，并返回
    115.                   .map(m -> m.setChildren(gerChildren(m, menus)))
    116.                   .collect(Collectors.toList());
    117.           return menuTree;
    118.      }
    119.  
    120.      //获取当前菜单的子菜单
    121.      private List gerChildren(Menu menu, List menus) {
    122.           //流处理，遍历每一个流对象，筛选出流对象的parentId=menu的id，即过滤
    123.           List children = menus.stream()
    124.                   .filter(m -> m.getParentId().equals(menu.getId()))
    125.                   //这里其实不必要写，这一步的逻辑是如果有三级，
    126.                   //可以把流对象中再过筛选出子菜单设置给对应的children并返回
    127.                   .map(m -> m.setChildren(gerChildren(m,menus)))
    128.                   .collect(Collectors.toList());
    129.           return children;
    130.      }
    131.  
    132. }
    3.2.3 测试

    4. 删除菜单

    能够删除菜单，但是如果要删除的菜单有子菜单则提示：存在子菜单不允许删除 并且删除失败

    4.1 接口分析

    请求方式请求路径是否需求token头
    DELETEcontent/article/{menuId}是

    请求参数PathVariable参数：

    menuId：要删除菜单的id

    响应格式： 

    1. {
    2. 	"code":200,
    3. 	"msg":"操作成功"
    4. }

    如果有子菜单

    1. {
    2. 	"code":500,
    3. 	"msg":"存在子菜单不允许删除"
    4. }

     4.2 代码实现

    第一步：controller层新增

    1. package com.keke.controller;
    2.  
    3.  
    4. import com.keke.domain.ResponseResult;
    5. import com.keke.domain.entity.Menu;
    6. import com.keke.service.MenuService;
    7. import org.springframework.beans.factory.annotation.Autowired;
    8. import org.springframework.web.bind.annotation.*;
    9.  
    10. @RestController
    11. @RequestMapping("/system/menu")
    12. public class MenuController {
    13.  
    14.      @Autowired
    15.      private MenuService menuService;
    16.  
    17.  
    18.      //查询菜单列表
    19.      @GetMapping("/list")
    20.      public ResponseResult selectAllMenu(Menu menu){
    21.           return menuService.selectAllMenu(menu);
    22.      }
    23.  
    24.      //新增菜单
    25.      @PostMapping
    26.      public ResponseResult add(@RequestBody Menu menu) {
    27.           menuService.save(menu);
    28.           return ResponseResult.okResult();
    29.      }
    30.  
    31.      @GetMapping("/{menuId}")
    32.      public ResponseResult getInfoById(@PathVariable("menuId") Long menuId){
    33.           Menu menu = menuService.getById(menuId);
    34.           return ResponseResult.okResult(menu);
    35.      }
    36.  
    37.      @PutMapping
    38.      public ResponseResult editMenu(@RequestBody Menu menu){
    39.           return menuService.editMenu(menu);
    40.      }
    41.  
    42.      @DeleteMapping("/{menuId}")
    43.      public ResponseResult deleteMenu(@PathVariable("menuId") Long menuId){
    44.           return menuService.deleteMenu(menuId);
    45.      }
    46.  
    47. }

    第二步：service层新增

    1. package com.keke.service;
    2.  
    3. import com.baomidou.mybatisplus.extension.service.IService;
    4. import com.keke.domain.ResponseResult;
    5. import com.keke.domain.entity.Menu;
    6.  
    7. import java.util.List;
    8.  
    9.  
    10. /**
    11.  * 菜单权限表(Menu)表服务接口
    12.  *
    13.  * @author makejava
    14.  * @since 2023-10-18 20:55:48
    15.  */
    16. public interface MenuService extends IService {
    17.  
    18.  
    19.      //查询用户权限信息
    20.      List selectPermsByUserId(Long userId);
    21.  
    22.      //查询用户的路由信息，也就是权限菜单
    23.      List selectRouterMenuTreeByUserId(Long userId);
    24.  
    25.      ResponseResult selectAllMenu(Menu menu);
    26.  
    27.      ResponseResult editMenu(Menu menu);
    28.  
    29.      ResponseResult deleteMenu(Long menuId);
    30. }

    第三步：impl层新增

    1. package com.keke.service.impl;
    2.  
    3. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
    4. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
    5. import com.keke.constants.SystemConstants;
    6. import com.keke.domain.ResponseResult;
    7. import com.keke.domain.entity.Menu;
    8. import com.keke.domain.vo.AdminMenuVo;
    9. import com.keke.mapper.MenuMapper;
    10. import com.keke.service.MenuService;
    11. import com.keke.utils.BeanCopyUtils;
    12. import com.keke.utils.SecurityUtils;
    13. import org.springframework.beans.factory.annotation.Autowired;
    14. import org.springframework.stereotype.Service;
    15. import org.springframework.util.StringUtils;
    16.  
    17. import java.util.List;
    18. import java.util.function.Function;
    19. import java.util.stream.Collectors;
    20.  
    21. /**
    22.  * 菜单权限表(Menu)表服务实现类
    23.  *
    24.  * @author makejava
    25.  * @since 2023-10-18 20:55:48
    26.  */
    27. @Service("menuService")
    28. public class MenuServiceImpl extends ServiceImpl implements MenuService {
    29.  
    30.      @Autowired
    31.      private MenuService menuService;
    32.  
    33.      //根据用户id查询权限关键字
    34.      @Override
    35.      public List selectPermsByUserId(Long userId) {
    36.           //如果用户id为1代表管理员，roles 中只需要有admin，
    37.           // permissions中需要有所有菜单类型为C(菜单)或者F(按钮)的，状态为正常的，未被删除的权限
    38.           if(SecurityUtils.isAdmin()) {
    39.                LambdaQueryWrapper lambdaQueryWrapper = new LambdaQueryWrapper<>();
    40.                lambdaQueryWrapper.in(Menu::getMenuType, SystemConstants.MENU, SystemConstants.BUTTON);
    41.                lambdaQueryWrapper.eq(Menu::getStatus, SystemConstants.STATUS_NORMAL);
    42.                //由于我们的逻辑删除字段已经配置了，所以无需封装lambdaQueryWrapper
    43.                List menuList = list(lambdaQueryWrapper);
    44.                //我们需要的是String类型的集合，这里我们要进行数据的处理，这里采用流的方式
    45.                List permissions = menuList.stream()
    46.                        .map(new Function() {
    47.                             @Override
    48.                             public String apply(Menu menu) {
    49.                                  String perms = menu.getPerms();
    50.                                  return perms;
    51.                             }
    52.                        })
    53.                        .collect(Collectors.toList());
    54.                return permissions;
    55.           }
    56.           //否则返回这个用户所具有的权限
    57.           //这里我们需要进行连表查询，因为我们的用户先和角色关联，然后角色才跟权限关联
    58.           MenuMapper menuMapper = getBaseMapper();
    59.           //我们期望menuMapper中有一个方法可以直接帮我们去实现这个复杂的逻辑，这里直接返回
    60.           return menuMapper.selectPermsByUserId(userId);
    61.      }
    62.  
    63.      @Override
    64.      public List selectRouterMenuTreeByUserId(Long userId) {
    65.           MenuMapper menuMapper = getBaseMapper();
    66.           List menus = null;
    67.           //如果是管理员，返回所有
    68.           if(SecurityUtils.isAdmin()){
    69.                menus = menuMapper.selectAllRoutersMenu();
    70.           }else {
    71.                //如果不是管理员，返回对应用户的菜单
    72.                menus = menuMapper.selectRoutersMenuTreeByUserId(userId);
    73.           }
    74.           //因为上面的查询都是从数据库进行查询，所以无法封装children，这里构建Tree
    75.  
    76.           List menuTree = buildMenuTree(menus,0L);
    77.           return menuTree;
    78.      }
    79.  
    80.      @Override
    81.      public ResponseResult selectAllMenu(Menu menu) {
    82.           //可以针对菜单名进行模糊查询。也可以针对菜单的状态进行查询
    83.           LambdaQueryWrapper lambdaQueryWrapper = new LambdaQueryWrapper<>();
    84.           lambdaQueryWrapper.like(StringUtils.hasText(menu.getMenuName()),Menu::getMenuName,menu.getMenuName());
    85.           lambdaQueryWrapper.eq(StringUtils.hasText(menu.getStatus()),Menu::getStatus,menu.getStatus());
    86.           //排序 parent_id和order_num
    87.           lambdaQueryWrapper.orderByAsc(Menu::getParentId,Menu::getOrderNum);
    88.           List menus = list(lambdaQueryWrapper);
    89.           List adminMenuVos = BeanCopyUtils.copyBeanList(menus, AdminMenuVo.class);
    90.           return ResponseResult.okResult(adminMenuVos);
    91.      }
    92.  
    93.      @Override
    94.      public ResponseResult editMenu(Menu menu) {
    95.           if(menu.getParentId().equals(menu.getId())){
    96.                return ResponseResult.okResult(500,"修改菜单" + "'" + menu.getMenuName() + "'" + "失败，上级菜单不能选择自己");
    97.           }
    98.           updateById(menu);
    99.           return ResponseResult.okResult();
    100.      }
    101.  
    102.      @Override
    103.      public ResponseResult deleteMenu(Long menuId) {
    104.           Menu menu = menuService.getById(menuId);
    105.           //如果该菜单有子菜单，那么就提示不能删除，逻辑就是查询菜单表中是否有父菜单id是当前菜单id
    106.           LambdaQueryWrapper lambdaQueryWrapper = new LambdaQueryWrapper<>();
    107.           lambdaQueryWrapper.eq(Menu::getParentId,menuId);
    108.           List menus = list(lambdaQueryWrapper);
    109.           if(!menus.isEmpty()) {
    110.                return ResponseResult.okResult(500, "存在子菜单不允许删除");
    111.           }
    112.           removeById(menuId);
    113.           return ResponseResult.okResult();
    114.      }
    115.  
    116.  
    117.      /**
    118.       * 构建MenuTree
    119.       * 思路先找第一层级的菜单，就是找到id于parentId的对应关系，然后把parentId设置为Id的children
    120.       * @param menus
    121.       * @return
    122.       */
    123.      private List buildMenuTree(List menus,Long parentId) {
    124.           //转化流处理
    125.           List menuTree = menus.stream()
    126.                   //过滤掉除一级菜单之外的菜单
    127.                   .filter(menu -> menu.getParentId().equals(parentId))
    128.                   //然后将获取其子菜单设置到children字段，并返回
    129.                   .map(m -> m.setChildren(gerChildren(m, menus)))
    130.                   .collect(Collectors.toList());
    131.           return menuTree;
    132.      }
    133.  
    134.      //获取当前菜单的子菜单
    135.      private List gerChildren(Menu menu, List menus) {
    136.           //流处理，遍历每一个流对象，筛选出流对象的parentId=menu的id，即过滤
    137.           List children = menus.stream()
    138.                   .filter(m -> m.getParentId().equals(menu.getId()))
    139.                   //这里其实不必要写，这一步的逻辑是如果有三级，
    140.                   //可以把流对象中再过筛选出子菜单设置给对应的children并返回
    141.                   .map(m -> m.setChildren(gerChildren(m,menus)))
    142.                   .collect(Collectors.toList());
    143.           return children;
    144.      }
    145. }

    4.3 测试

     

    十二、后台模块-角色列表

    1. 查询角色

    需要有角色列表分页查询的功能。

    要求能够针对角色名称进行模糊查询。

    要求能够针对状态进行查询。

    要求按照role_sort进行升序排列。

    1.1 接口分析

    请求方式请求路径是否需求token头
    GETsystem/role/list是

    Query格式请求参数：

    1. pageNum: 页码
    2.  
    3. pageSize: 每页条数
    4.  
    5. roleName：角色名称
    6.  
    7. status：状态

    响应格式：

    1. {
    2. 	"code":200,
    3. 	"data":{
    4. 		"rows":[
    5. 			{
    6. 				"id":"12",
    7. 				"roleKey":"link",
    8. 				"roleName":"友链审核员",
    9. 				"roleSort":"1",
    10. 				"status":"0"
    11. 			}
    12. 		],
    13. 		"total":"1"
    14. 	},
    15. 	"msg":"操作成功"
    16. }

    1.2 代码实现

    第一步：新建RoleController新增

    1. package com.keke.controller;
    2.  
    3. import com.keke.domain.ResponseResult;
    4. import com.keke.domain.dto.ChangeRoleStatusDto;
    5. import com.keke.domain.entity.Role;
    6. import com.keke.service.RoleService;
    7. import org.springframework.beans.factory.annotation.Autowired;
    8. import org.springframework.web.bind.annotation.*;
    9.  
    10. @RestController
    11. @RequestMapping("/system/role")
    12. public class RoleController {
    13.  
    14.      @Autowired
    15.      private RoleService roleService;
    16.  
    17.      @GetMapping("/list")
    18.      public ResponseResult selectPageRole(Role role,Integer pageNum,Integer pageSize){
    19.           return roleService.selectPageRole(role,pageNum,pageSize);
    20.      }
    21. }

    第二步：service层新增

    1. package com.keke.service;
    2.  
    3. import com.baomidou.mybatisplus.extension.service.IService;
    4. import com.keke.domain.ResponseResult;
    5. import com.keke.domain.dto.ChangeRoleStatusDto;
    6. import com.keke.domain.entity.Role;
    7.  
    8. import java.util.List;
    9.  
    10.  
    11. /**
    12.  * 角色信息表(Role)表服务接口
    13.  *
    14.  * @author makejava
    15.  * @since 2023-10-18 21:04:06
    16.  */
    17. public interface RoleService extends IService {
    18.  
    19.      List selectRoleKeyByUserId(Long userId);
    20.  
    21.  
    22.      ResponseResult selectPageRole(Role role, Integer pageNum, Integer pageSize);
    23. }

    第三步：impl层新增

    1. package com.keke.service.impl;
    2.  
    3. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
    4. import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
    5. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
    6. import com.keke.domain.ResponseResult;
    7. import com.keke.domain.dto.ChangeRoleStatusDto;
    8. import com.keke.domain.entity.Role;
    9. import com.keke.domain.vo.PageVo;
    10. import com.keke.mapper.RoleMapper;
    11. import com.keke.service.RoleService;
    12. import org.springframework.stereotype.Service;
    13. import org.springframework.util.StringUtils;
    14.  
    15. import java.util.ArrayList;
    16. import java.util.List;
    17.  
    18. /**
    19.  * 角色信息表(Role)表服务实现类
    20.  *
    21.  * @author makejava
    22.  * @since 2023-10-18 21:04:06
    23.  */
    24. @Service("roleService")
    25. public class RoleServiceImpl extends ServiceImpl implements RoleService {
    26.  
    27.  
    28.      //根据用户id查询角色信息
    29.      @Override
    30.      public List selectRoleKeyByUserId(Long userId) {
    31.           //如果userId为1，那么角色权限字符串就只需要返回一个admin
    32.           if(userId==1L){
    33.                List roles = new ArrayList<>();
    34.                roles.add("admin");
    35.                return roles;
    36.           }
    37.           //如果用户id不为1，那么需要根据userId连表查询对应的roleId，然后再去角色表中去查询
    38.           //对应的角色权限字符串
    39.           //这里我们期望RoleMapper中封装一个方法去帮我们实现这个复杂的操作
    40.           RoleMapper roleMapper = getBaseMapper();
    41.           return roleMapper.selectRoleKeyByUserId(userId);
    42.      }
    43.  
    44.      @Override
    45.      public ResponseResult selectPageRole(Role role, Integer pageNum, Integer pageSize) {
    46.           LambdaQueryWrapper lambdaQueryWrapper = new LambdaQueryWrapper<>();
    47.           lambdaQueryWrapper.like(StringUtils.hasText(role.getRoleName()),Role::getRoleName,role.getRoleName());
    48.           lambdaQueryWrapper.eq(StringUtils.hasText(role.getStatus()),Role::getStatus,role.getStatus());
    49.           lambdaQueryWrapper.orderByAsc(Role::getRoleSort);
    50.           Page page = new Page<>(pageNum,pageSize);
    51.           page(page,lambdaQueryWrapper);
    52.           PageVo pageVo = new PageVo(page.getRecords(),page.getTotal());
    53.           return ResponseResult.okResult(pageVo);
    54.      }
    55. }

    1.3 测试

    2. 改变角色状态

    要求能够修改角色的停启用状态

    2.1 接口分析

    请求方式请求路径是否需求token头
    PUTsystem/role/changeStatus是

    请求体：

    1. {
    2.     "roleId":"11",
    3.     "status":"1"
    4. }

    响应格式：

    1. {
    2. 	"code":200,
    3. 	"msg":"操作成功"
    4. }

    2.2 代码实现

    第一步：controller层新增

    1. package com.keke.controller;
    2.  
    3. import com.keke.domain.ResponseResult;
    4. import com.keke.domain.dto.ChangeRoleStatusDto;
    5. import com.keke.domain.entity.Role;
    6. import com.keke.service.RoleService;
    7. import org.springframework.beans.factory.annotation.Autowired;
    8. import org.springframework.web.bind.annotation.*;
    9.  
    10. @RestController
    11. @RequestMapping("/system/role")
    12. public class RoleController {
    13.  
    14.      @Autowired
    15.      private RoleService roleService;
    16.  
    17.      @GetMapping("/list")
    18.      public ResponseResult selectPageRole(Role role,Integer pageNum,Integer pageSize){
    19.           return roleService.selectPageRole(role,pageNum,pageSize);
    20.      }
    21.  
    22.      @PutMapping("/changeStatus")
    23.      public ResponseResult changeRoleStatus(@RequestBody ChangeRoleStatusDto changeRoleStatusDto){
    24.           return roleService.changeRoleStatus(changeRoleStatusDto);
    25.      }
    26. }

    第二步：domain/dto新增

    1. package com.keke.domain.dto;
    2.  
    3. import lombok.AllArgsConstructor;
    4. import lombok.Data;
    5. import lombok.NoArgsConstructor;
    6.  
    7. @Data
    8. @AllArgsConstructor
    9. @NoArgsConstructor
    10. public class ChangeRoleStatusDto {
    11.  
    12.      private Long roleId;
    13.      //角色状态（0正常 1停用）
    14.      private String status;
    15.  
    16. }

    第三步：service层新增

    1. package com.keke.service;
    2.  
    3. import com.baomidou.mybatisplus.extension.service.IService;
    4. import com.keke.domain.ResponseResult;
    5. import com.keke.domain.dto.ChangeRoleStatusDto;
    6. import com.keke.domain.entity.Role;
    7.  
    8. import java.util.List;
    9.  
    10.  
    11. /**
    12.  * 角色信息表(Role)表服务接口
    13.  *
    14.  * @author makejava
    15.  * @since 2023-10-18 21:04:06
    16.  */
    17. public interface RoleService extends IService {
    18.  
    19.      List selectRoleKeyByUserId(Long userId);
    20.  
    21.  
    22.      ResponseResult selectPageRole(Role role, Integer pageNum, Integer pageSize);
    23.  
    24.      ResponseResult changeRoleStatus(ChangeRoleStatusDto changeRoleStatusDto);
    25. }

    第四步：impl层新增

    1. package com.keke.service.impl;
    2.  
    3. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
    4. import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
    5. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
    6. import com.keke.domain.ResponseResult;
    7. import com.keke.domain.dto.ChangeRoleStatusDto;
    8. import com.keke.domain.entity.Role;
    9. import com.keke.domain.vo.PageVo;
    10. import com.keke.mapper.RoleMapper;
    11. import com.keke.service.RoleService;
    12. import org.springframework.stereotype.Service;
    13. import org.springframework.util.StringUtils;
    14.  
    15. import java.util.ArrayList;
    16. import java.util.List;
    17.  
    18. /**
    19.  * 角色信息表(Role)表服务实现类
    20.  *
    21.  * @author makejava
    22.  * @since 2023-10-18 21:04:06
    23.  */
    24. @Service("roleService")
    25. public class RoleServiceImpl extends ServiceImpl implements RoleService {
    26.  
    27.  
    28.      //根据用户id查询角色信息
    29.      @Override
    30.      public List selectRoleKeyByUserId(Long userId) {
    31.           //如果userId为1，那么角色权限字符串就只需要返回一个admin
    32.           if(userId==1L){
    33.                List roles = new ArrayList<>();
    34.                roles.add("admin");
    35.                return roles;
    36.           }
    37.           //如果用户id不为1，那么需要根据userId连表查询对应的roleId，然后再去角色表中去查询
    38.           //对应的角色权限字符串
    39.           //这里我们期望RoleMapper中封装一个方法去帮我们实现这个复杂的操作
    40.           RoleMapper roleMapper = getBaseMapper();
    41.           return roleMapper.selectRoleKeyByUserId(userId);
    42.      }
    43.  
    44.      @Override
    45.      public ResponseResult selectPageRole(Role role, Integer pageNum, Integer pageSize) {
    46.           LambdaQueryWrapper lambdaQueryWrapper = new LambdaQueryWrapper<>();
    47.           lambdaQueryWrapper.like(StringUtils.hasText(role.getRoleName()),Role::getRoleName,role.getRoleName());
    48.           lambdaQueryWrapper.eq(StringUtils.hasText(role.getStatus()),Role::getStatus,role.getStatus());
    49.           lambdaQueryWrapper.orderByAsc(Role::getRoleSort);
    50.           Page page = new Page<>(pageNum,pageSize);
    51.           page(page,lambdaQueryWrapper);
    52.           PageVo pageVo = new PageVo(page.getRecords(),page.getTotal());
    53.           return ResponseResult.okResult(pageVo);
    54.      }
    55.  
    56.      @Override
    57.      public ResponseResult changeRoleStatus(ChangeRoleStatusDto changeRoleStatusDto) {
    58.           Long roleId = changeRoleStatusDto.getRoleId();
    59.           Role role = getById(roleId);
    60.           role.setStatus(changeRoleStatusDto.getStatus());
    61.           updateById(role);
    62.           return ResponseResult.okResult();
    63.      }
    64. }

    2.3 测试

    把该用户启用

    数据库中状态正常

    3. 新增角色

    需要提供新增角色的功能。新增角色时能够直接设置角色所关联的菜单权限

    首先应该获取权限菜单数，勾选，然后才能新增

    分析下来，有两个接口需要实现

    3.1 获取菜单权限树接口

    3.1.1 接口分析
    请求方式请求路径是否需求token头
    GET/system/menu/treeselect是

    无需请求参数

    响应格式：

    1. {
    2. 	"code":200,
    3. 	"data":[
    4. 		{
    5. 			"children":[],
    6. 			"id":"2023",
    7. 			"label":"写博文",
    8. 			"parentId":"0"
    9. 		},
    10. 		{
    11. 			"children":[
    12. 				{
    13. 					"children":[
    14. 						{
    15. 							"children":[],
    16. 							"id":"1001",
    17. 							"label":"用户查询",
    18. 							"parentId":"100"
    19. 						},
    20. 						{
    21. 							"children":[],
    22. 							"id":"1007",
    23. 							"label":"重置密码",
    24. 							"parentId":"100"
    25. 						}
    26. 					],
    27. 					"id":"100",
    28. 					"label":"用户管理",
    29. 					"parentId":"1"
    30. 				},
    31. 				{
    32. 					"children":[
    33. 						{
    34. 							"children":[],
    35. 							"id":"2024",
    36. 							"label":"友链新增",
    37. 							"parentId":"2022"
    38. 						},
    39. 						{
    40. 							"children":[],
    41. 							"id":"2025",
    42. 							"label":"友链修改",
    43. 							"parentId":"2022"
    44. 						},
    45. 						{
    46. 							"children":[],
    47. 							"id":"2026",
    48. 							"label":"友链删除",
    49. 							"parentId":"2022"
    50. 						},
    51. 						{
    52. 							"children":[],
    53. 							"id":"2027",
    54. 							"label":"友链查询",
    55. 							"parentId":"2022"
    56. 						}
    57. 					],
    58. 					"id":"2022",
    59. 					"label":"友链管理",
    60. 					"parentId":"2017"
    61. 				},
    62. 				{
    63. 					"children":[],
    64. 					"id":"2021",
    65. 					"label":"标签管理",
    66. 					"parentId":"2017"
    67. 				}
    68. 			],
    69. 			"id":"2017",
    70. 			"label":"内容管理",
    71. 			"parentId":"0"
    72. 		}
    73. 	],
    74. 	"msg":"操作成功"
    75. }
    3.1.2 代码实现

    第一步：keke-framework的domain/entity Role实体类修改如下，加上mp自填充，并且加上menuIds字段

    1. package com.keke.domain.entity;
    2.  
    3. import java.util.Date;
    4. import java.io.Serializable;
    5. import java.util.List;
    6.  
    7. import com.baomidou.mybatisplus.annotation.FieldFill;
    8. import com.baomidou.mybatisplus.annotation.TableField;
    9. import lombok.AllArgsConstructor;
    10. import lombok.Data;
    11. import lombok.NoArgsConstructor;
    12. import com.baomidou.mybatisplus.annotation.TableName;
    13.  
    14. /**
    15.  * 角色信息表(Role)表实体类
    16.  *
    17.  * @author makejava
    18.  * @since 2023-10-18 21:03:52
    19.  */
    20. @SuppressWarnings("serial")
    21. @Data
    22. @NoArgsConstructor
    23. @AllArgsConstructor
    24. @TableName("sys_role")
    25. public class Role {
    26.     //角色ID
    27.     private Long id;
    28.     //角色名称
    29.     private String roleName;
    30.     //角色权限字符串
    31.     private String roleKey;
    32.     //显示顺序
    33.     private Integer roleSort;
    34.     //角色状态（0正常 1停用）
    35.     private String status;
    36.     //删除标志（0代表存在 1代表删除）
    37.     private String delFlag;
    38.     //创建者
    39.     @TableField(fill = FieldFill.INSERT)
    40.     private Long createBy;
    41.     //创建时间
    42.     @TableField(fill = FieldFill.INSERT)
    43.     private Date createTime;
    44.     //更新者
    45.     @TableField(fill = FieldFill.INSERT_UPDATE)
    46.     private Long updateBy;
    47.     //更新时间
    48.     @TableField(fill = FieldFill.INSERT_UPDATE)
    49.     private Date updateTime;
    50.     //备注
    51.     private String remark;
    52.     //角色关联的menuIds
    53.     List menuIds;
    54. }

    第二步：vo层创建MenuTreeVo 

    1. package com.keke.domain.vo;
    2.  
    3. import lombok.AllArgsConstructor;
    4. import lombok.Data;
    5. import lombok.NoArgsConstructor;
    6. import lombok.experimental.Accessors;
    7.  
    8. import java.util.List;
    9.  
    10.  
    11. @Data
    12. @NoArgsConstructor
    13. @AllArgsConstructor
    14. @Accessors(chain = true)
    15. //新增角色-获取菜单下拉树列表
    16. public class MenuTreeVo {
    17.      private static final long serialVersionUID = 1L;
    18.      /** 节点ID */
    19.      private Long id;
    20.      /** 节点名称 */
    21.      private String label;
    22.      
    23.      private Long parentId;
    24.      /** 子节点 */
    25.      private List children;
    26. }

    第三步：entity层新增RoleMenu实体类

    1. package com.keke.domain.entity;
    2.  
    3. import java.io.Serializable;
    4. import lombok.AllArgsConstructor;
    5. import lombok.Data;
    6. import lombok.NoArgsConstructor;
    7. import com.baomidou.mybatisplus.annotation.TableName;
    8.  
    9. /**
    10.  * 角色和菜单关联表(RoleMenu)表实体类
    11.  *
    12.  * @author makejava
    13.  * @since 2023-10-23 17:00:27
    14.  */
    15. @SuppressWarnings("serial")
    16. @Data
    17. @NoArgsConstructor
    18. @AllArgsConstructor
    19. @TableName("sys_role_menu")
    20. public class RoleMenu {
    21.     //角色ID
    22.     private Long roleId;
    23.     //菜单ID
    24.     private Long menuId;
    25.  
    26. }

    第四步：mapper层新增RoleMenuMapper

    1. package com.keke.mapper;
    2.  
    3. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    4. import com.keke.domain.entity.RoleMenu;
    5.  
    6.  
    7. /**
    8.  * 角色和菜单关联表(RoleMenu)表数据库访问层
    9.  *
    10.  * @author makejava
    11.  * @since 2023-10-23 17:01:09
    12.  */
    13. public interface RoleMenuMapper extends BaseMapper {
    14.  
    15. }

    第五步：service层新增RoleMenuService

    1. package com.keke.service;
    2.  
    3. import com.baomidou.mybatisplus.extension.service.IService;
    4. import com.keke.domain.entity.RoleMenu;
    5.  
    6.  
    7. /**
    8.  * 角色和菜单关联表(RoleMenu)表服务接口
    9.  *
    10.  * @author makejava
    11.  * @since 2023-10-23 17:01:09
    12.  */
    13. public interface RoleMenuService extends IService {
    14.  
    15. }

    第六步：impl层新增RoleMenuServiceImpl

    1. package com.keke.service.impl;
    2.  
    3. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
    4. import com.keke.domain.entity.RoleMenu;
    5. import com.keke.mapper.RoleMenuMapper;
    6. import com.keke.service.RoleMenuService;
    7. import org.springframework.stereotype.Service;
    8.  
    9. /**
    10.  * 角色和菜单关联表(RoleMenu)表服务实现类
    11.  *
    12.  * @author makejava
    13.  * @since 2023-10-23 17:01:09
    14.  */
    15. @Service("roleMenuService")
    16. public class RoleMenuServiceImpl extends ServiceImpl implements RoleMenuService {
    17.  
    18. }

     第七步：在keke-framework工程的utils目录新建SystemConverter类，写入如下，是一个获取菜单下拉树工具类

    1. package com.keke.utils;
    2.  
    3. import com.keke.domain.entity.Menu;
    4. import com.keke.domain.vo.MenuTreeVo;
    5.  
    6. import java.util.List;
    7. import java.util.Objects;
    8. import java.util.stream.Collectors;
    9.  
    10. public class SystemConverter {
    11.  
    12.      private SystemConverter() {}
    13.  
    14.      public static List buildMenuSelectTree(List menus) {
    15.           List MenuTreeVos = menus.stream()
    16.                   .map(m -> new MenuTreeVo(m.getId(), m.getMenuName(), m.getParentId(), null))
    17.                   .collect(Collectors.toList());
    18.           List options = MenuTreeVos.stream()
    19.                   .filter(o -> o.getParentId().equals(0L))
    20.                   .map(o -> o.setChildren(getChildList(MenuTreeVos, o)))
    21.                   .collect(Collectors.toList());
    22.           return options;
    23.      }
    24.  
    25.  
    26.      /**
    27.       * 得到子节点列表
    28.       */
    29.      private static List getChildList(List list, MenuTreeVo option) {
    30.           List options = list.stream()
    31.                   .filter(o -> Objects.equals(o.getParentId(), option.getId()))
    32.                   .map(o -> o.setChildren(getChildList(list, o)))
    33.                   .collect(Collectors.toList());
    34.           return options;
    35.      }
    36. }

    第八步：keke-admin的MenuController中写接口 

    1. package com.keke.controller;
    2.  
    3.  
    4. import com.keke.domain.ResponseResult;
    5. import com.keke.domain.entity.Menu;
    6. import com.keke.domain.vo.AdminMenuVo;
    7. import com.keke.domain.vo.MenuTreeVo;
    8. import com.keke.service.MenuService;
    9. import com.keke.utils.BeanCopyUtils;
    10. import com.keke.utils.SystemConverter;
    11. import org.springframework.beans.factory.annotation.Autowired;
    12. import org.springframework.web.bind.annotation.*;
    13.  
    14. import java.util.List;
    15.  
    16. @RestController
    17. @RequestMapping("/system/menu")
    18. public class MenuController {
    19.  
    20.      @Autowired
    21.      private MenuService menuService;
    22.  
    23.  
    24.      //查询菜单列表
    25.      @GetMapping("/list")
    26.      public ResponseResult selectAllMenu(Menu menu){
    27.           List adminMenuVos = menuService.selectAllMenu(menu);
    28.           return ResponseResult.okResult(adminMenuVos);
    29.      }
    30.  
    31.      //新增菜单
    32.      @PostMapping
    33.      public ResponseResult add(@RequestBody Menu menu) {
    34.           menuService.save(menu);
    35.           return ResponseResult.okResult();
    36.      }
    37.  
    38.      @GetMapping("/{menuId}")
    39.      public ResponseResult getInfoById(@PathVariable("menuId") Long menuId){
    40.           Menu menu = menuService.getById(menuId);
    41.           return ResponseResult.okResult(menu);
    42.      }
    43.  
    44.      @PutMapping
    45.      public ResponseResult editMenu(@RequestBody Menu menu){
    46.           return menuService.editMenu(menu);
    47.      }
    48.  
    49.      @DeleteMapping("/{menuId}")
    50.      public ResponseResult deleteMenu(@PathVariable("menuId") Long menuId){
    51.           return menuService.deleteMenu(menuId);
    52.      }
    53.  
    54.      @GetMapping("/treeselect")
    55.      public ResponseResult treeSelect(){
    56.           //复用之前的selectMenuList方法。方法需要参数，参数可以用来进行条件查询，而这个方法不需要条件，所以直接new Menu()传入
    57.           //这样就可以获取所有的菜单了
    58.           List adminMenuVos = menuService.selectAllMenu(new Menu());
    59.           List menus = BeanCopyUtils.copyBeanList(adminMenuVos, Menu.class);
    60.           List options = SystemConverter.buildMenuSelectTree(menus);
    61.           return ResponseResult.okResult(options);
    62.      }
    63.  
    64. }
    3.1.3 测试

    3.2 新增角色接口

    3.2.1 接口分析
    请求方式请求路径是否需求token头
    POSTsystem/role是

    请求体：

    1. {
    2.     "roleName":"测试新增角色",
    3.     "roleKey":"wds",
    4.     "roleSort":0,
    5.     "status":"0",
    6.     "menuIds":[
    7.         "1",
    8.         "100"
    9.     ],
    10.     "remark":"我是角色备注"
    11. }

    响应格式：

    1. {
    2. 	"code":200,
    3. 	"msg":"操作成功"
    4. }
    3.2.2 代码实现

    第一步：domain/dto层新增

    1. package com.keke.domain.dto;
    2.  
    3. import com.baomidou.mybatisplus.annotation.FieldFill;
    4. import com.baomidou.mybatisplus.annotation.TableField;
    5. import lombok.AllArgsConstructor;
    6. import lombok.Data;
    7. import lombok.NoArgsConstructor;
    8.  
    9. import java.util.Date;
    10. import java.util.List;
    11.  
    12. @Data
    13. @AllArgsConstructor
    14. @NoArgsConstructor
    15. public class AdminAddRoleDto {
    16.      //角色名称
    17.      private String roleName;
    18.      //角色权限字符串
    19.      private String roleKey;
    20.      //显示顺序
    21.      private Integer roleSort;
    22.      //角色状态（0正常 1停用）
    23.      private String status;
    24.      //备注
    25.      private String remark;
    26.      //关联的menuId
    27.      List menuIds;
    28. }

    第二步：domain/entity层新增

    1. package com.keke.domain.entity;
    2.  
    3. import java.io.Serializable;
    4. import lombok.AllArgsConstructor;
    5. import lombok.Data;
    6. import lombok.NoArgsConstructor;
    7. import com.baomidou.mybatisplus.annotation.TableName;
    8.  
    9. /**
    10.  * 角色和菜单关联表(RoleMenu)表实体类
    11.  *
    12.  * @author makejava
    13.  * @since 2023-10-23 17:00:27
    14.  */
    15. @SuppressWarnings("serial")
    16. @Data
    17. @NoArgsConstructor
    18. @AllArgsConstructor
    19. @TableName("sys_role_menu")
    20. public class RoleMenu {
    21.     //角色ID
    22.     private Long roleId;
    23.     //菜单ID
    24.     private Long menuId;
    25.  
    26. }

    第三步：mapper层新增RoleMenuMapper

    1. package com.keke.mapper;
    2.  
    3. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    4. import com.keke.domain.entity.RoleMenu;
    5.  
    6.  
    7. /**
    8.  * 角色和菜单关联表(RoleMenu)表数据库访问层
    9.  *
    10.  * @author makejava
    11.  * @since 2023-10-23 17:01:09
    12.  */
    13. public interface RoleMenuMapper extends BaseMapper {
    14.  
    15. }

    第四步：service新增RoleMenuService

    1. package com.keke.service;
    2.  
    3. import com.baomidou.mybatisplus.extension.service.IService;
    4. import com.keke.domain.entity.RoleMenu;
    5.  
    6.  
    7. /**
    8.  * 角色和菜单关联表(RoleMenu)表服务接口
    9.  *
    10.  * @author makejava
    11.  * @since 2023-10-23 17:01:09
    12.  */
    13. public interface RoleMenuService extends IService {
    14.  
    15. }

    第五步：impl层新增RoleMenuServiceImpl

    1. package com.keke.service.impl;
    2.  
    3. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
    4. import com.keke.domain.entity.RoleMenu;
    5. import com.keke.mapper.RoleMenuMapper;
    6. import com.keke.service.RoleMenuService;
    7. import org.springframework.stereotype.Service;
    8.  
    9. /**
    10.  * 角色和菜单关联表(RoleMenu)表服务实现类
    11.  *
    12.  * @author makejava
    13.  * @since 2023-10-23 17:01:09
    14.  */
    15. @Service("roleMenuService")
    16. public class RoleMenuServiceImpl extends ServiceImpl implements RoleMenuService {
    17.  
    18. }

    第六步：controller的RoleController新增

    1. package com.keke.controller;
    2.  
    3. import com.keke.domain.ResponseResult;
    4. import com.keke.domain.dto.AdminAddRoleDto;
    5. import com.keke.domain.dto.ChangeRoleStatusDto;
    6. import com.keke.domain.entity.Role;
    7. import com.keke.service.RoleService;
    8. import org.springframework.beans.factory.annotation.Autowired;
    9. import org.springframework.web.bind.annotation.*;
    10.  
    11. @RestController
    12. @RequestMapping("/system/role")
    13. public class RoleController {
    14.  
    15.      @Autowired
    16.      private RoleService roleService;
    17.  
    18.      @GetMapping("/list")
    19.      public ResponseResult selectPageRole(Role role,Integer pageNum,Integer pageSize){
    20.           return roleService.selectPageRole(role,pageNum,pageSize);
    21.      }
    22.  
    23.      @PutMapping("/changeStatus")
    24.      public ResponseResult changeRoleStatus(@RequestBody ChangeRoleStatusDto changeRoleStatusDto){
    25.           return roleService.changeRoleStatus(changeRoleStatusDto);
    26.      }
    27.  
    28.      @PostMapping
    29.      public ResponseResult addRole(@RequestBody AdminAddRoleDto adminAddRoleDto){
    30.           return roleService.addRole(adminAddRoleDto);
    31.      }
    32.  
    33. }

    第七步：service层的RoleService新增

    1. package com.keke.service;
    2.  
    3. import com.baomidou.mybatisplus.extension.service.IService;
    4. import com.keke.domain.ResponseResult;
    5. import com.keke.domain.dto.AdminAddRoleDto;
    6. import com.keke.domain.dto.ChangeRoleStatusDto;
    7. import com.keke.domain.entity.Role;
    8.  
    9. import java.util.List;
    10.  
    11.  
    12. /**
    13.  * 角色信息表(Role)表服务接口
    14.  *
    15.  * @author makejava
    16.  * @since 2023-10-18 21:04:06
    17.  */
    18. public interface RoleService extends IService {
    19.  
    20.      List selectRoleKeyByUserId(Long userId);
    21.  
    22.  
    23.      ResponseResult selectPageRole(Role role, Integer pageNum, Integer pageSize);
    24.  
    25.      ResponseResult changeRoleStatus(ChangeRoleStatusDto changeRoleStatusDto);
    26.  
    27.      ResponseResult addRole(AdminAddRoleDto adminAddRoleDto);
    28.  
    29. }

    第八步：impl层的RoleServiceImpl新增，记得方法加上@Transactional注解

    1. package com.keke.service.impl;
    2.  
    3. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
    4. import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
    5. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
    6. import com.keke.domain.ResponseResult;
    7. import com.keke.domain.dto.AdminAddRoleDto;
    8. import com.keke.domain.dto.ChangeRoleStatusDto;
    9. import com.keke.domain.entity.Role;
    10. import com.keke.domain.entity.RoleMenu;
    11. import com.keke.domain.vo.PageVo;
    12. import com.keke.mapper.RoleMapper;
    13. import com.keke.service.RoleMenuService;
    14. import com.keke.service.RoleService;
    15. import com.keke.utils.BeanCopyUtils;
    16. import org.springframework.beans.factory.annotation.Autowired;
    17. import org.springframework.stereotype.Service;
    18. import org.springframework.transaction.annotation.Transactional;
    19. import org.springframework.util.StringUtils;
    20.  
    21. import java.util.ArrayList;
    22. import java.util.List;
    23. import java.util.function.Function;
    24. import java.util.stream.Collectors;
    25.  
    26. /**
    27.  * 角色信息表(Role)表服务实现类
    28.  *
    29.  * @author makejava
    30.  * @since 2023-10-18 21:04:06
    31.  */
    32. @Service("roleService")
    33. public class RoleServiceImpl extends ServiceImpl implements RoleService {
    34.  
    35.      @Autowired
    36.      private RoleMenuService roleMenuService;
    37.  
    38.      //根据用户id查询角色信息
    39.      @Override
    40.      public List selectRoleKeyByUserId(Long userId) {
    41.           //如果userId为1，那么角色权限字符串就只需要返回一个admin
    42.           if(userId==1L){
    43.                List roles = new ArrayList<>();
    44.                roles.add("admin");
    45.                return roles;
    46.           }
    47.           //如果用户id不为1，那么需要根据userId连表查询对应的roleId，然后再去角色表中去查询
    48.           //对应的角色权限字符串
    49.           //这里我们期望RoleMapper中封装一个方法去帮我们实现这个复杂的操作
    50.           RoleMapper roleMapper = getBaseMapper();
    51.           return roleMapper.selectRoleKeyByUserId(userId);
    52.      }
    53.  
    54.      @Override
    55.      public ResponseResult selectPageRole(Role role, Integer pageNum, Integer pageSize) {
    56.           LambdaQueryWrapper lambdaQueryWrapper = new LambdaQueryWrapper<>();
    57.           lambdaQueryWrapper.like(StringUtils.hasText(role.getRoleName()),Role::getRoleName,role.getRoleName());
    58.           lambdaQueryWrapper.eq(StringUtils.hasText(role.getStatus()),Role::getStatus,role.getStatus());
    59.           lambdaQueryWrapper.orderByAsc(Role::getRoleSort);
    60.           Page page = new Page<>(pageNum,pageSize);
    61.           page(page,lambdaQueryWrapper);
    62.           PageVo pageVo = new PageVo(page.getRecords(),page.getTotal());
    63.           return ResponseResult.okResult(pageVo);
    64.      }
    65.  
    66.      @Override
    67.      public ResponseResult changeRoleStatus(ChangeRoleStatusDto changeRoleStatusDto) {
    68.           Long roleId = changeRoleStatusDto.getRoleId();
    69.           Role role = getById(roleId);
    70.           role.setStatus(changeRoleStatusDto.getStatus());
    71.           updateById(role);
    72.           return ResponseResult.okResult();
    73.      }
    74.  
    75.      @Transactional
    76.      @Override
    77.      public ResponseResult addRole(AdminAddRoleDto adminAddRoleDto) {
    78.           //Bean拷贝
    79.           Role role = BeanCopyUtils.copyBean(adminAddRoleDto, Role.class);
    80.           //拿到菜单权限id集合
    81.           List menuIds = adminAddRoleDto.getMenuIds();
    82.           //流式处理转化，把每一个menuId都设置到该roleId下
    83.           List roleMenuList = menuIds.stream()
    84.                   .map(new Function() {
    85.                        @Override
    86.                        public RoleMenu apply(Long menuId) {
    87.                             RoleMenu roleMenu = new RoleMenu();
    88.                             roleMenu.setRoleId(role.getId());
    89.                             roleMenu.setMenuId(menuId);
    90.                             return roleMenu;
    91.                        }
    92.                   }).collect(Collectors.toList());
    93.           //mp批量保存到数据库中
    94.           roleMenuService.saveBatch(roleMenuList);
    95.           //封装返回
    96.           return ResponseResult.okResult();
    97.      }
    98. }

    第九步：domain/entity的Role实体类修改四个字段为mp自动填充

    1. package com.keke.domain.entity;
    2.  
    3. import java.util.Date;
    4. import java.io.Serializable;
    5.  
    6. import com.baomidou.mybatisplus.annotation.FieldFill;
    7. import com.baomidou.mybatisplus.annotation.TableField;
    8. import lombok.AllArgsConstructor;
    9. import lombok.Data;
    10. import lombok.NoArgsConstructor;
    11. import com.baomidou.mybatisplus.annotation.TableName;
    12.  
    13. /**
    14.  * 角色信息表(Role)表实体类
    15.  *
    16.  * @author makejava
    17.  * @since 2023-10-18 21:03:52
    18.  */
    19. @SuppressWarnings("serial")
    20. @Data
    21. @NoArgsConstructor
    22. @AllArgsConstructor
    23. @TableName("sys_role")
    24. public class Role {
    25.     //角色ID
    26.     private Long id;
    27.     //角色名称
    28.     private String roleName;
    29.     //角色权限字符串
    30.     private String roleKey;
    31.     //显示顺序
    32.     private Integer roleSort;
    33.     //角色状态（0正常 1停用）
    34.     private String status;
    35.     //删除标志（0代表存在 1代表删除）
    36.     private String delFlag;
    37.     //创建者
    38.     @TableField(fill = FieldFill.INSERT)
    39.     private Long createBy;
    40.     //创建时间
    41.     @TableField(fill = FieldFill.INSERT)
    42.     private Date createTime;
    43.     //更新者
    44.     @TableField(fill = FieldFill.INSERT_UPDATE)
    45.     private Long updateBy;
    46.     //更新时间
    47.     @TableField(fill = FieldFill.INSERT_UPDATE)
    48.     private Date updateTime;
    49.     //备注
    50.     private String remark;
    51. }
    3.2.3 测试

    4. 修改角色

    需要提供修改角色的功能。修改角色时可以修改角色所关联的菜单权限

    这里可以分析到修改角色有三个接口，一个点击是修改角色后，角色信息的回显接口，回显中有一个菜单权限树接口，另一个是修改角色的接口

    4.1 角色信息回显接口

    4.1.1接口分析
    请求路径请求方式是否需求token头
    system/role/{id}Get是

    请求参数PathVariable格式：

    id: 角色id

    响应格式：

    1. {
    2. 	"code":200,
    3. 	"data":{
    4. 		"id":"11",
    5. 		"remark":"嘎嘎嘎",
    6. 		"roleKey":"aggag",
    7. 		"roleName":"嘎嘎嘎",
    8. 		"roleSort":"5",
    9. 		"status":"0"
    10. 	},
    11. 	"msg":"操作成功"
    12. }
    4.1.2 代码实现

    第一步：controller层

    1. package com.keke.controller;
    2.  
    3. import com.keke.domain.ResponseResult;
    4. import com.keke.domain.dto.AdminAddRoleDto;
    5. import com.keke.domain.dto.ChangeRoleStatusDto;
    6. import com.keke.domain.entity.Role;
    7. import com.keke.service.RoleService;
    8. import org.springframework.beans.factory.annotation.Autowired;
    9. import org.springframework.web.bind.annotation.*;
    10.  
    11. @RestController
    12. @RequestMapping("/system/role")
    13. public class RoleController {
    14.  
    15.      @Autowired
    16.      private RoleService roleService;
    17.  
    18.      @GetMapping("/list")
    19.      public ResponseResult selectPageRole(Role role,Integer pageNum,Integer pageSize){
    20.           return roleService.selectPageRole(role,pageNum,pageSize);
    21.      }
    22.  
    23.      @PutMapping("/changeStatus")
    24.      public ResponseResult changeRoleStatus(@RequestBody ChangeRoleStatusDto changeRoleStatusDto){
    25.           return roleService.changeRoleStatus(changeRoleStatusDto);
    26.      }
    27.  
    28.      @PostMapping
    29.      public ResponseResult addRole(@RequestBody AdminAddRoleDto adminAddRoleDto){
    30.           return roleService.addRole(adminAddRoleDto);
    31.      }
    32.  
    33.      @GetMapping("/{id}")
    34.      public ResponseResult getRoleInfo(@PathVariable("id") Long id){
    35.           return roleService.getRoleInfo(id);
    36.      }
    37. }

    第二步：domain/vo层新增

    1. package com.keke.domain.vo;
    2.  
    3. import com.baomidou.mybatisplus.annotation.FieldFill;
    4. import com.baomidou.mybatisplus.annotation.TableField;
    5. import lombok.AllArgsConstructor;
    6. import lombok.Data;
    7. import lombok.NoArgsConstructor;
    8.  
    9. import java.util.Date;
    10.  
    11. @Data
    12. @AllArgsConstructor
    13. @NoArgsConstructor
    14. public class AdminRoleVo {
    15.      //角色ID
    16.      private Long id;
    17.      //角色名称
    18.      private String roleName;
    19.      //角色权限字符串
    20.      private String roleKey;
    21.      //显示顺序
    22.      private Integer roleSort;
    23.      //角色状态（0正常 1停用）
    24.      private String status;
    25.      //备注
    26.      private String remark;
    27. }

    第三步：service层

    1. package com.keke.service;
    2.  
    3. import com.baomidou.mybatisplus.extension.service.IService;
    4. import com.keke.domain.ResponseResult;
    5. import com.keke.domain.dto.AdminAddRoleDto;
    6. import com.keke.domain.dto.ChangeRoleStatusDto;
    7. import com.keke.domain.entity.Role;
    8.  
    9. import java.util.List;
    10.  
    11.  
    12. /**
    13.  * 角色信息表(Role)表服务接口
    14.  *
    15.  * @author makejava
    16.  * @since 2023-10-18 21:04:06
    17.  */
    18. public interface RoleService extends IService {
    19.  
    20.      List selectRoleKeyByUserId(Long userId);
    21.  
    22.  
    23.      ResponseResult selectPageRole(Role role, Integer pageNum, Integer pageSize);
    24.  
    25.      ResponseResult changeRoleStatus(ChangeRoleStatusDto changeRoleStatusDto);
    26.  
    27.      ResponseResult addRole(AdminAddRoleDto adminAddRoleDto);
    28.  
    29.      ResponseResult getRoleInfo(Long id);
    30. }

    第四步：impl层新增

    1. package com.keke.service.impl;
    2.  
    3. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
    4. import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
    5. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
    6. import com.keke.domain.ResponseResult;
    7. import com.keke.domain.dto.AdminAddRoleDto;
    8. import com.keke.domain.dto.ChangeRoleStatusDto;
    9. import com.keke.domain.entity.Role;
    10. import com.keke.domain.entity.RoleMenu;
    11. import com.keke.domain.vo.AdminRoleVo;
    12. import com.keke.domain.vo.PageVo;
    13. import com.keke.mapper.RoleMapper;
    14. import com.keke.service.RoleMenuService;
    15. import com.keke.service.RoleService;
    16. import com.keke.utils.BeanCopyUtils;
    17. import org.springframework.beans.factory.annotation.Autowired;
    18. import org.springframework.stereotype.Service;
    19. import org.springframework.transaction.annotation.Transactional;
    20. import org.springframework.util.StringUtils;
    21.  
    22. import java.util.ArrayList;
    23. import java.util.List;
    24. import java.util.function.Function;
    25. import java.util.stream.Collectors;
    26.  
    27. /**
    28.  * 角色信息表(Role)表服务实现类
    29.  *
    30.  * @author makejava
    31.  * @since 2023-10-18 21:04:06
    32.  */
    33. @Service("roleService")
    34. public class RoleServiceImpl extends ServiceImpl implements RoleService {
    35.  
    36.      @Autowired
    37.      private RoleMenuService roleMenuService;
    38.  
    39.      //根据用户id查询角色信息
    40.      @Override
    41.      public List selectRoleKeyByUserId(Long userId) {
    42.           //如果userId为1，那么角色权限字符串就只需要返回一个admin
    43.           if(userId==1L){
    44.                List roles = new ArrayList<>();
    45.                roles.add("admin");
    46.                return roles;
    47.           }
    48.           //如果用户id不为1，那么需要根据userId连表查询对应的roleId，然后再去角色表中去查询
    49.           //对应的角色权限字符串
    50.           //这里我们期望RoleMapper中封装一个方法去帮我们实现这个复杂的操作
    51.           RoleMapper roleMapper = getBaseMapper();
    52.           return roleMapper.selectRoleKeyByUserId(userId);
    53.      }
    54.  
    55.      @Override
    56.      public ResponseResult selectPageRole(Role role, Integer pageNum, Integer pageSize) {
    57.           LambdaQueryWrapper lambdaQueryWrapper = new LambdaQueryWrapper<>();
    58.           lambdaQueryWrapper.like(StringUtils.hasText(role.getRoleName()),Role::getRoleName,role.getRoleName());
    59.           lambdaQueryWrapper.eq(StringUtils.hasText(role.getStatus()),Role::getStatus,role.getStatus());
    60.           lambdaQueryWrapper.orderByAsc(Role::getRoleSort);
    61.           Page page = new Page<>(pageNum,pageSize);
    62.           page(page,lambdaQueryWrapper);
    63.           PageVo pageVo = new PageVo(page.getRecords(),page.getTotal());
    64.           return ResponseResult.okResult(pageVo);
    65.      }
    66.  
    67.      @Override
    68.      public ResponseResult changeRoleStatus(ChangeRoleStatusDto changeRoleStatusDto) {
    69.           Long roleId = changeRoleStatusDto.getRoleId();
    70.           Role role = getById(roleId);
    71.           role.setStatus(changeRoleStatusDto.getStatus());
    72.           updateById(role);
    73.           return ResponseResult.okResult();
    74.      }
    75.  
    76.      @Transactional
    77.      @Override
    78.      public ResponseResult addRole(AdminAddRoleDto adminAddRoleDto) {
    79.           //Bean拷贝
    80.           Role role = BeanCopyUtils.copyBean(adminAddRoleDto, Role.class);
    81.           //拿到菜单权限id集合
    82.           List menuIds = adminAddRoleDto.getMenuIds();
    83.           //流式处理转化，把每一个menuId都设置到该roleId下
    84.           List roleMenuList = menuIds.stream()
    85.                   .map(new Function() {
    86.                        @Override
    87.                        public RoleMenu apply(Long menuId) {
    88.                             RoleMenu roleMenu = new RoleMenu();
    89.                             roleMenu.setRoleId(role.getId());
    90.                             roleMenu.setMenuId(menuId);
    91.                             return roleMenu;
    92.                        }
    93.                   }).collect(Collectors.toList());
    94.           //mp批量保存到数据库中
    95.           roleMenuService.saveBatch(roleMenuList);
    96.           //封装返回
    97.           return ResponseResult.okResult();
    98.      }
    99.  
    100.      @Override
    101.      public ResponseResult getRoleInfo(Long id) {
    102.           Role role = getById(id);
    103.           AdminRoleVo adminRoleVo = BeanCopyUtils.copyBean(role, AdminRoleVo.class);
    104.           return ResponseResult.okResult(adminRoleVo);
    105.      }
    106. }
    4.1.3 测试

    回显成功

    4.2 对应角色菜单权限树接口

    4.2.1 接口分析
    请求方式请求路径是否需求token头
    Get/system/menu/roleMenuTreeselect/{id}是

    请求参数PathVariable格式：

    id: 角色id

    响应格式：

    字段介绍

    menus：菜单树

    checkedKeys：角色所关联的菜单权限id列表

    1. {
    2. 	"code":200,
    3. 	"data":{
    4. 		"menus":[
    5. 			{
    6. 				"children":[],
    7. 				"id":"2023",
    8. 				"label":"写博文",
    9. 				"parentId":"0"
    10. 			},
    11. 			{
    12. 				"children":[
    13. 					{
    14. 						"children":[
    15. 							{
    16. 								"children":[],
    17. 								"id":"1001",
    18. 								"label":"用户查询",
    19. 								"parentId":"100"
    20. 							},
    21. 							{
    22. 								"children":[],
    23. 								"id":"1002",
    24. 								"label":"用户新增",
    25. 								"parentId":"100"
    26. 							},
    27. 							{
    28. 								"children":[],
    29. 								"id":"1003",
    30. 								"label":"用户修改",
    31. 								"parentId":"100"
    32. 							},
    33. 							{
    34. 								"children":[],
    35. 								"id":"1004",
    36. 								"label":"用户删除",
    37. 								"parentId":"100"
    38. 							},
    39. 							{
    40. 								"children":[],
    41. 								"id":"1005",
    42. 								"label":"用户导出",
    43. 								"parentId":"100"
    44. 							},
    45. 							{
    46. 								"children":[],
    47. 								"id":"1006",
    48. 								"label":"用户导入",
    49. 								"parentId":"100"
    50. 							},
    51. 							{
    52. 								"children":[],
    53. 								"id":"1007",
    54. 								"label":"重置密码",
    55. 								"parentId":"100"
    56. 							}
    57. 						],
    58. 						"id":"100",
    59. 						"label":"用户管理",
    60. 						"parentId":"1"
    61. 					},
    62. 					{
    63. 						"children":[
    64. 							{
    65. 								"children":[],
    66. 								"id":"1008",
    67. 								"label":"角色查询",
    68. 								"parentId":"101"
    69. 							},
    70. 							{
    71. 								"children":[],
    72. 								"id":"1009",
    73. 								"label":"角色新增",
    74. 								"parentId":"101"
    75. 							},
    76. 							{
    77. 								"children":[],
    78. 								"id":"1010",
    79. 								"label":"角色修改",
    80. 								"parentId":"101"
    81. 							},
    82. 							{
    83. 								"children":[],
    84. 								"id":"1011",
    85. 								"label":"角色删除",
    86. 								"parentId":"101"
    87. 							},
    88. 							{
    89. 								"children":[],
    90. 								"id":"1012",
    91. 								"label":"角色导出",
    92. 								"parentId":"101"
    93. 							}
    94. 						],
    95. 						"id":"101",
    96. 						"label":"角色管理",
    97. 						"parentId":"1"
    98. 					},
    99. 					{
    100. 						"children":[
    101. 							{
    102. 								"children":[],
    103. 								"id":"1013",
    104. 								"label":"菜单查询",
    105. 								"parentId":"102"
    106. 							},
    107. 							{
    108. 								"children":[],
    109. 								"id":"1014",
    110. 								"label":"菜单新增",
    111. 								"parentId":"102"
    112. 							},
    113. 							{
    114. 								"children":[],
    115. 								"id":"1015",
    116. 								"label":"菜单修改",
    117. 								"parentId":"102"
    118. 							},
    119. 							{
    120. 								"children":[],
    121. 								"id":"1016",
    122. 								"label":"菜单删除",
    123. 								"parentId":"102"
    124. 							}
    125. 						],
    126. 						"id":"102",
    127. 						"label":"菜单管理",
    128. 						"parentId":"1"
    129. 					}
    130. 				],
    131. 				"id":"1",
    132. 				"label":"系统管理",
    133. 				"parentId":"0"
    134. 			},
    135. 			{
    136. 				"children":[
    137. 					{
    138. 						"children":[],
    139. 						"id":"2019",
    140. 						"label":"文章管理",
    141. 						"parentId":"2017"
    142. 					},
    143. 					{
    144. 						"children":[
    145. 							{
    146. 								"children":[],
    147. 								"id":"2028",
    148. 								"label":"导出分类",
    149. 								"parentId":"2018"
    150. 							}
    151. 						],
    152. 						"id":"2018",
    153. 						"label":"分类管理",
    154. 						"parentId":"2017"
    155. 					},
    156. 					{
    157. 						"children":[
    158. 							{
    159. 								"children":[],
    160. 								"id":"2024",
    161. 								"label":"友链新增",
    162. 								"parentId":"2022"
    163. 							},
    164. 							{
    165. 								"children":[],
    166. 								"id":"2025",
    167. 								"label":"友链修改",
    168. 								"parentId":"2022"
    169. 							},
    170. 							{
    171. 								"children":[],
    172. 								"id":"2026",
    173. 								"label":"友链删除",
    174. 								"parentId":"2022"
    175. 							},
    176. 							{
    177. 								"children":[],
    178. 								"id":"2027",
    179. 								"label":"友链查询",
    180. 								"parentId":"2022"
    181. 							}
    182. 						],
    183. 						"id":"2022",
    184. 						"label":"友链管理",
    185. 						"parentId":"2017"
    186. 					},
    187. 					{
    188. 						"children":[],
    189. 						"id":"2021",
    190. 						"label":"标签管理",
    191. 						"parentId":"2017"
    192. 					}
    193. 				],
    194. 				"id":"2017",
    195. 				"label":"内容管理",
    196. 				"parentId":"0"
    197. 			}
    198. 		],
    199. 		"checkedKeys":[
    200. 			"1001"  
    201. 		]
    202. 	},
    203. 	"msg":"操作成功"
    204. }
    4.2.2 代码实现

    第一步：vo层新建RoleMenuTreeSelectVo，用于响应返回

    1. package com.keke.domain.vo;
    2.  
    3. import lombok.AllArgsConstructor;
    4. import lombok.Data;
    5. import lombok.NoArgsConstructor;
    6.  
    7. import java.util.List;
    8.  
    9. @Data
    10. @AllArgsConstructor
    11. @NoArgsConstructor
    12. public class RoleMenuTreeSelectVo {
    13.  
    14.      private List menus;
    15.  
    16.      private List checkedKeys;
    17. }

    第二步: 把keke-framework工程的MenuService接口修改为如下，增加了 '根据角色id查询对应角色菜单列表树' 的接口 

    1. package com.keke.service;
    2.  
    3. import com.baomidou.mybatisplus.extension.service.IService;
    4. import com.keke.domain.ResponseResult;
    5. import com.keke.domain.entity.Menu;
    6. import com.keke.domain.vo.AdminMenuVo;
    7.  
    8. import java.util.List;
    9.  
    10.  
    11. /**
    12.  * 菜单权限表(Menu)表服务接口
    13.  *
    14.  * @author makejava
    15.  * @since 2023-10-18 20:55:48
    16.  */
    17. public interface MenuService extends IService {
    18.  
    19.  
    20.      //查询用户权限信息
    21.      List selectPermsByUserId(Long userId);
    22.  
    23.      //查询用户的路由信息，也就是权限菜单
    24.      List selectRouterMenuTreeByUserId(Long userId);
    25.  
    26.      List selectAllMenu(Menu menu);
    27.  
    28.      ResponseResult editMenu(Menu menu);
    29.  
    30.      ResponseResult deleteMenu(Long menuId);
    31.  
    32.  
    33.      List selectMenuListByRoleId(Long roleId);
    34. }

    第三步：MenuServiceImpl

    1. package com.keke.service.impl;
    2.  
    3. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
    4. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
    5. import com.keke.constants.SystemConstants;
    6. import com.keke.domain.ResponseResult;
    7. import com.keke.domain.entity.Menu;
    8. import com.keke.domain.vo.AdminMenuVo;
    9. import com.keke.mapper.MenuMapper;
    10. import com.keke.service.MenuService;
    11. import com.keke.utils.BeanCopyUtils;
    12. import com.keke.utils.SecurityUtils;
    13. import org.springframework.beans.factory.annotation.Autowired;
    14. import org.springframework.stereotype.Service;
    15. import org.springframework.util.StringUtils;
    16.  
    17. import java.util.List;
    18. import java.util.function.Function;
    19. import java.util.stream.Collectors;
    20.  
    21. /**
    22.  * 菜单权限表(Menu)表服务实现类
    23.  *
    24.  * @author makejava
    25.  * @since 2023-10-18 20:55:48
    26.  */
    27. @Service("menuService")
    28. public class MenuServiceImpl extends ServiceImpl implements MenuService {
    29.  
    30.      @Autowired
    31.      private MenuService menuService;
    32.  
    33.      //根据用户id查询权限关键字
    34.      @Override
    35.      public List selectPermsByUserId(Long userId) {
    36.           //如果用户id为1代表管理员，roles 中只需要有admin，
    37.           // permissions中需要有所有菜单类型为C(菜单)或者F(按钮)的，状态为正常的，未被删除的权限
    38.           if(SecurityUtils.isAdmin()) {
    39.                LambdaQueryWrapper lambdaQueryWrapper = new LambdaQueryWrapper<>();
    40.                lambdaQueryWrapper.in(Menu::getMenuType, SystemConstants.MENU, SystemConstants.BUTTON);
    41.                lambdaQueryWrapper.eq(Menu::getStatus, SystemConstants.STATUS_NORMAL);
    42.                //由于我们的逻辑删除字段已经配置了，所以无需封装lambdaQueryWrapper
    43.                List menuList = list(lambdaQueryWrapper);
    44.                //我们需要的是String类型的集合，这里我们要进行数据的处理，这里采用流的方式
    45.                List permissions = menuList.stream()
    46.                        .map(new Function() {
    47.                             @Override
    48.                             public String apply(Menu menu) {
    49.                                  String perms = menu.getPerms();
    50.                                  return perms;
    51.                             }
    52.                        })
    53.                        .collect(Collectors.toList());
    54.                return permissions;
    55.           }
    56.           //否则返回这个用户所具有的权限
    57.           //这里我们需要进行连表查询，因为我们的用户先和角色关联，然后角色才跟权限关联
    58.           MenuMapper menuMapper = getBaseMapper();
    59.           //我们期望menuMapper中有一个方法可以直接帮我们去实现这个复杂的逻辑，这里直接返回
    60.           return menuMapper.selectPermsByUserId(userId);
    61.      }
    62.  
    63.      @Override
    64.      public List selectRouterMenuTreeByUserId(Long userId) {
    65.           MenuMapper menuMapper = getBaseMapper();
    66.           List menus = null;
    67.           //如果是管理员，返回所有
    68.           if(SecurityUtils.isAdmin()){
    69.                menus = menuMapper.selectAllRoutersMenu();
    70.           }else {
    71.                //如果不是管理员，返回对应用户的菜单
    72.                menus = menuMapper.selectRoutersMenuTreeByUserId(userId);
    73.           }
    74.           //因为上面的查询都是从数据库进行查询，所以无法封装children，这里构建Tree
    75.  
    76.           List menuTree = buildMenuTree(menus,0L);
    77.           return menuTree;
    78.      }
    79.  
    80.      @Override
    81.      public List selectAllMenu(Menu menu) {
    82.           //可以针对菜单名进行模糊查询。也可以针对菜单的状态进行查询
    83.           LambdaQueryWrapper lambdaQueryWrapper = new LambdaQueryWrapper<>();
    84.           lambdaQueryWrapper.like(StringUtils.hasText(menu.getMenuName()),Menu::getMenuName,menu.getMenuName());
    85.           lambdaQueryWrapper.eq(StringUtils.hasText(menu.getStatus()),Menu::getStatus,menu.getStatus());
    86.           //排序 parent_id和order_num
    87.           lambdaQueryWrapper.orderByAsc(Menu::getParentId,Menu::getOrderNum);
    88.           List menus = list(lambdaQueryWrapper);
    89.           List adminMenuVos = BeanCopyUtils.copyBeanList(menus, AdminMenuVo.class);
    90.           return adminMenuVos;
    91.      }
    92.  
    93.      @Override
    94.      public ResponseResult editMenu(Menu menu) {
    95.           if(menu.getParentId().equals(menu.getId())){
    96.                return ResponseResult.okResult(500,"修改菜单" + "'" + menu.getMenuName() + "'" + "失败，上级菜单不能选择自己");
    97.           }
    98.           updateById(menu);
    99.           return ResponseResult.okResult();
    100.      }
    101.  
    102.      @Override
    103.      public ResponseResult deleteMenu(Long menuId) {
    104.           Menu menu = menuService.getById(menuId);
    105.           //如果该菜单有子菜单，那么就提示不能删除，逻辑就是查询菜单表中是否有父菜单id是当前菜单id
    106.           LambdaQueryWrapper lambdaQueryWrapper = new LambdaQueryWrapper<>();
    107.           lambdaQueryWrapper.eq(Menu::getParentId,menuId);
    108.           List menus = list(lambdaQueryWrapper);
    109.           if(!menus.isEmpty()) {
    110.                return ResponseResult.okResult(500, "存在子菜单不允许删除");
    111.           }
    112.           removeById(menuId);
    113.           return ResponseResult.okResult();
    114.      }
    115.  
    116.      @Override
    117.      public List selectMenuListByRoleId(Long roleId) {
    118.           return getBaseMapper().selectMenuListByRoleId(roleId);
    119.      }
    120.  
    121.  
    122.      /**
    123.       * 构建MenuTree
    124.       * 思路先找第一层级的菜单，就是找到id于parentId的对应关系，然后把parentId设置为Id的children
    125.       * @param menus
    126.       * @return
    127.       */
    128.      private List buildMenuTree(List menus,Long parentId) {
    129.           //转化流处理
    130.           List menuTree = menus.stream()
    131.                   //过滤掉除一级菜单之外的菜单
    132.                   .filter(menu -> menu.getParentId().equals(parentId))
    133.                   //然后将获取其子菜单设置到children字段，并返回
    134.                   .map(m -> m.setChildren(gerChildren(m, menus)))
    135.                   .collect(Collectors.toList());
    136.           return menuTree;
    137.      }
    138.  
    139.      //获取当前菜单的子菜单
    140.      private List gerChildren(Menu menu, List menus) {
    141.           //流处理，遍历每一个流对象，筛选出流对象的parentId=menu的id，即过滤
    142.           List children = menus.stream()
    143.                   .filter(m -> m.getParentId().equals(menu.getId()))
    144.                   //这里其实不必要写，这一步的逻辑是如果有三级，
    145.                   //可以把流对象中再过筛选出子菜单设置给对应的children并返回
    146.                   .map(m -> m.setChildren(gerChildren(m,menus)))
    147.                   .collect(Collectors.toList());
    148.           return children;
    149.      }
    150.  
    151. }

    第四步：MenuMapper新增 

    1. package com.keke.mapper;
    2.  
    3. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    4. import com.keke.domain.entity.Menu;
    5. import org.apache.ibatis.annotations.Mapper;
    6.  
    7. import java.util.List;
    8.  
    9.  
    10. /**
    11.  * 菜单权限表(Menu)表数据库访问层
    12.  *
    13.  * @author makejava
    14.  * @since 2023-10-18 20:55:48
    15.  */
    16. @Mapper
    17. public interface MenuMapper extends BaseMapper {
    18.  
    19.      //Mapper的实现类对应xml映射文件
    20.      List selectPermsByUserId(Long userId);
    21.  
    22.      List selectAllRoutersMenu();
    23.  
    24.      List selectRoutersMenuTreeByUserId(Long userId);
    25.  
    26.      List selectMenuListByRoleId(Long roleId);
    27. }

     第五步: 把keke-framework工程的resources/mapper目录的MenuMapper.xml修改为如下，增加了 '根据角色id查询对应角色菜单列表树' 的具体实现代码

    1. "1.0" encoding="UTF-8" ?>
    2. mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
    3. <mapper namespace="com.keke.mapper.MenuMapper">
    4.     <select id="selectPermsByUserId" resultType="java.lang.String">
    5. -- 这里的逻辑是先用userId连表查询roleId，再用roleId连表查询menuId，再根据menuId
    6. -- 查询对应的用户权限
    7.             select
    8.                 DISTINCT m.`perms`
    9.             from `sys_user_role` ur
    10.                      left join `sys_role_menu` rm on ur.`role_id`=rm.`role_id`
    11.                      left join `sys_menu` m on m.`id`=rm.`menu_id`
    12.             where
    13.                 ur.`user_id`=#{userId} and
    14.                 m.`menu_type` in ('C','F') and
    15.                 m.`status`=0 and
    16.                 m.`del_flag`=0
    17.     select>
    18.     <select id="selectAllRoutersMenu" resultType="com.keke.domain.entity.Menu">
    19. --         这里与上面的sql差不多，只是menu_type有差别，还有查询的字段个数
    20.         SELECT
    21.             DISTINCT m.id, m.parent_id, m.menu_name, m.path, m.component, m.visible, m.status,
    22.                      IFNULL(m.perms,'') AS perms, m.is_frame,  m.menu_type, m.icon, m.order_num, m.create_time
    23.         FROM
    24.             `sys_menu` m
    25.         WHERE
    26. --             查询所有的，所以不需要加userId的条件
    27.             m.`menu_type` IN ('C','M') AND
    28.             m.`status` = 0 AND
    29.             m.`del_flag` = 0
    30.         ORDER BY
    31.             m.parent_id,m.order_num
    32.     select>
    33.  
    34.     <select id="selectRoutersMenuTreeByUserId" resultType="com.keke.domain.entity.Menu">
    35. --         这里与上面的sql差不多
    36.         SELECT
    37.             DISTINCT m.id, m.parent_id, m.menu_name, m.path, m.component, m.visible, m.status,
    38.                      IFNULL(m.perms,'') AS perms, m.is_frame,  m.menu_type, m.icon, m.order_num, m.create_time
    39.         FROM
    40.             `sys_user_role` ur
    41.                 LEFT JOIN `sys_role_menu` rm ON ur.`role_id` = rm.`role_id`
    42.                 LEFT JOIN `sys_menu` m ON m.`id` = rm.`menu_id`
    43.         WHERE
    44.             ur.`user_id` = #{userId} AND
    45.             m.`menu_type` IN ('C','M') AND
    46.             m.`status` = 0 AND
    47.             m.`del_flag` = 0
    48.         ORDER BY
    49.             m.parent_id,m.order_num
    50.     select>
    51.  
    52.     <select id="selectMenuListByRoleId" resultType="java.lang.Long">
    53.         select m.id
    54.         from sys_menu m
    55.                  left join sys_role_menu rm on m.id = rm.menu_id
    56.         where rm.role_id = #{roleId}
    57.  
    58.  
    59.         order by m.parent_id, m.order_num
    60.     select>
    61.  
    62. mapper>

    第六步：MenuController

    1. package com.keke.controller;
    2.  
    3.  
    4. import com.keke.domain.ResponseResult;
    5. import com.keke.domain.entity.Menu;
    6. import com.keke.domain.vo.AdminMenuVo;
    7. import com.keke.domain.vo.MenuTreeVo;
    8. import com.keke.domain.vo.RoleMenuTreeSelectVo;
    9. import com.keke.service.MenuService;
    10. import com.keke.utils.BeanCopyUtils;
    11. import com.keke.utils.SystemConverter;
    12. import org.springframework.beans.factory.annotation.Autowired;
    13. import org.springframework.security.core.parameters.P;
    14. import org.springframework.web.bind.annotation.*;
    15.  
    16. import java.util.List;
    17.  
    18. @RestController
    19. @RequestMapping("/system/menu")
    20. public class MenuController {
    21.  
    22.      @Autowired
    23.      private MenuService menuService;
    24.  
    25.  
    26.      //查询菜单列表
    27.      @GetMapping("/list")
    28.      public ResponseResult selectAllMenu(Menu menu){
    29.           List adminMenuVos = menuService.selectAllMenu(menu);
    30.           return ResponseResult.okResult(adminMenuVos);
    31.      }
    32.  
    33.      //新增菜单
    34.      @PostMapping
    35.      public ResponseResult add(@RequestBody Menu menu) {
    36.           menuService.save(menu);
    37.           return ResponseResult.okResult();
    38.      }
    39.  
    40.      @GetMapping("/{menuId}")
    41.      public ResponseResult getInfoById(@PathVariable("menuId") Long menuId){
    42.           Menu menu = menuService.getById(menuId);
    43.           return ResponseResult.okResult(menu);
    44.      }
    45.  
    46.      @GetMapping("/roleMenuTreeselect/{id}")
    47.      public ResponseResult selectMenuListByRoleId(@PathVariable("id") Long roleId){
    48.           List adminMenuVos = menuService.selectAllMenu(new Menu());
    49.           List menus = BeanCopyUtils.copyBeanList(adminMenuVos, Menu.class);
    50.           List checkedKeys = menuService.selectMenuListByRoleId(roleId);
    51.           List menuTreeVos = SystemConverter.buildMenuSelectTree(menus);
    52.           RoleMenuTreeSelectVo roleMenuTreeSelectVo = new RoleMenuTreeSelectVo(menuTreeVos,checkedKeys);
    53.           return ResponseResult.okResult(roleMenuTreeSelectVo);
    54.  
    55.      }
    56.  
    57.      @PutMapping
    58.      public ResponseResult editMenu(@RequestBody Menu menu){
    59.           return menuService.editMenu(menu);
    60.      }
    61.  
    62.      @DeleteMapping("/{menuId}")
    63.      public ResponseResult deleteMenu(@PathVariable("menuId") Long menuId){
    64.           return menuService.deleteMenu(menuId);
    65.      }
    66.  
    67.      @GetMapping("/treeselect")
    68.      public ResponseResult treeSelect(){
    69.           //复用之前的selectMenuList方法。方法需要参数，参数可以用来进行条件查询，而这个方法不需要条件，所以直接new Menu()传入
    70.           //这样就可以获取所有的菜单了
    71.           List adminMenuVos = menuService.selectAllMenu(new Menu());
    72.           List menus = BeanCopyUtils.copyBeanList(adminMenuVos, Menu.class);
    73.           List options = SystemConverter.buildMenuSelectTree(menus);
    74.           return ResponseResult.okResult(options);
    75.      }
    76.  
    77. }
    4.2.3 测试

    可用看到回显出了对应角色的权限信息

    4.3 修改角色接口

    4.3.1 接口分析
    请求方式请求路径是否需求token头
    PUTsystem/role是

    请求体：

    1. {
    2.     "id":"13",
    3.     "remark":"我是角色备注",
    4.     "roleKey":"wds",
    5.     "roleName":"测试新增角色",
    6.     "roleSort":0,
    7.     "status":"0",
    8.     "menuIds":[
    9.         "1",
    10.         "100",
    11.         "1001"
    12.     ]
    13. }

    响应体

    1. {
    2. 	"code":200,
    3. 	"msg":"操作成功"
    4. }
    4.3.2 代码实现

    第一步：domain/dto层新增

    1. package com.keke.domain.dto;
    2.  
    3. import com.baomidou.mybatisplus.annotation.FieldFill;
    4. import com.baomidou.mybatisplus.annotation.TableField;
    5. import lombok.AllArgsConstructor;
    6. import lombok.Data;
    7. import lombok.NoArgsConstructor;
    8.  
    9. import java.util.Date;
    10. import java.util.List;
    11.  
    12. @Data
    13. @AllArgsConstructor
    14. @NoArgsConstructor
    15. public class EditRoleDto {
    16.      //角色ID
    17.      private Long id;
    18.      //角色名称
    19.      private String roleName;
    20.      //角色权限字符串
    21.      private String roleKey;
    22.      //显示顺序
    23.      private Integer roleSort;
    24.      //角色状态（0正常 1停用）
    25.      private String status;
    26.      //备注
    27.      private String remark;
    28.      //权限id
    29.      private List menuIds;
    30. }

    第二步：controller层新增EditRole接口

    1. package com.keke.controller;
    2.  
    3. import com.keke.domain.ResponseResult;
    4. import com.keke.domain.dto.AdminAddRoleDto;
    5. import com.keke.domain.dto.ChangeRoleStatusDto;
    6. import com.keke.domain.dto.EditRoleDto;
    7. import com.keke.domain.entity.Role;
    8. import com.keke.service.RoleService;
    9. import org.springframework.beans.factory.annotation.Autowired;
    10. import org.springframework.web.bind.annotation.*;
    11.  
    12. @RestController
    13. @RequestMapping("/system/role")
    14. public class RoleController {
    15.  
    16.      @Autowired
    17.      private RoleService roleService;
    18.  
    19.      @GetMapping("/list")
    20.      public ResponseResult selectPageRole(Role role,Integer pageNum,Integer pageSize){
    21.           return roleService.selectPageRole(role,pageNum,pageSize);
    22.      }
    23.  
    24.      @PutMapping("/changeStatus")
    25.      public ResponseResult changeRoleStatus(@RequestBody ChangeRoleStatusDto changeRoleStatusDto){
    26.           return roleService.changeRoleStatus(changeRoleStatusDto);
    27.      }
    28.  
    29.      @PostMapping
    30.      public ResponseResult addRole(@RequestBody AdminAddRoleDto adminAddRoleDto){
    31.           return roleService.addRole(adminAddRoleDto);
    32.      }
    33.  
    34.      @GetMapping("/{id}")
    35.      public ResponseResult getRoleInfo(@PathVariable("id") Long id){
    36.           return roleService.getRoleInfo(id);
    37.      }
    38.  
    39.      @PutMapping
    40.      public ResponseResult editRole(@RequestBody EditRoleDto editRoleDto){
    41.           return roleService.editRole(editRoleDto);
    42.      }
    43. }

    第二步：service新增

    1. package com.keke.service;
    2.  
    3. import com.baomidou.mybatisplus.extension.service.IService;
    4. import com.keke.domain.ResponseResult;
    5. import com.keke.domain.dto.AdminAddRoleDto;
    6. import com.keke.domain.dto.ChangeRoleStatusDto;
    7. import com.keke.domain.dto.EditRoleDto;
    8. import com.keke.domain.entity.Role;
    9.  
    10. import java.util.List;
    11.  
    12.  
    13. /**
    14.  * 角色信息表(Role)表服务接口
    15.  *
    16.  * @author makejava
    17.  * @since 2023-10-18 21:04:06
    18.  */
    19. public interface RoleService extends IService {
    20.  
    21.      List selectRoleKeyByUserId(Long userId);
    22.  
    23.  
    24.      ResponseResult selectPageRole(Role role, Integer pageNum, Integer pageSize);
    25.  
    26.      ResponseResult changeRoleStatus(ChangeRoleStatusDto changeRoleStatusDto);
    27.  
    28.      ResponseResult addRole(AdminAddRoleDto adminAddRoleDto);
    29.  
    30.      ResponseResult getRoleInfo(Long id);
    31.  
    32.      ResponseResult editRole(EditRoleDto editRoleDto);
    33. }

    第三步：impl新增，逻辑和添加用户一样

    1. package com.keke.service.impl;
    2.  
    3. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
    4. import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
    5. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
    6. import com.keke.domain.ResponseResult;
    7. import com.keke.domain.dto.AdminAddRoleDto;
    8. import com.keke.domain.dto.ChangeRoleStatusDto;
    9. import com.keke.domain.dto.EditRoleDto;
    10. import com.keke.domain.entity.Role;
    11. import com.keke.domain.entity.RoleMenu;
    12. import com.keke.domain.vo.AdminRoleVo;
    13. import com.keke.domain.vo.PageVo;
    14. import com.keke.mapper.RoleMapper;
    15. import com.keke.service.RoleMenuService;
    16. import com.keke.service.RoleService;
    17. import com.keke.utils.BeanCopyUtils;
    18. import org.springframework.beans.factory.annotation.Autowired;
    19. import org.springframework.stereotype.Service;
    20. import org.springframework.transaction.annotation.Transactional;
    21. import org.springframework.util.StringUtils;
    22.  
    23. import java.util.ArrayList;
    24. import java.util.List;
    25. import java.util.function.Function;
    26. import java.util.stream.Collectors;
    27.  
    28. /**
    29.  * 角色信息表(Role)表服务实现类
    30.  *
    31.  * @author makejava
    32.  * @since 2023-10-18 21:04:06
    33.  */
    34. @Service("roleService")
    35. public class RoleServiceImpl extends ServiceImpl implements RoleService {
    36.  
    37.      @Autowired
    38.      private RoleMenuService roleMenuService;
    39.  
    40.      //根据用户id查询角色信息
    41.      @Override
    42.      public List selectRoleKeyByUserId(Long userId) {
    43.           //如果userId为1，那么角色权限字符串就只需要返回一个admin
    44.           if(userId==1L){
    45.                List roles = new ArrayList<>();
    46.                roles.add("admin");
    47.                return roles;
    48.           }
    49.           //如果用户id不为1，那么需要根据userId连表查询对应的roleId，然后再去角色表中去查询
    50.           //对应的角色权限字符串
    51.           //这里我们期望RoleMapper中封装一个方法去帮我们实现这个复杂的操作
    52.           RoleMapper roleMapper = getBaseMapper();
    53.           return roleMapper.selectRoleKeyByUserId(userId);
    54.      }
    55.  
    56.      @Override
    57.      public ResponseResult selectPageRole(Role role, Integer pageNum, Integer pageSize) {
    58.           LambdaQueryWrapper lambdaQueryWrapper = new LambdaQueryWrapper<>();
    59.           lambdaQueryWrapper.like(StringUtils.hasText(role.getRoleName()),Role::getRoleName,role.getRoleName());
    60.           lambdaQueryWrapper.eq(StringUtils.hasText(role.getStatus()),Role::getStatus,role.getStatus());
    61.           lambdaQueryWrapper.orderByAsc(Role::getRoleSort);
    62.           Page page = new Page<>(pageNum,pageSize);
    63.           page(page,lambdaQueryWrapper);
    64.           PageVo pageVo = new PageVo(page.getRecords(),page.getTotal());
    65.           return ResponseResult.okResult(pageVo);
    66.      }
    67.  
    68.      @Override
    69.      public ResponseResult changeRoleStatus(ChangeRoleStatusDto changeRoleStatusDto) {
    70.           Long roleId = changeRoleStatusDto.getRoleId();
    71.           Role role = getById(roleId);
    72.           role.setStatus(changeRoleStatusDto.getStatus());
    73.           updateById(role);
    74.           return ResponseResult.okResult();
    75.      }
    76.  
    77.      @Transactional
    78.      @Override
    79.      public ResponseResult addRole(AdminAddRoleDto adminAddRoleDto) {
    80.           //Bean拷贝
    81.           Role role = BeanCopyUtils.copyBean(adminAddRoleDto, Role.class);
    82.           //拿到菜单权限id集合
    83.           List menuIds = adminAddRoleDto.getMenuIds();
    84.           //流式处理转化，把每一个menuId都设置到该roleId下
    85.           List roleMenuList = menuIds.stream()
    86.                   .map(new Function() {
    87.                        @Override
    88.                        public RoleMenu apply(Long menuId) {
    89.                             RoleMenu roleMenu = new RoleMenu();
    90.                             roleMenu.setRoleId(role.getId());
    91.                             roleMenu.setMenuId(menuId);
    92.                             return roleMenu;
    93.                        }
    94.                   }).collect(Collectors.toList());
    95.           //mp批量保存到数据库中
    96.           roleMenuService.saveBatch(roleMenuList);
    97.           //封装返回
    98.           return ResponseResult.okResult();
    99.      }
    100.  
    101.      @Override
    102.      public ResponseResult getRoleInfo(Long id) {
    103.           Role role = getById(id);
    104.           AdminRoleVo adminRoleVo = BeanCopyUtils.copyBean(role, AdminRoleVo.class);
    105.           return ResponseResult.okResult(adminRoleVo);
    106.      }
    107.  
    108.      @Override
    109.      public ResponseResult editRole(EditRoleDto editRoleDto) {
    110.           Role role = BeanCopyUtils.copyBean(editRoleDto, Role.class);
    111.           List menuIds = editRoleDto.getMenuIds();
    112.           List roleMenuList = menuIds.stream()
    113.                   .map(new Function() {
    114.                        @Override
    115.                        public RoleMenu apply(Long menuId) {
    116.                             RoleMenu roleMenu = new RoleMenu();
    117.                             roleMenu.setRoleId(role.getId());
    118.                             roleMenu.setMenuId(menuId);
    119.                             return roleMenu;
    120.                        }
    121.                   }).collect(Collectors.toList());
    122.           roleMenuService.saveBatch(roleMenuList);
    123.           return ResponseResult.okResult();
    124.      }
    125. }
    4.3.3 测试

    可用新增角色，并且赋予其相应的菜单权限

    5. 删除角色

    删除固定的某个角色（逻辑删除）

    5.1 接口分析

    请求方式请求路径是否需求token头
    DELETEsystem/role/{id}是

    请求参数PathVariable格式：

    id：要删除的角色id

     响应格式：

    1. {
    2. 	"code":200,
    3. 	"msg":"操作成功"
    4. }

    5.2 代码实现

    controller层新增接口，逻辑较少直接写

    1. package com.keke.controller;
    2.  
    3. import com.keke.domain.ResponseResult;
    4. import com.keke.domain.dto.AdminAddRoleDto;
    5. import com.keke.domain.dto.ChangeRoleStatusDto;
    6. import com.keke.domain.dto.EditRoleDto;
    7. import com.keke.domain.entity.Role;
    8. import com.keke.service.RoleService;
    9. import org.springframework.beans.factory.annotation.Autowired;
    10. import org.springframework.web.bind.annotation.*;
    11.  
    12. @RestController
    13. @RequestMapping("/system/role")
    14. public class RoleController {
    15.  
    16.      @Autowired
    17.      private RoleService roleService;
    18.  
    19.      @GetMapping("/list")
    20.      public ResponseResult selectPageRole(Role role,Integer pageNum,Integer pageSize){
    21.           return roleService.selectPageRole(role,pageNum,pageSize);
    22.      }
    23.  
    24.      @PutMapping("/changeStatus")
    25.      public ResponseResult changeRoleStatus(@RequestBody ChangeRoleStatusDto changeRoleStatusDto){
    26.           return roleService.changeRoleStatus(changeRoleStatusDto);
    27.      }
    28.  
    29.      @PostMapping
    30.      public ResponseResult addRole(@RequestBody AdminAddRoleDto adminAddRoleDto){
    31.           return roleService.addRole(adminAddRoleDto);
    32.      }
    33.  
    34.      @GetMapping("/{id}")
    35.      public ResponseResult getRoleInfo(@PathVariable("id") Long id){
    36.           return roleService.getRoleInfo(id);
    37.      }
    38.  
    39.      @PutMapping
    40.      public ResponseResult editRole(@RequestBody EditRoleDto editRoleDto){
    41.           return roleService.editRole(editRoleDto);
    42.      }
    43.  
    44.      @DeleteMapping("/{id}")
    45.      public ResponseResult deleteRoleById(@PathVariable("id") Long id){
    46.           roleService.removeById(id);
    47.           return ResponseResult.okResult();
    48.      }
    49. }

    5.3 测试

     只是逻辑删除

     十三、后台模块-用户列表

    1. 查询用户

    需要用户分页列表接口。

    可以根据用户名模糊搜索。

    可以进行手机号的搜索。

    可以进行状态的查询。

    1.1 接口分析

    请求方式请求路径是否需求token头
    GETsystem/user/list是

    请求参数query格式：  

    1. pageNum: 页码
    2.  
    3. pageSize: 每页条数
    4.  
    5. userName：用户名
    6.  
    7. phonenumber：手机号
    8.  
    9. status:状态

    响应格式：

    1. {
    2. 	"code":200,
    3. 	"data":{
    4. 		"rows":[
    5. 			{
    6. 				"avatar":"http://r7yxkqloa.bkt.clouddn.com/2022/03/05/75fd15587811443a9a9a771f24da458d.png",
    7. 				"createTime":"2022-01-05 17:01:56",
    8. 				"email":"23412332@qq.com",
    9. 				"id":"1",
    10. 				"nickName":"sg3334",
    11. 				"phonenumber":"18888888888",
    12. 				"sex":"1",
    13. 				"status":"0",
    14. 				"updateBy":"1",
    15. 				"updateTime":"2022-03-13 21:36:22",
    16. 				"userName":"sg"
    17. 			}
    18. 		],
    19. 		"total":"1"
    20. 	},
    21. 	"msg":"操作成功"
    22. }

    1.2 代码实现

    第一步：keke-admin的controller层新建UserController

    1. package com.keke.controller;
    2.  
    3. import com.keke.domain.ResponseResult;
    4. import com.keke.domain.entity.User;
    5. import com.keke.service.UserService;
    6. import org.springframework.beans.factory.annotation.Autowired;
    7. import org.springframework.web.bind.annotation.GetMapping;
    8. import org.springframework.web.bind.annotation.RequestMapping;
    9. import org.springframework.web.bind.annotation.RestController;
    10.  
    11. @RestController
    12. @RequestMapping("/system/user")
    13. public class UserController {
    14.  
    15.      @Autowired
    16.      private UserService userService;
    17.  
    18.      @GetMapping("/list")
    19.      public ResponseResult selectPageUser(User user, Integer pageNum, Integer pageSize){
    20.           return userService.selectPageUser(user,pageNum,pageSize);
    21.      }
    22. }

    第二步：service层

    1. package com.keke.service;
    2.  
    3. import com.baomidou.mybatisplus.extension.service.IService;
    4. import com.keke.domain.ResponseResult;
    5. import com.keke.domain.dto.RegisterUserDto;
    6. import com.keke.domain.dto.UserInfoDto;
    7. import com.keke.domain.entity.User;
    8. import org.springframework.stereotype.Service;
    9.  
    10.  
    11. /**
    12.  * 用户表(User)表服务接口
    13.  *
    14.  * @author makejava
    15.  * @since 2023-10-13 09:08:38
    16.  */
    17.  
    18. public interface UserService extends IService {
    19.  
    20.      ResponseResult userInfo();
    21.  
    22.      ResponseResult updateUserInfo(UserInfoDto userInfoDto);
    23.  
    24.      ResponseResult register(RegisterUserDto registerUserDto);
    25.  
    26.      //后台接口分页查询用户
    27.      ResponseResult selectPageUser(User user, Integer pageNum, Integer pageSize);
    28. }

    第三步：impl层

    1. package com.keke.service.impl;
    2.  
    3. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
    4. import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
    5. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
    6. import com.keke.domain.ResponseResult;
    7. import com.keke.domain.dto.RegisterUserDto;
    8. import com.keke.domain.dto.UserInfoDto;
    9. import com.keke.domain.entity.User;
    10. import com.keke.domain.vo.PageVo;
    11. import com.keke.domain.vo.UserInfoVo;
    12. import com.keke.enums.AppHttpCodeEnum;
    13. import com.keke.handler.exception.exception.SystemException;
    14. import com.keke.mapper.UserMapper;
    15. import com.keke.service.UserService;
    16. import com.keke.utils.BeanCopyUtils;
    17. import com.keke.utils.SecurityUtils;
    18. import org.springframework.beans.factory.annotation.Autowired;
    19. import org.springframework.security.crypto.password.PasswordEncoder;
    20. import org.springframework.stereotype.Service;
    21. import org.springframework.util.StringUtils;
    22.  
    23. /**
    24.  * 用户表(User)表服务实现类
    25.  *
    26.  * @author makejava
    27.  * @since 2023-10-13 10:12:51
    28.  */
    29. @Service("userService")
    30. public class UserServiceImpl extends ServiceImpl implements UserService {
    31.  
    32.      @Autowired
    33.      private PasswordEncoder passwordEncoder;
    34.  
    35.      @Override
    36.      public ResponseResult userInfo() {
    37.           Long userId = SecurityUtils.getUserId();
    38.           User user = getById(userId);
    39.           UserInfoVo userInfoVo = BeanCopyUtils.copyBean(user, UserInfoVo.class);
    40.           return ResponseResult.okResult(userInfoVo);
    41.      }
    42.  
    43.      @Override
    44.      public ResponseResult updateUserInfo(UserInfoDto userInfoDto) {
    45.           User user = BeanCopyUtils.copyBean(userInfoDto, User.class);
    46.           updateById(user);
    47.           return ResponseResult.okResult();
    48.      }
    49.  
    50.      @Override
    51.      public ResponseResult register(RegisterUserDto registerUserDto) {
    52.           //对前端传过来的用户名进行非空判断，例如null、""，就抛出异常
    53.           if(!StringUtils.hasText(registerUserDto.getUserName())){
    54.                //SystemException是我们写的异常类、AppHttpCodeEnum是我们写的枚举类
    55.                throw new SystemException(AppHttpCodeEnum.USERNAME_NOT_NULL);
    56.           }
    57.           //密码
    58.           if(!StringUtils.hasText(registerUserDto.getPassword())){
    59.                throw new SystemException(AppHttpCodeEnum.PASSWORD_NOT_NULL);
    60.           }
    61.           //邮箱
    62.           if(!StringUtils.hasText(registerUserDto.getEmail())){
    63.                throw new SystemException(AppHttpCodeEnum.EMAIL_NOT_NULL);
    64.           }
    65.           //昵称
    66.           if(!StringUtils.hasText(registerUserDto.getNickName())){
    67.                throw new SystemException(AppHttpCodeEnum.NICKNAME_NOT_NULL);
    68.           }
    69.  
    70.           //判断用户传给我们的用户名是否在数据库已经存在。userNameExist方法是下面定义的
    71.           if(userNameExist(registerUserDto.getUserName())){
    72.                //SystemException是我们写的异常类、AppHttpCodeEnum是我们写的枚举类
    73.                throw new SystemException(AppHttpCodeEnum.USERNAME_EXIST);
    74.           }
    75.           //判断用户传给我们的昵称是否在数据库已经存在。NickNameExist方法是下面定义的
    76.           if(nickNameExist(registerUserDto.getNickName())){
    77.                //SystemException是我们写的异常类、AppHttpCodeEnum是我们写的枚举类
    78.                throw new SystemException(AppHttpCodeEnum.NICKNAME_EXIST);
    79.           }
    80.           //判断用户传给我们的邮箱是否在数据库已经存在。NickNameExist方法是下面定义的
    81.           if(emailExist(registerUserDto.getEmail())){
    82.                //SystemException是我们写的异常类、AppHttpCodeEnum是我们写的枚举类
    83.                throw new SystemException(AppHttpCodeEnum.EMAIL_EXIST);
    84.           }
    85.  
    86.           //经过上面的判断，可以确保用户传给我们的用户名和昵称是数据库不存在的，且相关字段都不为空。就可以存入数据库
    87.           //注意用户传给我们的密码是明文，对于密码我们要转成密文之后再存入数据库。注意加密要和解密用同一套算法
    88.           //keke-blog工程的securityConfig类里面有解密算法，当时我们写了一个passwordEncoder方法，并且注入到了spring容器
    89.  
    90.           //解密
    91.           String encodePassword = passwordEncoder.encode(registerUserDto.getPassword());
    92.           //封装成user存数据库中
    93.           User user = BeanCopyUtils.copyBean(registerUserDto, User.class);
    94.           //设置密码为加密的密码
    95.           user.setPassword(encodePassword);
    96.           //存入数据库中
    97.           save(user);
    98.           //封装返回
    99.           return ResponseResult.okResult();
    100.      }
    101.  
    102.      @Override
    103.      public ResponseResult selectPageUser(User user, Integer pageNum, Integer pageSize) {
    104.           LambdaQueryWrapper lambdaQueryWrapper = new LambdaQueryWrapper<>();
    105.           //可以根据用户名模糊搜索
    106.           lambdaQueryWrapper.like(StringUtils.hasText(user.getUserName()),User::getUserName,user.getUserName());
    107.           //可以进行手机号的搜索
    108.           lambdaQueryWrapper.eq(StringUtils.hasText(user.getPhonenumber()),User::getPhonenumber,user.getPhonenumber());
    109.           //可以根据状态进行搜索
    110.           lambdaQueryWrapper.eq(StringUtils.hasText(user.getStatus()),User::getStatus,user.getStatus());
    111.           //mp分页器
    112.           Page page = new Page<>(pageNum,pageSize);
    113.           page(page,lambdaQueryWrapper);
    114.           //封装vo
    115.           PageVo pageVo = new PageVo(page.getRecords(),page.getTotal());
    116.           //响应返回
    117.           return ResponseResult.okResult(pageVo);
    118.      }
    119.  
    120.  
    121.      //'判断用户传给我们的用户名是否在数据库已经存在' 的方法
    122.      public boolean userNameExist(String userName){
    123.           LambdaQueryWrapper lambdaQueryWrapper = new LambdaQueryWrapper<>();
    124.           //查询数据库中有用户名相同的数据没有
    125.           lambdaQueryWrapper.eq(User::getUserName,userName);
    126.           //如果查出来有，就说明存在，返回true
    127.           int count = count(lambdaQueryWrapper);
    128.           return count>0;
    129.      }
    130.  
    131.      //'判断用户传给我们的昵称是否在数据库已经存在' 的方法
    132.      public boolean nickNameExist(String nickName){
    133.           LambdaQueryWrapper lambdaQueryWrapper = new LambdaQueryWrapper<>();
    134.           //查询数据库中有用户名相同的数据没有
    135.           lambdaQueryWrapper.eq(User::getNickName,nickName);
    136.           //如果查出来有，就说明存在，返回true
    137.           int count = count(lambdaQueryWrapper);
    138.           return count>0;
    139.      }
    140.  
    141.  
    142.      //'判断用户传给我们的邮箱是否在数据库已经存在' 的方法
    143.      public boolean emailExist(String email){
    144.           LambdaQueryWrapper lambdaQueryWrapper = new LambdaQueryWrapper<>();
    145.           //查询数据库中有用户名相同的数据没有
    146.           lambdaQueryWrapper.eq(User::getEmail,email);
    147.           //如果查出来有，就说明存在，返回true
    148.           int count = count(lambdaQueryWrapper);
    149.           return count>0;
    150.      }
    151.  
    152. }

     1.3 测试

    2. 新增用户

    需要新增用户功能。新增用户时可以直接关联角色。

    注意：新增用户时注意密码加密存储。

    用户名不能为空，否则提示：必需填写用户名

    用户名必须之前未存在，否则提示：用户名已存在

    手机号必须之前未存在，否则提示：手机号已存在

    邮箱必须之前未存在，否则提示：邮箱已存在

    2.1 查询角色列表接口

    注意：查询的是所有状态正常的角色

    2.1.1 接口分析
    请求方式请求路径是否需求token头
    GET/system/role/listAllRole是

    响应格式：

    1. {
    2. 	"code":200,
    3. 	"data":[
    4. 		{
    5. 			"createBy":"0",
    6. 			"createTime":"2021-11-12 18:46:19",
    7. 			"delFlag":"0",
    8. 			"id":"1",
    9. 			"remark":"超级管理员",
    10. 			"roleKey":"admin",
    11. 			"roleName":"超级管理员",
    12. 			"roleSort":"1",
    13. 			"status":"0",
    14. 			"updateBy":"0"
    15. 		},
    16. 		{
    17. 			"createBy":"0",
    18. 			"createTime":"2021-11-12 18:46:19",
    19. 			"delFlag":"0",
    20. 			"id":"2",
    21. 			"remark":"普通角色",
    22. 			"roleKey":"common",
    23. 			"roleName":"普通角色",
    24. 			"roleSort":"2",
    25. 			"status":"0",
    26. 			"updateBy":"0",
    27. 			"updateTime":"2022-01-02 06:32:58"
    28. 		},
    29. 		{
    30. 			"createTime":"2022-01-06 22:07:40",
    31. 			"delFlag":"0",
    32. 			"id":"11",
    33. 			"remark":"嘎嘎嘎",
    34. 			"roleKey":"aggag",
    35. 			"roleName":"嘎嘎嘎",
    36. 			"roleSort":"5",
    37. 			"status":"0",
    38. 			"updateBy":"1",
    39. 			"updateTime":"2022-09-12 10:00:25"
    40. 		},
    41. 		{
    42. 			"createTime":"2022-01-16 14:49:30",
    43. 			"delFlag":"0",
    44. 			"id":"12",
    45. 			"roleKey":"link",
    46. 			"roleName":"友链审核员",
    47. 			"roleSort":"1",
    48. 			"status":"0",
    49. 			"updateTime":"2022-01-16 16:05:09"
    50. 		}
    51. 	],
    52. 	"msg":"操作成功"
    53. }
    2.1.2 代码实现

    第一步：在keke-admin的controller层的RoleController新增查询状态正常角色的接口

    1. package com.keke.controller;
    2.  
    3. import com.keke.domain.ResponseResult;
    4. import com.keke.domain.dto.AdminAddRoleDto;
    5. import com.keke.domain.dto.ChangeRoleStatusDto;
    6. import com.keke.domain.dto.EditRoleDto;
    7. import com.keke.domain.entity.Role;
    8. import com.keke.service.RoleService;
    9. import org.springframework.beans.factory.annotation.Autowired;
    10. import org.springframework.web.bind.annotation.*;
    11.  
    12. @RestController
    13. @RequestMapping("/system/role")
    14. public class RoleController {
    15.  
    16.      @Autowired
    17.      private RoleService roleService;
    18.  
    19.      @GetMapping("/list")
    20.      public ResponseResult selectPageRole(Role role,Integer pageNum,Integer pageSize){
    21.           return roleService.selectPageRole(role,pageNum,pageSize);
    22.      }
    23.  
    24.      @PutMapping("/changeStatus")
    25.      public ResponseResult changeRoleStatus(@RequestBody ChangeRoleStatusDto changeRoleStatusDto){
    26.           return roleService.changeRoleStatus(changeRoleStatusDto);
    27.      }
    28.  
    29.      @PostMapping
    30.      public ResponseResult addRole(@RequestBody AdminAddRoleDto adminAddRoleDto){
    31.           return roleService.addRole(adminAddRoleDto);
    32.      }
    33.  
    34.      @GetMapping("/{id}")
    35.      public ResponseResult getRoleInfo(@PathVariable("id") Long id){
    36.           return roleService.getRoleInfo(id);
    37.      }
    38.  
    39.      @PutMapping
    40.      public ResponseResult editRole(@RequestBody EditRoleDto editRoleDto){
    41.           return roleService.editRole(editRoleDto);
    42.      }
    43.  
    44.      @DeleteMapping("/{id}")
    45.      public ResponseResult deleteRoleById(@PathVariable("id") Long id){
    46.           roleService.removeById(id);
    47.           return ResponseResult.okResult();
    48.      }
    49.  
    50.      @GetMapping("/listAllRole")
    51.      public ResponseResult listAllRole(){
    52.           return roleService.listAllRole();
    53.      }
    54. }

    第二步：service层新增

    1. package com.keke.service;
    2.  
    3. import com.baomidou.mybatisplus.extension.service.IService;
    4. import com.keke.domain.ResponseResult;
    5. import com.keke.domain.dto.AdminAddRoleDto;
    6. import com.keke.domain.dto.ChangeRoleStatusDto;
    7. import com.keke.domain.dto.EditRoleDto;
    8. import com.keke.domain.entity.Role;
    9.  
    10. import java.util.List;
    11.  
    12.  
    13. /**
    14.  * 角色信息表(Role)表服务接口
    15.  *
    16.  * @author makejava
    17.  * @since 2023-10-18 21:04:06
    18.  */
    19. public interface RoleService extends IService {
    20.  
    21.      List selectRoleKeyByUserId(Long userId);
    22.  
    23.  
    24.      ResponseResult selectPageRole(Role role, Integer pageNum, Integer pageSize);
    25.  
    26.      ResponseResult changeRoleStatus(ChangeRoleStatusDto changeRoleStatusDto);
    27.  
    28.      ResponseResult addRole(AdminAddRoleDto adminAddRoleDto);
    29.  
    30.      ResponseResult getRoleInfo(Long id);
    31.  
    32.      ResponseResult editRole(EditRoleDto editRoleDto);
    33.  
    34.      ResponseResult listAllRole();
    35.  
    36. }

    第三步：impl层新增

    1. package com.keke.service.impl;
    2.  
    3. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
    4. import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
    5. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
    6. import com.keke.constants.SystemConstants;
    7. import com.keke.domain.ResponseResult;
    8. import com.keke.domain.dto.AdminAddRoleDto;
    9. import com.keke.domain.dto.ChangeRoleStatusDto;
    10. import com.keke.domain.dto.EditRoleDto;
    11. import com.keke.domain.entity.Role;
    12. import com.keke.domain.entity.RoleMenu;
    13. import com.keke.domain.vo.AdminRoleVo;
    14. import com.keke.domain.vo.PageVo;
    15. import com.keke.mapper.RoleMapper;
    16. import com.keke.service.RoleMenuService;
    17. import com.keke.service.RoleService;
    18. import com.keke.utils.BeanCopyUtils;
    19. import org.springframework.beans.factory.annotation.Autowired;
    20. import org.springframework.stereotype.Service;
    21. import org.springframework.transaction.annotation.Transactional;
    22. import org.springframework.util.StringUtils;
    23.  
    24. import java.util.ArrayList;
    25. import java.util.List;
    26. import java.util.function.Function;
    27. import java.util.stream.Collectors;
    28.  
    29. /**
    30.  * 角色信息表(Role)表服务实现类
    31.  *
    32.  * @author makejava
    33.  * @since 2023-10-18 21:04:06
    34.  */
    35. @Service("roleService")
    36. public class RoleServiceImpl extends ServiceImpl implements RoleService {
    37.  
    38.      @Autowired
    39.      private RoleMenuService roleMenuService;
    40.  
    41.      //根据用户id查询角色信息
    42.      @Override
    43.      public List selectRoleKeyByUserId(Long userId) {
    44.           //如果userId为1，那么角色权限字符串就只需要返回一个admin
    45.           if(userId==1L){
    46.                List roles = new ArrayList<>();
    47.                roles.add("admin");
    48.                return roles;
    49.           }
    50.           //如果用户id不为1，那么需要根据userId连表查询对应的roleId，然后再去角色表中去查询
    51.           //对应的角色权限字符串
    52.           //这里我们期望RoleMapper中封装一个方法去帮我们实现这个复杂的操作
    53.           RoleMapper roleMapper = getBaseMapper();
    54.           return roleMapper.selectRoleKeyByUserId(userId);
    55.      }
    56.  
    57.      @Override
    58.      public ResponseResult selectPageRole(Role role, Integer pageNum, Integer pageSize) {
    59.           LambdaQueryWrapper lambdaQueryWrapper = new LambdaQueryWrapper<>();
    60.           lambdaQueryWrapper.like(StringUtils.hasText(role.getRoleName()),Role::getRoleName,role.getRoleName());
    61.           lambdaQueryWrapper.eq(StringUtils.hasText(role.getStatus()),Role::getStatus,role.getStatus());
    62.           lambdaQueryWrapper.orderByAsc(Role::getRoleSort);
    63.           Page page = new Page<>(pageNum,pageSize);
    64.           page(page,lambdaQueryWrapper);
    65.           PageVo pageVo = new PageVo(page.getRecords(),page.getTotal());
    66.           return ResponseResult.okResult(pageVo);
    67.      }
    68.  
    69.      @Override
    70.      public ResponseResult changeRoleStatus(ChangeRoleStatusDto changeRoleStatusDto) {
    71.           Long roleId = changeRoleStatusDto.getRoleId();
    72.           Role role = getById(roleId);
    73.           role.setStatus(changeRoleStatusDto.getStatus());
    74.           updateById(role);
    75.           return ResponseResult.okResult();
    76.      }
    77.  
    78.      @Transactional
    79.      @Override
    80.      public ResponseResult addRole(AdminAddRoleDto adminAddRoleDto) {
    81.           //Bean拷贝
    82.           Role role = BeanCopyUtils.copyBean(adminAddRoleDto, Role.class);
    83.           //拿到菜单权限id集合
    84.           List menuIds = adminAddRoleDto.getMenuIds();
    85.           //流式处理转化，把每一个menuId都设置到该roleId下
    86.           List roleMenuList = menuIds.stream()
    87.                   .map(new Function() {
    88.                        @Override
    89.                        public RoleMenu apply(Long menuId) {
    90.                             RoleMenu roleMenu = new RoleMenu();
    91.                             roleMenu.setRoleId(role.getId());
    92.                             roleMenu.setMenuId(menuId);
    93.                             return roleMenu;
    94.                        }
    95.                   }).collect(Collectors.toList());
    96.           //mp批量保存到数据库中
    97.           roleMenuService.saveBatch(roleMenuList);
    98.           //封装返回
    99.           return ResponseResult.okResult();
    100.      }
    101.  
    102.      @Override
    103.      public ResponseResult getRoleInfo(Long id) {
    104.           Role role = getById(id);
    105.           AdminRoleVo adminRoleVo = BeanCopyUtils.copyBean(role, AdminRoleVo.class);
    106.           return ResponseResult.okResult(adminRoleVo);
    107.      }
    108.  
    109.      @Override
    110.      public ResponseResult editRole(EditRoleDto editRoleDto) {
    111.           Role role = BeanCopyUtils.copyBean(editRoleDto, Role.class);
    112.           List menuIds = editRoleDto.getMenuIds();
    113.           List roleMenuList = menuIds.stream()
    114.                   .map(new Function() {
    115.                        @Override
    116.                        public RoleMenu apply(Long menuId) {
    117.                             RoleMenu roleMenu = new RoleMenu();
    118.                             roleMenu.setRoleId(role.getId());
    119.                             roleMenu.setMenuId(menuId);
    120.                             return roleMenu;
    121.                        }
    122.                   }).collect(Collectors.toList());
    123.           roleMenuService.saveBatch(roleMenuList);
    124.           return ResponseResult.okResult();
    125.      }
    126.  
    127.      @Override
    128.      public ResponseResult listAllRole() {
    129.           LambdaQueryWrapper lambdaQueryWrapper = new LambdaQueryWrapper<>();
    130.           lambdaQueryWrapper.eq(Role::getStatus, SystemConstants.STATUS_NORMAL);
    131.           List roleList = list(lambdaQueryWrapper);
    132.           return ResponseResult.okResult(roleList);
    133.      }
    134. }
    2.1.3 测试

    2.2 新增用户接口

    2.2.1 接口分析
    请求方式请求路径是否需求token头
    POSTsystem/user是

    请求体：

    1. {
    2.     "userName":"wqeree",
    3.     "nickName":"测试新增用户",
    4.     "password":"1234343",
    5.     "phonenumber":"18889778907",
    6.     "email":"233@sq.com",
    7.     "sex":"0",
    8.     "status":"0",
    9.     "roleIds":[
    10.         "2"
    11.     ]
    12. }

    响应格式：

    1. {
    2. 	"code":200,
    3. 	"msg":"操作成功"
    4. }
    2.2.2 代码实现

    第一步：keke-framework的domain/entity新增

    1. package com.keke.domain.entity;
    2.  
    3. import java.io.Serializable;
    4. import lombok.AllArgsConstructor;
    5. import lombok.Data;
    6. import lombok.NoArgsConstructor;
    7. import com.baomidou.mybatisplus.annotation.TableName;
    8.  
    9. /**
    10.  * 用户和角色关联表(UserRole)表实体类
    11.  *
    12.  * @author makejava
    13.  * @since 2023-10-23 21:17:14
    14.  */
    15. @SuppressWarnings("serial")
    16. @Data
    17. @NoArgsConstructor
    18. @AllArgsConstructor
    19. @TableName("sys_user_role")
    20. public class UserRole {
    21.     //用户ID
    22.     private Long userId;
    23.     //角色ID
    24.     private Long roleId;
    25. }

    第二步：keke-framework的service新增

    1. package com.keke.service;
    2.  
    3. import com.baomidou.mybatisplus.extension.service.IService;
    4.  
    5.  
    6. /**
    7.  * 用户和角色关联表(UserRole)表服务接口
    8.  *
    9.  * @author makejava
    10.  * @since 2023-10-23 21:17:32
    11.  */
    12. public interface UserRoleService extends IService {
    13.  
    14. }

    第三步：keke-framework的service/impl新增

    1. package com.keke.service.impl;
    2.  
    3. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
    4. import com.keke.domain.entity.UserRole;
    5. import com.keke.mapper.UserRoleMapper;
    6. import com.keke.service.UserRoleService;
    7. import org.springframework.stereotype.Service;
    8.  
    9. /**
    10.  * 用户和角色关联表(UserRole)表服务实现类
    11.  *
    12.  * @author makejava
    13.  * @since 2023-10-23 21:17:32
    14.  */
    15. @Service("userRoleService")
    16. public class UserRoleServiceImpl extends ServiceImpl implements UserRoleService {
    17.  
    18. }

    第四步：keke-framework的mapper新增

    1. package com.keke.mapper;
    2.  
    3. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    4. import com.keke.domain.entity.User;
    5. import org.apache.ibatis.annotations.Mapper;
    6.  
    7.  
    8. /**
    9.  * 用户表(User)表数据库访问层
    10.  *
    11.  * @author makejava
    12.  * @since 2023-10-11 20:26:26
    13.  */
    14. @Mapper
    15. public interface UserMapper extends BaseMapper {
    16.  
    17. }

    第五步：keke-framework的domain/dto新增

    1. package com.keke.domain.dto;
    2.  
    3. import lombok.AllArgsConstructor;
    4. import lombok.Data;
    5. import lombok.NoArgsConstructor;
    6.  
    7. import java.util.List;
    8.  
    9.  
    10. @Data
    11. @AllArgsConstructor
    12. @NoArgsConstructor
    13. public class AdminAddUserDto {
    14.      //用户名
    15.      private String userName;
    16.      //昵称
    17.      private String nickName;
    18.      //密码
    19.      private String password;
    20.      //账号状态（0正常 1停用）
    21.      private String status;
    22.      //邮箱
    23.      private String email;
    24.      //手机号
    25.      private String phonenumber;
    26.      //用户性别（0男，1女，2未知）
    27.      private String sex;
    28.      //roleId
    29.      List roleIds;
    30. }

    第六步：keke-admin的controller层UserController新增

    1. package com.keke.controller;
    2.  
    3. import com.keke.domain.ResponseResult;
    4. import com.keke.domain.dto.AdminAddUserDto;
    5. import com.keke.domain.entity.User;
    6. import com.keke.service.UserService;
    7. import org.springframework.beans.factory.annotation.Autowired;
    8. import org.springframework.web.bind.annotation.*;
    9.  
    10. @RestController
    11. @RequestMapping("/system/user")
    12. public class UserController {
    13.  
    14.      @Autowired
    15.      private UserService userService;
    16.  
    17.      @GetMapping("/list")
    18.      public ResponseResult selectPageUser(User user, Integer pageNum, Integer pageSize){
    19.           return userService.selectPageUser(user,pageNum,pageSize);
    20.      }
    21.  
    22.      @PostMapping
    23.      public ResponseResult addUser(@RequestBody AdminAddUserDto adminAddUserDto){
    24.           return userService.addUser(adminAddUserDto);
    25.      }
    26.  
    27.  
    28. }

    第七步：service层UserService新增

    1. package com.keke.service;
    2.  
    3. import com.baomidou.mybatisplus.extension.service.IService;
    4. import com.keke.domain.ResponseResult;
    5. import com.keke.domain.dto.AdminAddUserDto;
    6. import com.keke.domain.dto.RegisterUserDto;
    7. import com.keke.domain.dto.UserInfoDto;
    8. import com.keke.domain.entity.User;
    9. import org.springframework.stereotype.Service;
    10.  
    11.  
    12. /**
    13.  * 用户表(User)表服务接口
    14.  *
    15.  * @author makejava
    16.  * @since 2023-10-13 09:08:38
    17.  */
    18.  
    19. public interface UserService extends IService {
    20.  
    21.      ResponseResult userInfo();
    22.  
    23.      ResponseResult updateUserInfo(UserInfoDto userInfoDto);
    24.  
    25.      ResponseResult register(RegisterUserDto registerUserDto);
    26.  
    27.      //后台接口分页查询用户
    28.      ResponseResult selectPageUser(User user, Integer pageNum, Integer pageSize);
    29.  
    30.      ResponseResult addUser(AdminAddUserDto adminAddUserDto);
    31. }

    第八步：impl层实现方法

    1. package com.keke.service.impl;
    2.  
    3. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
    4. import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
    5. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
    6. import com.keke.domain.ResponseResult;
    7. import com.keke.domain.dto.AdminAddUserDto;
    8. import com.keke.domain.dto.RegisterUserDto;
    9. import com.keke.domain.dto.UserInfoDto;
    10. import com.keke.domain.entity.User;
    11. import com.keke.domain.entity.UserRole;
    12. import com.keke.domain.vo.PageVo;
    13. import com.keke.domain.vo.UserInfoVo;
    14. import com.keke.enums.AppHttpCodeEnum;
    15. import com.keke.handler.exception.exception.SystemException;
    16. import com.keke.mapper.UserMapper;
    17. import com.keke.service.UserRoleService;
    18. import com.keke.service.UserService;
    19. import com.keke.utils.BeanCopyUtils;
    20. import com.keke.utils.SecurityUtils;
    21. import org.springframework.beans.factory.annotation.Autowired;
    22. import org.springframework.security.crypto.password.PasswordEncoder;
    23. import org.springframework.stereotype.Service;
    24. import org.springframework.util.StringUtils;
    25.  
    26. import java.util.List;
    27. import java.util.function.Function;
    28. import java.util.stream.Collectors;
    29.  
    30. /**
    31.  * 用户表(User)表服务实现类
    32.  *
    33.  * @author makejava
    34.  * @since 2023-10-13 10:12:51
    35.  */
    36. @Service("userService")
    37. public class UserServiceImpl extends ServiceImpl implements UserService {
    38.  
    39.      @Autowired
    40.      private PasswordEncoder passwordEncoder;
    41.  
    42.      @Autowired
    43.      private UserRoleService userRoleService;
    44.  
    45.      @Override
    46.      public ResponseResult userInfo() {
    47.           Long userId = SecurityUtils.getUserId();
    48.           User user = getById(userId);
    49.           UserInfoVo userInfoVo = BeanCopyUtils.copyBean(user, UserInfoVo.class);
    50.           return ResponseResult.okResult(userInfoVo);
    51.      }
    52.  
    53.      @Override
    54.      public ResponseResult updateUserInfo(UserInfoDto userInfoDto) {
    55.           User user = BeanCopyUtils.copyBean(userInfoDto, User.class);
    56.           updateById(user);
    57.           return ResponseResult.okResult();
    58.      }
    59.  
    60.      @Override
    61.      public ResponseResult register(RegisterUserDto registerUserDto) {
    62.           //对前端传过来的用户名进行非空判断，例如null、""，就抛出异常
    63.           if(!StringUtils.hasText(registerUserDto.getUserName())){
    64.                //SystemException是我们写的异常类、AppHttpCodeEnum是我们写的枚举类
    65.                throw new SystemException(AppHttpCodeEnum.USERNAME_NOT_NULL);
    66.           }
    67.           //密码
    68.           if(!StringUtils.hasText(registerUserDto.getPassword())){
    69.                throw new SystemException(AppHttpCodeEnum.PASSWORD_NOT_NULL);
    70.           }
    71.           //邮箱
    72.           if(!StringUtils.hasText(registerUserDto.getEmail())){
    73.                throw new SystemException(AppHttpCodeEnum.EMAIL_NOT_NULL);
    74.           }
    75.           //昵称
    76.           if(!StringUtils.hasText(registerUserDto.getNickName())){
    77.                throw new SystemException(AppHttpCodeEnum.NICKNAME_NOT_NULL);
    78.           }
    79.  
    80.           //判断用户传给我们的用户名是否在数据库已经存在。userNameExist方法是下面定义的
    81.           if(userNameExist(registerUserDto.getUserName())){
    82.                //SystemException是我们写的异常类、AppHttpCodeEnum是我们写的枚举类
    83.                throw new SystemException(AppHttpCodeEnum.USERNAME_EXIST);
    84.           }
    85.           //判断用户传给我们的昵称是否在数据库已经存在。NickNameExist方法是下面定义的
    86.           if(nickNameExist(registerUserDto.getNickName())){
    87.                //SystemException是我们写的异常类、AppHttpCodeEnum是我们写的枚举类
    88.                throw new SystemException(AppHttpCodeEnum.NICKNAME_EXIST);
    89.           }
    90.           //判断用户传给我们的邮箱是否在数据库已经存在。NickNameExist方法是下面定义的
    91.           if(emailExist(registerUserDto.getEmail())){
    92.                //SystemException是我们写的异常类、AppHttpCodeEnum是我们写的枚举类
    93.                throw new SystemException(AppHttpCodeEnum.EMAIL_EXIST);
    94.           }
    95.  
    96.           //经过上面的判断，可以确保用户传给我们的用户名和昵称是数据库不存在的，且相关字段都不为空。就可以存入数据库
    97.           //注意用户传给我们的密码是明文，对于密码我们要转成密文之后再存入数据库。注意加密要和解密用同一套算法
    98.           //keke-blog工程的securityConfig类里面有解密算法，当时我们写了一个passwordEncoder方法，并且注入到了spring容器
    99.  
    100.           //解密
    101.           String encodePassword = passwordEncoder.encode(registerUserDto.getPassword());
    102.           //封装成user存数据库中
    103.           User user = BeanCopyUtils.copyBean(registerUserDto, User.class);
    104.           //设置密码为加密的密码
    105.           user.setPassword(encodePassword);
    106.           //存入数据库中
    107.           save(user);
    108.           //封装返回
    109.           return ResponseResult.okResult();
    110.      }
    111.  
    112.      @Override
    113.      public ResponseResult selectPageUser(User user, Integer pageNum, Integer pageSize) {
    114.           LambdaQueryWrapper lambdaQueryWrapper = new LambdaQueryWrapper<>();
    115.           //可以根据用户名模糊搜索
    116.           lambdaQueryWrapper.like(StringUtils.hasText(user.getUserName()),User::getUserName,user.getUserName());
    117.           //可以进行手机号的搜索
    118.           lambdaQueryWrapper.eq(StringUtils.hasText(user.getPhonenumber()),User::getPhonenumber,user.getPhonenumber());
    119.           //可以根据状态进行搜索
    120.           lambdaQueryWrapper.eq(StringUtils.hasText(user.getStatus()),User::getStatus,user.getStatus());
    121.           //mp分页器
    122.           Page page = new Page<>(pageNum,pageSize);
    123.           page(page,lambdaQueryWrapper);
    124.           //封装vo
    125.           PageVo pageVo = new PageVo(page.getRecords(),page.getTotal());
    126.           //响应返回
    127.           return ResponseResult.okResult(pageVo);
    128.      }
    129.  
    130.      @Override
    131.      public ResponseResult addUser(AdminAddUserDto adminAddUserDto) {
    132.           User user = BeanCopyUtils.copyBean(adminAddUserDto, User.class);
    133.           List roleIds = adminAddUserDto.getRoleIds();
    134.           List userRoleList = roleIds.stream()
    135.                   .map(new Function() {
    136.                        @Override
    137.                        public UserRole apply(Long roleId) {
    138.                             UserRole userRole = new UserRole();
    139.                             userRole.setUserId(user.getId());
    140.                             userRole.setRoleId(roleId);
    141.                             return userRole;
    142.                        }
    143.                   }).collect(Collectors.toList());
    144.           userRoleService.saveBatch(userRoleList);
    145.           return ResponseResult.okResult();
    146.      }
    147.  
    148.  
    149.      //'判断用户传给我们的用户名是否在数据库已经存在' 的方法
    150.      public boolean userNameExist(String userName){
    151.           LambdaQueryWrapper lambdaQueryWrapper = new LambdaQueryWrapper<>();
    152.           //查询数据库中有用户名相同的数据没有
    153.           lambdaQueryWrapper.eq(User::getUserName,userName);
    154.           //如果查出来有，就说明存在，返回true
    155.           int count = count(lambdaQueryWrapper);
    156.           return count>0;
    157.      }
    158.  
    159.      //'判断用户传给我们的昵称是否在数据库已经存在' 的方法
    160.      public boolean nickNameExist(String nickName){
    161.           LambdaQueryWrapper lambdaQueryWrapper = new LambdaQueryWrapper<>();
    162.           //查询数据库中有用户名相同的数据没有
    163.           lambdaQueryWrapper.eq(User::getNickName,nickName);
    164.           //如果查出来有，就说明存在，返回true
    165.           int count = count(lambdaQueryWrapper);
    166.           return count>0;
    167.      }
    168.  
    169.  
    170.      //'判断用户传给我们的邮箱是否在数据库已经存在' 的方法
    171.      public boolean emailExist(String email){
    172.           LambdaQueryWrapper lambdaQueryWrapper = new LambdaQueryWrapper<>();
    173.           //查询数据库中有用户名相同的数据没有
    174.           lambdaQueryWrapper.eq(User::getEmail,email);
    175.           //如果查出来有，就说明存在，返回true
    176.           int count = count(lambdaQueryWrapper);
    177.           return count>0;
    178.      }
    179.  
    180. }
    2.2.3 测试

    十四、后台模块-分类列表

    1. 查询分类

    需要分页查询分类列表。

    能根据分类名称进行模糊查询。

    能根据状态进行查询。

    1.1 接口分析

    请求方式请求路径是否需求token头
    GETcontent/category/list是

    Query格式请求参数：

    1. pageNum: 页码
    2.  
    3. pageSize: 每页条数
    4.  
    5. name：分类名
    6.  
    7. status: 状态

     响应格式：

    1. {
    2. 	"code":200,
    3. 	"data":{
    4. 		"rows":[
    5. 			{
    6. 				"description":"wsd",
    7. 				"id":"1",
    8. 				"name":"java",
    9. 				"status":"0"
    10. 			},
    11. 			{
    12. 				"description":"wsd",
    13. 				"id":"2",
    14. 				"name":"PHP",
    15. 				"status":"0"
    16. 			}
    17. 		],
    18. 		"total":"2"
    19. 	},
    20. 	"msg":"操作成功"
    21. }

    1.2 代码实现

    第一步：keke-admin controller层

    1. package com.keke.controller;
    2.  
    3.  
    4. import com.alibaba.excel.EasyExcel;
    5. import com.alibaba.fastjson.JSON;
    6. import com.keke.domain.ResponseResult;
    7. import com.keke.domain.entity.Category;
    8. import com.keke.domain.vo.ExcelCategoryVo;
    9. import com.keke.enums.AppHttpCodeEnum;
    10. import com.keke.service.CategoryService;
    11. import com.keke.utils.BeanCopyUtils;
    12. import com.keke.utils.WebUtils;
    13. import io.swagger.annotations.Api;
    14. import org.springframework.beans.factory.annotation.Autowired;
    15. import org.springframework.security.access.prepost.PreAuthorize;
    16. import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
    17. import org.springframework.web.bind.annotation.GetMapping;
    18. import org.springframework.web.bind.annotation.RequestMapping;
    19. import org.springframework.web.bind.annotation.RestController;
    20.  
    21. import javax.servlet.http.HttpServletResponse;
    22. import java.io.UnsupportedEncodingException;
    23. import java.util.List;
    24.  
    25. @RestController
    26. @RequestMapping("/content/category")
    27. @Api(tags = "后台标签相关接口")
    28. public class CategoryController {
    29.  
    30.      @Autowired
    31.      private CategoryService categoryService;
    32.  
    33.      @GetMapping("/listAllCategory")
    34.      public ResponseResult listAllCategory(){
    35.           return categoryService.listAllCategory();
    36.      }
    37.  
    38.      //权限控制，ps是PermissionService类的bean名称
    39.      @PreAuthorize("@ps.hasPermission('content:category:export')")
    40.      @GetMapping("/export")
    41.      public void export(HttpServletResponse response){
    42.  
    43.           try {
    44.                //设置下载文件的请求头
    45.                WebUtils.setDownLoadHeader("分类.xlsx",response);
    46.                //获取需要导出的数据
    47.                List categoryList = categoryService.list();
    48.                List excelCategoryVos = BeanCopyUtils.copyBeanList(categoryList, ExcelCategoryVo.class);
    49.                //把数据写入Excel中
    50.                EasyExcel.write(response.getOutputStream(), ExcelCategoryVo.class).autoCloseStream(Boolean.FALSE).sheet("分类导出")
    51.                        .doWrite(excelCategoryVos);
    52.           } catch (Exception e) {
    53.                //如果出现异常,就返回失败的json数据给前端
    54.                ResponseResult result = ResponseResult.errorResult(AppHttpCodeEnum.SYSTEM_ERROR);
    55.                //WebUtils是我们在keke-framework工程写的类，里面的renderString方法是将json字符串写入到请求体，然后返回给前端
    56.                WebUtils.renderString(response, JSON.toJSONString(result));
    57.           }
    58.      }
    59.  
    60.  
    61.      @GetMapping("/list")
    62.      public ResponseResult selectPageCategory(Category category,Integer pageNum,Integer pageSize){
    63.           return categoryService.selectPageCategory(category,pageNum,pageSize);
    64.      }
    65. }

    第二步：keke-framework service层

    1. package com.keke.service;
    2.  
    3. import com.baomidou.mybatisplus.extension.service.IService;
    4. import com.keke.domain.ResponseResult;
    5. import com.keke.domain.entity.Category;
    6. import org.springframework.web.bind.annotation.RequestMapping;
    7.  
    8.  
    9. /**
    10.  * 分类表(Category)表服务接口
    11.  *
    12.  * @author makejava
    13.  * @since 2023-10-10 20:42:22
    14.  */
    15. public interface CategoryService extends IService {
    16.  
    17.      ResponseResult getCategoryList();
    18.  
    19.      //后台接口，查询所有文章分类
    20.      ResponseResult listAllCategory();
    21.  
    22.      ResponseResult selectPageCategory(Category category, Integer pageNum, Integer pageSize);
    23. }

     第三步：keke-framework impl层 实现selectPageCategory

    1. package com.keke.service.impl;
    2.  
    3. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
    4. import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
    5. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
    6. import com.keke.constants.SystemConstants;
    7. import com.keke.domain.ResponseResult;
    8. import com.keke.domain.entity.Article;
    9. import com.keke.domain.entity.Category;
    10. import com.keke.domain.vo.AdminCategoryVo;
    11. import com.keke.domain.vo.CategoryVo;
    12. import com.keke.domain.vo.PageVo;
    13. import com.keke.mapper.CategoryMapper;
    14. import com.keke.service.ArticleService;
    15. import com.keke.service.CategoryService;
    16. import com.keke.utils.BeanCopyUtils;
    17. import org.springframework.beans.factory.annotation.Autowired;
    18. import org.springframework.stereotype.Service;
    19. import org.springframework.util.StringUtils;
    20. import org.springframework.web.bind.annotation.RequestMapping;
    21.  
    22. import java.util.List;
    23. import java.util.Set;
    24. import java.util.function.Function;
    25. import java.util.stream.Collectors;
    26.  
    27. /**
    28.  * 分类表(Category)表服务实现类
    29.  *
    30.  * @author makejava
    31.  * @since 2023-10-10 20:42:22
    32.  */
    33. @Service("categoryService")
    34. public class CategoryServiceImpl extends ServiceImpl implements CategoryService {
    35.  
    36.      @Autowired
    37.      private ArticleService articleService;
    38.  
    39.      @Override
    40.      public ResponseResult getCategoryList() {
    41.           //查询文章表，状态已发布的文章，但是在CategoryService下，查询文章表，就要注入ArticleService
    42.           LambdaQueryWrapper
       articleWrapper = new LambdaQueryWrapper<>();
    43.           articleWrapper.eq(Article::getStatus, SystemConstants.ARTICLE_STATUS_NORMAL);
    44.           List
       articleList = articleService.list(articleWrapper);
    45.           //获取文章的分类id，并去重
    46.           Set categoryIds = articleList.stream()
    47.                   .map(article -> article.getCategoryId())
    48.                   //toSet可以去除重复的id
    49.                   .collect(Collectors.toSet());
    50.           //查询分类表
    51.           List categories = listByIds(categoryIds);
    52.           //分类表中只获取正常状态非禁用的分类，用stream流过滤
    53.           categories = categories.stream()
    54.                   .filter(category -> SystemConstants.STATUS_NORMAL.equals(category.getStatus()))
    55.                   .collect(Collectors.toList());
    56.           //封装Vo
    57.           List categoryVos = BeanCopyUtils.copyBeanList(categories, CategoryVo.class);
    58.           //封装到响应体中，因为有数据，所以要调用有参okResult()，把参数传进去
    59.           return ResponseResult.okResult(categoryVos);
    60.      }
    61.  
    62.      @Override
    63.      public ResponseResult listAllCategory() {
    64.           LambdaQueryWrapper lambdaQueryWrapper = new LambdaQueryWrapper<>();
    65.           lambdaQueryWrapper.eq(Category::getStatus,SystemConstants.STATUS_NORMAL);
    66.           List categoryList = list(lambdaQueryWrapper);
    67.           List adminCategoryVos = BeanCopyUtils.copyBeanList(categoryList, AdminCategoryVo.class);
    68.           return ResponseResult.okResult(adminCategoryVos);
    69.      }
    70.  
    71.      @Override
    72.      public ResponseResult selectPageCategory(Category category, Integer pageNum, Integer pageSize) {
    73.           LambdaQueryWrapper lambdaQueryWrapper = new LambdaQueryWrapper<>();
    74.           //根据分类名进行模糊查询
    75.           lambdaQueryWrapper.like(StringUtils.hasText(category.getName()),Category::getName,category.getName());
    76.           lambdaQueryWrapper.eq(StringUtils.hasText(category.getStatus()),Category::getStatus,category.getStatus());
    77.           //构造分页器
    78.           Page page = new Page<>(pageNum,pageSize);
    79.           page(page,lambdaQueryWrapper);
    80.           //封装Vo
    81.           PageVo pageVo = new PageVo(page.getRecords(),page.getTotal());
    82.           return ResponseResult.okResult(pageVo);
    83.      }
    84. }

     1.3 测试

    2. 新增分类

    需要新增分类功能

    2.1 接口分析

    请求方式请求路径是否需求token头
    POST/content/category是

    请求体：

    1. {
    2.     "name":"威威",
    3.     "description":"是的",
    4.     "status":"0"
    5. }

    响应格式：

    1. {
    2. 	"code":200,
    3. 	"msg":"操作成功"
    4. }

    2.2 代码实现

    第一步：新增dto，接受前端传来的参数

    1. package com.keke.domain.dto;
    2.  
    3. import lombok.AllArgsConstructor;
    4. import lombok.Data;
    5. import lombok.NoArgsConstructor;
    6.  
    7. import java.util.Date;
    8.  
    9. @Data
    10. @AllArgsConstructor
    11. @NoArgsConstructor
    12. public class AdminCategoryDto {
    13.      //分类名
    14.      private String name;
    15.      //描述
    16.      private String description;
    17.      //状态0:正常,1禁用
    18.      private String status;
    19. }

    第二步：entity层Category修改mp自填充

    1. package com.keke.domain.entity;
    2.  
    3. import java.util.Date;
    4. import java.io.Serializable;
    5.  
    6. import com.baomidou.mybatisplus.annotation.FieldFill;
    7. import com.baomidou.mybatisplus.annotation.TableField;
    8. import com.baomidou.mybatisplus.annotation.TableId;
    9. import com.baomidou.mybatisplus.annotation.TableName;
    10. import lombok.AllArgsConstructor;
    11. import lombok.Data;
    12. import lombok.NoArgsConstructor;
    13.  
    14. /**
    15.  * 分类表(Category)表实体类
    16.  *
    17.  * @author makejava
    18.  * @since 2023-10-10 20:42:21
    19.  */
    20. @SuppressWarnings("serial")
    21. @Data
    22. @NoArgsConstructor
    23. @AllArgsConstructor
    24. @TableName("ke_category")
    25. public class Category {
    26.     @TableId
    27.     private Long id;
    28.     //分类名
    29.     private String name;
    30.     //父分类id，如果没有父分类为-1
    31.     private Long pid;
    32.     //描述
    33.     private String description;
    34.     //状态0:正常,1禁用
    35.     private String status;
    36.  
    37.     //创建者
    38.     @TableField(fill = FieldFill.INSERT)
    39.     private Long createBy;
    40.     //创建时间
    41.     @TableField(fill = FieldFill.INSERT)
    42.     private Date createTime;
    43.     //更新者
    44.     @TableField(fill = FieldFill.INSERT_UPDATE)
    45.     private Long updateBy;
    46.     //更新时间
    47.     @TableField(fill = FieldFill.INSERT_UPDATE)
    48.     private Date updateTime;
    49.     
    50.     //删除标志（0代表未删除，1代表已删除）
    51.     private Integer delFlag;
    52.  
    53. }

    第三步： keke-admin的Controller层

    1. package com.keke.controller;
    2.  
    3.  
    4. import com.alibaba.excel.EasyExcel;
    5. import com.alibaba.fastjson.JSON;
    6. import com.keke.domain.ResponseResult;
    7. import com.keke.domain.dto.AdminCategoryDto;
    8. import com.keke.domain.entity.Category;
    9. import com.keke.domain.vo.ExcelCategoryVo;
    10. import com.keke.enums.AppHttpCodeEnum;
    11. import com.keke.service.CategoryService;
    12. import com.keke.utils.BeanCopyUtils;
    13. import com.keke.utils.WebUtils;
    14. import io.swagger.annotations.Api;
    15. import org.springframework.beans.factory.annotation.Autowired;
    16. import org.springframework.security.access.prepost.PreAuthorize;
    17. import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
    18. import org.springframework.web.bind.annotation.*;
    19.  
    20. import javax.servlet.http.HttpServletResponse;
    21. import java.io.UnsupportedEncodingException;
    22. import java.util.List;
    23.  
    24. @RestController
    25. @RequestMapping("/content/category")
    26. @Api(tags = "后台标签相关接口")
    27. public class CategoryController {
    28.  
    29.      @Autowired
    30.      private CategoryService categoryService;
    31.  
    32.      @GetMapping("/listAllCategory")
    33.      public ResponseResult listAllCategory(){
    34.           return categoryService.listAllCategory();
    35.      }
    36.  
    37.      //权限控制，ps是PermissionService类的bean名称
    38.      @PreAuthorize("@ps.hasPermission('content:category:export')")
    39.      @GetMapping("/export")
    40.      public void export(HttpServletResponse response){
    41.  
    42.           try {
    43.                //设置下载文件的请求头
    44.                WebUtils.setDownLoadHeader("分类.xlsx",response);
    45.                //获取需要导出的数据
    46.                List categoryList = categoryService.list();
    47.                List excelCategoryVos = BeanCopyUtils.copyBeanList(categoryList, ExcelCategoryVo.class);
    48.                //把数据写入Excel中
    49.                EasyExcel.write(response.getOutputStream(), ExcelCategoryVo.class).autoCloseStream(Boolean.FALSE).sheet("分类导出")
    50.                        .doWrite(excelCategoryVos);
    51.           } catch (Exception e) {
    52.                //如果出现异常,就返回失败的json数据给前端
    53.                ResponseResult result = ResponseResult.errorResult(AppHttpCodeEnum.SYSTEM_ERROR);
    54.                //WebUtils是我们在keke-framework工程写的类，里面的renderString方法是将json字符串写入到请求体，然后返回给前端
    55.                WebUtils.renderString(response, JSON.toJSONString(result));
    56.           }
    57.      }
    58.  
    59.  
    60.      @GetMapping("/list")
    61.      public ResponseResult selectPageCategory(Category category,Integer pageNum,Integer pageSize){
    62.           return categoryService.selectPageCategory(category,pageNum,pageSize);
    63.      }
    64.  
    65.      @PostMapping
    66.      public ResponseResult addCategory(@RequestBody AdminCategoryDto adminCategoryDto){
    67.           return categoryService.addCategory(adminCategoryDto);
    68.      }
    69.  
    70. }

    第四步：keke-framework的service层 

    1. package com.keke.service;
    2.  
    3. import com.baomidou.mybatisplus.extension.service.IService;
    4. import com.keke.domain.ResponseResult;
    5. import com.keke.domain.dto.AdminCategoryDto;
    6. import com.keke.domain.entity.Category;
    7. import org.springframework.web.bind.annotation.RequestMapping;
    8.  
    9.  
    10. /**
    11.  * 分类表(Category)表服务接口
    12.  *
    13.  * @author makejava
    14.  * @since 2023-10-10 20:42:22
    15.  */
    16. public interface CategoryService extends IService {
    17.  
    18.      ResponseResult getCategoryList();
    19.  
    20.      //后台接口，查询所有文章分类
    21.      ResponseResult listAllCategory();
    22.  
    23.      ResponseResult selectPageCategory(Category category, Integer pageNum, Integer pageSize);
    24.  
    25.      ResponseResult addCategory(AdminCategoryDto adminCategoryDto);
    26.      
    27. }

     第五步：keke-framework的impl层 

    1. package com.keke.service.impl;
    2.  
    3. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
    4. import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
    5. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
    6. import com.keke.constants.SystemConstants;
    7. import com.keke.domain.ResponseResult;
    8. import com.keke.domain.dto.AdminCategoryDto;
    9. import com.keke.domain.entity.Article;
    10. import com.keke.domain.entity.Category;
    11. import com.keke.domain.vo.AdminCategoryVo;
    12. import com.keke.domain.vo.CategoryVo;
    13. import com.keke.domain.vo.PageVo;
    14. import com.keke.mapper.CategoryMapper;
    15. import com.keke.service.ArticleService;
    16. import com.keke.service.CategoryService;
    17. import com.keke.utils.BeanCopyUtils;
    18. import org.springframework.beans.factory.annotation.Autowired;
    19. import org.springframework.stereotype.Service;
    20. import org.springframework.util.StringUtils;
    21. import org.springframework.web.bind.annotation.RequestMapping;
    22.  
    23. import java.util.List;
    24. import java.util.Set;
    25. import java.util.function.Function;
    26. import java.util.stream.Collectors;
    27.  
    28. /**
    29.  * 分类表(Category)表服务实现类
    30.  *
    31.  * @author makejava
    32.  * @since 2023-10-10 20:42:22
    33.  */
    34. @Service("categoryService")
    35. public class CategoryServiceImpl extends ServiceImpl implements CategoryService {
    36.  
    37.      @Autowired
    38.      private ArticleService articleService;
    39.  
    40.      @Override
    41.      public ResponseResult getCategoryList() {
    42.           //查询文章表，状态已发布的文章，但是在CategoryService下，查询文章表，就要注入ArticleService
    43.           LambdaQueryWrapper
       articleWrapper = new LambdaQueryWrapper<>();
    44.           articleWrapper.eq(Article::getStatus, SystemConstants.ARTICLE_STATUS_NORMAL);
    45.           List
       articleList = articleService.list(articleWrapper);
    46.           //获取文章的分类id，并去重
    47.           Set categoryIds = articleList.stream()
    48.                   .map(article -> article.getCategoryId())
    49.                   //toSet可以去除重复的id
    50.                   .collect(Collectors.toSet());
    51.           //查询分类表
    52.           List categories = listByIds(categoryIds);
    53.           //分类表中只获取正常状态非禁用的分类，用stream流过滤
    54.           categories = categories.stream()
    55.                   .filter(category -> SystemConstants.STATUS_NORMAL.equals(category.getStatus()))
    56.                   .collect(Collectors.toList());
    57.           //封装Vo
    58.           List categoryVos = BeanCopyUtils.copyBeanList(categories, CategoryVo.class);
    59.           //封装到响应体中，因为有数据，所以要调用有参okResult()，把参数传进去
    60.           return ResponseResult.okResult(categoryVos);
    61.      }
    62.  
    63.      @Override
    64.      public ResponseResult listAllCategory() {
    65.           LambdaQueryWrapper lambdaQueryWrapper = new LambdaQueryWrapper<>();
    66.           lambdaQueryWrapper.eq(Category::getStatus,SystemConstants.STATUS_NORMAL);
    67.           List categoryList = list(lambdaQueryWrapper);
    68.           List adminCategoryVos = BeanCopyUtils.copyBeanList(categoryList, AdminCategoryVo.class);
    69.           return ResponseResult.okResult(adminCategoryVos);
    70.      }
    71.  
    72.      @Override
    73.      public ResponseResult selectPageCategory(Category category, Integer pageNum, Integer pageSize) {
    74.           LambdaQueryWrapper lambdaQueryWrapper = new LambdaQueryWrapper<>();
    75.           //根据分类名进行模糊查询
    76.           lambdaQueryWrapper.like(StringUtils.hasText(category.getName()),Category::getName,category.getName());
    77.           lambdaQueryWrapper.eq(StringUtils.hasText(category.getStatus()),Category::getStatus,category.getStatus());
    78.           //构造分页器
    79.           Page page = new Page<>(pageNum,pageSize);
    80.           page(page,lambdaQueryWrapper);
    81.           //封装Vo
    82.           PageVo pageVo = new PageVo(page.getRecords(),page.getTotal());
    83.           return ResponseResult.okResult(pageVo);
    84.      }
    85.  
    86.      @Override
    87.      public ResponseResult addCategory(AdminCategoryDto adminCategoryDto) {
    88.           Category category = BeanCopyUtils.copyBean(adminCategoryDto, Category.class);
    89.           save(category);
    90.           return ResponseResult.okResult();
    91.      }
    92. }

    2.3 测试

    3. 修改分类

    需要提供修改分类的功能

    分析：点击修改按钮，需要回显出分类的相关信息

               点击确定按钮，修改成功

    所以这里需要实现两个接口

    3.1 回显分类信息接口

    3.1.1 接口分析

    根据id查询分类

    请求方式请求路径是否需求token头
    Getcontent/category/{id}是
    3.1.2 代码实现

    逻辑较少，直接在Controller层写逻辑

    1. package com.keke.controller;
    2.  
    3.  
    4. import com.alibaba.excel.EasyExcel;
    5. import com.alibaba.fastjson.JSON;
    6. import com.keke.domain.ResponseResult;
    7. import com.keke.domain.dto.AdminCategoryDto;
    8. import com.keke.domain.entity.Category;
    9. import com.keke.domain.vo.ExcelCategoryVo;
    10. import com.keke.enums.AppHttpCodeEnum;
    11. import com.keke.service.CategoryService;
    12. import com.keke.utils.BeanCopyUtils;
    13. import com.keke.utils.WebUtils;
    14. import io.swagger.annotations.Api;
    15. import org.springframework.beans.factory.annotation.Autowired;
    16. import org.springframework.security.access.prepost.PreAuthorize;
    17. import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
    18. import org.springframework.web.bind.annotation.*;
    19.  
    20. import javax.servlet.http.HttpServletResponse;
    21. import java.io.UnsupportedEncodingException;
    22. import java.util.List;
    23.  
    24. @RestController
    25. @RequestMapping("/content/category")
    26. @Api(tags = "后台标签相关接口")
    27. public class CategoryController {
    28.  
    29.      @Autowired
    30.      private CategoryService categoryService;
    31.  
    32.      @GetMapping("/listAllCategory")
    33.      public ResponseResult listAllCategory(){
    34.           return categoryService.listAllCategory();
    35.      }
    36.  
    37.      //权限控制，ps是PermissionService类的bean名称
    38.      @PreAuthorize("@ps.hasPermission('content:category:export')")
    39.      @GetMapping("/export")
    40.      public void export(HttpServletResponse response){
    41.  
    42.           try {
    43.                //设置下载文件的请求头
    44.                WebUtils.setDownLoadHeader("分类.xlsx",response);
    45.                //获取需要导出的数据
    46.                List categoryList = categoryService.list();
    47.                List excelCategoryVos = BeanCopyUtils.copyBeanList(categoryList, ExcelCategoryVo.class);
    48.                //把数据写入Excel中
    49.                EasyExcel.write(response.getOutputStream(), ExcelCategoryVo.class).autoCloseStream(Boolean.FALSE).sheet("分类导出")
    50.                        .doWrite(excelCategoryVos);
    51.           } catch (Exception e) {
    52.                //如果出现异常,就返回失败的json数据给前端
    53.                ResponseResult result = ResponseResult.errorResult(AppHttpCodeEnum.SYSTEM_ERROR);
    54.                //WebUtils是我们在keke-framework工程写的类，里面的renderString方法是将json字符串写入到请求体，然后返回给前端
    55.                WebUtils.renderString(response, JSON.toJSONString(result));
    56.           }
    57.      }
    58.  
    59.  
    60.      @GetMapping("/list")
    61.      public ResponseResult selectPageCategory(Category category,Integer pageNum,Integer pageSize){
    62.           return categoryService.selectPageCategory(category,pageNum,pageSize);
    63.      }
    64.  
    65.      @PostMapping
    66.      public ResponseResult addCategory(@RequestBody AdminCategoryDto adminCategoryDto){
    67.           return categoryService.addCategory(adminCategoryDto);
    68.      }
    69.  
    70.      @GetMapping("/{id}")
    71.      public ResponseResult getInfoById(@PathVariable("id") Long id){
    72.           Category category = categoryService.getById(id);
    73.           return ResponseResult.okResult(category);
    74.      }
    75.  
    76. }
    3.1.3 测试

    成功回显出分类信息

    3.2 修改分类接口

    3.2.1 接口分析
    请求方式请求路径是否需求token头
    PUT/content/category是

     请求体：

    1. {
    2.     "description":"是的",
    3.     "id":"3",
    4.     "name":"威威2",
    5.     "status":"0"
    6. }

     响应格式：

    1. {
    2. 	"code":200,
    3. 	"msg":"操作成功"
    4. }
    3.2.2 代码实现

    逻辑较少，直接在controller层实现

    1.  
    2.      @PutMapping
    3.      public ResponseResult editCategory(@RequestBody Category category){
    4.           categoryService.updateById(category);
    5.           return ResponseResult.okResult();
    6.      }
    3.2.3 测试

    4. 删除分类

    删除某个分类（逻辑删除）

    4.1 接口分析

    请求方式请求路径是否需求token头
    DELETE/content/category/{id}是

    请求参数PathVariable格式：

    id：要删除的分类id

    响应格式：  

    1. {
    2. 	"code":200,
    3. 	"msg":"操作成功"
    4. }

     4.2 代码实现

    逻辑较少，直接在controller层实现

    1.   @DeleteMapping("/{id}")
    2.      public ResponseResult deleteCategory(@PathVariable("/id") Long id){
    3.           categoryService.removeById(id);
    4.           return ResponseResult.okResult();
    5.      }

    4.3 测试

     

    十五、后台模块-友链列表

    1.  查询友链

    需要分页查询友链列表。

    能根据友链名称进行模糊查询。

    能根据状态进行查询。

    1.1 接口分析

    请求方式请求路径是否需求token头
    GET/content/link/list是

    Query格式请求参数：

    1. pageNum: 页码
    2.  
    3. pageSize: 每页条数
    4.  
    5. name：友链名
    6.  
    7. status:状态

     响应格式：

    1. {
    2. 	"code":200,
    3. 	"data":{
    4. 		"rows":[
    5. 			{
    6. 				"address":"https://www.baidu.com",
    7. 				"description":"sda",
    8. 				"id":"1",
    9.                 "logo":"图片URL",		
    10. 				"name":"sda",
    11. 				"status":"0"
    12. 			}
    13. 		],
    14. 		"total":"1"
    15. 	},
    16. 	"msg":"操作成功"
    17. }

     1.2 代码实现

    第一步：keke-admin的controller层新建LinkController

    1. package com.keke.controller;
    2.  
    3. import com.keke.domain.ResponseResult;
    4. import com.keke.domain.entity.Link;
    5. import com.keke.service.LinkService;
    6. import org.springframework.beans.factory.annotation.Autowired;
    7. import org.springframework.web.bind.annotation.GetMapping;
    8. import org.springframework.web.bind.annotation.RequestMapping;
    9. import org.springframework.web.bind.annotation.RestController;
    10.  
    11. @RestController
    12. @RequestMapping("/system/link")
    13. public class LinkController {
    14.      
    15.      @Autowired
    16.      private LinkService linkService;
    17.      
    18.      @GetMapping("/list")
    19.      public ResponseResult selectPageLink(Link link, Integer pageNum, Integer pageSize){
    20.           return linkService.selectPageLink(link,pageNum,pageSize);
    21.      }
    22. }

    第二步：keke-framework的service层新增方法

    1. package com.keke.service;
    2.  
    3. import com.keke.domain.ResponseResult;
    4. import com.keke.domain.entity.Link;
    5. import com.baomidou.mybatisplus.extension.service.IService;
    6.  
    7. /**
    8.  * 友链(Link)表服务接口
    9.  *
    10.  * @author makejava
    11.  * @since 2023-10-11 15:46:23
    12.  */
    13. public interface LinkService extends IService {
    14.  
    15.      ResponseResult getAllLink();
    16.  
    17.      ResponseResult selectPageLink(Link link, Integer pageNum, Integer pageSize);
    18. }

    第三步：keke-framework的impl层实现方法

    1. package com.keke.service.impl;
    2.  
    3.  
    4. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
    5. import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
    6. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
    7. import com.keke.constants.SystemConstants;
    8. import com.keke.domain.ResponseResult;
    9. import com.keke.domain.entity.Link;
    10. import com.keke.domain.vo.LinkVo;
    11. import com.keke.domain.vo.PageVo;
    12. import com.keke.mapper.LinkMapper;
    13. import com.keke.service.LinkService;
    14. import com.keke.utils.BeanCopyUtils;
    15. import org.springframework.stereotype.Service;
    16. import org.springframework.util.StringUtils;
    17.  
    18. import java.util.List;
    19.  
    20. /**
    21.  * 友链(Link)表服务实现类
    22.  *
    23.  * @author makejava
    24.  * @since 2023-10-11 16:53:47
    25.  */
    26. @Service("linkService")
    27. public class LinkServiceImpl extends ServiceImpl implements LinkService {
    28.  
    29.      @Override
    30.      public ResponseResult getAllLink() {
    31.           //查询所有审核通过的
    32.           LambdaQueryWrapper lambdaQueryWrapper = new LambdaQueryWrapper<>();
    33.           lambdaQueryWrapper.eq(Link::getStatus, SystemConstants.Link_STATUS_NORMAL);
    34.           List links = list(lambdaQueryWrapper);
    35.           //转换Vo
    36.           List linkVos = BeanCopyUtils.copyBeanList(links, LinkVo.class);
    37.           //封装响应体
    38.           return ResponseResult.okResult(linkVos);
    39.      }
    40.  
    41.      @Override
    42.      public ResponseResult selectPageLink(Link link, Integer pageNum, Integer pageSize) {
    43.           LambdaQueryWrapper lambdaQueryWrapper = new LambdaQueryWrapper<>();
    44.           //根据友链名进行模糊查询
    45.           lambdaQueryWrapper.like(StringUtils.hasText(link.getName()),Link::getName,link.getName());
    46.           //根据状态进行查询
    47.           lambdaQueryWrapper.eq(StringUtils.hasText(link.getStatus()),Link::getStatus,link.getStatus());
    48.           //构造分页器
    49.           Page page = new Page<>(pageNum,pageSize);
    50.           page(page,lambdaQueryWrapper);
    51.           //封装Vo
    52.           PageVo pageVo = new PageVo(page.getRecords(),page.getTotal());
    53.           //封装响应体返回
    54.           return ResponseResult.okResult(pageVo);
    55.      }
    56. }

    1.3 测试

    2. 新增友链

    需要新增友链功能

    2.1 接口分析

    请求方式请求路径是否需求token头
    POST/content/link是

    请求体：

    1. {
    2.     "name":"sda",
    3.     "description":"weqw",
    4.     "address":"wewe",
    5.     "logo":"weqe",
    6.     "status":"2"
    7. }

    响应格式：

    1. {
    2. 	"code":200,
    3. 	"msg":"操作成功"
    4. }

     2.2 代码实现

    第一步：修改entity层Link实体类，修改四字段为mp自动填充

    1. package com.keke.domain.entity;
    2.  
    3. import java.util.Date;
    4. import java.io.Serializable;
    5.  
    6. import com.baomidou.mybatisplus.annotation.FieldFill;
    7. import com.baomidou.mybatisplus.annotation.TableField;
    8. import lombok.AllArgsConstructor;
    9. import lombok.Data;
    10. import lombok.NoArgsConstructor;
    11. import com.baomidou.mybatisplus.annotation.TableName;
    12.  
    13. /**
    14.  * 友链(Link)表实体类
    15.  *
    16.  * @author makejava
    17.  * @since 2023-10-11 15:45:54
    18.  */
    19. @SuppressWarnings("serial")
    20. @Data
    21. @NoArgsConstructor
    22. @AllArgsConstructor
    23. @TableName("ke_link")
    24. public class Link {
    25.     
    26.     private Long id;
    27.     
    28.     private String name;
    29.     
    30.     private String logo;
    31.     
    32.     private String description;
    33.     //网站地址
    34.     private String address;
    35.     //审核状态 (0代表审核通过，1代表审核未通过，2代表未审核)
    36.     private String status;
    37.  
    38.     //创建者
    39.     @TableField(fill = FieldFill.INSERT)
    40.     private Long createBy;
    41.     //创建时间
    42.     @TableField(fill = FieldFill.INSERT)
    43.     private Date createTime;
    44.     //更新者
    45.     @TableField(fill = FieldFill.INSERT_UPDATE)
    46.     private Long updateBy;
    47.     //更新时间
    48.     @TableField(fill = FieldFill.INSERT_UPDATE)
    49.     private Date updateTime;
    50.     
    51.     //删除标志（0代表未删除，1代表已删除）
    52.     private Integer delFlag;
    53.  
    54. }

    第二步：keke-admin的controller层新增添加友链的接口

    1. package com.keke.controller;
    2.  
    3. import com.keke.domain.ResponseResult;
    4. import com.keke.domain.entity.Link;
    5. import com.keke.service.LinkService;
    6. import org.springframework.beans.factory.annotation.Autowired;
    7. import org.springframework.web.bind.annotation.*;
    8.  
    9. @RestController
    10. @RequestMapping("/content/link")
    11. public class LinkController {
    12.  
    13.      @Autowired
    14.      private LinkService linkService;
    15.  
    16.      //分页查询友链
    17.      @GetMapping("/list")
    18.      public ResponseResult selectPageLink(Link link, Integer pageNum, Integer pageSize){
    19.           return linkService.selectPageLink(link,pageNum,pageSize);
    20.      }
    21.  
    22.      //新增友链
    23.      @PostMapping
    24.      public ResponseResult addLink(@RequestBody Link link){
    25.           linkService.save(link);
    26.           return ResponseResult.okResult();
    27.      }
    28. }

     2.3 测试

    3. 修改友链

     需要提供修改友链的功能

    3.1 回显友链信息接口

    3.1.1 接口分析

    根据id查询友链

    请求方式请求路径是否需求token头
    Getcontent/link/{id}是

    请求PathVariable格式参数：

    id: 友链id

     响应格式：

    1. {
    2. 	"code":200,
    3. 	"data":{
    4. 		"address":"wewe",
    5. 		"description":"weqw",
    6. 		"id":"4",
    7. 		"logo":"weqe",
    8. 		"name":"sda",
    9. 		"status":"2"
    10. 	},
    11. 	"msg":"操作成功"
    12. }
    3.1.2 代码实现

    逻辑较少，直接在controller层写

    1.      //回显友链信息
    2.      @GetMapping("/{id}")
    3.      public ResponseResult getInfoById(@PathVariable("id") Long id){
    4.           Link link = linkService.getById(id);
    5.           return ResponseResult.okResult(link);
    6.      }
    3.1.3 测试

    3.2 修改友链接口

    3.2.1 接口分析
    请求方式请求路径是否需求token头
    PUT/content/link是

    请求头：

    1. {
    2.     "address":"https://www.qq.com",
    3.     "description":"dada2",
    4.     "id":"2",
    5.     "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",
    6.     "name":"sda",
    7.     "status":"0"
    8. }

    响应体：

    1. {
    2. 	"code":200,
    3. 	"msg":"操作成功"
    4. }
     3.2.2 代码实现
    1.      //修改友链
    2.      @PutMapping
    3.      public ResponseResult editLink(@RequestBody Link link){
    4.           linkService.updateById(link);
    5.           return ResponseResult.okResult();
    6.      }
     3.2.3 测试

    我们把刚才新增的友链LOG修改成猴子图标

    4. 删除友链

    删除某个友链（逻辑删除）

    4.1 接口分析

    请求方式请求路径是否需求token头
    DELETE/content/link/{id}是

    请求参数PathVariable格式：

    id：要删除的友链id

     响应格式：

    1. {
    2. 	"code":200,
    3. 	"msg":"操作成功"
    4. }

     4.2 代码实现

    1. package com.keke.controller;
    2.  
    3. import com.keke.domain.ResponseResult;
    4. import com.keke.domain.entity.Link;
    5. import com.keke.service.LinkService;
    6. import org.springframework.beans.factory.annotation.Autowired;
    7. import org.springframework.web.bind.annotation.*;
    8.  
    9. @RestController
    10. @RequestMapping("/content/link")
    11. public class LinkController {
    12.  
    13.      @Autowired
    14.      private LinkService linkService;
    15.  
    16.      //分页查询友链
    17.      @GetMapping("/list")
    18.      public ResponseResult selectPageLink(Link link, Integer pageNum, Integer pageSize){
    19.           return linkService.selectPageLink(link,pageNum,pageSize);
    20.      }
    21.  
    22.      //新增友链
    23.      @PostMapping
    24.      public ResponseResult addLink(@RequestBody Link link){
    25.           linkService.save(link);
    26.           return ResponseResult.okResult();
    27.      }
    28.  
    29.      //回显友链信息
    30.      @GetMapping("/{id}")
    31.      public ResponseResult getInfoById(@PathVariable("id") Long id){
    32.           Link link = linkService.getById(id);
    33.           return ResponseResult.okResult(link);
    34.      }
    35.  
    36.      //修改友链
    37.      @PutMapping
    38.      public ResponseResult editLink(@RequestBody Link link){
    39.           linkService.updateById(link);
    40.           return ResponseResult.okResult();
    41.      }
    42.      
    43.      //根据id删除友链
    44.      @DeleteMapping("/{id}")
    45.      public ResponseResult deleteLink(@PathVariable("id") Long id){
    46.           linkService.removeById(id);
    47.           return ResponseResult.okResult();
    48.      }
    49. }

     4.3 测试

     

     

     至此，KekeBlog的后台模块开发全部结束

  • 相关阅读:
    关于自动化测试工具selenium
    程序员必备，一款让你提高工作效率N倍的神器uTools
    JVM(Java虚拟机)
    mysql—各种函数的使用
    25个例子学会Pandas Groupby 操作
    基于扩张观测器(LESO)的滑模控制
    神经网络激活函数的使用
    ccs: memory range overlaps existing memory range
    阿里云国际版云服务器防火墙设置
    Nacos集群配置以及在springboot中使用
  • 原文地址：https://blog.csdn.net/m0_63732435/article/details/134022825