使用hibernate实现树形结构无限级分类

使用hibernate实现树形结构无限级分类

　　在系统中，经常会用到无限级的树形结构分类，如组织机构管理、商品/地区分类等等。一般无外采用两种方式：

　　一是类似struts-menu（http://struts-menu.sourceforge.net）的XML文件管理方式，配置起来比较方便，但很难与系统中其它应用数据集成；

　　二是使用数据库存储，定义父子关系。

　　在我们现在开发的一个产品中，使用hibernate实现了一套树形结构的处理方法，简介如下：

　　由于菜单本身属于权限系统的一部分，存储在数据库中后可以方便的与部门、用户、岗位、职务等进行关联，并进行权限控制。

　　■树形结构显示，使用的是xtree。为便于编辑维护，自己写了一个左键弹出菜单（xtree的右键事件无法更改），进行节点的添加、修改、删除、转移操作。（PS：这套维护界面是完全跨浏览器的，有兴趣的不妨一试）

　　■关联关系：

　　可以使用objects对象来配置关联关系，实现多对多/一对多等关系。在BaseTree中，getObjects()方法是abstract的，可以根据需要自己定义。如论坛分类与每个分类所对应的贴子相关联，商品分类与商品编码相关联等，可以根据需要来处理hbm文件。若需要多项关联，亦可扩展。如菜单与用户、部门、岗位分别进行关联

　　■hibernate2.1.7的一个bug，在这个测试源码的dao中，TreeManager的getRoots方法，
session.createQuery(" from " + cls.getName() + " where enabled=? and parent_id is null order by id");
在hibernate2中必须像写成parent_id is null，才能正确运行，这应该是2.1.7中的一个bug。而hibernate3中，可以使用parent is null的hsql。 

　　■主要代码：

　　继承关系如下，假如要实现国家分类：

CountryTree extends BaseTree(abstract class)
　　　　　　　　　　BaseTree(abstract class) implements Tree(interface)

　　为节省版面，下面代码去掉了javadoc

　　Tree.java 代码

1. /**  
2.  * 实现了树的基本操作，上溯、下溯、子节点的添加/移除和递归查找、对象关联等  
3.  */  
4. package test.testtree.base;   
5. import java.util.Set;   
6.   
7. public interface Tree {     
8.     public String getCode();   
9.     public String getName();   
10.     public String getDescription();   
11.     public Tree getParent();   
12.     public boolean isRoot();   
13.     public boolean isLeaf();   
14.     public boolean isParentOf(Tree tree);   
15.     public boolean isChildOf(Tree tree);   
16.     public void addChild(Tree tree);   
17.     public void rmChild(Tree tree);   
18.     public Set getAllChildren();   
19.     public Set getChildren();   
20.     public Set getAllLeaves();   
21.     public void addObject(Object obj);   
22.     public void rmObject(Object obj);   
23.     public Set getObjects();   
24.     public Long getId();   
25. }   

 

BaseTree.java代码

1. package test.testtree.base;   
2. import java.util.*;   
3.   
4. public abstract class BaseTree extends BasePojo implements Tree{        
5.     protected String code;       
6.     protected String name;       
7.     protected String description;           
8.     protected BaseTree parent;      
9.     protected Set children = new HashSet();       
10.     protected Set objects = new HashSet();       
11.     public void setCode(String code) {    
12.         this.code = code;   
13.     }       
14.     abstract public String getCode();   
15.     public void setName(String name) {    
16.         this.name = name;   
17.     }       
18.     abstract public String getName();       
19.     public void setDescription(String description) {    
20.         this.description = description;   
21.     }   
22.     abstract public String getDescription();   
23.     abstract public Tree getParent();           
24.     public boolean isRoot() {    
25.         return (getParent()==null);   
26.     }       
27.     public boolean isLeaf() {    
28.         return (this.getChildren().size()==0);   
29.     }       
30.     public boolean isParentOf(Tree tree) {    
31.         if (tree==null || ((BaseTree) tree).equals(this)) {    
32.             /*如果对方为空*/  
33.             return false;   
34.         }else if(this.isLeaf()){    
35.             /*如果自己为叶子,则返回FALSE*/  
36.             return false;   
37.         }else if(tree.isRoot()){    
38.             /*如果对方为根,返回FALSE*/  
39.             return false;   
40.         }else{    
41.             BaseTree bt = (BaseTree) (tree.getParent());   
42.             if (this.equals(bt)){    
43.                 /*如果对方的父节点是自己,则返回TRUE*/  
44.                 return true;   
45.             }else{    
46.                 /*判断对方的父节点是否是自己的孩子,进行递归*/  
47.                 return isParentOf(bt);   
48.             }   
49.         }   
50.     }   
51.     public boolean isChildOf(Tree tree) {    
52.         return (tree.isParentOf(this));   
53.     }   
54.     public void addChild(Tree tree) {    
55.         children.add(tree);   
56.     }   
57.     public void rmChild(Tree tree) {    
58.         children.remove(tree);   
59.         ((BaseTree) tree).setParent(null);   
60.     }   
61.     public Set getAllLeaves() {    
62.         Set set_old = this.getAllChildren();   
63.         Set set = new HashSet();   
64.         set.addAll(set_old);   
65.         Iterator itr = set_old.iterator();   
66.         while(itr.hasNext()){    
67.             BaseTree bt = (BaseTree) itr.next();   
68.             if (! bt.isLeaf()){    
69.                 set.remove(bt);   
70.             }   
71.         }   
72.         return set;   
73.     }           
74.     public Set getAllChildren() {    
75.         Set set = new HashSet();   
76.         Stack stack = new Stack();   
77.         stack.push(this);   
78.         while(!stack.empty()){    
79.             BaseTree bt = (BaseTree) stack.pop();   
80.             set.add(bt);   
81.             Iterator itr = bt.getChildren().iterator();   
82.             while(itr.hasNext()){    
83.                 BaseTree btchild = (BaseTree) itr.next();   
84.                 stack.push(btchild);   
85.             }   
86.         }   
87.         set.remove(this);   
88.         return set;   
89.     }       
90.     public List getMeAndListAllChildren() {            
91.         List lst = new Vector();   
92.         lst.add(this);   
93.         Iterator itr = this.getChildren().iterator();   
94.         while(itr.hasNext()){    
95.             BaseTree bt = (BaseTree) itr.next();   
96.             lst.addAll(bt.getMeAndListAllChildren());                  
97.         }           
98.         return lst;   
99.     }   
100.     abstract public Set getChildren();   
101.     public void addObject(Object obj) {    
102.         objects.add(obj);   
103.     }   
104.     public void rmObject(Object obj) {    
105.         objects.remove(obj);   
106.     }   
107.     abstract public Set getObjects();   
108.     public void setParent(Tree parent) {    
109.         this.parent = (BaseTree) parent;   
110.     }   
111.     public void setChildren(Set children) {    
112.         this.children = children;   
113.     }   
114.     public void setObjects(Set objects) {    
115.         this.objects = objects;   
116.     }       
117. }