递归查询级联信息

时间 2019-11-11

原文原文链接

1. 需求背景

在不少场合，咱们须要对表中的数据对递归查询。如如下状况：java

1. 菜单分类中，咱们每每须要由一级菜单得到对应的子菜单。node

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

咱们但愿获得的结果为，由图书能够查到：mysql

{ 图书:  [ 杂志,
          {儿童读物:[卡通,睡前故事]}
         ]        
}

2. 在相似上述具备依赖关系的查询时，咱们将父子依赖关系抽象成如下字段：算法

col	col_parent
value1	value2
value2	value3

由col中的value1查询到col_parent值为value2；
再由value2做为col查询，查询到value3。
注：父依赖或子依赖只是称呼不一样而已。sql

value1的全部父依赖

value1-->value2-->value3数据库

value2的全部父依赖

value2-->value3mybatis

2. 实现方案

针对上述问题，本文提出两种解决方案。app

方法1：使用mybatis中的collection标签
优势：框架已经封装好了，不用深刻实现原理。
缺点：返回结果的结构固定，不能灵活处理。对结构的解析也较复杂。扩展性差

方法2：只需根据一条查询语句select col_parent from table_name where col=#{col}及本身的代码便可
优势：灵活性高。返回结构可扩展
难点：须要理解实现原理。

demo说明
对于mysql中以下数据表结构：框架

id	code	parent_code
...	...	...

目标：咱们要求经过code找到左右父code（包括祖辈code）ide

2.1 方法1：mybatis中collection标签实现

查询代码实现

核心代码（其余实现代码不作展现）

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

public class RelationTreeDTO {
    private String code;
    private String parentCode;
    private List<RelationTreeDTO> parentCodeList; //List嵌套自己，装父节点信息
   // getter and setter
}

mapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.***.dao.RelationTreeDao">
    <!---->
    <resultMap id="relationTreeMap" type="com.***.dto.RelationTreeDTO">
        <result column="task_code" property="taskCode" jdbcType="VARCHAR" javaType="String"/>
        <result column="parent_code" property="parentCode" jdbcType="VARCHAR" javaType="String"/>
        <collection column="parent_code" property="parentCodeList"
                select="selectAllParentsByCode">
         </collection>
    </resultMap>

    <!-- relation表中选择全部的父节点 -->
    <select id="selectAllParentsByCode"  parameterType="java.lang.String" resultMap="relationTreeMap">
        SELECT
            `code`,`parent_code`
        FROM
            `relation`
        WHERE
            `code` = #{code}
        AND
            `parent_code` is not NULL
    </select>
</mapper>

说明：

RelationTreeDTO做为查询结果的映射对象，其中须要定义自嵌套的List
mapper中的select也为简单查询，可是其映射结果resultMap中有collection标签。会将column="parent_code"再做为参数#{code}循环查询。

结果：

relationTreeDao.selectAllParentsByCode("yourCode");查询结果将会以RelationTreeDTO对象返回，如有多条父依赖，将显示在List的嵌套中。

[
    {
        "code": ***,
        "parentCode": ***,
        "parentCodeList": [
            {
               "code": ***,
                "parentCode": ***,
                "parentCodeList": []
            },
            ...
           ]
    }
]

结果解析

对于上述结果，咱们每每须要进一步获取有用信息。如只须要一个List：

[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;
    }

至此，该方式级联查询结束。
上述实现，collection结果为固定的树结构，在解析时，要使用算法（如DFS）获取树种的节点信息。虽然在mapper查询时，一次性得到了级联结构，后续解析仍然复杂。下面介绍推荐方式。

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

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

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" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<!-- 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 column="parent_code" property="parentCode" jdbcType="VARCHAR" javaType="String"/>
    </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 < relation.size(); i++) {
                    String parent = relation.get(i).getParentCode();
                    //这个parent是须要的，同时要将其放入stack
                    parentSet.add(parent);
                    stack.push(parent);
                }
            }
            // 从otherRelation表中查找pop()元素的父任务，将其加入stack
            if(!otherRelation.isEmpty()){
                for (int i = 0; i < otherRelation.size(); i++) {
                    String parent = otherRelation.get(i).getParentCode();
                    //这个parent是须要的，同时要将其放入stack
                    parentSet.add(parent);
                    stack.push(parent);
                }
            }
        }
        list.addAll(parentSet);
        // 仅有taskCode，无parentCode时，将list清空
        if(list.size() == 1){
            list.clear();
        }
        return list;
    }

原理

说明：上述原理，使用栈（递归亦可，所谓递归，无非进栈出栈）来循环查询。初始化时，将待查询的code入栈，第一次查询时，该code出栈，做为参数查询，若有查询结果（一条或多条），将查询到的结果进栈（放入栈中，下次循环计就能够取出做为参数输入了！）。
如上述进行了两个表的查询，灵活。

总结

mybatis中的collection标签，不推荐使用。本人在项目实践中已由该方式更改成方式2。
循环将查询到的结果parentCode做为code再次查询，看似复杂，理解原理就简单。
栈的使用。能够代替递归，思路清晰。
上述代码为项目代码，已经去除敏感信息。可能不能直接运行。如不能解决问题，可联系代码中邮箱。