/**
* 实现思路:
* 1.先查询一级菜单信息 parent_id = 0
* 2.将一级菜单循环遍历 一级菜单对象.
* 3.根据一级菜单信息,查询当前菜单下的二级.
* 4.将查询得到的二级菜单,封装到一级对象中
* 实现思路二(扩展):
* 利用左连接 实现关联查询 封装数据.
* @return
*/
@Override
public List<Rights> getRightsList() {
//1.查询一级列表信息
QueryWrapper<Rights> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("parent_id",0);
List<Rights> oneList = rightsMapper.selectList(queryWrapper);
//2.遍历一级列表
for (Rights oneRights : oneList){
//根据一级查询二级
queryWrapper.clear(); //清除之前的条件
queryWrapper.eq("parent_id",oneRights.getId());
List<Rights> twoList = rightsMapper.selectList(queryWrapper);
//将查询的结果封装一级对象中
oneRights.setChildren(twoList);
}
return oneList;

 

 

3级分类菜单数据查询

/**
* 1.数据结构: Map<K,V> key=parentId value="List<ItemCat>"
* 2.封装Map的数据类型
* 3.如果level=1 只获取一级.
* 4.如果level=2 获取一级,一级嵌套二级
* 5.如果level=3 获取一级,一级嵌套二级,二级嵌套三级.
* @param level
* @return
*/
@Override
public List<ItemCat> findItemCatList(Integer level) {
long startTime = System.currentTimeMillis();
//1.封装Map集合
Map<Integer,List<ItemCat>> map = getMap();

//2.判断level的值
if(level == 1){
return map.get(0);
}

if(level == 2){

return getTwoList(map);
}

//如果level不是1-2级则一定是三级
List<ItemCat> list = getThreeList(map);
long endTime = System.currentTimeMillis();
System.out.println("耗时:"+(endTime - startTime)+"毫秒");
return list;
}

private List<ItemCat> getThreeList(Map<Integer, List<ItemCat>> map) {
//获取一级和二级
List<ItemCat> oneList = getTwoList(map);
//封装三级,遍历二级菜单,之后封装.
for(ItemCat oneItemCat : oneList){
//获取二级集合
List<ItemCat> twoList = oneItemCat.getChildren();
if(twoList == null || twoList.size() == 0){
System.out.println("执行跳过循环操作");
//由于业务数据不合理,跳过本次循环,执行下一次
continue;
}
for (ItemCat twoItemCat : twoList){
//查询三级列表,需要parentId=二级Id
int parentId = twoItemCat.getId();
List<ItemCat> threeList = map.get(parentId);
twoItemCat.setChildren(threeList);
}
}
return oneList;
}

private List<ItemCat> getTwoList(Map<Integer, List<ItemCat>> map) {
//1.先获取一级列表
List<ItemCat> oneList = map.get(0);
//2.根据一级查询二级
for(ItemCat oneItemCat :oneList){
//查询二级,所以parentId是一级的Id
int parentId = oneItemCat.getId();
List<ItemCat> twoList = map.get(parentId);
//封装数据
oneItemCat.setChildren(twoList);
}
return oneList;
}

/**
* 1.查询所有的商品分类列表. 查询一次数据库.
* 2.循环遍历所有的数据,按照parentId,List<ItemCat>方式封装数据.
* @return
*/
private Map<Integer, List<ItemCat>> getMap() {
Map<Integer,List<ItemCat>> map = new HashMap<>();
List<ItemCat> list = itemCatMapper.selectList(null);
for(ItemCat itemCat : list){
//获取parentId
int parentId = itemCat.getParentId();
if(map.containsKey(parentId)){
//key存在
map.get(parentId).add(itemCat);
}else{
//key不存在
List<ItemCat> childrenList = new ArrayList<>();
childrenList.add(itemCat);
//将第一个元素封装到map中
map.put(parentId,childrenList);
}
}
return map;
}

 

 

 

 

 

编辑ItemCatService
/**
* 1.查询所有的一级菜单
* 2.遍历一级查询所有的二级菜单
* 3.遍历二级查询所有的三级菜单
* 4. 2级封装3级菜单, 1级封装2级菜单
* @param level
* @return
*/

QueryWrapper<ItemCat> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("parent_id", 0);
List<ItemCat> oneList = itemCatMapper.selectList(queryWrapper);
//2.遍历一级菜单 根据一级查询二级菜单
for (ItemCat oneItemCat :oneList){
queryWrapper.clear();
queryWrapper.eq("parent_id", oneItemCat.getId());
List<ItemCat> twoList = itemCatMapper.selectList(queryWrapper);
//3.将二级列表进行遍历，根据二级ID查询三级
for (ItemCat twoItemCat :twoList){
queryWrapper.clear();
queryWrapper.eq("parent_id", twoItemCat.getId());
List<ItemCat> threeList = itemCatMapper.selectList(queryWrapper);
//数据封装
twoItemCat.setChildren(threeList);
}
//将二级数据封装到一级中
oneItemCat.setChildren(twoList);
}
long endTime = System.currentTimeMillis();
System.out.println("程序耗时:"+(endTime - startTime));
return oneList;