使用hibernate實現樹形結構無限級分類

在系統中，常常會用到無限級的樹形結構分類，如組織機構管理、商品/地區分類等等。在之前的一個貼子：http://www.iteye.com/topic/26987「複雜商品分類的表如何創建？」中，討論過樹形無級分類的實現方法。

通常無外採用兩種方式，
　　一是相似struts-menu（http://struts-menu.sourceforge.net）的XML文件管理方式，配置起來比較方便，但很難與系統中其它應用數據集成；
　　二是使用數據庫存儲，定義父子關係。

在咱們如今開發的一個產品中，使用hibernate實現了一套樹形結構的處理方法，實現了樹的基本操做，上溯、下溯、子節點的添加/移除和遞歸查找、對象關聯等。簡介以下：
■適用範圍，具備樹形特徵的全部對象，如樹形菜單、組織結構、信息分類、論壇主貼與回覆等。
■完整源碼下載（內置了hsql數據庫及測試數據，正式使用時請將war置於APPSERVER的 webapps目錄下，修改解包後的WEB-INF/classes/hibernate.cfg.xml，編輯其中hsqldb的物理路徑。如 jdbc:hsqldb:file:c:\tomcat5\webapps\treetest\db\test）見附件，運行 http://ServerName:ServerPort/treetest/menumanage.do。
■樹形結構顯示，使用的是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

/**
 * 實現了樹的基本操做，上溯、下溯、子節點的添加/移除和遞歸查找、對象關聯等
 */
package test.testtree.base;
import java.util.Set;

public interface Tree {
    public String getCode();
    public String getName();
    public String getDescription();
    public Tree getParent();
    public Set getParents();
    public boolean isRoot();
    public boolean isLeaf();
    public boolean isParentOf(Tree tree);
    public boolean isChildOf(Tree tree);
    public void addChild(Tree tree);
    public void rmChild(Tree tree);
    public Set getAllChildren();
    public Set getChildren();
    public Set getAllLeaves();
    public void addObject(Object obj);
    public void rmObject(Object obj);
    public Set getObjects();
    public Long getId();
}

BaseTree.java

package test.testtree.base;
import java.util.*;

public abstract class BaseTree extends BasePojo implements Tree{
    protected String code;
    protected String name;
    protected String description;
    protected BaseTree parent;
    protected Set children = new HashSet();
    protected Set objects = new HashSet();
    public void setCode(String code) {
        this.code = code;
    }
    abstract public String getCode();
    public void setName(String name) {
        this.name = name;
    }
    abstract public String getName();
    public void setDescription(String description) {
        this.description = description;
    }
    abstract public String getDescription();
    abstract public Tree getParent();
    public boolean isRoot() {
        return (getParent()==null);
    }
    public boolean isLeaf() {
        return (this.getChildren().size()==0);
    }
    public boolean isParentOf(Tree tree) {
        if (tree==null || ((BaseTree) tree).equals(this)) {
            /*若是對方爲空*/
            return false;
        }else if(this.isLeaf()){
            /*若是本身爲葉子,則返回FALSE*/
            return false;
        }else if(tree.isRoot()){
            /*若是對方爲根,返回FALSE*/
            return false;
        }else{
            BaseTree bt = (BaseTree) (tree.getParent());
            if (this.equals(bt)){
                /*若是對方的父節點是本身,則返回TRUE*/
                return true;
            }else{
                /*判斷對方的父節點是不是本身的孩子,進行遞歸*/
                return isParentOf(bt);
            }
        }
    }
    public boolean isChildOf(Tree tree) {
        return (tree.isParentOf(this));
    }
    public void addChild(Tree tree) {
        children.add(tree);
    }
    public void rmChild(Tree tree) {
        children.remove(tree);
        ((BaseTree) tree).setParent(null);
    }
    public Set getAllLeaves() {
        Set set_old = this.getAllChildren();
        Set set = new HashSet();
        set.addAll(set_old);
        Iterator itr = set_old.iterator();
        while(itr.hasNext()){
            BaseTree bt = (BaseTree) itr.next();
            if (! bt.isLeaf()){
                set.remove(bt);
            }
        }
        return set;
    }
   public Set getParents(){
        Set parents = new HashSet();
        Tree p = this.getParent();
        if(p!=null){
            parents.add(p);
            parents.addAll(p.getParents());
        }
        return parents;
    }

    public Set getAllChildren() {
        Set set = new HashSet();
        Stack stack = new Stack();
        stack.push(this);
        while(!stack.empty()){
            BaseTree bt = (BaseTree) stack.pop();
            set.add(bt);
            Iterator itr = bt.getChildren().iterator();
            while(itr.hasNext()){
                BaseTree btchild = (BaseTree) itr.next();
                stack.push(btchild);
            }
        }
        set.remove(this);
        return set;
    }
    abstract public Set getChildren();
    public void addObject(Object obj) {
        objects.add(obj);
    }
    public void rmObject(Object obj) {
        objects.remove(obj);
    }
    abstract public Set getObjects();
    public void setParent(Tree parent) {
        this.parent = (BaseTree) parent;
    }
    public void setChildren(Set children) {
        this.children = children;
    }
    public void setObjects(Set objects) {
        this.objects = objects;
    }
}