多级菜单(树形结构)-查询和删除(递归)

目录

1、效果图：

2、仅有一级菜单和二级菜单（利用嵌套的方法）（代码冗余）

3、多级菜单

3、1（利用嵌套，在2的基础上，多层嵌套）

3、2（利用递归）

4、多级菜单递归删除

---

1、效果图：

2、仅有一级菜单和二级菜单（利用嵌套的方法）（代码冗余）

@Override
    public List<ChapterVo> getChapterVideoByCourseId(String courseId) {
        //1、 根据--课程id--查询  ---EduChapter--- 课程里面所以的章节
        QueryWrapper<EduChapter> wrapper = new QueryWrapper<>();
        wrapper.eq("course_id",courseId);
        List<EduChapter> eduChapters = baseMapper.selectList(wrapper);

        //2、 根据--课程id--查询  ---eduVideo----  课程里面的所有的小结
        QueryWrapper<EduVideo> wrapper1 = new QueryWrapper<>();
        wrapper.eq("course_id",courseId);
        List<EduVideo> list = eduVideoService.list(wrapper1);

        //最终返回结果
        List<ChapterVo> finalList = new ArrayList<>();

        for (EduChapter eduChapter : eduChapters) {
            ChapterVo chapterVo = new ChapterVo();
            BeanUtils.copyProperties(eduChapter,chapterVo);
            finalList.add(chapterVo);
            List<VideoVo> list1 = new ArrayList<>();
            for (EduVideo eduVideo : list) {
                if (eduChapter.getCourseId().equals(eduVideo.getCourseId())){
                    VideoVo videoVo = new VideoVo();
                    BeanUtils.copyProperties(eduVideo,videoVo);
                    list1.add(videoVo);
                }
            }
            chapterVo.setChildren(list1);
        }
        return finalList;
    }

3、多级菜单

3、1 利用嵌套，（在2的基础上，多层嵌套）

【优点：代码多，缺点：易理解】

 @Override
    public Map<String, List<CateLog2Vo>> getCataJson() {
        // 1、查出所有的一级分类，用来封装Map<String, Object>中的key
        List<CategoryEntity> oneEntities = baseMapper.selectList(new QueryWrapper<CategoryEntity>().eq("parent_cid", 0));
        // 2、 封装需要返回的类型
        Map<String, List<CateLog2Vo>> map = oneEntities.stream().collect(Collectors.toMap(
                k -> k.getCatId().toString(),
                v -> {
                    // 二级分类
                    List<CategoryEntity> entities = baseMapper.selectList(new QueryWrapper<CategoryEntity>().eq("parent_cid", v.getCatId()));
                    // 封装二级分类的结果
                    List<CateLog2Vo> collect2Vos = null;
                    if (entities != null) {
                        collect2Vos = entities.stream().map(two -> {
                            // 三级分类的  类
                            List<CategoryEntity> twoList = baseMapper.selectList(new QueryWrapper<CategoryEntity>().eq("parent_cid", two.getCatId()));
                            // 封装三级分类的结果
                            List<CateLog2Vo.Catalog3ListVo> collectLog3=null;
                            if (twoList !=null){
                                collectLog3 = twoList.stream().map(three -> {
                                    CateLog2Vo.Catalog3ListVo catalog3ListVo = new CateLog2Vo.Catalog3ListVo(two.getCatId().toString(),three.getCatId().toString(),three.getName());
                                    return catalog3ListVo;
                                }).collect(Collectors.toList());
                            }
                            // 封装二级分类的  基本属性
                            CateLog2Vo cateLog2Vo = new CateLog2Vo(v.getCatId().toString(), collectLog3, two.getCatId().toString(), two.getName());
                            return cateLog2Vo;
                        }).collect(Collectors.toList());
                    }
                    return collect2Vos;
                }));
        return map;
    }

3、2（利用递归）

【优点：代码少，缺点：不易理解】

/**
     * 递归查询菜单
     * @return
     */
    @Override
    public List<Permission> queryAllMenuGuli2() {
        // 1、 查询菜单所以数据
        QueryWrapper<Permission> wrapper = new QueryWrapper<>();
        wrapper.orderByDesc("id");
        List<Permission> permissions = baseMapper.selectList(wrapper);
        // 2、把查询所有菜单list集合按照要求进行封装
        return bulidPermission2(permissions);
    }

    /**
     * 查询一级菜单
     * @param permissionList
     * @return
     */
    private List<Permission> bulidPermission2(List<Permission> permissionList) {
        // 用户数据的最终封装
        List<Permission> finalNode = new ArrayList<>();
        for (Permission permissionNode : permissionList) {
            // pid = 0 代表就是顶层菜单
            if ("0".equals(permissionNode.getPid())){
                // 设置顶层菜单的level为1
                permissionNode.setLevel(1);
                // 根据顶层菜单，向里面进行查询子菜单，封装到finalNode里面中
                finalNode.add(selectChildren2(permissionNode,permissionList));
            }
        }
        return finalNode;
    }

    private Permission selectChildren2(Permission permissionNode, List<Permission> permissionList) {
        //1、因为向一层菜单里面方二层菜单，二层里面还有放三层...
        permissionNode.setChildren(new ArrayList<>());
        for (Permission it : permissionList) {
            if (permissionNode.getId().equals(it.getPid())){ // 相等的话就为为二级
                // 把父菜单的level值+1
                int level = permissionNode.getLevel()+1;
                it.setLevel(level);
                // 把查询出来的子菜单，放到父菜单里面中
                List<Permission> children = permissionNode.getChildren();
                if (permissionNode.getChildren() == null){
                    permissionNode.setChildren(new ArrayList<>());
                }
                children.add(selectChildren2(it,permissionList));
            }
        }
        return permissionNode;
    }

4、多级菜单递归删除

/**
     * 递归删除菜单
     */
    @Override
    public void removeChildByIdGuli2(String id) {
        List<String> idList = new ArrayList<>(); // 创建一个集合，用于存储需要删除的id
        this.selectChildList2ById(id,idList);
        idList.add(id); // 把本身id的一行数据也删除掉
        baseMapper.deleteBatchIds(idList);
    }
    // 查询传入的id，的下面的子孩子的集合
    private void selectChildList2ById(String id,List<String> idList) {
        QueryWrapper<Permission> wrapper = new QueryWrapper<>();
        wrapper.eq("pid",id);
        wrapper.select("id");
        List<Permission> childIdList = baseMapper.selectList(wrapper);
        
        childIdList.stream().forEach(item->{
            idList.add(item.getId()); // 把需要删除的id添加到集合中
            this.selectChildList2ById(item.getId(),idList);
        });

    }

        不易理解，多读，多理解，其实不难