Java开发企业级权限管理系统（九）

权限树结构接口开发

部门树开发
部门树实体

DeptLevelDTO

@Getter
@Setter
@ToString
public class DeptLevelDTO extends SysDept {

    private List<DeptLevelDTO> deptList = Lists.newArrayList();

    public static DeptLevelDTO adapt(SysDept dept) {
        DeptLevelDTO dto = new DeptLevelDTO();
        BeanUtils.copyProperties(dept, dto);
        return dto;
    }
}

接口定义 SysTreeService

List<DeptLevelDTO> deptTree();

实现层实现代码

@Override
    public List<DeptLevelDTO> deptTree() {
        List<SysDept> deptList = sysDeptMapper.getAllDept();

        List<DeptLevelDTO> dtoList = new ArrayList<>();
        for(SysDept sysDept:deptList){
            DeptLevelDTO deptLevelDTO = DeptLevelDTO.adapt(sysDept);
            dtoList.add(deptLevelDTO);
        }
        return deptListToTree(dtoList);
    }

    public List<DeptLevelDTO> deptListToTree(List<DeptLevelDTO> deptLevelList){
        //初始化
        if(CollectionUtils.isEmpty(deptLevelList)){
            return Lists.newArrayList();
        }
        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);
            }

        }
        Collections.sort(rootList, new Comparator<DeptLevelDTO>() {
            @Override
            public int compare(DeptLevelDTO o1, DeptLevelDTO o2) {
                return o1.getSeq()-o2.getSeq();
            }
        });
        //递归生成树
        transformDeptTree(rootList,LevelUtil.ROOT,levelDeptMap);
        return rootList;

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

    }

实现层代码解析：
先对部门数据进行初始化，调用树形结构实体类对所有部门数据实体化后调用生成树方法deptListToTree
生成树方法

Multimap<String,DeptLevelDTO> levelDeptMap = ArrayListMultimap.create();

利用multimap结构，该map相当于map<String,List<DeptLevelDTO>>

利用这个结构将相同层级的dept放在同一个key下，
初始化父节点部门
后递归调用transformDeptTree方法

//rootList 父节点部门列表，LevelUtil.ROOT当前层级，levelDeptMap所有部门列表按层级存入
transformDeptTree(rootList,LevelUtil.ROOT,levelDeptMap);

transformDeptTree方法遍历传入的部门列表，比如说取第一个父节点部门，拼凑出他的下一级层级，父层级+当前id，他的下一级部门列表从levelDeptMap中按下一级层级取
List tempDeptList = (List) levelDeptMap.get(nextLevel);
设定好后如果他的下一级部门列表不为空，遍历下一级部门列表调用transformDeptTree

其他结构树方法相同

public interface SysTreeService {

    List<DeptLevelDTO> deptTree();

    List<AclModuleLevelDTO> aclModuleTree();

    List<AclModuleLevelDTO> roleTree(int roleId);

    List<AclModuleLevelDTO> userAclTree(int userId);



}

@Service
public class SysTreeServiceImpl implements SysTreeService {

    @Resource
    private SysDeptMapper sysDeptMapper;
    @Resource
    private SysAclModuleMapper sysAclModuleMapper;
    @Resource
    private SysCoreService sysCoreService;
    @Resource
    private SysAclMapper sysAclMapper;

    @Override
    public List<AclModuleLevelDTO> userAclTree(int userId) {
        List<SysAcl> userAclList = sysCoreService.getUserAclList(userId);
        List<AclDTO> aclDtoList = Lists.newArrayList();
        for (SysAcl acl : userAclList) {
            AclDTO dto = AclDTO.adapt(acl);
            dto.setHasAcl(true);
            dto.setChecked(true);
            aclDtoList.add(dto);
        }
        return aclListToTree(aclDtoList);
    }

    @Override
    public List<AclModuleLevelDTO> roleTree(int roleId) {
        // 1、当前用户已分配的权限点
        List<SysAcl> userAclList = sysCoreService.getCurrentUserAclList();
        // 2、当前角色分配的权限点
        List<SysAcl> roleAclList = sysCoreService.getRoleAclList(roleId);
        // 3、当前系统所有权限点
        List<AclDTO> aclDtoList = Lists.newArrayList();

        Set<Integer> userAclIdSet = userAclList.stream().map(sysAcl -> sysAcl.getId()).collect(Collectors.toSet());
        Set<Integer> roleAclIdSet = roleAclList.stream().map(sysAcl -> sysAcl.getId()).collect(Collectors.toSet());

        List<SysAcl> allAclList = sysAclMapper.getAll();
        for (SysAcl acl : allAclList) {
            AclDTO dto = AclDTO.adapt(acl);
            if (userAclIdSet.contains(acl.getId())) {
                dto.setHasAcl(true);
            }
            if (roleAclIdSet.contains(acl.getId())) {
                dto.setChecked(true);
            }
            aclDtoList.add(dto);
        }
        return aclListToTree(aclDtoList);
    }

    @Override
    public List<DeptLevelDTO> deptTree() {
        List<SysDept> deptList = sysDeptMapper.getAllDept();

        List<DeptLevelDTO> dtoList = new ArrayList<>();
        for(SysDept sysDept:deptList){
            DeptLevelDTO deptLevelDTO = DeptLevelDTO.adapt(sysDept);
            dtoList.add(deptLevelDTO);
        }
        return deptListToTree(dtoList);
    }

    @Override
    public List<AclModuleLevelDTO> aclModuleTree() {
        List<SysAclModule> aclModuleList = sysAclModuleMapper.getAll();

        List<AclModuleLevelDTO> dtoList = new ArrayList<>();
        for(SysAclModule sysAclModule:aclModuleList){
            AclModuleLevelDTO aclModuleLevelDTO = AclModuleLevelDTO.adapt(sysAclModule);
            dtoList.add(aclModuleLevelDTO);
        }
        return aclModuleListToTree(dtoList);

    }



    public List<DeptLevelDTO> deptListToTree(List<DeptLevelDTO> deptLevelList){
        //初始化
        if(CollectionUtils.isEmpty(deptLevelList)){
            return Lists.newArrayList();
        }
        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);
            }

        }
        Collections.sort(rootList, new Comparator<DeptLevelDTO>() {
            @Override
            public int compare(DeptLevelDTO o1, DeptLevelDTO o2) {
                return o1.getSeq()-o2.getSeq();
            }
        });
        //递归生成树
        transformDeptTree(rootList,LevelUtil.ROOT,levelDeptMap);
        return rootList;

    }

    public void transformDeptTree(List<DeptLevelDTO> deptLevelDTOList,String level,Multimap<String,DeptLevelDTO> levelDeptMap){
        for(int i=0;i<deptLevelDTOList.size();i++){
            //遍历该层的每个元素
            DeptLevelDTO deptLevelDTO = deptLevelDTOList.get(i);
            //处理当前层级的数据
            String nextLevel = LevelUtil.calculateLevel(level,deptLevelDTO.getParentId());
            //处理下一层
            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>() {
        @Override
        public int compare(DeptLevelDTO o1, DeptLevelDTO o2) {
            return o1.getSeq() - o2.getSeq();
        }
    };

    public List<AclModuleLevelDTO> aclModuleListToTree(List<AclModuleLevelDTO> dtoList){
        if(CollectionUtils.isEmpty(dtoList)){
            return Lists.newArrayList();
        }
        Multimap<String,AclModuleLevelDTO> levelAclModuleMap = ArrayListMultimap.create();
        List<AclModuleLevelDTO> rootList = Lists.newArrayList();
        for(AclModuleLevelDTO dto:dtoList){
            levelAclModuleMap.put(dto.getLevel(),dto);
            if(LevelUtil.ROOT.equals(dto.getLevel())){
                rootList.add(dto);
            }

        }
        Collections.sort(rootList,aclModuleSeqComparator );
        //递归生成树
        transformAclModuleTree(rootList,LevelUtil.ROOT,levelAclModuleMap);
        return rootList;

    }

    public void  transformAclModuleTree(List<AclModuleLevelDTO> dtoList,String level,Multimap<String,AclModuleLevelDTO> levelAclModuleMap){
        for(int i=0;i<dtoList.size();i++){
            AclModuleLevelDTO dto =  dtoList.get(i);
            String nextLevel = LevelUtil.calculateLevel(dto.getLevel(),dto.getId());
            List<AclModuleLevelDTO> tempList = (List<AclModuleLevelDTO>) levelAclModuleMap.get(nextLevel);
            if (CollectionUtils.isNotEmpty(tempList)){
                Collections.sort(tempList,aclModuleSeqComparator);
                dto.setAclModuleList(tempList);
                transformAclModuleTree(tempList,nextLevel,levelAclModuleMap);
            }
        }
    }

    public Comparator<AclModuleLevelDTO> aclModuleSeqComparator = new Comparator<AclModuleLevelDTO>() {
        @Override
        public int compare(AclModuleLevelDTO o1, AclModuleLevelDTO o2) {
            return o1.getSeq() - o2.getSeq();
        }
    };

    public List<AclModuleLevelDTO> aclListToTree(List<AclDTO> aclDtoList){
        if(CollectionUtils.isEmpty(aclDtoList)){
            return Lists.newArrayList();
        }
        List<AclModuleLevelDTO> aclModuleLevelList = aclModuleTree();
        Multimap<Integer, AclDTO> moduleIdAclMap = ArrayListMultimap.create();
        for(AclDTO acl : aclDtoList) {
            if (acl.getStatus() == 1) {
                moduleIdAclMap.put(acl.getAclModuleId(), acl);
            }
        }
        bindAclsWithOrder(aclModuleLevelList, moduleIdAclMap);
        return aclModuleLevelList;
    }

    //模块绑定权限点
    public void bindAclsWithOrder(List<AclModuleLevelDTO> aclModuleLevelList, Multimap<Integer, AclDTO> moduleIdAclMap) {
        if (CollectionUtils.isEmpty(aclModuleLevelList)) {
            return;
        }
        for (AclModuleLevelDTO dto : aclModuleLevelList) {
            List<AclDTO> aclDtoList = (List<AclDTO>)moduleIdAclMap.get(dto.getId());
            if (CollectionUtils.isNotEmpty(aclDtoList)) {
                Collections.sort(aclDtoList, aclSeqComparator);
                dto.setAclList(aclDtoList);
            }
            bindAclsWithOrder(dto.getAclModuleList(), moduleIdAclMap);
        }
    }
    public Comparator<AclDTO> aclSeqComparator = new Comparator<AclDTO>() {
        @Override
        public int compare(AclDTO o1, AclDTO o2) {
            return o1.getSeq() - o2.getSeq();
        }
    };


}