递归构造树形菜单

后台主要是在关系型数据库中拼接为树形的数据结构。
递归遍历如下:

package com.merit.common;



import com.alibaba.fastjson.JSONArray;

import java.util.ArrayList;
import java.util.List;

public class TreeBuilder {
    List<Node> nodes = new ArrayList<>();

    public JSONArray buildTree(List<Node> nodes) {

        TreeBuilder treeBuilder = new TreeBuilder(nodes);

        return treeBuilder.buildJSONTree();
    }

    public TreeBuilder() {
    }

    public TreeBuilder(List<Node> nodes) {
        super();
        this.nodes = nodes;
    }

    // 构建JSON树形结构
    public JSONArray buildJSONTree() {
        List<Node> nodeTree = buildTree();
        JSONArray jsonArray = JSONArray.parseArray(JSONArray.toJSONString(nodeTree));
        return jsonArray;
    }

    // 构建树形结构
    public List<Node> buildTree() {
        List<Node> treeNodes = new ArrayList<>();
        List<Node> rootNodes = getRootNodes();
        for (Node rootNode : rootNodes) {
            buildChildNodes(rootNode);
            treeNodes.add(rootNode);
        }
        return treeNodes;
    }

    // 递归子节点
    public void buildChildNodes(Node node) {
        List<Node> children = getChildNodes(node);
        if (!children.isEmpty()) {
            for (Node child : children) {
                buildChildNodes(child);
            }
            node.setNodes(children);
        }
    }

    // 获取父节点下所有的子节点
    public List<Node> getChildNodes(Node pnode) {
        List<Node> childNodes = new ArrayList<>();
        for (Node n : nodes) {
            if (pnode.getHref().equals(n.getSjdwbm())) {
                childNodes.add(n);
            }
        }
        return childNodes;
    }

    // 判断是否为根节点
    public boolean rootNode(Node node) {
        boolean isRootNode = true;
        for (Node n : nodes) {
           if(node.getSjdwbm()!=null){
               if (node.getSjdwbm().equals(n.getHref())) {
                   isRootNode = false;
                   break;
               }
           }
        }
        return isRootNode;
    }

    // 获取集合中所有的根节点
    public List<Node> getRootNodes() {
        List<Node> rootNodes = new ArrayList<>();
        for (Node n : nodes) {
            if (rootNode(n)) {
                rootNodes.add(n);
            }
        }
        return rootNodes;
    }

    public static class Node {

        private String href;  //单位编码
        private String sjdwbm; //上级单位编码
        private String text; //单位名称
        private String dwlx;//单位类型
        private String dwjb;//单位级别
        private List<Node> nodes;
        public Node() {
        }

        public String getDwlx() {
            return dwlx;
        }

        public void setDwlx(String dwlx) {
            this.dwlx = dwlx;
        }

        public String getDwjb() {
            return dwjb;
        }

        public void setDwjb(String dwjb) {
            this.dwjb = dwjb;
        }

        public Node(String href, String sjdwbm, String text) {
            super();
            this.href = href;
            this.sjdwbm = sjdwbm;
            this.text = text;
        }

        public String getHref() {
            return href;
        }

        public void setHref(String href) {
            this.href = href;
        }

        public String getSjdwbm() {
            return sjdwbm;
        }

        public void setSjdwbm(String sjdwbm) {
            this.sjdwbm = sjdwbm;
        }

        public String getText() {
            return text;
        }

        public void setText(String text) {
            this.text = text;
        }

        public List<Node> getNodes() {
            return nodes;
        }

        public void setNodes(List<Node> nodes) {
            this.nodes = nodes;
        }
    }

}

在controller层的调用如下:

 @ResponseBody
    @RequestMapping("/getTree")
    public JSONObject getTree(){
// 获取全部目录节点
        List<TreeBuilder.Node> nodes = userService.selecTreeNode();
        JSONObject josn = new JSONObject();
        // 拼装树形json字符串
        JSONArray str = new TreeBuilder().buildTree(nodes);
        josn.put("list",str);
        return josn;
    }