递归建立数据库的字段要建立pid
既pid是父id

这里的pid要能在id找到 找到就说明当前id的组织是父组织 如果找不到就说明的顶级id 图中的主菜单1就是顶级组织

  public Menu getMenuTree() {
        //先查询顶级目录
        LambdaQueryWrapper<Menu> menuLambdaQueryWrapper = new LambdaQueryWrapper<>();
        menuLambdaQueryWrapper.eq(Menu::getPid, "0");
        Menu menusBase = menuMapper.selectOne(menuLambdaQueryWrapper);
        //查询除了顶级组织以外的组织
        LambdaQueryWrapper<Menu> menuLambdaQueryWrapper2 = new LambdaQueryWrapper<>();
        menuLambdaQueryWrapper2.ne(Menu::getPid, "0");
        List<Menu> menuLNotBase = menuMapper.selectList(menuLambdaQueryWrapper2);
        List<Menu> menus = iterateMenus(menuLNotBase, menusBase.getId());
        menusBase.setMenuChildren(menus);
        return menusBase;
    }

反复调用iterateMenus方法 直到循环遍历结束

    /**
     * 多级组织查询方法
     *
     * @param menuVoList 不包含最高层次组织的组织集合
     * @param pid        父类id
     * @return
     */
    public List<Menu> iterateMenus(List<Menu> menuVoList, String pid) {
        List<Menu> result = new ArrayList<>();
        int a =0;
        for (Menu menu : menuVoList) {
            //获取菜单的id
            String menuid = menu.getId();
            //获取菜单的父id
            String parentid = menu.getPid();

                if (parentid.equals(pid)) {
                    //递归查询当前子菜单的子菜单
                    List<Menu> iterateMenu = iterateMenus(menuVoList, menuid);
                    menu.setMenuChildren(iterateMenu);
                    result.add(menu);
                }
        }
        return result;
    }

Entity有些字段不需要 我加是因为自己的业务

@Data
@NoArgsConstructor
@TableName("Menu")
public class Menu {

    private String  id;
    private String name;
    private String pid;
    @TableField(exist = false)
    private List<Menu> menuChildren;
    @TableField(exist = false)
    private Boolean nextRank;
}

类目表是多级目录表，数据如下：

想获取所有数据的多级目录，代码如下：

  /**
     * 获取树形接口的 类目
     *
     * @return
     */
    @Override
    public List<ExamCategory> selectExamCategoryTreeList() {
        //1、 获取所有的一级目录
        ExamCategory examCategory = new ExamCategory();
        examCategory.setParentId( 0 );
        List<ExamCategory> examCategoryList = examCategoryDao.selectExamCategoryList( examCategory );
        
        List<ExamCategory> parentList = new ArrayList<>();
        for (ExamCategory category : examCategoryList) {
            if (category.getParentId().intValue() == 0) {
                parentList.add( category );
            }
        }

        //获取一级目录下的多级目录
        if (parentList != null) {
            for (ExamCategory category : parentList) {
                fillMenuNode( category );
            }
        }

        return parentList;
    }


    //递归实现查询多级类目
    public ExamCategory fillMenuNode(ExamCategory examCategory) {
        ExamCategory examCategorySearch = new ExamCategory();
        examCategorySearch.setParentId( examCategory.getCategoryId() );
        List<ExamCategory> examCategoryList = examCategoryDao.selectExamCategoryList( examCategorySearch );
        if (CollectionUtils.isEmpty( examCategoryList )) {
            return examCategory;
        }
        List<ExamCategory> subMenuList = examCategoryList.stream().map( subMenu -> fillMenuNode( subMenu ) ).collect( Collectors.toList() );//递归实现查询多级菜单
        examCategory.setChildrenList( subMenuList );
        return examCategory;
    }

最近项目中遇到了一个普通需求，在根据目录节点id查询的时候，要求连带把该目录下的子节点一起查出。以前也做过这种递归的，但是太久没做，一上来，竟然差点给自己搞懵了。所以决定记录下来，供自己以后查阅，也希望可以帮到有需要的朋友。直接上代码。

 /**
     * 根据父节点 id查询所有子节点id集合（包括自身id）
     *
     * @param parentId 父节点id
     * @param clientId 客户端id
     * @return List<Long> 子节点id集合（包括自身id）
     */
    @Override
    public List<Long> getByParentId(Long parentId, Long clientId) {
        //查询出所有目录
        List<CatalogueInfo> catalogueInfos = lambdaQuery().eq(CatalogueInfo::getClientId, clientId).
                eq(CatalogueInfo::getUseFlag, "1").select(CatalogueInfo::getId, CatalogueInfo::getParentId).list();
        //根据目录的parentId, id把所有包含子目录的目录分组为map
        ImmutableListMultimap<Long, Long> catalogueInfoMap = catalogueInfos.stream().collect(ImmutableListMultimap.toImmutableListMultimap
                (CatalogueInfo::getParentId, CatalogueInfo::getId));
        //查询parentId下的所有子目录id
        List<Long> childIds = catalogueInfoMap.get(parentId);
        //最终返回的所有符合条件的目录id
        ArrayList<Long> resultIds = new ArrayList<>(childIds);
        //将父id添加
        resultIds.add(parentId);
        //递归查询子节点的子节点
        reduce(childIds, catalogueInfoMap, resultIds);
        return resultIds;
    }

clientId：这个只是我查询所有目录业务中需要用到的参数，具体根据实际需求查出所有即可。

ImmutableListMultimap<Long, Long> catalogueInfoMap = catalogueInfos.stream().collect(ImmutableListMultimap.toImmutableListMultimap
                (CatalogueInfo::getParentId, CatalogueInfo::getId));

这块代码主要是将所有目录分组，注意，只有当该目录下有子目录时候，会将该目录id作为key，子目录id作为value,这里的value是一个list集合。后面递归的时候，其实就是通过这个分组后的map，递归拿到子目录节点id,就是下方的List<Long> ids = catalogueInfoMap.get(id);

递归方法

    /**
     * 递归查询所有子节点
     *
     * @param childIds         待遍历id集合
     * @param catalogueInfoMap 分组map
     * @param resultIds        满足条件的id集合
     */
    private void reduce(List<Long> childIds, ImmutableListMultimap<Long, Long> catalogueInfoMap, ArrayList<Long> resultIds) {
        //递归查询子节点的子节点，将所有的子节点添加到resultIds
        for (Long id : childIds) {
            List<Long> ids = catalogueInfoMap.get(id);
            if (ids.isEmpty()) {
                continue;
            }
            resultIds.addAll(ids);
            reduce(ids, catalogueInfoMap, resultIds);
        }
    }