小型数据，比如标签，部门之类的，可以组织数据，成层状结构，一并返回前端，节省请求次数；
但是大型数据，比如省市区等等联动，如果一并返回组织好的数据，查询量大，页面多次刷新，恶意请求，放入缓存还可以，其实还可以将这种数据直接放到前台，与后台无光关

对一张有树形结构的表查询：

1.获取该表下的所有数据

2.将数据转换成Dto集合，对集合进行遍历，将每一层级的数据分组，可以根据parentId，也可以根据表中的层级字段level等，产生Map<String,List<Dto>>类型，可以根据给定一个level，返回该level下的节点（单纯的一层节点）

3.收集所有根节点，List<Dto>

4.将List<Dto>，Map<String,List<dto>>，level作为三个参数，设置递归算法

void recursive(List<dto> list，Map<String,List<Dto>> map，Stirng level){

　　for(Dto dto:list){

　　List<Dto> li = map.get(dto.getLevel());

　　li集合的sort操作//对节点排序

　　dto.setListdto(li);//树形结构

　　recursive(li,map,dto.getLevel());

　　}

}

实例：

//1.将所有数据根据level分组（也可以根据parentId分组），这个map（level，List<dto>）帮助我们，给定一个level，返回该level下的节点
//2.收集所有根节点
public List<DeptLevelDto> deptListToTree(List<DeptLevelDto> deptLevelList) {
    if (CollectionUtils.isEmpty(deptLevelList)) {
        return Lists.newArrayList();
    }
    // level -> [dept1, dept2, ...] Map<String, List<Object>>
    Multimap<String, DeptLevelDto> levelDeptMap = ArrayListMultimap.create();
    List<DeptLevelDto> rootList = Lists.newArrayList();

    for (DeptLevelDto dto : deptLevelList) {
        levelDeptMap.put(dto.getLevel(), dto);
        if (LevelUtil.ROOT.equals(dto.getLevel())) {
            rootList.add(dto);
        }
    }
    // 按照seq从小到大排序
    Collections.sort(rootList, new Comparator<DeptLevelDto>() {
        public int compare(DeptLevelDto o1, DeptLevelDto o2) {
            return o1.getSeq() - o2.getSeq();
        }
    });
    // 递归生成树
    transformDeptTree(rootList, LevelUtil.ROOT, levelDeptMap);
    return rootList;
}


public void transformDeptTree(List<DeptLevelDto> deptLevelList, String level, Multimap<String, DeptLevelDto> levelDeptMap) {
    for (int i = 0; i < deptLevelList.size(); i++) {
        // 遍历该层的每个元素
        DeptLevelDto deptLevelDto = deptLevelList.get(i);
        // 处理当前层级的数据
        String nextLevel = LevelUtil.calculateLevel(level, deptLevelDto.getId());
        // 处理下一层
        List<DeptLevelDto> tempDeptList = (List<DeptLevelDto>) levelDeptMap.get(nextLevel);
        if (CollectionUtils.isNotEmpty(tempDeptList)) {
            // 排序
            Collections.sort(tempDeptList, deptSeqComparator);
            // 设置下一层部门
            deptLevelDto.setDeptList(tempDeptList);
            // 进入到下一层处理
            transformDeptTree(tempDeptList, nextLevel, levelDeptMap);
        }
    }
}

public Comparator<DeptLevelDto> deptSeqComparator = new Comparator<DeptLevelDto>() {
    public int compare(DeptLevelDto o1, DeptLevelDto o2) {
        return o1.getSeq() - o2.getSeq();
    }
};

 //  public Comparator<DeptLevelDto> deptComparator = (x,y)->x.getSeq()-y.getSeq();

————————–java8版本———————–

public List<DeptLevelDto> deptListoTree(List<DeptLevelDto> collect) {

    if(CollectionUtils.isEmpty(collect)){
        return Lists.newArrayList();
    }

    //@1
    List<DeptLevelDto> rootList = Lists.newArrayList();
    rootList =  collect.stream().filter(
            x->x.getLevel().equals(LevelUtil.ROOT)
        ).collect(Collectors.toList());

    //@2
    Map<String, List<DeptLevelDto>> multiMap = collect.stream().collect(Collectors.groupingBy(
            x -> x.getLevel(), Collectors.toList()
    ));

    //对root排序：
    Collections.sort(rootList,deptComparator);
    transformDeptTree(rootList,LevelUtil.ROOT,multiMap);
    return rootList;
    //tip:@1和@2可以使用guava的multiMap，一个key对应多个value
}

//递归生成树
public void transformDeptTree(List<DeptLevelDto> deptLevelList, String level,  Map<String, List<DeptLevelDto>> levelDeptMap) {

    deptLevelList.stream().forEach(x->{
       // 以该节点为父节点，寻找子节点集合
        String childLevel = LevelUtil.calculateLevel(level, x.getId());
        List<DeptLevelDto> child = levelDeptMap.get(childLevel);

        if(CollectionUtils.isNotEmpty(child)){//递归终止条件
            Collections.sort(child,deptComparator);
            x.setList(child);
            transformDeptTree(child,childLevel,levelDeptMap);
        }
    });

}