摘要：需求背景在很多場合，我們需要對表中的數(shù)據(jù)對遞歸查詢。結果查詢結果將會以對象返回，若有多條父依賴，將顯示在的嵌套中。雖然在查詢時，一次性獲得了級聯(lián)結構，后續(xù)解析仍然復雜。故長度最短為如果入棧次數(shù)太多，表明可能出現(xiàn)環(huán)形依賴。

在很多場合，我們需要對表中的數(shù)據(jù)對遞歸查詢。如以下情況：

1. 菜單分類中，我們往往需要由一級菜單獲得對應的子菜單。

我們希望得到的結果為，由圖書可以查到：

{ 圖書:  [ 雜志,
          {兒童讀物:[卡通,睡前故事]}
         ]        
}             

2. 在類似上述具有依賴關系的查詢時，我們將父子依賴關系抽象成以下字段：

由col中的value1查詢到col_parent值為value2；
再由value2作為col查詢，查詢到value3。
注：父依賴或子依賴只是稱呼不同而已。

value1的所有父依賴

value1-->value2-->value3

value2的所有父依賴

value2-->value3

針對上述問題，本文提出兩種解決方案。

方法1：使用mybatis中的collection標簽
優(yōu)點：框架已經封裝好了，不用深入實現(xiàn)原理。
缺點：返回結果的結構固定，不能靈活處理。對結構的解析也較復雜。擴展性差

方法2：只需根據(jù)一條查詢語句select col_parent from table_name where col=#{col}及自己的代碼即可
優(yōu)點：靈活性高。返回結構可擴展
難點：需要理解實現(xiàn)原理。

demo說明
對于mysql中如下數(shù)據(jù)表結構：

目標：我們要求通過code找到左右父code（包括祖輩code）

核心代碼（其他實現(xiàn)代碼不做展示）

dao

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

dto

public class RelationTreeDTO {
    private String code;
    private String parentCode;
    private List parentCodeList; //List嵌套本身，裝父節(jié)點信息
   // getter and setter
}

mapper.xml

    
    
        
        
        
         
    

    
    
        SELECT
            `code`,`parent_code`
        FROM
            `relation`
        WHERE
            `code` = #{code}
        AND
            `parent_code` is not NULL
    

說明：

RelationTreeDTO作為查詢結果的映射對象，其中需要定義自嵌套的List

mapper中的select也為簡單查詢，但是其映射結果resultMap中有collection標簽。會將column="parent_code"再作為參數(shù)#{code}循環(huán)查詢。

結果：

relationTreeDao.selectAllParentsByCode("yourCode");查詢結果將會以RelationTreeDTO對象返回，若有多條父依賴，將顯示在List的嵌套中。

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

對于上述結果，我們往往需要進一步獲取有用信息。如只需要一個List：

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

由于RelationTreeDTO是一個樹結構，這就涉及到樹的遍歷。在此，以樹的深度優(yōu)先搜索算法，獲得上述list。

/**
     * description:深度優(yōu)先搜索DTO中的所有父節(jié)點
     * @author wanghongbing whbing1991@gmail.com
     * @param treeDTO RelationTreeDTO待解析的樹結構對象
     * @return list [0]存code, [1]開始存parents
     * 一定會有一個父節(jié)點，list長度>=2
     */
    @Override
    public List depthFirst(RelationTreeDTO treeDTO) {

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

        while (!stack.isEmpty()){
            RelationTreeDTO node =stack.pop();
            list.add(node.getParentCode());
            //獲取嵌套節(jié)點
            List 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;
    }

至此，該方式級聯(lián)查詢結束。
上述實現(xiàn)，collection結果為固定的樹結構，在解析時，要使用算法（如DFS）獲取樹種的節(jié)點信息。雖然在mapper查詢時，一次性獲得了級聯(lián)結構，后續(xù)解析仍然復雜。下面介紹推薦方式。

dao

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

dto（或entity，如數(shù)據(jù)庫對應的話）

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

mapper.xml（假設有relation表和other_relation表，其字段相同。兩個表完全為了展示擴展）

    
    
        
        
    

    
    
        SELECT
            `code`,`parent_code`
        FROM
            `relation`
        WHERE
            `code` = #{code}
        AND
            `parent_code` is not NULL
    
    
    
        SELECT
            `code`,`parent_code`
        FROM
            `other_relation`
        WHERE
            `code` = #{code}
        AND
            `parent_code` is not NULL
    

說明：上述查詢僅為最簡單的sql查詢，我們將遞歸查詢寫在業(yè)務方法中。

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 getAllParentsByCode(String code) {
        List list = new ArrayList<>();
        Set parentSet = new HashSet<>();
        ArrayDeque stack = new ArrayDeque();
        int count = 0;
        final int MAX_LOOP_COUNT = 50;

        // 初始化stack，將code放入stack
        stack.push(code);
        // 將code加入list。如果最終list.isEmpty()，表明沒有父節(jié)點，將其清空。故list長度最短為2
        list.add(code);

        while (!stack.isEmpty()){
            // 如果入棧次數(shù)太多，表明可能出現(xiàn)環(huán)形依賴。強行終止
            if(count++ > MAX_LOOP_COUNT){
                LOGGER.error("code為["+code+"]任務其父任務超過"+MAX_LOOP_COUNT+"個，請檢查是否有環(huán)形依賴");
                list.addAll(parentSet);
                // 僅有taskCode，無parentCode時，將list清空
                if(list.size() == 1){
                    list.clear();
                }
                return list;
            }
            String childCode = stack.pop();
/**
可能會出現(xiàn)兩個表交叉依賴情況，故有otherRelation
*/
            List relation =relationDao.selectTagParentByCode(childCode);
            List 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;
    }

原理

說明：上述原理，使用棧（遞歸亦可，所謂遞歸，無非進棧出棧）來循環(huán)查詢。初始化時，將待查詢的code入棧，第一次查詢時，該code出棧，作為參數(shù)查詢，如有查詢結果（一條或多條），將查詢到的結果進棧（放入棧中，下次循環(huán)計就可以取出作為參數(shù)輸入了！）。
如上述進行了兩個表的查詢，靈活。

mybatis中的collection標簽，不推薦使用。本人在項目實踐中已由該方式更改為方式2。

循環(huán)將查詢到的結果parentCode作為code再次查詢，看似復雜，理解原理就簡單。

棧的使用。可以代替遞歸，思路清晰。

上述代碼為項目代碼，已經去除敏感信息。可能不能直接運行。如不能解決問題，可聯(lián)系代碼中郵箱。