多叉树结合JavaScript树形控件实现无限级树形菜单（一种构建多级有序树形结构JSON（或XML）数据源的方法）

多叉树结合JavaScript树形控件实现无限级树形菜单（一种构建多级有序树形结构JSON（或XML）数据源的方法）

一、问题研究的背景和意义
在Web应用程序开发领域，基于AJAX技术的JavaScript树形控件已经被广泛使用，它用来在Html页面上展现具有层次结构的数据项。目前市场上常见的JavaScript框架及组件库中均包含自己的树形控件，例如jQuery、Dojo、Yahoo UI、Ext JS等，还有一些独立的树形控件，例如dhtmlxtree等，这些树形控件完美的解决了层次数据的展示问题。展示离不开数据，树形控件主要利用AJAX技术从服务器端获取数据源，数据源的格式主要包括JSON、XML等，而这些层次数据一般都存储在数据库中。“无限级树形菜单”，顾名思义，没有级别的限制，它的数据通常来自数据库中的无限级层次数据，这种数据的存储表通常包括id和parentId这两个字段，以此来表示数据之间的层次关系。现在问题来了，既然树形控件的数据源采用JSON或XML等格式的字符串来组织层次数据，而层次数据又存储在数据库的表中，那么如何建立起树形控件与层次数据之间的关系，换句话说，如何将数据库中的层次数据转换成对应的层次结构的JSON或XML格式的字符串，返回给客户端的JavaScript树形控件？这就是我们要解决的关键技术问题。本文将以目前市场上比较火热的Ext JS框架为例，讲述实现无限级树形菜单的方法，该方法同样适用于其它类似的JS树形控件。

 

Ext JS框架是富客户端开发中出类拔萃的框架之一。在Ext的UI控件中，树形控件无疑是最为常用的控件之一，它用来实现树形结构的菜单。TreeNode用来实现静态的树形菜单，AsyncTreeNode用来实现动态的异步加载树形菜单，后者最为常用，它通过接收服务器端返回来的JSON格式的数据，动态生成树形菜单节点。动态生成树有两种思路：一种是一次性生成全部树节点，另一种是逐级加载树节点（利用AJAX，每次点击节点时查询下一级节点）。对于大数据量的菜单节点来说，逐级加载是比较合适的选择，但是对于小数据量的菜单来说，一次性生成全部节点应该是最为合理的方案。在实际应用开发中，一般不会遇到特别大数据量的场景，所以一次性生成全部菜单节点是我们重点研究的技术点，也就是本文要解决的关键技术问题。本文以基于Ext JS的应用系统为例，讲述如何将数据库中的无限级层次数据一次性在界面中生成全部菜单节点（例如在界面中以树形方式一次性展示出银行所有分支机构的信息），同时对每一个层次的菜单节点按照某一属性和规则排序，展示出有序的菜单树。

 

解决一次性构造无限级树形菜单的问题，可以拓展出更多的应用场景，例如树形结构表格TreeGrid，一次性生成树形表格，对树形表格进行完整分页，对表格列进行全排序；或者可以利用本文的思路扩展出其他的更复杂的应用场景。

先看两个图例，有个直观上的认识：
图一，银行分支机构树形结构菜单

 

图二，树形结构表格
 

 

二、详细设计方案

让我们先看两段代码片段：

文件一，branchTree.html （Ext树形控件页面）

Js代码  

1. Ext.onReady(  
2.  function(){  
3.     var  tree = new Ext.tree.TreePanel({  
4.        height: 300,  
5.        width: 400,  
6.        animate:true,  
7.        enableDD:true,  
8.        containerScroll: true,  
9.        rootVisible: false,  
10.        frame: true,  
11.        // getBranch.do请求服务器返回多级树形结构的JSON字符串  
12.      loader: new Ext.tree.TreeLoader({dataUrl:'getBranch.do'}),   
13.        root : new Ext.tree.AsyncTreeNode({id:'0',text:'根结点'})    
14.       });        
15.       tree.expandAll();  
16.   }  
17. );  

 
文件二，branchTreeJSON.jsp （接收getBranch.do请求，返回多级树形结构的JSON字符串）

Java代码  

1. <%  
2. // 读取银行分支机构的层次数据  
3. List result = DataAccess.getBankInfoList();  
4. // 将层次数据转换为多叉树对象（本文下面会详细介绍该数据结构的实现方法）  
5. Node root = ExtTreeHelper.createExtTree(result);   
6. %>                                                
7. [  
8. <%=root.toString()%> <!-- 以JSON的形式返回响应数据，Ext.tree.TreeLoader会根据此数据生成树形菜单 -->  
9. ]  

 

以上两个程序文件是一次性生成无限级树形菜单所必须的，其中最为关键的部分就是如何生成一个无限级的树形结构JSON字符串，返回给客户端的Ext树形控件。对于银行分支机构来说，需要返回类似如下的JSON串：

Js代码  

1. {  
2.   id: '100000',  
3.   text: '廊坊银行总行',  
4.   children: [  
5.     {  
6.       id: '110000',  
7.       text: '廊坊分行',  
8.       children: [  
9.         {  
10.           id: '113000',  
11.           text: '廊坊银行开发区支行',  
12.           leaf: true  
13.         },  
14.         {  
15.           id: '112000',  
16.           text: '廊坊银行解放道支行',  
17.           children: [  
18.             {  
19.               id: '112200',  
20.               text: '廊坊银行三大街支行',  
21.               leaf: true  
22.             },  
23.             {  
24.               id: '112100',  
25.               text: '廊坊银行广阳道支行',  
26.               leaf: true  
27.             }  
28.           ]  
29.         },  
30.         {  
31.           id: '111000',  
32.           text: '廊坊银行金光道支行',  
33.           leaf: true  
34.         }  
35.       ]  
36.     }  
37.   ]  
38. }  

 

 

 

同时还需要对树中每一个层次的节点按照某一属性（比如分支机构编号）进行排序，以展示出有序的树形菜单。

 

现在可以把问题概括为：
1、 把数据库中的层次数据转换成多级树形结构的JSON格式的字符串
2、 对树中每一个层次的节点按照某一属性（比如分支机构编号）进行排序

 

下面介绍解决问题的思路：
在数据结构这门课中，我们都学过树，无限级树形菜单就可以抽象成一种多叉树结构，即每个节点下包含多个子节点的树形结构，首先就需要把数据库中的层次数据转换成多叉树结构的对象树，也就是构造出一棵多叉树。

 

有了数据结构，还要实现相应的算法，我们需要实现两种算法：
1、兄弟节点横向排序算法，对隶属于同一个父节点下面的所有直接子节点按照某一节点属性和规则进行排序，保持兄弟节点横向有序；
2、先序遍历算法，递归打印出无限级JSON字符串。

 

概括起来分为三步：
1、 构造无序的多叉树结构
2、 实现兄弟节点横向排序方法
3、 实现先序遍历方法，打印出JSON字符串

如图所示：
 

 

 

 

三、源代码实现（Java语言版）
实现这样一颗树，需要设计两个类：树类（MultipleTree）、节点类（Node）；排序时还需要一个比较器类（NodeIDComparator）；为了方便演示，还需要构造一些假的层次数据，因此还需要建一个构造假数据的类（VirtualDataGenerator），以下代码拷贝出来之后可直接运行测试：

 

 

Java代码  

1. package test;  
2.   
3. import java.util.ArrayList;  
4. import java.util.Comparator;  
5. import java.util.HashMap;  
6. import java.util.Iterator;  
7. import java.util.List;  
8. import java.util.Map;  
9. import java.util.Set;  
10. import java.util.Collections;  
11.   
12. /** 
13.  * 多叉树类 
14.  */  
15. public class MultipleTree {  
16.     public static void main(String[] args) {  
17.         // 读取层次数据结果集列表   
18.         List dataList = VirtualDataGenerator.getVirtualResult();  
19.   
20.         // 节点列表（散列表，用于临时存储节点对象）  
21.         HashMap nodeList = new HashMap();  
22.         // 根节点  
23.         Node root = null;  
24.         // 将结果集存入散列表（后面将借助散列表构造多叉树）  
25.         for (Iterator it = dataList.iterator(); it.hasNext();) {  
26.             Map dataRecord = (Map) it.next();  
27.             Node node = new Node();  
28.             node.id = (String) dataRecord.get("id");  
29.             node.text = (String) dataRecord.get("text");  
30.             node.parentId = (String) dataRecord.get("parentId");  
31.             nodeList.put(node.id, node);  
32.         }  
33.         // 构造无序的多叉树  
34.         Set entrySet = nodeList.entrySet();  
35.         for (Iterator it = entrySet.iterator(); it.hasNext();) {  
36.             Node node = (Node) ((Map.Entry) it.next()).getValue();  
37.             if (node.parentId == null || node.parentId.equals("")) {  
38.                 root = node;  
39.             } else {  
40.                 ((Node) nodeList.get(node.parentId)).addChild(node);  
41.             }  
42.         }  
43.         // 输出无序的树形菜单的JSON字符串  
44.         System.out.println(root);  
45.         // 对多叉树进行横向排序  
46.         root.sortChildren();  
47.         // 输出有序的树形菜单的JSON字符串  
48.         System.out.println(root);  
49.   
50.         // 程序输出结果如下:  
51.         //  
52.         // 无序的树形菜单（格式化后的结果，可使用JSON格式化工具查看，  
53.         // 例如 http://jsonviewer.stack.hu/ 在线查看器）:    
54.         //  {  
55.         //   id : '100000',   
56.         //   text : '廊坊银行总行',   
57.         //   children : [  
58.         //     {  
59.         //     id : '110000',   
60.         //     text : '廊坊分行',   
61.         //     children : [  
62.         //       {  
63.         //       id : '113000',   
64.         //       text : '廊坊银行开发区支行',   
65.         //       leaf : true  
66.         //       },  
67.         //       {  
68.         //       id : '111000',   
69.         //       text : '廊坊银行金光道支行',   
70.         //       leaf : true  
71.         //       },  
72.         //       {  
73.         //       id : '112000',   
74.         //       text : '廊坊银行解放道支行',   
75.         //       children : [  
76.         //         {  
77.         //         id : '112200',   
78.         //         text : '廊坊银行三大街支行',   
79.         //         leaf : true  
80.         //         },  
81.         //         {  
82.         //         id : '112100',   
83.         //         text : '廊坊银行广阳道支行',   
84.         //         leaf : true  
85.         //         }  
86.         //       ]  
87.         //       }  
88.         //     ]  
89.         //     }  
90.         //   ]  
91.         //  }  
92.   
93.         // 有序的树形菜单（格式化后的结果）：  
94.         //  {  
95.         //   id : '100000',   
96.         //   text : '廊坊银行总行',   
97.         //   children : [  
98.         //     {  
99.         //     id : '110000',   
100.         //     text : '廊坊分行',   
101.         //     children : [  
102.         //       {  
103.         //       id : '111000',   
104.         //       text : '廊坊银行金光道支行',   
105.         //       leaf : true  
106.         //       },  
107.         //       {  
108.         //       id : '112000',   
109.         //       text : '廊坊银行解放道支行',   
110.         //       children : [  
111.         //         {  
112.         //         id : '112100',   
113.         //         text : '廊坊银行广阳道支行',   
114.         //         leaf : true  
115.         //         },  
116.         //         {  
117.         //         id : '112200',   
118.         //         text : '廊坊银行三大街支行',   
119.         //         leaf : true  
120.         //         }  
121.         //       ]  
122.         //       },  
123.         //       {  
124.         //       id : '113000',   
125.         //       text : '廊坊银行开发区支行',   
126.         //       leaf : true  
127.         //       }  
128.         //     ]  
129.         //     }  
130.         //   ]  
131.         //  }    
132.   
133.     }  
134.   
135. }  
136.   
137. /** 
138.  * 节点类 
139.  */  
140. class Node {  
141.     /** 
142.      * 节点编号 
143.      */  
144.     public String id;  
145.   
146.     /** 
147.      * 节点内容 
148.      */  
149.     public String text;  
150.   
151.     /** 
152.      * 父节点编号 
153.      */  
154.     public String parentId;  
155.   
156.     /** 
157.      * 孩子节点列表 
158.      */  
159.     private List children = new ArrayList();  
160.   
161.     // 添加孩子节点  
162.     public void addChild(Node node) {  
163.         children.add(node);  
164.     }  
165.   
166.     // 先序遍历，拼接JSON字符串  
167.     public String toString() {  
168.         String result = "{" + "id : '" + id + "'" + ", text : '" + text + "'";  
169.         if (children.size() != 0) {  
170.             result += ", children : [";  
171.             for (Iterator it = children.iterator(); it.hasNext();) {  
172.                 result += ((Node) it.next()).toString() + ",";  
173.             }  
174.             result = result.substring(0, result.length() - 1);  
175.             result += "]";  
176.         } else {  
177.             result += ", leaf : true";  
178.         }  
179.         return result + "}";  
180.     }  
181.   
182.     // 兄弟节点横向排序  
183.     public void sortChildren() {  
184.         if (children.size() != 0) {  
185.             // 对本层节点进行排序（可根据不同的排序属性，传入不同的比较器，这里传入ID比较器）  
186.             Collections.sort(children, new NodeIDComparator());  
187.             // 对每个节点的下一层节点进行排序  
188.             for (Iterator it = children.iterator(); it.hasNext();) {  
189.                 ((Node) it.next()).sortChildren();  
190.             }  
191.         }  
192.     }  
193.   
194. }  
195.   
196. /** 
197.  * 节点比较器 
198.  */  
199. class NodeIDComparator implements Comparator {  
200.     // 按照节点编号比较  
201.     public int compare(Object o1, Object o2) {  
202.         int j1 = Integer.parseInt(((Node) o1).id);  
203.         int j2 = Integer.parseInt(((Node) o2).id);  
204.         return (j1 < j2 ? -1 : (j1 == j2 ? 0 : 1));  
205.     }  
206. }  
207.   
208. /** 
209.  * 构造虚拟的层次数据 
210.  */  
211. class VirtualDataGenerator {  
212.     // 构造无序的结果集列表，实际应用中，该数据应该从数据库中查询获得；  
213.     public static List getVirtualResult() {  
214.         List dataList = new ArrayList();  
215.   
216.         HashMap dataRecord1 = new HashMap();  
217.         dataRecord1.put("id", "112000");  
218.         dataRecord1.put("text", "廊坊银行解放道支行");  
219.         dataRecord1.put("parentId", "110000");  
220.   
221.         HashMap dataRecord2 = new HashMap();  
222.         dataRecord2.put("id", "112200");  
223.         dataRecord2.put("text", "廊坊银行三大街支行");  
224.         dataRecord2.put("parentId", "112000");  
225.   
226.         HashMap dataRecord3 = new HashMap();  
227.         dataRecord3.put("id", "112100");  
228.         dataRecord3.put("text", "廊坊银行广阳道支行");  
229.         dataRecord3.put("parentId", "112000");  
230.   
231.         HashMap dataRecord4 = new HashMap();  
232.         dataRecord4.put("id", "113000");  
233.         dataRecord4.put("text", "廊坊银行开发区支行");  
234.         dataRecord4.put("parentId", "110000");  
235.   
236.         HashMap dataRecord5 = new HashMap();  
237.         dataRecord5.put("id", "100000");  
238.         dataRecord5.put("text", "廊坊银行总行");  
239.         dataRecord5.put("parentId", "");  
240.   
241.         HashMap dataRecord6 = new HashMap();  
242.         dataRecord6.put("id", "110000");  
243.         dataRecord6.put("text", "廊坊分行");  
244.         dataRecord6.put("parentId", "100000");  
245.   
246.         HashMap dataRecord7 = new HashMap();  
247.         dataRecord7.put("id", "111000");  
248.         dataRecord7.put("text", "廊坊银行金光道支行");  
249.         dataRecord7.put("parentId", "110000");  
250.   
251.         dataList.add(dataRecord1);  
252.         dataList.add(dataRecord2);  
253.         dataList.add(dataRecord3);  
254.         dataList.add(dataRecord4);  
255.         dataList.add(dataRecord5);  
256.         dataList.add(dataRecord6);  
257.         dataList.add(dataRecord7);  
258.   
259.         return dataList;  
260.     }  
261. }  

 

好了，通过上面的代码，就可以实现多叉树的兄弟节点横向排序和先序遍历了，实现了将层次数据转换为有序无限级树形结构JSON字符串的目的。

在实际的项目中，可以把上面的有效代码融入其中，或者在此基础上进行一些扩展：
 1、 实现对指定层次的排序（例如只排序第一层的节点，或者只排序某一父节点下的所有子节点）
 2、 遍历输出树形结构时可以加入判断条件过滤掉某些节点
 3、 实现节点的删除功能
 4、 在节点类中增加一个父节点的引用，就可以计算出某一节点所处的级别
 5、 在不支持层次查询的数据库应用系统中使用该算法实现相同的效果

 

四、思考与总结
这篇文章的重点是如何构造有序的无限级的树形结构JSON字符串，一次性生成树形菜单，而不是利用AJAX的方式，反复向服务器端发送请求，一级接一级的加载树节点。

 

既然可以构造无限级的JSON字符串，那么也可以根据这个思路构造无限级的XML字符串，或者构造具有层次结构的UL – LI组合（用UL - LI来展示树形结构），或者构造具有层次结构的TABLE（用TABLE来展示树形结构）。如下所示：

 

（1）XML层次结构

Xml代码  

1. <menuGroup id="100000" name="廊坊银行总行">  
2.   <menuGroup id="110000" name="廊坊分行">  
3.      <menu id="113000" name="廊坊银行开发区支行">    
4.      </menu>  
5.      <menu id="111000" name="廊坊银行金光道支行">    
6.      </menu>  
7.      <menuGroup id="112000" name="廊坊银行解放道支行">  
8.        <menu id="112200" name="廊坊银行三大街支行">     
9.        </menu>  
10.        <menu id="112100" name="廊坊银行广阳道支行">     
11.        </menu>  
12.      </menuGroup>  
13.   </menuGroup>  
14. </menuGroup>  

 

 

（2）UL - LI 层次结构

Html代码  

1. <ul>  
2.  <li>廊坊银行总行</li>  
3.  <ul>  
4.   <li>廊坊分行</li>  
5.   <ul>  
6.     <li>廊坊银行开发区支行</li>       
7.      <li>廊坊银行解放道支行</li>  
8.      <ul>  
9.       <li>廊坊银行三大街支行</li>  
10.       <li>廊坊银行广阳道支行</li>  
11.      </ul>   
12.     <li>廊坊银行金光道支行</li>  
13.   </ul>   
14.  </ul>   
15. </ul>   

  

 

（3）TABLE层次结构

Html代码  

1. <table>  
2. <tr><td>廊坊银行总行</td></tr>  
3. <tr><td>&nbsp;&nbsp;廊坊分行</td></tr>  
4. <tr><td>&nbsp;&nbsp;&nbsp;&nbsp;廊坊银行开发区支行</td></tr>  
5. <tr><td>&nbsp;&nbsp;&nbsp;&nbsp;廊坊银行解放道支行</td></tr>  
6. <tr><td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;廊坊银行三大街支行</td></tr>  
7. <tr><td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;廊坊银行广阳道支行</td></tr>  
8. <tr><td>&nbsp;&nbsp;&nbsp;&nbsp;廊坊银行金光道支行</td></tr>  
9. </table>  

 

另外对TreeGrid树形表格也有一定的价值：
1、 一次性构造树形表格，实现数据分级展示
2、 通过更换比较器，实现对不同表格列的全排序（全排序指的是对所有页的数据进行排序，而不是只对当前页的数据排序）
3、 实现对树形表格的完整分页（每次分页时，只取固定数目的第一层节点，之后调用toString方法，展示出完整条数的分级数据）

 

 

五、参考书籍
1、Mark Allen Weiss，数据结构与算法分析（Java语言描述）
2、Bruce Eckel，Thinking In Java Third Edition
3、David Flanagan，JavaScript: The Definitive Guide, 5th Edition
4、OCA Oracle Database 11g SQL Fundamentals I Exam Guide

 

注：本文的思路方法是受到Oracle层次查询的启发，所以将《OCA Oracle Database 11g SQL Fundamentals I Exam Guide》这本书也写在了参考书籍里面，构造多叉树的方法是从数据结构中获得灵感， 故也把《数据结构与算法分析（Java语言描述）》这本书列了出来。

六、联系方式

[email protected]