模糊查询、构造树

记录本次工作中使用到的两种树形结构构造方法

1.java 代码构造树

构造思路：
1.从顶层（parenstId = -1）的数据开始，作为parentsId，在表中查询数据
2.再将获得的列表遍历，作为parenstId，在表中查询

/**
 * 模糊查询树形集合
 * @param vo
 * @return
 */
@Override
public List<TreeVO> getUnitListByName(Param param) {
      
      	//模糊查询参数
        String name = param.getName();

        // 获得最高级的节点（parenstId = -1）
        List<TreeVO> treeByParentsId = getBaseMapper().getTreeByParentsId(-1);

        if (treeByParentsId.size() > 0) {
            // 遍历最高级的节点列表，查询其子集，并构造树结构
            for (TreeVO vo : treeByParentsId) {
                vo = findChildList(vo);
            }
            
            // 保存待删除的节点
            List<TreeVO> removeList = new ArrayList<>();
            
            //筛选符合模糊查询条件的节点及其父节点
            if (!StringUtils.isEmpty(name)) {
                for (TreeVO treeVO : treeByParentsId) {
                
                    if (getChildren(treeVO, name) == null) {
                    	// 该节点及其子节点查询不到，加入待删除节点
                        removeList.add(treeVO);
                    } else {
                        treeVO = getChildren(treeVO, name);
                    }
                }
            }
            treeByParentsId.removeAll(removeList);
        }
        return treeByParentsId;
}

/**
 * 递归查找下级树节点集合
 * @param vo
 * @return
 */
public TreeVO findChildList(TreeVO vo) {
    
        List<TreeVO> childrenList = new ArrayList<>();
        List<TreeVO> childUnitTreeList = getBaseMapper().getTreeByParentsId(vo.getUnitId());
        if (childUnitTreeList.size() > 0) {
            for (TreeVO childVo : listByParentsId) {
            // 存在子节点合集，继续查询子节点合集的子节点合集
            childVo = findChildList(childVo);
        	}
			// 将结果填充并返回
            childrenList.add(unitListVO);
        }
        
        vo.setChildrenList(childrenList);
        return vo;
}

/**
 * 传入一个树的父节点，
 * 1.查看是否符合名称（模糊查询）条件，符合 ——》则返回
 * 2.如果子节点中存在符合条件的节点 ——》 返回
 * @param treeVO
 * @return
 */
public TreeVO getChildren(TreeVO treeVO, String name) {

        TreeVO resultVo = null;
        //记录需要移除的子节点
        List<TreeVO> removeUnitList = new ArrayList<>();

        if (treeVO.getUnitName().contains(name)) {
            //符合条件，则返回,且保留其所有子节点
            resultVo = treeVO;
        } else {
            //不符合条件，如果存在子节点，往下搜寻
            if (treeVO.getChildrenList().size() > 0) {
                List<TreeVO> childrenList = treeVO.getChildrenList();
                for (TreeVO childVo : childrenList) {
                    TreeVO childrenUnit = getChildren(childVo, name);
                    if (childrenUnit != null) {
                        resultVo = treeVO;
                    } else {
                        removeUnitList.add(childVo);
                    }
                }
                childrenList.removeAll(removeUnitList);
            }
        }
        return resultVo;
}

2. mysql 函数构造树

可查询出树的所有分支上的节点集合

find_in_set 函数构造树

select id from (

          select t1.id,

          if(find_in_set(parents_id, @pids) > 0, @pids := concat(@pids, ',', id), 0) as ischild

          from (

               select id,parents_id from [表名] t where t.data_status = 1 order by parents_id, id

              ) t1,

              (select @pids := 100000001) t2

         ) t3 where ischild != 0