菜单嵌套查询最全实现方式(持续更新)

     1.steam递归数据组装
     2.补充:双重for循环实现菜单信息组装
     3.补充:stream中遍历并分组方式实现
     4.补充:stream中groupingBy分组方式实现

1.steam递归数据组装

    上篇讲到嵌套的数据类型的查询方式: 三级菜单嵌套查询实现(collection标签),下面提供一种java Stream流的实现方式.主要的实现思路是将所有的菜单从数据库一次性查询出来,数据组装的方式在逻辑层进行处理,具体实现:先将顶级菜单筛选出来,然后进行递归遍历筛选出该菜单的所有子菜单信息,从性能的角度出发,整个实现过程使用stream流方式,当然从实现来讲,传统的for循环也是可以实现递归遍历组装数据,本文不做展开.数据查询上还需要collection标签,是因为菜单对象ManageUserMenu中子对象MenuMeta需要借助标签进行数据组装.
    实体类同上篇文件,这里不再展示,参考文章: 三级菜单嵌套查询实现(collection标签)
    数据库连接层:

   // 查询所有菜单
    List<ManageUserMenu> findAllManageMenu();

    配置文件:

    <resultMap id="UserMenuMap" type="com.kawaxiaoyu.manage.management.api.user.vo.ManageUserMenu">
        <id property="menuId" column="menu_id"></id>
        <result property="path" column="path"></result>
        <result property="hidden" column="hidden"></result>
        <result property="parentId" column="parent_id"></result>
        <result property="url" column="url"></result>
        <result property="perms" column="perms"></result>
        <result property="name" column="name"></result>
        <result property="component" column="component"></result>
        <result property="meta.title" column="title"></result>
        <result property="meta.icon" column="icon"></result>
    </resultMap>
    <select id="findAllManageMenu" resultMap="UserMenuMap" >
        select * from manage_menu
    </select>

    逻辑处理层:

	public void test3(){
		// 查询所有的菜单信息
		List<ManageUserMenu> allManageMenu = manageUserMapper.findAllManageMenu();
		// 按照格式进行组装
        List<ManageUserMenu> manageUserMenuList = 
        allManageMenu.stream().filter(manageUserMenu -> manageUserMenu.getParentId() == 0).map(manageUserMenu -> {               manageUserMenu.setChildren(getChildrenMenuList(manageUserMenu,allManageMenu);
                    return manageUserMenu;
                }).collect(Collectors.toList());
        System.out.println(manageUserMenuList);

    }

    // 查询指定菜单下面的所有子菜单信息
	public List<ManageUserMenu> getChildrenMenuList(ManageUserMenu origin,List<ManageUserMenu> allManageMenu){
        List<ManageUserMenu> childrenMenuList = allManageMenu.stream()
				.filter(manageUserMenu -> {
					return manageUserMenu.getParentId()==origin.getMenuId();
				})
				.map(
                manageUserMenu1 -> {
                    if (manageUserMenu1.getParentId() == origin.getMenuId()) {
                        manageUserMenu1.setChildren(getChildrenMenuList(manageUserMenu1, allManageMenu));
                    }
                    return manageUserMenu1;
                }
        ).collect(Collectors.toList());
        return childrenMenuList;
    }

补充三种逻辑层处理嵌套的实现方案
菜单实体类:

public class Menu {
    private int id;
    private int parentId;
    private String menuName;
    private List<Menu> menuList;

    public Menu(int id, int parentId, String menuName) {
        this.id = id;
        this.parentId = parentId;
        this.menuName = menuName;
	
	// 省略get/set方法
}

组装初始数据以及测试方法

public static void main(String[] args) {
	// 模拟数据库中查询所有的数据信息
    List<Menu> menuList = Arrays.asList(
            new Menu(1, 0, "电器"),
            new Menu(2, 0, "服饰"),
            new Menu(3, 1, "家用电器"),
            new Menu(4, 1, "工业电器"),
            new Menu(5, 3, "电风扇"),
            new Menu(6, 2, "成年衣服"),
            new Menu(7, 2, "童装"),
            new Menu(8, 6, "夹克衫"),
            new Menu(9, 7, "小帽子")
    );
    // 分组处理
    //method1(menuList);
    // 双重遍历进行组装
    //method2(menuList);
    // 双重循环
    method3(menuList);

2.双重for循环实现菜单信息组装

private static void method3(List<Menu> menuList) {
    ArrayList<Menu> finalMenuList = new ArrayList<>();
    for (Menu menu : menuList) {
        if(menu.getParentId() == 0){
            finalMenuList.add(menu);
        }

        for (Menu menu1 : menuList) {
            if(menu1.getParentId() == menu.getId()){
                List<Menu> subMenuList = menu.getMenuList();
                if(subMenuList == null){
                    subMenuList=new ArrayList<Menu>();
                }
                subMenuList.add(menu1);
                menu.setMenuList(subMenuList);
            }
        }
    }
    System.out.println(finalMenuList);
}
}

3.stream中遍历并分组方式实现

    遍历方式实现按照父类id进行分组,然后设置子菜单信息,过滤父类id为0的菜单信息

private static void method2(List<Menu> menuList) {
    HashMap<Integer, List<Menu>> menuListHashMap = new HashMap<>();
    menuList.stream().forEach(
            menu -> {
            // map.getOrDefault(1,1),获取key为1的value值,如果为空则返回1
                List<Menu> newMenuList = menuListHashMap.getOrDefault(menu.getParentId(), new ArrayList<>());
                newMenuList.add(menu);
                menuListHashMap.put(menu.getParentId(),newMenuList);
            }
    );
    menuList.forEach(menu -> {
        menu.setMenuList(menuListHashMap.get(menu.getId()));
    });
    List<Menu> finalMenuList = menuList.stream().filter(menu -> menu.getParentId() == 0).collect(Collectors.toList());
}

4.stream中groupingBy分组方式实现

    按照父类id进行分组,遍历设置每个菜单的子菜单集合,筛选父类id为0的菜单集合信息.

private static void method1(List<Menu> menuList) {
    // 按照菜单父类id进行分组
    Map<Integer, List<Menu>> menuListMap = menuList.stream().
            collect(Collectors.groupingBy(Menu::getParentId));
    // 设置每个菜单的子菜单信息
    menuList.stream().forEach(
            menu -> {
                menu.setMenuList(menuListMap.get(menu.getId()));
            }
    );
    // 只筛选出父类id为0的菜单信息
    List<Menu> finalMenuList = menuList.stream().filter(menu -> {
        return menu.getParentId() == 0;
    }).collect(Collectors.toList());
    System.out.println(finalMenuList);
}