基于springboot+redis+bootstrap+mysql开发一套属于自己的分布式springcloud云权限架构（十二）【权限架构生产者（菜单管理）】

红太狼 2022-05-31 11:09 109阅读 0赞

在第十一章我们完成了对组织架构管理的集成，本章我们将完成对菜单管理的集成开发工作，首先打开我们的rbac-produce工程，接着在com/produce/sys/dao目录底下创建一个UserDao.java接口内容如下：

package com.produce.sys.dao;
    
    
    
    import com.base.entity.QueryTree;
    import com.base.entity.Tree;
    import com.base.entity.User;
    import com.produce.common.base.dao.GenericDao;
    
    import java.util.List;
    
    /**
     *@author linzf
     **/
    public interface TreeDao extends GenericDao<Tree, QueryTree> {
    
        /**
         * 功能描述：加载用户的菜单树的数据
         * @param user
         * @return
         */
    	List<Tree> loadUserTree(User user);
    }

接着在我们的mapper文件夹底下创建一个mybatis\_tree.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.produce.sys.dao.TreeDao">
    	<resultMap type="com.base.entity.Tree" id="TreeMap">
    		<id property="id" column="id"/>
    		<result property="code" column="code"/>
    		<result property="icon" column="icon"/>
    		<result property="name" column="name"/>
    		<result property="pId" column="p_id"/>
    		<result property="treeOrder" column="tree_order"/>
    		<result property="url" column="url"/>
    		<result property="state" column="state"/>
    	</resultMap>
    
    	
    	<select id="loadUserTree" resultMap="TreeMap" parameterType="com.base.entity.User">
    		select DISTINCT t.*  from tree t inner join role_associate_tree rat on t.id = rat.tree_id inner join user_role ur on rat.role_id = ur.id where ur.id in
    		<foreach collection="roles" index="index" item="role" open="(" separator="," close=")">
    			#{role.id}
    		</foreach>
    	</select>
    
    	
    	<select id="get" parameterType="com.base.entity.Tree" resultMap="TreeMap">
    		SELECT id,code,icon,name,p_id,tree_order,url,state FROM tree 
    		WHERE id=#{id}
    	</select>
    
    	
    	<insert id="save" parameterType="com.base.entity.Tree" useGeneratedKeys="true" keyProperty="id">
    		INSERT INTO tree(code,icon,name,p_id,tree_order,url,state)
    		VALUES(#{code},#{icon},#{name},#{pId},#{treeOrder},#{url},#{state})
    	</insert>
    
    	
    	<update id="update" parameterType="com.base.entity.Tree">
    		UPDATE tree SET code=#{code},icon=#{icon},name=#{name},p_id=#{pId},tree_order=#{treeOrder},url=#{url},state=#{state}
    		WHERE id=#{id}
    	</update>
    
    	
    	<delete id="delete" parameterType="com.base.entity.Tree">
    		 DELETE FROM tree WHERE id=#{id}
    	</delete>
    
    	
    	<select id="findByPage" parameterType="com.base.entity.QueryTree" resultMap="TreeMap">
    		SELECT id,code,icon,name,p_id,tree_order,url,state FROM tree
    		WHERE 1=1
    		<if test="code!=null and code!='' ">
    		AND code=#{code}
    		</if>
    		<if test="icon!=null and icon!='' ">
    		AND icon=#{icon}
    		</if>
    		<if test="name!=null and name!='' ">
    		AND name=#{name}
    		</if>
    		<if test="pId!=null and pId!='' ">
    		AND p_id=#{pId}
    		</if>
    		<if test="treeOrder!=null and treeOrder!='' ">
    		AND tree_order=#{treeOrder}
    		</if>
    		<if test="url!=null and url!='' ">
    		AND url=#{url}
    		</if>
    		<if test="state!=null and state!='' ">
    		AND state=#{state}
    		</if>
    		<if test="sort!= null and sort!='' ">
    		order by ${sort} ${order}
    		</if>
    		limit #{offset},#{limit}
    	</select>
    
    	
    	<select id="count" parameterType="com.base.entity.QueryTree" resultType="int">
    		SELECT count(*) FROM tree
    		WHERE 1=1
    		<if test="code!=null and code!='' ">
    			AND code=#{code}
    		</if>
    		<if test="icon!=null and icon!='' ">
    			AND icon=#{icon}
    		</if>
    		<if test="name!=null and name!='' ">
    			AND name=#{name}
    		</if>
    		<if test="pId!=null and pId!='' ">
    			AND p_id=#{pId}
    		</if>
    		<if test="treeOrder!=null and treeOrder!='' ">
    			AND tree_order=#{treeOrder}
    		</if>
    		<if test="url!=null and url!='' ">
    			AND url=#{url}
    		</if>
    		<if test="state!=null and state!='' ">
    			AND state=#{state}
    		</if>
    		<if test="sort!= null and sort!='' ">
    			order by ${sort} ${order}
    		</if>
    	</select>
    
    	
    	<select id="query" parameterType="com.base.entity.QueryTree" resultMap="TreeMap">
    		SELECT id,code,icon,name,p_id,tree_order,url,state FROM tree
    		WHERE 1=1
    		<if test="code!=null and code!='' ">
    			AND code=#{code}
    		</if>
    		<if test="icon!=null and icon!='' ">
    			AND icon=#{icon}
    		</if>
    		<if test="name!=null and name!='' ">
    			AND name=#{name}
    		</if>
    		<if test="pId!=null and pId!='' ">
    			AND p_id=#{pId}
    		</if>
    		<if test="treeOrder!=null and treeOrder!='' ">
    			AND tree_order=#{treeOrder}
    		</if>
    		<if test="url!=null and url!='' ">
    			AND url=#{url}
    		</if>
    		<if test="state!=null and state!='' ">
    			AND state=#{state}
    		</if>
    		<if test="sort!= null and sort!='' ">
    			order by ${sort} ${order}
    		</if>
    	</select>
    </mapper>

由于我们对菜单进行维护的时候，我们在对角色管理的时候会对相应的角色赋予相应的菜单，因此在我们删除某些菜单的时候，我们需要同时删除菜单与角色相关联的数据，因此我们需要在com/produce/sys/dao目录底下创建一个RoleAssociateTreeDao.java接口内容如下：

package com.produce.sys.dao;
    
    
    import com.base.entity.QueryRoleAssociateTree;
    import com.base.entity.RoleAssociateTree;
    import com.base.entity.Tree;
    import com.base.entity.UserRole;
    import com.produce.common.base.dao.GenericDao;
    
    /**
     *@author linzf
     **/
    public interface RoleAssociateTreeDao extends GenericDao<RoleAssociateTree, QueryRoleAssociateTree> {
    
        /**
         * 功能描述：根据菜单ID来删除关联的菜单数据
         * @param tree
         * @return
         */
        int removeTreeByTreeId(Tree tree);
    
        /**
         * 功能描述：根据角色ID来删除关联的菜单数据
         * @param userRole
         * @return
         */
        int removeTreeByRoleId(UserRole userRole);
    	
    }

接着在我们的mapper文件夹底下创建一个mybatis\_roleAssociateTree.xml文件，文件内容如下：

在我们的用户加载菜单的时候，我们需要根据用户的信息来实现加载菜单，因此我们需要在我们的rbac-produce工程中引入redis的依赖以及注入redis和redis的配置，因此我们需要分别修改以下的文件：

1、在主入口类引入如下的配置：

![20180222210124288][]

2、在com/produce/common/util底下创建一个node包，同时在该包底下创建NodeUtil.java类内容如下：

package com.produce.common.util.node;
    
    
    
    
    
    
    
    import com.base.entity.Tree;
    
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Iterator;
    import java.util.List;
    
    /*
    * 类描述：
    * @auther linzf
    * @create 2017/9/20 0020 
    */
    public class NodeUtil {
    
        private static List<Tree> returnList = new ArrayList<Tree>();
    
        /**
         * 根据父节点的ID获取所有子节点
         * @param list 分类表
         * @param typeId 传入的父节点ID
         * @return String
         */
        public static List<Tree> getChildNodes(List<Tree> list, Long typeId) {
            returnList = new ArrayList<Tree>();
            if(list == null && typeId == null) return new ArrayList<Tree>();
            for (Iterator<Tree> iterator = list.iterator(); iterator.hasNext();) {
                Tree node = (Tree) iterator.next();
                // 一、根据传入的某个父节点ID,遍历该父节点的所有子节点
                if (node.getpId()==0 && typeId==node.getId()) {
                    recursionFn(list, node);
                }
                // 二、遍历所有的父节点下的所有子节点
                if (node.getpId()==0) {
                    recursionFn(list, node);
                }
            }
            // 对顶层菜单按照treeOrder从大到小进行进行排序
            Collections.sort(returnList);
            return returnList;
        }
    
        private static void recursionFn(List<Tree> list, Tree node) {
            List<Tree> childList = getChildList(list, node);// 得到子节点列表
            if (hasChild(list, node)) {// 判断是否有子节点
                Iterator<Tree> it = childList.iterator();
                while (it.hasNext()) {
                    Tree n = (Tree) it.next();
                    if(hasChild(list,n)){// 判断子节点是否还有相应的子节点，若有则再次递归遍历
                        recursionFn(list, n);
                    }
                }
                node.setChild(childList);
                returnList.add(node);
            }
        }
    
        // 得到子节点列表
        private static List<Tree> getChildList(List<Tree> list, Tree node) {
            List<Tree> nodeList = new ArrayList<Tree>();
            Iterator<Tree> it = list.iterator();
            while (it.hasNext()) {
                Tree n = (Tree) it.next();
                if (n.getpId() == node.getId()) {
                    nodeList.add(n);
                }
            }
            Collections.sort(nodeList);
            return nodeList;
        }
    
        // 判断是否有子节点
        private static boolean hasChild(List<Tree> list, Tree node) {
            return getChildList(list, node).size() > 0 ? true : false;
        }
    
    }

3、在com/produce/common/util/user包的UserInfo.java类中增加以下的方法：

/**
         * 功能描述：加载菜单节点的数据
         * @return
         */
        public static List<Tree> loadUserTree(TreeService treeService, User user){
            Map<Long,Tree> treeMap = new HashMap<Long,Tree>();
            for(Tree tree:treeService.loadUserTree(user)){
                treeMap.put(tree.getId(),tree);
            }
            List<Tree> treeList = NodeUtil.getChildNodes(new ArrayList<Tree>(treeMap.values()),0l);
            return treeList;
        }

最后在我们的com/produce/sys/controller底下创建我们的TreeController.java实现类内容如下：

package com.produce.sys.controller;
    
    
    import com.base.entity.QueryTree;
    import com.base.entity.Tree;
    import com.base.entity.User;
    import com.base.util.redis.RedisCache;
    import com.produce.common.base.constant.SystemStaticConst;
    import com.produce.common.base.controller.GenericController;
    import com.produce.common.base.service.GenericService;
    import com.produce.common.util.user.UserInfo;
    import com.produce.sys.service.TreeService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.http.MediaType;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestMethod;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    /*
    * 类描述：菜单操作controller
    * @auther linzf
    * @create 2017/10/10 0010 
    */
    @RestController
    @RequestMapping("/tree")
    public class TreeController extends GenericController<Tree,QueryTree> {
    
        @Autowired
        private TreeService treeService;
    
        @Autowired
        private RedisCache redisCache;
    
        @Override
        protected GenericService<Tree, QueryTree> getService() {
            return treeService;
        }
    
        /**
         * 功能描述：加载首页菜单节点的数据
         * @return
         */
        @RequestMapping(value="/mainTree",method = RequestMethod.POST,produces = MediaType.APPLICATION_JSON_VALUE)
        public Map<String,Object> mainTree(String token){
            Map<String,Object> result = new HashMap<String, Object>();
            List<Tree> trees = UserInfo.loadUserTree(treeService,(User)redisCache.getObject(token,User.class));
            result.put("data",trees);
            result.put(SystemStaticConst.RESULT, SystemStaticConst.SUCCESS);
            return result;
        }
    
    
        /**
         * 功能描述：直接加载整个菜单树的数据(且必须要有管理员权限才可以加载该菜单树的数据)
         * @return
         */
        @RequestMapping(value = "/loadUserTree",method = RequestMethod.POST,produces = MediaType.APPLICATION_JSON_VALUE)
        public Map<String,Object> loadUserTree(){
            Map<String,Object> result = new HashMap<String, Object>();
            List<Tree> treeList = treeService.query(null);
            result.put(SystemStaticConst.RESULT, SystemStaticConst.SUCCESS);
            result.put(SystemStaticConst.MSG,"加载菜单数据成功！");
            result.put("data",treeList);
            return result;
        }
    
    
    }

到此处我们完成了对菜单管理的集成，接着启动我们的注册中心，链路中心同时启动我们的rbac-produce，接着直接访问我们的swagger工程地址：http://127.0.0.1:8100/swagger-ui.html\#/，那么我们会看到如下的页面则表示我们的菜单管理已经集成成功了。

![20180222211205101][]

到此为止的GitHub项目地址：[https://github.com/185594-5-27/spring-cloud-rbac/tree/master-base-produce-tree][https_github.com_185594-5-27_spring-cloud-rbac_tree_master-base-produce-tree]

上一篇文章地址：[基于springboot+redis+bootstrap+mysql开发一套属于自己的分布式springcloud云权限架构（十一）【权限架构生产者（组织架构）】][springboot_redis_bootstrap_mysql_springcloud]

下一篇文章地址：[基于springboot+redis+bootstrap+mysql开发一套属于自己的分布式springcloud云权限架构（十三）【权限架构生产者（改造角色管理）】][springboot_redis_bootstrap_mysql_springcloud 1]

QQ交流群：578746866

[20180222210124288]: /images/20220531/fdf6d21fb2374ac68ee59a613344b176.png
[20180222211205101]: /images/20220531/c4f5ba3d11bc479986e891acabe59476.png
[https_github.com_185594-5-27_spring-cloud-rbac_tree_master-base-produce-tree]: https://github.com/185594-5-27/spring-cloud-rbac/tree/master-base-produce-tree
[springboot_redis_bootstrap_mysql_springcloud]: http://blog.csdn.net/linzhefeng89/article/details/79349309
[springboot_redis_bootstrap_mysql_springcloud 1]: http://blog.csdn.net/linzhefeng89/article/details/79349663

基于springboot+redis+bootstrap+mysql开发一套属于自己的分布式springcloud云权限架构（十二）【权限架构生产者（菜单管理）】

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关基于springboot+redis+bootstrap+mysql开发一套属于自己的分布式springcloud云权限架构（十八）【权限架构系统（完结）】

相关基于springboot+redis+bootstrap+mysql开发一套属于自己的分布式springcloud云权限架构（十三）【权限架构生产者（改造角色管理）】

相关基于springboot+redis+bootstrap+mysql开发一套属于自己的分布式springcloud云权限架构（十二）【权限架构生产者（菜单管理）】

相关基于springboot+redis+bootstrap+mysql开发一套属于自己的分布式springcloud云权限架构（十一）【权限架构生产者（组织架构）】

相关基于springboot+redis+bootstrap+mysql开发一套属于自己的分布式springcloud云权限架构（十）【权限架构生产者（用户管理）】

相关基于springboot+redis+bootstrap+mysql开发一套属于自己的分布式springcloud云权限架构（九）【权限架构生产者（角色管理）】

相关基于springboot+redis+bootstrap+mysql开发一套属于自己的分布式springcloud云权限架构（八）【权限架构生产者（swagger2集成）】

相关基于springboot+redis+bootstrap+mysql开发一套属于自己的分布式springcloud云权限架构（七）【权限架构生产者（数据字典）】

相关基于springboot+redis+bootstrap+mysql开发一套属于自己的分布式springcloud云权限架构（六）【权限架构生产者（通用类编写）】

相关基于springboot+redis+bootstrap+mysql开发一套属于自己的分布式springcloud云权限架构（一）【云架构前言】