树形结构

项目原型: 

 

 

 设计的数据库结构 : 

 

 

 

 

查询树结构的代码(全加载模式): 

    /**
     * 查询设备树
     *
     * @return
     */
    @Override
    @Transactional(readOnly = false)
    public ResultModelVO selectEquipmentTree(String orgId) {

        //查询所有的设备信息
        List<EquimentTree> lstEquimentTree = this.getAppService().getCapBaseCommonDAO().queryList("queryEquipmentTree", orgId);
        //当组织下没有设备时,默认创建根节点树
        if (CollUtil.isEmpty(lstEquimentTree)) {
            //添加根节点
            EquipmentVO equipmentVO = new EquipmentVO();
            equipmentVO.setOrgId(orgId);  //公司id
            equipmentVO.setEquipmentName("设备台账树");
            equipmentVO.setParentId("-1");
            equipmentVO.setSortNo(IOpportunityType.FIRST);
            equipmentVO.setEquipmentLevel(IOpportunityType.FIRST);
            this.insert(equipmentVO);
            return ResultModelVO.success(equipmentVO);
        }

        //  声明一个变量，用来存放找到的根节点
        EquimentTree rootEquipment = null;
        //创建Map对象用来存储id和Menu对象的对应关系便于查找父节点
        Map<String, EquimentTree> menuMap = new HashMap<>();
        lstEquimentTree.stream().forEach(equimentTree -> {
            //获取当前的父id
            String id = equimentTree.getEquipmentId();
            menuMap.put(id, equimentTree);
        });
        //再次遍历menuList查找根节点、组装父子节点
        for (EquimentTree equimentTree : lstEquimentTree) {
            String parentId = equimentTree.getParentId();
            //如果parentId为-1, 表示为根节点
            if ("-1".equals(parentId)) {
                rootEquipment = equimentTree;
                //停止本次循环,继续执行下次循环
                continue;
            }

            //如果pid不为-1，说明当前节点有父节点，那么可以根据parentId到menuMap中查找对应的equipmentVO对象
            EquimentTree father = menuMap.get(parentId);
            // 将子节点存入父节点的children集合中
            father.getChildrenList().add(equimentTree);
        }
        return ResultModelVO.success(rootEquipment);
    }

　　

 @Override
    @Transactional
    public ResultModelVO moveEquipmentTree(String beforeEquipmentId, String afterEquipmentId) {
        if (beforeEquipmentId.equals(afterEquipmentId)) return ResultModelVO.fail(false, "id有误");
        EquipmentVO beforeEquipment = this.loadById(beforeEquipmentId); //移动前的根节点
        EquipmentVO afterEquipment = this.loadById(afterEquipmentId); //移动后的根节点
        if ("-1".equals(afterEquipment.getParentId())|| "-1".equals(beforeEquipment.getParentId()) ) return ResultModelVO.fail(false, "不能移动到根节点");
        if (beforeEquipment.getEquipmentLevel() == IOpportunityType.SECOND && abstractEnergyPowerAccountFacade.isBindingByDeviceId(beforeEquipmentId))
            return ResultModelVO.fail(false, "该节点已关联用电账号,不能移动");


        // if (afterEquipment.getEquipmentLevel() >= 5) return ResultModelVO.fail(false, "最多只能有五成");

        beforeEquipment.setSortNo(1);
        //同级节点拖拽
        if (beforeEquipment.getParentId().equals(afterEquipment.getParentId())) {
            beforeEquipment.setParentId(afterEquipment.getEquipmentId());
            beforeEquipment.setEquipmentLevel(afterEquipment.getEquipmentLevel() + 1);
            //查询所有兄弟节点
            List<EquipmentVO> brotherNode = this.queryBrotherNode(afterEquipment.getEquipmentId());
            this.update(brotherNode);
        } else {
            beforeEquipment.setParentId(afterEquipment.getParentId());
            beforeEquipment.setEquipmentLevel(afterEquipment.getEquipmentLevel());
            //查询所有兄弟节点
            List<EquipmentVO> brotherNode = this.queryBrotherNode(afterEquipment.getParentId());
            this.update(brotherNode);
        }
        if (beforeEquipment.getEquipmentLevel() > IOpportunityType.FIVE) return ResultModelVO.fail(false, "最多只能有五成");
        List<String> lstIds = new ArrayList<>();
        lstIds.add(beforeEquipment.getEquipmentId());
        List<EquipmentVO> lstEquipments = updateLevel(lstIds, beforeEquipment.getEquipmentLevel());
        long count = lstEquipments.stream().filter(equipmentVO -> equipmentVO.getEquipmentLevel() <= IOpportunityType.FIVE).count();
        if (lstEquipments.size() != count) return ResultModelVO.fail(false, "最多只能有五成");
        this.update(lstEquipments);
        this.update(beforeEquipment);
        return ResultModelVO.success(true, "移动成功");
    }

 

    //递归查询当前节点的所有父节点
    public List<EquipmentVO> queryUpById(EquipmentVO equipmentVO) {

        List<EquipmentVO> childList = getAppService().getCapBaseCommonDAO().queryList("queryUpById", equipmentVO.getParentId());
        //存在父节点
        if (CollUtil.isNotEmpty(childList)) {
            for (EquipmentVO equipment : childList) {
                childList.addAll(queryUpById(equipment));
                return childList;
            }

        }
        return Lists.newArrayList();
    }


    //递归查询设备节点下的所有设备
    public List<EquipmentVO> queryEquipmentById(List<String> lstIds) {

        HashMap<String, Object> params = CollUtil.newHashMap();
        params.put("ids", lstIds);
        List<EquipmentVO> childList = getAppService().getCapBaseCommonDAO().queryList("queryIdByParentLstIds", params);

        //存在子节点
        if (CollUtil.isNotEmpty(childList)) {
            //拿到当前所有设备id
            List<String> parentIds = childList.stream().map(equipment -> equipment.getEquipmentId()).collect(Collectors.toList());
            childList.addAll(queryEquipmentById(parentIds));
            return childList;
        }
        return Lists.newArrayList();
    }

    //递归修改层级关系
    private List<EquipmentVO> updateLevel(List<String> lstIds, Integer level) {
        Integer newLevel = level + 1;

        HashMap<String, Object> params = CollUtil.newHashMap();
        params.put("ids", lstIds);

        List<EquipmentVO> childList = getAppService().getCapBaseCommonDAO().queryList("queryIdByParentLstIds", params);
        List<EquipmentVO> collect = childList.stream().map(equipmentVO -> {
            equipmentVO.setEquipmentLevel(newLevel);
            return equipmentVO;
        }).collect(Collectors.toList());
        //存在子节点
        if (CollUtil.isNotEmpty(childList)) {
            List<String> parentIds = collect.stream().map(equipmentVO -> equipmentVO.getEquipmentId()).collect(Collectors.toList());
            for (EquipmentVO equipment : collect) {
                collect.addAll(updateLevel(parentIds, equipment.getEquipmentLevel()));
                return collect;
            }
        }
        return Lists.newArrayList();
    }

    //递归添加设备
    private Boolean insterEquipment(EquipmentVO equipmentVO, String id, String parentId) {
        //添加设备
        equipmentVO.setEquipmentId(null);
        //设置设备名称
        equipmentVO.setEquipmentName(equipmentVO.getEquipmentName() + "_复制");
        //查询数据库是否存在
        HashMap<String, String> param = CollUtil.newHashMap();
        param.put("orgId", equipmentVO.getOrgId());
        param.put("equipmentName", equipmentVO.getEquipmentName());
        int count = (int) this.getAppService().getCapBaseCommonDAO().selectOne("queryCountByName", param);
        if (count > 0) {
            equipmentVO.setEquipmentName(equipmentVO.getEquipmentName() + "_1");
            equipmentVO.setEquipmentName(createName(equipmentVO));
        }
        equipmentVO.setSortNo(1);
        List<EquipmentVO> brotherNode = this.queryBrotherNode(parentId);
        if (CollUtil.isNotEmpty(brotherNode)) {
            this.update(brotherNode);
        }
        //设置父id
        equipmentVO.setParentId(parentId);
        //添加设备信息
        this.insert(equipmentVO);


        //查询是否有子节点
        List<EquipmentVO> lstEquipmentVOS = this.getAppService().getCapBaseCommonDAO().queryList("queryIdByParentId", id);
        if (CollUtil.isNotEmpty(lstEquipmentVOS)) {
            for (EquipmentVO vo : lstEquipmentVOS) {
                insterEquipment(vo, vo.getEquipmentId(), equipmentVO.getEquipmentId());
            }
        }
        return true;
    }

    /**
     * 递归生成设备名
     *
     * @param equipmentVO
     * @return
     */
    private String createName(EquipmentVO equipmentVO) {
        //封装查询参数
        HashMap<String, String> param = CollUtil.newHashMap();
        param.put("orgId", equipmentVO.getOrgId());
        param.put("equipmentName", equipmentVO.getEquipmentName());
        int count = (int) this.getAppService().getCapBaseCommonDAO().selectOne("queryCountByName", param);

        //查询数据库名称是否有重复
        if (count > 0) {
            String[] s = equipmentVO.getEquipmentName().split("_");
            int i = Integer.parseInt(s[2]);
            equipmentVO.setEquipmentName(s[0] + "_" + s[1] + "_" + (i + 1));
            createName(equipmentVO);
        }
        return equipmentVO.getEquipmentName();
    }