详解Hibernate树形结构

本文向大家介绍Hibernate树形结构，可能好多人还不了解Hibernate树形结构，没有关系，看完本文你肯定有不少收获，希望本文能教会你更多东西。

创新互联建站专业提供西部信息中心服务，为用户提供五星数据中心、电信、双线接入解决方案，用户可自行在线购买西部信息中心服务，并享受7*24小时金牌售后服务。

在系统中，经常会用到无限级的Hibernate树形结构分类，如组织机构管理、商品/地区分类等等。一般无外采用两种方式：
◆一是类似struts-menu的XML文件管理方式，配置起来比较方便，但很难与系统中其它应用数据集成；
◆二是使用数据库存储，定义父子关系。

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

一.Hibernate树形结构显示

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

二.关联关系：

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

三.主要代码：

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

【编辑推荐】

  1. 描述Hibernate持久性类
  2. 分析Java应用程序和Hibernate
  3. Hibernate3和JBOSS 3.2强强联手
  4. 详解Hibernate.properties文件
  5. 浅谈定制Hibernate映射

分享题目：详解Hibernate树形结构
当前地址：http://www.shufengxianlan.com/qtweb/news20/2220.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

虚拟主机知识

同城分类信息

什邡网站建设　　 　江油网站建设　　 　江油网站建设　　 　成都网站建设　　 　成都网站运营维护　　 　成都网站设计制作公司　　 　网站seo优化　　 　橡塑保温板　　 　内江智速网站建设　　 　网站制作价格　　 　软文营销　　 　内江广告　　 　达州网站设计　　 　东电技服　　 　泸州网站建设　　 　全网营销推广　　 　主机租用　　 　网站维护报价　　 　成都广告制作　　 　古蔺网站建设