1.企业级权限管理系统 save dept，生成树结构

save

    public void save(DeptParam param) {
        BeanValidator.check(param);
        if(checkExist(param.getParentId(), param.getName(), param.getId())) {
            throw new ParamException("同一层级下存在相同名称的部门");
        }
        //name parentId seq remark 前台传递
        SysDept dept = SysDept.builder().name(param.getName()).parentId(param.getParentId())
                .seq(param.getSeq()).remark(param.getRemark()).build();

        dept.setLevel(LevelUtil.calculateLevel(getLevel(param.getParentId()), param.getParentId()));
        dept.setOperator(RequestHolder.getCurrentUser().getUsername());
        dept.setOperateIp(IpUtil.getRemoteIp(RequestHolder.getCurrentRequest()));
        dept.setOperateTime(new Date());
        sysDeptMapper.insertSelective(dept);
        sysLogService.saveDeptLog(null, dept);
    }

@Builder
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class SysDept {

//通过ID查询出部门，使用的时候传递的 parentId，就是查询出，父类的level
    private String getLevel(Integer deptId) {
        SysDept dept = sysDeptMapper.selectByPrimaryKey(deptId);
        if (dept == null) {
            return null;
        }
        return dept.getLevel();
    }

//levelUtil工具类，拼接 父类level 和 父类 id 如果父level不存在，为0
public class LevelUtil {
    public final static String SEPARATOR = ".";
    public final static String ROOT = "0";
    // 0
    // 0.1
    // 0.1.2
    // 0.1.3
    // 0.4
    public static String calculateLevel(String parentLevel, int parentId) {
        if (StringUtils.isBlank(parentLevel)) {
            return ROOT;
        } else {
            return StringUtils.join(parentLevel, SEPARATOR, parentId);
        }
    }
}

tree.json

@Getter
@Setter
@ToString
public class DeptLevelDto extends SysDept {
//继承原来的类，定义自己的类的List
    private List<DeptLevelDto> deptList = Lists.newArrayList();
    //提供适配方法， 把原来的类，转换成 自己的类
    public static DeptLevelDto adapt(SysDept dept) {
        DeptLevelDto dto = new DeptLevelDto();
        BeanUtils.copyProperties(dept, dto);
        return dto;
    }
}

    public List<DeptLevelDto> deptTree() {
        //查询所有 的部门
        List<SysDept> deptList = sysDeptMapper.getAllDept();
        //把所有的部门，转换 成 适配类
        List<DeptLevelDto> dtoList = Lists.newArrayList();
        for (SysDept dept : deptList) {
            DeptLevelDto dto = DeptLevelDto.adapt(dept);
            dtoList.add(dto);
        }
        //调用 把 list 转换成 tree的方法
        return deptListToTree(dtoList);
    }

    public List<DeptLevelDto> deptListToTree(List<DeptLevelDto> deptLevelList) {
        if (CollectionUtils.isEmpty(deptLevelList)) {
        //如果list 为 空，返回一个 arrList 对象
            return Lists.newArrayList();
        }
        // level -> [dept1, dept2, ...] Map<String, List<Object>>
        //创建MultiMap
        Multimap<String, DeptLevelDto> levelDeptMap = ArrayListMultimap.create();
        //定义根节点，下面是对根节点的处理
        List<DeptLevelDto> rootList = Lists.newArrayList();

        for (DeptLevelDto dto : deptLevelList) {
            //先把 map 塞满 值，所有的 部门都塞进去
            levelDeptMap.put(dto.getLevel(), dto);
            if (LevelUtil.ROOT.equals(dto.getLevel())) {
                //如果是根节点，就把根节点塞 入 根节点list
                rootList.add(dto);
            }
        }
        // 按照seq从小到大排序
        Collections.sort(rootList, new Comparator<DeptLevelDto>() {
            public int compare(DeptLevelDto o1, DeptLevelDto o2) {
            // 1 - 2 = -1 小于 0，所以 1放在前面 
                return o1.getSeq() - o2.getSeq();
            }
        });
        // 递归生成树 递归的起始点 是根节点，0，所有的map
        transformDeptTree(rootList, LevelUtil.ROOT, levelDeptMap);
        return rootList;
    }

    // level:0, 0, all 0->0.1,0.2
    // level:0.1
    // level:0.2
    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);
            // 处理当前层级的数据 存的时候是存 父level.父Id，是level，自己id ，取到下一层
            String nextLevel = LevelUtil.calculateLevel(level, deptLevelDto.getId());
            // 处理下一层 从multiMap中取 的是 List 参数是下一个
            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();
        }
    };