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

最新推荐文章于 2018-07-16 22:52:54 发布
转载 最新推荐文章于 2018-07-16 22:52:54 发布 · 927 阅读 · 1
文章标签：

#hibernate #tree #hsqldb #null #interface #javadoc

本文介绍了一种使用Hibernate实现的树形结构处理方法，适用于树形菜单、组织结构等多种场景。该方法支持树的基本操作，如上溯、下溯、子节点的添加/移除等。
 
关键字:   hibernate    

　　在系统中，经常会用到无限级的树形结构分类，如组织机构管理、商品/地区分类等等。在以前的一个贴子：http://www.javaeye.com/topic/26987“复杂商品分类的表如何建立？”中，讨论过树形无级分类的实现方法。

一般无外采用两种方式，
　　一是类似struts-menu（http://struts-menu.sourceforge.net）的XML文件管理方式，配置起来比较方便，但很难与系统中其它应用数据集成；
　　二是使用数据库存储，定义父子关系。

在我们现在开发的一个产品中，使用hibernate实现了一套树形结构的处理方法，实现了树的基本操作，上溯、下溯、子节点的添加/移除和递归查找、对象关联等。简介如下：
■适用范围，具有树形特征的所有对象，如树形菜单、组织结构、信息分类、论坛主贴与回复等。
■演示地址：http://219.143.69.2:8000/treetest/menumanage.do?todoaction=list
演示的是系统菜单的层次实现。由于菜单本身属于权限系统的一部分，存储在数据库中后可以方便的与部门、用户、岗位、职务等进行关联，并进行权限控制。
■完整源码下载（内置了hsql数据库及测试数据，正式使用时请将war置于APPSERVER的webapps目录下，修改解包 后的WEB-INF/classes/hibernate.cfg.xml，编辑其中hsqldb的物理路径。如jdbc:hsqldb:file:c: /tomcat5/webapps/treetest/db/test）：http://219.143.69.2:8000/treetest/treetest.war
，运行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

代码
  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 Set getParents();  
  13.     public boolean isRoot();  
  14.     public boolean isLeaf();  
  15.     public boolean isParentOf(Tree tree);  
  16.     public boolean isChildOf(Tree tree);  
  17.     public void addChild(Tree tree);  
  18.     public void rmChild(Tree tree);  
  19.     public Set getAllChildren();  
  20.     public Set getChildren();  
  21.     public Set getAllLeaves();  
  22.     public void addObject(Object obj);  
  23.     public void rmObject(Object obj);  
  24.     public Set getObjects();  
  25.     public Long getId();  
  26. }  

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 getParents(){  
  75.         Set parents = new HashSet();          
  76.         Tree p = this.getParent();  
  77.         if(p!=null){  
  78.             parents.add(p);  
  79.             parents.addAll(p.getParents());  
  80.         }  
  81.         return parents;  
  82.     }  
  83.   
  84.     public Set getAllChildren() {  
  85.         Set set = new HashSet();  
  86.         Stack stack = new Stack();  
  87.         stack.push(this);  
  88.         while(!stack.empty()){  
  89.             BaseTree bt = (BaseTree) stack.pop();  
  90.             set.add(bt);  
  91.             Iterator itr = bt.getChildren().iterator();  
  92.             while(itr.hasNext()){  
  93.                 BaseTree btchild = (BaseTree) itr.next();  
  94.                 stack.push(btchild);  
  95.             }  
  96.         }  
  97.         set.remove(this);  
  98.         return set;  
  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. }  
最后更新：2006-12-31 13:24
nickshen3
关注
Hibernate映射树形结构
04-22
NULL 博文链接：https://cdxs2.iteye.com/blog/1934896
Hibernate 单表实现树结构
03-28
NULL 博文链接：https://dreamzhong.iteye.com/blog/1256055
Hibernate表现树状结构
chenggil10的专栏
09-30 1693
package com.bjsxt.hibernate; import java.util.HashSet; import java.util.Set; import javax.persistence.CascadeType; import javax.persistence.Entity; import javax.persistence.FetchType; import javax.persistence.GeneratedValue; import javax.persist
[转载]使用hibernate实现树形结构无限级分类
05-30
针对你的问题，我可以告诉你如何使用Hibernate实现树形结构无限级分类。 首先，你需要在实体类中定义一个父级ID属性，用于表示该节点的父级节点。例如： ``` @Entity @Table(name = "category") public class ...
Java实现无限级分类树形结构及MySQL数据库连接教程
在前端展示无限级分类树形结构时，通常会使用AJAX（Asynchronous JavaScript and XML）技术实现异步刷新。这意味着不需要重新加载整个页面，就能从服务器获取最新的数据，并更新到当前页面的特定部分。这样能够提升...
Hibernate第十二讲 树形结构
三丰的专栏
03-20 849
package com.bjsxt.hibernate; import java.util.HashSet; import java.util.Set; import javax.persistence.CascadeType; import javax.persistence.Entity; import javax.persistence.FetchType; im
无限极树(1.0)
LYQ2332826438的博客
07-16 287
在权限实体类中写一个递归的方法 StringBuffer sb1=new StringBuffer(); StringBuffer sb=new StringBuffer(); /** * 递归实现无限级分类 * @param parentID * @return StringBuffer */ public StringBuffer getNodes1(S...
Hibernate（七）：继承映射
努力找工作呀
08-08 360
继承是面向对象的特性，在Hibernate 中是以面向对象的思想进行持久化操作，所以在Hibernate中数据表所映射的实体对象也是可以存在继承关系的。主要有三种继承关系： 1.类继承树映射成一张表（subclass）      将域模型中的每一个实体对象映射到一个独立的表中，也就是说不用在关系数据模型中考虑域模型中的继承和多态。 （1）使用subclass的继承映射可以实现继关系中父类和子
hibernate树形结构
黄方 （舞动的心弦） 的专栏
09-12 1007
树形结构：也就是目录结构，有父目录、子目录、文件等信息，而在程序中树形结构只是称为节点。 一棵树有一个根节点，而根节点也有一个或多个子节点，而一个子节点有且仅有一个父节点(当前除根节点外)，而且也存在一个或多个子节点。 也就是说树形结构，重点就是节点，也就是我们需要关心的节点对象。 节点：一个节点有一个ID、一个名称、它所属的父节点(根节点无父节点或为null)，有一个或多的子节点等其它信息
Hibernate之树状结构设计
qq30211478的博客
09-18 1216
（一）在系统中，经常会用到无限级递归的树形结构，比如菜单、组织机构管理、多级分类等等，一般是在同一个表中定义父子关系实现这种树形结构。 （二）对于父类来说，它与子类的关系是一对多；对于子类来说，它与父类的关系是多对一。由于父类和子类都存在对方的对象引用，因此它们之间的关系是一对多，多对一之间的双向关联。因此需要设置mappedby，以及测试代码中的父类与子类、子类与父类之间的关系都要设置好。
Hibernate 树状映射
chilllaxxx的博客
11-25 1534
目录： 概述环境代码示例测试结果 [一]、概述 在系统中，经常会用到无限级递归的树形结构，比如菜单、组织机构管理、多级分类等等，一般是在同一个表中定义父子关系实现这种树形结构，本文主要讲述如何运用hibernate全注解的方式实现这个功能。 [二]、环境 hibernate 4.1.2java 1.6mysql 5.1 [三]、代码示例 第一步：创建Entity类，并添加注解
【hibernate框架】练习-树状结构设计(非常重要)
weixin_33919950的博客
02-22 185
作业：树状结构的设计 在同一个类中使用OneToMany和ManyToOne 首先想数据库的模型，再想面向对象的模型，然后再来想怎么去做映射，做完映射在想怎么去做CRUD。 1.首先设计数据库的模型 应该是Id、parent_Id.单一父亲，好多孩子这就是一棵树。 数据库首先存在的属性有： Id<int> parent_Id<int&...
Hibernate注解实现单表递归树形结构
热门推荐
budapest的专栏
09-09 1万+
目录： 概述环境代码示例测试结果 [一]、概述 在系统中，经常会用到无限级递归的树形结构，比如菜单、组织机构管理、多级分类等等，一般是在同一个表中定义父子关系实现这种树形结构，本文主要讲述如何运用hibernate全注解的方式实现这个功能。 [二]、环境 hibernate 4.1.2java 1.6mysql 5.1 [三]、代码示例 第一步：创建Entity类，并添加注解
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值