递归查询级联信息

在IT行业这个发展更新速度很快的行业，只有不停止的学习，才不会被行业所淘汰。如果你是数据库学习者，那么本文《递归查询级联信息》就很适合你！本篇内容主要包括递归查询级联信息，希望对大家的知识积累有所帮助，助力实战开发！

1. 需求背景

在很多场合，我们需要对表中的数据对递归查询。如以下情况：

1. 菜单分类中，我们往往需要由一级菜单获得对应的子菜单。

id	name	pid
1	图书	0
2	服装	0
3	儿童读物	1
4	杂志	1
5	卡通	3
6	睡前故事	3

我们希望得到的结果为，由图书可以查到：

@Mapper
public interface RelationTreeDao {
    List<relationtreedto> selectAllParentsByCode(String code);</relationtreedto>

• dto

[code, parentCode, parentCode, parentCode,...]

由于

RelationTreeDTO

是一个树结构，这就涉及到树的遍历。在此，以

树的深度优先搜索算法

，获得上述list。

/**
     * description:深度优先搜索DTO中的所有父节点
     * @author wanghongbing whbing1991@gmail.com
     * @param treeDTO RelationTreeDTO待解析的树结构对象
     * @return list [0]存code, [1]开始存parents
     * 一定会有一个父节点，list长度>=2
     */
    @Override
    public List<string> depthFirst(RelationTreeDTO treeDTO) {

        //list [0]存code, [1]开始存parents
        List<string> list = new ArrayList();
        list.add(treeDTO.getCode()); //list[0]
        
        ArrayDeque<relationtreedto> stack = new ArrayDeque();
        stack.push(treeDTO);

        while (!stack.isEmpty()){
            RelationTreeDTO node =stack.pop();
            list.add(node.getParentCode());
            //获取嵌套节点
            List<relationtreedto> parents = node.getParentCodeList();
            if(parents !=null && parents.size() >0){
                for (int i = parents.size()-1; i >=0 ; i--) {
                    stack.push(parents.get(i));
                }
            }
        }
        return list;
    }</relationtreedto></relationtreedto></string></string>

至此，该方式级联查询结束。
上述实现，

collection

结果为固定的树结构，在解析时，要使用算法（如

DFS

）获取树种的节点信息。虽然在mapper查询时，一次性获得了级联结构，后续解析仍然复杂。下面介绍推荐方式。

2.2 方法2：自定义实现级联查询

• dao

@Mapper
public interface RelationDao {
    List<taskrelationdto> selectParentByCode(String code);
   // 其他表
    List<taskrelationdto> selectOtherParentByCode(String code);
}</taskrelationdto></taskrelationdto>

• dto（或entity，如数据库对应的话）

public class TaskRelationDTO {
    private String code;
    private String parentCode;
    // getter and setter
}

• mapper.xml（假设有relation表和other_relation表，其字段相同。两个表完全为了展示扩展）

<?xml version="1.0" encoding="UTF-8" ?><!-- recommended not modified but can be added --><mapper namespace="com.***.dao.RelationDao"><!--tag--><resultmap id="relationMap" type="com.***.dto.RelationDTO"><result column="code" property="code" jdbctype="VARCHAR" javatype="String"></result><result column="parent_code" property="parentCode" jdbctype="VARCHAR" javatype="String"></result></resultmap><!-- a_relation表中选择当前code的父节点 --><select id="selectParentByCode" parametertype="java.lang.String" resultmap="relationMap">
        SELECT
            `code`,`parent_code`
        FROM
            `relation`
        WHERE
            `code` = #{code}
        AND
            `parent_code` is not NULL
    </select><!-- other_relation表中选择当前code的父节点 --><select id="selectOtherParentByCode" parametertype="java.lang.String" resultmap="relationMap">
        SELECT
            `code`,`parent_code`
        FROM
            `other_relation`
        WHERE
            `code` = #{code}
        AND
            `parent_code` is not NULL
    </select></mapper>

说明：上述查询仅为最简单的sql查询，我们将递归查询写在业务方法中。

• service

   /**
     *
     * @param code 待查找父任务的子任务
     * @return 返回的list.size()>=2 list[0]当前code，[1]以后去重后的无序parentsCode
     *         如：[tag-depend-2, path-depend-0-p, path-depend-2, tag-depend-0, path-depend-0]
     */
    @Override
    public List<string> getAllParentsByCode(String code) {
        List<string> list = new ArrayList();
        Set<string> parentSet = new HashSet();
        ArrayDeque<string> stack = new ArrayDeque();
        int count = 0;
        final int MAX_LOOP_COUNT = 50;

        // 初始化stack，将code放入stack
        stack.push(code);
        // 将code加入list。如果最终list.isEmpty()，表明没有父节点，将其清空。故list长度最短为2
        list.add(code);

        while (!stack.isEmpty()){
            // 如果入栈次数太多，表明可能出现环形依赖。强行终止
            if(count++ > MAX_LOOP_COUNT){
                LOGGER.error("code为["+code+"]任务其父任务超过"+MAX_LOOP_COUNT+"个，请检查是否有环形依赖");
                list.addAll(parentSet);
                // 仅有taskCode，无parentCode时，将list清空
                if(list.size() == 1){
                    list.clear();
                }
                return list;
            }
            String childCode = stack.pop();
/**
可能会出现两个表交叉依赖情况，故有otherRelation
*/
            List<relationdto> relation =relationDao.selectTagParentByCode(childCode);
            List<taskrelationdto> otherRelation =relationDao.selectOtherParentByCode(childCode);

            // 从relation表中查找pop()元素的父任务，将其加入stack
            if(!relation.isEmpty()){
                for (int i = 0; i </taskrelationdto></relationdto></string></string></string></string>

原理

说明：上述原理，使用

栈

（递归亦可，所谓递归，无非进栈出栈）来循环查询。初始化时，将待查询的

code

入栈，第一次查询时，该

code

出栈，作为参数查询，如有查询结果（一条或多条），将查询到的结果进栈（放入栈中，下次循环计就可以取出作为参数输入了！）。
如上述进行了两个表的查询，灵活。

---

总结

1. mybatis

   中的

   collection

   标签，不推荐使用。本人在项目实践中已由该方式更改为方式2。
2. 循环将查询到的结果

   parentCode

   作为

   code

   再次查询，看似复杂，理解原理就简单。
3. 栈的使用。可以代替递归，思路清晰。
4. 上述代码为项目代码，已经去除敏感信息。可能不能直接运行。如不能解决问题，可联系代码中邮箱。

---

本篇关于《递归查询级联信息》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于数据库的相关知识，请关注golang学习网公众号！