spring boot+iview 前后端分离架构之菜单管理的实现（二十七）

喜欢ヅ旅行 2021-12-14 06:55 235阅读 0赞

### spring boot 与 iview 前后端分离架构之菜单管理的实现（二十七） ###

*  公众号
 *  菜单管理
 *   *  相关工具类的实现
     *   *  TreeDto【实体转换类】
         *  TreeMapper【菜单实体转换】
         *  TreeInstall【菜单组装工具类】
         *  TreeStaticConstant菜单静态类
     *  菜单管理的实现
     *   *  RoleTreeDao.xml代码实现如下
         *  RoleTreeDao代码实现如下
         *  TreeDao的实现
         *  TreeService的实现
         *  TreeController的实现
         *  前端本章缺失
     *  运行项目

# 公众号 #

![在这里插入图片描述][20191218155125364.jpg]  
大家可以直接微信扫描上面的二维码关注我的公众号，然后回复【bg27】 里面就会给到源代码的下载地址同时会附上相应的视频教程，并定期在我的公众号上给大家推送相应的技术文章，欢迎大家关注我的公众号。

# 菜单管理 #

在上一章节我们已经实现了字典管理，在本章我们则需要实现我们的菜单管理。

## 相关工具类的实现 ##

在我们开始编写菜单管理的时候我们首先需要实现一些相关工具类，例如菜单映射的mapper、菜单的组装工具类等。

### TreeDto【实体转换类】 ###

在core目录底下创建一个TreeDto，用于作为返回给前端加载菜单的实体，代码如下：

package com.github.bg.admin.core.dto;
    
    import java.util.List;
    
    /**
     * @author linzf
     * @since 2019/5/5
     * 类描述：前端展示菜单的dto实体
     */
    public class TreeDto {
    
        /**
         * 菜单流水ID
         */
        private Integer treeId;
        /**
         * 菜单名字
         */
        private String title;
    
        /**
         * 菜单编码
         */
        private String treeCode;
        /**
         * 菜单状态【1：可用；2：禁用】
         */
        private String treeState;
        /**
         * 菜单类型【1：菜单节点；2：按钮节点】
         */
        private String treeType;
        /**
         * 父节点唯一标识
         */
        private Integer parentTreeId;
        /**
         * 父节点名字
         */
        private String parentTreeName;
        /**
         * 默认子节点都是展开的
         */
        private boolean expand = true;
        /**
         * 默认节点是没有选中的
         */
        private boolean checked = false;
        /**
         * 子节点数据
         */
        private List<TreeDto> children;
    
        public Integer getTreeId() {
            return treeId;
        }
    
        public void setTreeId(Integer treeId) {
            this.treeId = treeId;
        }
    
        public String getTitle() {
            return title;
        }
    
        public void setTitle(String title) {
            this.title = title;
        }
    
        public String getTreeCode() {
            return treeCode;
        }
    
        public void setTreeCode(String treeCode) {
            this.treeCode = treeCode;
        }
    
        public String getTreeState() {
            return treeState;
        }
    
        public void setTreeState(String treeState) {
            this.treeState = treeState;
        }
    
        public String getTreeType() {
            return treeType;
        }
    
        public void setTreeType(String treeType) {
            this.treeType = treeType;
        }
    
        public Integer getParentTreeId() {
            return parentTreeId;
        }
    
        public void setParentTreeId(Integer parentTreeId) {
            this.parentTreeId = parentTreeId;
        }
    
        public String getParentTreeName() {
            return parentTreeName;
        }
    
        public void setParentTreeName(String parentTreeName) {
            this.parentTreeName = parentTreeName;
        }
    
        public boolean isExpand() {
            return expand;
        }
    
        public void setExpand(boolean expand) {
            this.expand = expand;
        }
    
        public boolean isChecked() {
            return checked;
        }
    
        public void setChecked(boolean checked) {
            this.checked = checked;
        }
    
        public List<TreeDto> getChildren() {
            return children;
        }
    
        public void setChildren(List<TreeDto> children) {
            this.children = children;
        }
    }

### TreeMapper【菜单实体转换】 ###

package com.github.bg.admin.core.mapper;
    
    
    import com.github.bg.admin.core.dto.TreeDto;
    import com.github.bg.admin.core.entity.Tree;
    import org.mapstruct.Mapper;
    import org.mapstruct.Mapping;
    import org.mapstruct.Mappings;
    
    import java.util.List;
    
    /**
     * @author linzf
     * @since 2019/5/5
     * 类描述：菜单实体快速转换的实现
     */
    @Mapper(componentModel = "spring")
    public interface TreeMapper {
    
        /**
         * 功能描述：实现数据的转换
         *
         * @param entity
         * @return
         */
        @Mappings({
                @Mapping(target = "title", source = "treeName"),
                @Mapping(target = "treeId", source = "treeId")
        })
        TreeDto treeToTreeDto(Tree entity);
    
        /**
         * 功能描述：实现集合的数据的转换，这边先设置实体之间的转换集合的设置才会实现
         *
         * @param trees
         * @return
         */
        List<TreeDto> treesToTreeDTO(List<Tree> trees);
    
    }

### TreeInstall【菜单组装工具类】 ###

package com.github.bg.admin.core.util;
    
    
    
    import com.github.bg.admin.core.dto.TreeDto;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Map;
    
    /**
     * @author linzf
     * @since 2019/5/5
     * 类描述：实现组装菜单树的数据
     */
    public class TreeInstall {
    
    
        /**
         * 功能描述：实现递归组装选中的菜单节点的数据
         * @param treeList 全部菜单节点的集合
         * @param treeMap
         * @return
         */
        public static List<TreeDto> installCheckTree(List<TreeDto> treeList, Map<String,Object> treeMap){
            List<TreeDto> trees = new ArrayList<>();
            for(TreeDto roleTree : treeList ){
                if(0 == roleTree.getParentTreeId()){
                    roleTree.setChildren(getCheckChild(roleTree.getTreeId(),treeList,treeMap));
                    // 用于防止子节点部分选中，而父节点全部选中
                    if(roleTree.getChildren().size()>0){
                        for(TreeDto checkTree:roleTree.getChildren()){
                            if(!checkTree.isChecked()){
                                roleTree.setChecked(false);
                                break;
                            }
                        }
                    }
                    trees.add(roleTree);
                }
            }
            return trees;
        }
    
        /**
         * 功能描述：实现树形菜单数据的组装
         * @param treeList
         */
        public static  List<TreeDto> installTree(List<TreeDto> treeList){
            List<TreeDto> trees = new ArrayList<>();
            for(TreeDto roleTree : treeList ){
                if(0 == roleTree.getParentTreeId()){
                    roleTree.setChildren(getChild(roleTree.getTreeId(),treeList));
                    trees.add(roleTree);
                }
            }
            return trees;
        }
    
    
        /**
         * 功能描述：递归遍历菜单节点
         * @param id
         * @param trees
         * @param treeMap
         * @return
         */
        private static List<TreeDto> getCheckChild(Integer id, List<TreeDto> trees, Map<String,Object> treeMap) {
            List<TreeDto> childList = new ArrayList<>();
            for (TreeDto tree : trees) {
                if(tree.getParentTreeId().intValue()==id.intValue()){
                    tree.setChildren(getCheckChild(tree.getTreeId(),trees,treeMap));
                    if(treeMap.get(tree.getTreeId().toString())!=null){
                        tree.setChecked(true);
                    }else{
                        tree.setChecked(false);
                    }
                    if(tree.getChildren().size()>0){
                        for(TreeDto checkTree:tree.getChildren()){
                            if(!checkTree.isChecked()){
                                tree.setChecked(false);
                                break;
                            }
                        }
                    }
                    childList.add(tree);
                }
            }
            return childList;
        }
    
        /**
         * 功能描述：递归遍历菜单节点
         * @param id
         * @param trees
         * @return
         */
        private static List<TreeDto> getChild(Integer id, List<TreeDto> trees) {
            List<TreeDto> childList = new ArrayList<>();
            for (TreeDto tree : trees) {
                if(tree.getParentTreeId().intValue()==id.intValue()){
                    tree.setChildren(getChild(tree.getTreeId(),trees));
                    childList.add(tree);
                }
            }
            return childList;
        }
    
    }

### TreeStaticConstant菜单静态类 ###

package com.github.bg.admin.core.constant;
    
    /**
     * @author linzf
     * @since 2019/5/5
     * 类描述：
     */
    public class TreeStaticConstant {
    
        /**
         * 菜单状态为正常
         */
        public static final String TREE_STATE_NORMAL = "1";
    
        /**
         * 菜单类型为菜单节点
         */
        public static final String TREE_TYPE_MENU = "1";
    
        /**
         * 菜单类型为按钮节点
         */
        public static final String TREE_TYPE_BUTTON = "2";
    
    
        /**
         * 验证是否通过的标识
         */
        public static final String CHECK_TREE_TIP = "success";
    
        /**
         * 验证通过
         */
        public static final String CHECK_TREE_PASS = "pass";
    
        /**
         * 验证不通过
         */
        public static final String CHECK_TREE_UN_PASS = "unPass";
    
    }

## 菜单管理的实现 ##

由于菜单是和角色是相互关联的，因此当我们在删除菜单的时候，我们应该同时需要删除二者之间的关联关系，因此我们在此处需要实现根据菜单ID来删除菜单和角色的关联关系的方法。

### RoleTreeDao.xml代码实现如下 ###

<?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="com.github.bg.admin.core.dao.RoleTreeDao">
      <resultMap id="BaseResultMap" type="com.github.bg.admin.core.entity.RoleTree">
        <id column="roleTreeId" jdbcType="VARCHAR" property="roleTreeId" />
        <result column="roleId" jdbcType="VARCHAR" property="roleId" />
        <result column="treeId" jdbcType="INTEGER" property="treeId" />
      </resultMap>
    
      
      <delete id="deleteRoleTreeByTreeId">
        delete from t_role_tree where treeId = #{treeId}
      </delete>
    
    </mapper>

### RoleTreeDao代码实现如下 ###

package com.github.bg.admin.core.dao;
    
    import com.github.bg.admin.core.entity.RoleTree;
    import org.apache.ibatis.annotations.Param;
    import tk.mybatis.mapper.common.Mapper;
    
    public interface RoleTreeDao extends Mapper<RoleTree> {
    
        /**
         * 功能描述：根据菜单ID删除关联关系
         * @param treeId 菜单ID
         * @return 返回删除结果
         */
        int deleteRoleTreeByTreeId(@Param("treeId")Integer treeId);
    
    }

### TreeDao的实现 ###

package com.github.bg.admin.core.dao;
    
    import com.github.bg.admin.core.entity.Tree;
    import org.apache.ibatis.annotations.Param;
    import tk.mybatis.mapper.common.Mapper;
    
    import java.util.List;
    
    /**
     * @author linzf
     * @since 2019-07-05
     * 类描述：菜单的dao
     */
    public interface TreeDao extends Mapper<Tree> {
    
        /**
         * 功能描述：根据用户登录的ID来获取权限数据的集合
         * @param userId 用户ID
         * @return 返回数据集合
         */
        List<Tree> getLoginUserPowerPath(@Param("userId") String userId);
    
        /**
         * 功能描述：根据用户登录的ID来获取菜单节点的数据
         * @param userId 用户ID
         * @return 返回数据集合
         */
        List<Tree> getLoginUserTree(@Param("userId") String userId);
        /**
         * 功能描述：根据菜单流水ID来更新菜单数据
         * @param treeId 菜单流水ID
         * @param treeCode 菜单编码
         * @param treeName 菜单名称
         * @param powerPath 权限集合
         * @return 返回更新结果
         */
        int updateTree(@Param("treeId") Integer treeId,
                       @Param("treeCode") String treeCode,
                       @Param("treeName") String treeName,
                       @Param("powerPath")String powerPath);
    
        /**
         * 功能描述：统计当前菜单节点底下是否还有子节点
         * @param treeId 菜单流水ID
         * @return 返回统计结果
         */
        int countTreeChildren(@Param("treeId") Integer treeId);
    
        /**
         * 功能描述：冻结/解冻按钮
         * @param treeId 节点ID
         * @param treeState 节点状态
         * @return 返回操作结果
         */
        int operateButton(@Param("treeId") Integer treeId,@Param("treeState") String treeState);
    
        /**
         * 功能描述：更新节点的路径
         * @param fullPath 节点路径
         * @param treeId  节点ID
         * @return 返回更新节点路径结果
         */
        int updateFullPath(@Param("fullPath") String fullPath,@Param("treeId") Integer treeId);
    
        /**
         * 功能描述：更新按钮节点
         * @param treeCode 节点编码
         * @param treeName 节点名称
         * @param treeId 节点ID
         * @param powerPath 权限集合
         * @return 返回更新结果
         */
        int updateButton(@Param("treeCode") String treeCode,
                         @Param("treeName") String treeName,
                         @Param("treeId") Integer treeId,
                         @Param("powerPath") String powerPath);
    
        /**
         * 功能描述：验证菜单节点或者按钮节点的编码是否已经存在了
         * @param treeCode 节点编码
         * @param treeId 节点ID
         * @return 返回验证结果
         */
        int checkTreeCode(@Param("treeCode") String treeCode,@Param("treeId") Integer treeId);
    
        /**
         * 功能描述：获取菜单的按钮的列表
         * @param search 模糊查询treeName和treeCode的数据
         * @param parentTreeId 父节点ID
         * @return 返回该父节点底下的当级的按钮的数据
         */
        List<Tree> queryTreeButtonList(@Param("search") String search, @Param("parentTreeId") Integer parentTreeId);
    
        /**
         * 功能描述：根据角色ID来查询该角色底下的所有的关联的菜单的数据
         *
         * @param roleId 角色ID
         * @return 返回查询结果
         */
        List<Tree> queryTreeByRoleId(@Param("roleId") String roleId);
    
    }

### TreeService的实现 ###

package com.github.bg.admin.core.service;
    
    
    import com.github.bg.admin.core.constant.SystemStaticConst;
    import com.github.bg.admin.core.constant.TreeStaticConstant;
    import com.github.bg.admin.core.dao.RoleTreeDao;
    import com.github.bg.admin.core.dao.TreeDao;
    import com.github.bg.admin.core.entity.Page;
    import com.github.bg.admin.core.entity.ReturnInfo;
    import com.github.bg.admin.core.entity.Tree;
    import com.github.bg.admin.core.mapper.TreeMapper;
    import com.github.bg.admin.core.util.PageUtil;
    import com.github.bg.admin.core.util.TreeInstall;
    import com.github.pagehelper.PageHelper;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import org.springframework.transaction.annotation.Transactional;
    import org.springframework.web.bind.annotation.PostMapping;
    
    import java.util.Date;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    /**
     * @author linzf
     * @since 2019-05-07
     * 类描述：菜单的service实现类
     */
    @Service
    @Transactional(rollbackFor = {IllegalArgumentException.class})
    public class TreeService {
    
        @Autowired
        private TreeDao treeDao;
        @Autowired
        private RoleTreeDao roleTreeDao;
        @Autowired
        private TreeMapper treeMapper;
    
        /**
         * 功能描述：根据菜单流水ID来更新菜单数据
         * @param treeId 菜单流水ID
         * @param treeCode 菜单编码
         * @param treeName 菜单名称
         * @param powerPath 权限集合
         * @return 返回更新结果
         */
        public ReturnInfo updateTree(Integer treeId, String treeCode, String treeName, String powerPath){
            if(treeDao.updateTree(treeId, treeCode, treeName,powerPath)>0){
                return new ReturnInfo(SystemStaticConst.SUCCESS,"更新菜单节点成功");
            }else{
                return new ReturnInfo(SystemStaticConst.FAIL,"更新菜单节点失败");
            }
        }
    
        /**
         * 功能描述：根据菜单ID来获取菜单数据
         * @param treeId 菜单ID
         * @return 返回操作结果
         */
        public ReturnInfo getTreeByTreeId(Integer treeId){
            Tree tree = treeDao.selectByPrimaryKey(treeId);
            if(tree==null){
                return new ReturnInfo(SystemStaticConst.FAIL,"查无此菜单数据");
            }else{
                return new ReturnInfo(SystemStaticConst.SUCCESS,"获取菜单节点成功",tree);
            }
        }
    
        /**
         * 功能描述：删除菜单节点
         * @param treeId 菜单节点ID
         * @return 返回删除结果
         */
        public ReturnInfo deleteTree(Integer treeId){
            if(treeDao.countTreeChildren(treeId)>0){
                return new ReturnInfo(SystemStaticConst.FAIL, "当前菜单节点底下还有其他节点，请先删除底下的节点以后再来删除当前节点");
            }
            if(treeDao.deleteByPrimaryKey(treeId)>0){
                roleTreeDao.deleteRoleTreeByTreeId(treeId);
                return new ReturnInfo(SystemStaticConst.SUCCESS,"删除菜单节点成功");
            }else{
                return new ReturnInfo(SystemStaticConst.FAIL,"删除菜单节点失败");
            }
        }
    
        /**
         * 功能描述：冻结/解冻按钮
         * @param treeId 节点ID
         * @param treeState 节点状态
         * @return 返回操作结果
         */
        public ReturnInfo operateButton(Integer treeId,String treeState){
            if(treeDao.operateButton(treeId, treeState)>0){
                return new ReturnInfo(SystemStaticConst.SUCCESS, "操作成功");
            }else{
                return new ReturnInfo(SystemStaticConst.FAIL, "操作失败");
            }
        }
    
        /**
         * 功能描述：增加按钮
         * @param treeCode 按钮编码
         * @param treeName 按钮名称
         * @param powerPath 权限集合
         * @param parentTreeId 父菜单节点ID
         * @param treeType 节点类型
         * @return 返回增加结果
         */
        public ReturnInfo addButton(String treeCode,String treeName,String powerPath,Integer parentTreeId,String treeType){
            StringBuilder fullPath = new StringBuilder();
            Tree tree = new Tree();
            tree.setTreeCode(treeCode);
            tree.setTreeName(treeName);
            tree.setTreeType(treeType);
            tree.setPowerPath(powerPath);
            tree.setTreeState(TreeStaticConstant.TREE_STATE_NORMAL);
            tree.setParentTreeId(parentTreeId);
            tree.setCrtDate(new Date());
            if(parentTreeId.intValue()==0){
                tree.setParentTreeName("");
            }else{
                Tree parentTree = treeDao.selectByPrimaryKey(parentTreeId);
                if(parentTree==null){
                    return new ReturnInfo(SystemStaticConst.FAIL, "增加按钮失败，不存在当前父菜单");
                }
                tree.setParentTreeName(parentTree.getTreeName());
                fullPath.append(parentTree.getFullPath());
            }
            if(treeDao.insert(tree)>0){
                fullPath.append(".").append(tree.getTreeId());
                treeDao.updateFullPath(fullPath.toString(),tree.getTreeId());
                return new ReturnInfo(SystemStaticConst.SUCCESS, "增加按钮成功",tree);
            }else{
                return new ReturnInfo(SystemStaticConst.FAIL, "增加按钮失败");
            }
        }
    
        /**
         * 功能描述：验证菜单节点是否已经增加过
         * @param treeId 菜单流水ID
         * @param treeCode 菜单编码
         * @return 返回验证结果
         */
        public ReturnInfo checkTreeCode(Integer treeId,String treeCode){
            Map<String,Object> result = new HashMap<>(1);
            if(treeDao.checkTreeCode(treeCode,treeId)>0){
                result.put(TreeStaticConstant.CHECK_TREE_TIP,TreeStaticConstant.CHECK_TREE_UN_PASS);
                return new ReturnInfo(SystemStaticConst.SUCCESS, "该编码已经存在了，请修改以后再提交！",result);
            }else{
                result.put(TreeStaticConstant.CHECK_TREE_TIP,TreeStaticConstant.CHECK_TREE_PASS);
                return new ReturnInfo(SystemStaticConst.SUCCESS, "验证通过！",result);
            }
        }
    
        /**
         * 功能描述：更新按钮节点
         * @param treeId 按钮节点ID
         * @param treeName 按钮名字
         * @param treeCode 按钮编码
         * @param powerPath 权限集合
         * @return 返回更新操作结果
         */
        public ReturnInfo updateButton(Integer treeId,String treeName,String treeCode,String powerPath){
            if(treeDao.checkTreeCode(treeCode,treeId)>0){
                return new ReturnInfo(SystemStaticConst.FAIL, "该编码已经存在了，请修改以后再提交！");
            }
            if(treeDao.updateButton(treeCode, treeName, treeId,powerPath)>0){
                return new ReturnInfo(SystemStaticConst.SUCCESS, "更新按钮节点成功！");
            }else{
                return new ReturnInfo(SystemStaticConst.FAIL, "更新按钮节点失败！");
            }
        }
    
        /**
         * 功能描述：删除按钮节点
         * @param treeId 按钮的ID
         * @return 返回删除结果
         */
        public ReturnInfo deleteButton(Integer treeId){
            if(treeDao.deleteByPrimaryKey(treeId)>0){
                roleTreeDao.deleteRoleTreeByTreeId(treeId);
                return new ReturnInfo(SystemStaticConst.SUCCESS,"删除按钮节点成功");
            }else{
                return new ReturnInfo(SystemStaticConst.FAIL,"删除按钮节点失败");
            }
        }
    
        /**
         * 功能描述：获取菜单的按钮的列表
         *
         * @param search   模糊匹配菜单的treeName，treeCode 允许为空
         * @param pageSize 每页显示的记录的条数
         * @param parentTreeId 父节点id
         * @param current  当前访问第几页
         * @param orderKey     排序字段
         * @param orderByValue 排序方式，降序还是升序
         * @return 返回查询结果
         */
        public ReturnInfo queryTreeButtonList(String search,Integer parentTreeId, int pageSize, int current, String orderKey, String orderByValue){
            PageHelper.startPage(current, (pageSize > 0 && pageSize <= 500) ? pageSize : 20,(orderKey != null && !"".equals(orderKey)) ? ((orderByValue != null && !"".equals(orderByValue)) ? (orderKey + " " + orderByValue) : orderKey) : "");
            HashMap<String, Object> res = PageUtil.getResult(treeDao.queryTreeButtonList(search,parentTreeId));
            return new ReturnInfo(SystemStaticConst.SUCCESS, "获取按钮列表数据成功！", new Page(pageSize, current, (long) res.get("total"), (List) res.get("rows")));
        }
    
        /**
         * 功能描述：获取菜单树目录
         * @return 返回菜单目录数据
         */
        @PostMapping("getTreeList")
        public ReturnInfo getTreeList(){
            Tree tree = new Tree();
            tree.setTreeState(TreeStaticConstant.TREE_STATE_NORMAL);
            tree.setTreeType(TreeStaticConstant.TREE_TYPE_MENU);
            return new ReturnInfo(SystemStaticConst.SUCCESS, "加载菜单数据成功", TreeInstall.installTree(treeMapper.treesToTreeDTO(treeDao.select(tree))));
        }
    
    }

### TreeController的实现 ###

package com.github.bg.admin.core.controller;
    
    
    import com.github.bg.admin.core.constant.TreeStaticConstant;
    import com.github.bg.admin.core.entity.ReturnInfo;
    import com.github.bg.admin.core.service.TreeService;
    import io.swagger.annotations.ApiOperation;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.RestController;
    
    /**
     * @author linzf
     * @since 2019/05/07
     * 类描述：菜单管理的controller
     */
    @RestController
    @RequestMapping("/tree")
    public class TreeController {
    
        @Autowired
        private TreeService treeService;
    
        /**
         * 功能描述：根据菜单流水ID来更新菜单数据
         *
         * @param treeId   菜单流水ID
         * @param treeCode 菜单编码
         * @param treeName 菜单名称
         * @param powerPath 权限集合
         * @return 返回更新结果
         */
        @ApiOperation(value = "根据菜单流水ID来更新菜单数据")
        @PostMapping("updateTree")
        public ReturnInfo updateTree(@RequestParam(name = "treeId") Integer treeId,
                                     @RequestParam(name = "treeCode") String treeCode,
                                     @RequestParam(name = "treeName") String treeName,
                                     @RequestParam(name = "powerPath") String powerPath) {
            return treeService.updateTree(treeId, treeCode, treeName,powerPath);
        }
    
        /**
         * 功能描述：根据菜单ID来获取菜单数据
         *
         * @param treeId 菜单ID
         * @return 返回操作结果
         */
        @ApiOperation(value = "根据菜单ID来获取菜单数据")
        @PostMapping("getTreeByTreeId")
        public ReturnInfo getTreeByTreeId(@RequestParam(name = "treeId") Integer treeId) {
            return treeService.getTreeByTreeId(treeId);
        }
    
        /**
         * 功能描述：删除菜单节点
         *
         * @param treeId 菜单节点ID
         * @return 返回删除结果
         */
        @ApiOperation(value = "删除菜单")
        @PostMapping("deleteTree")
        public ReturnInfo deleteTree(@RequestParam(name = "treeId") Integer treeId) {
            return treeService.deleteTree(treeId);
        }
    
        /**
         * 功能描述：增加菜单
         *
         * @param treeCode     菜单编码
         * @param treeName     菜单名称
         * @param parentTreeId 父菜单节点ID
         * @param powerPath    权限集合
         * @return 返回增加结果
         */
        @ApiOperation(value = "增加菜单")
        @PostMapping("addTree")
        public ReturnInfo addTree(@RequestParam(name = "treeCode") String treeCode,
                                  @RequestParam(name = "treeName") String treeName,
                                  @RequestParam(name = "powerPath") String powerPath,
                                  @RequestParam(name = "parentTreeId") Integer parentTreeId) {
            return treeService.addButton(treeCode, treeName, powerPath, parentTreeId, TreeStaticConstant.TREE_TYPE_MENU);
        }
    
        /**
         * 功能描述：冻结/解冻按钮
         *
         * @param treeId    节点ID
         * @param treeState 节点状态
         * @return 返回操作结果
         */
        @ApiOperation(value = "冻结/解冻按钮")
        @PostMapping("operateButton")
        public ReturnInfo operateButton(@RequestParam(name = "treeId") Integer treeId, @RequestParam(name = "treeState") String treeState) {
            return treeService.operateButton(treeId, treeState);
        }
    
        /**
         * 功能描述：增加按钮
         *
         * @param treeCode     按钮编码
         * @param treeName     按钮名称
         * @param parentTreeId 父菜单节点ID
         * @return 返回增加结果
         */
        @ApiOperation(value = "增加按钮")
        @PostMapping("addButton")
        public ReturnInfo addButton(@RequestParam(name = "treeCode") String treeCode,
                                    @RequestParam(name = "treeName") String treeName,
                                    @RequestParam(name = "powerPath") String powerPath,
                                    @RequestParam(name = "parentTreeId") Integer parentTreeId) {
            return treeService.addButton(treeCode, treeName, powerPath, parentTreeId, TreeStaticConstant.TREE_TYPE_BUTTON);
        }
    
        /**
         * 功能描述：验证菜单节点是否已经增加过
         *
         * @param treeId   菜单流水ID
         * @param treeCode 菜单编码
         * @return 返回验证结果
         */
        @ApiOperation(value = "验证菜单节点是否已经增加过")
        @PostMapping("checkTreeCode")
        public ReturnInfo checkTreeCode(@RequestParam(name = "treeId", required = false) Integer treeId, @RequestParam(name = "treeCode") String treeCode) {
            return treeService.checkTreeCode(treeId, treeCode);
        }
    
        /**
         * 功能描述：更新按钮节点
         *
         * @param treeId   按钮节点ID
         * @param treeName 按钮名字
         * @param treeCode 按钮编码
         * @param powerPath 权限集合
         * @return
         */
        @ApiOperation(value = "更新按钮节点")
        @PostMapping("updateButton")
        public ReturnInfo updateButton(@RequestParam(name = "treeId") Integer treeId,
                                       @RequestParam(name = "treeName") String treeName,
                                       @RequestParam(name = "treeCode") String treeCode,
                                       @RequestParam(name = "powerPath") String powerPath) {
            return treeService.updateButton(treeId, treeName, treeCode,powerPath);
        }
    
        /**
         * 功能描述：删除按钮节点
         *
         * @param treeId 按钮的ID
         * @return 返回删除结果
         */
        @ApiOperation(value = "删除按钮节点")
        @PostMapping("deleteButton")
        public ReturnInfo deleteButton(Integer treeId) {
            return treeService.deleteButton(treeId);
        }
    
        /**
         * 功能描述：获取菜单的按钮的列表
         *
         * @param search       模糊匹配菜单的treeName，treeCode 允许为空
         * @param pageSize     每页显示的记录的条数
         * @param current      当前访问第几页
         * @param orderKey     排序字段
         * @param orderByValue 排序方式，降序还是升序
         * @return 返回查询结果
         */
        @ApiOperation(value = "获取菜单的按钮的列表")
        @PostMapping("queryTreeButtonList")
        public ReturnInfo queryTreeButtonList(@RequestParam(name = "search", required = false) String search, @RequestParam(name = "parentTreeId") int parentTreeId, @RequestParam(name = "pageSize") int pageSize, @RequestParam(name = "current") int current, @RequestParam(name = "orderKey", required = false) String orderKey, @RequestParam(name = "orderByValue", required = false) String orderByValue) {
            return treeService.queryTreeButtonList(search, parentTreeId, pageSize, current, orderKey, orderByValue);
        }
    
        /**
         * 功能描述：获取菜单树目录
         *
         * @return 返回菜单目录数据
         */
        @PostMapping("getTreeList")
        public ReturnInfo getTreeList() {
            return treeService.getTreeList();
        }
    
    }

### 前端本章缺失 ###

由于前端的部分在菜单管理章节有部分缺失因此，此处就不再累述了，已经把代码整合到本章中了，大家直接从本章的代码地址拷贝代码下来即可，拷贝的位置如下：  
![在这里插入图片描述][2019070814480299.png]

## 运行项目 ##

最后我们重新编译我们的项目，记得一定要重新编译，因为我们引入了mapper，不重新编译是会报错的，然后我们使用账号：admin密码：123456登录系统操作我们的菜单模块，可以正常的对整个菜单模块进行相应的操作，这样我们就完成了菜单的整合。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnpoZWZlbmc4OQ_size_16_color_FFFFFF_t_70]  
上一篇文章地址：[spring boot+iview 前后端分离架构之数据字典的实现（二十六）][spring boot_iview]  
下一篇文章地址：[spring boot+iview 前后端分离架构之角色管理的实现（二十八）][spring boot_iview 1]

[20191218155125364.jpg]: /images/20211213/e9c5b6a56ddc470a91e8a8bdd8f4adce.png
[2019070814480299.png]: /images/20211213/81275fcaa49e4ac59551b556cc790cfe.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnpoZWZlbmc4OQ_size_16_color_FFFFFF_t_70]: /images/20211213/308175a8c8fa47b9848cf92f984524fb.png
[spring boot_iview]: https://blog.csdn.net/linzhefeng89/article/details/95043046
[spring boot_iview 1]: https://blog.csdn.net/linzhefeng89/article/details/95108001