hibernate生成树

1. package com.bjsxt.hibernate;
3. import java.util.Set;
5. public class Node {
7.     // 标识符
8.     private int id;
10.     // 节点名称
11.     private String name;
13.     // 层次
14.     private int level;
16.     // 是否叶子节点
17.     private boolean leaf;
19.     // 父节点 * --- 1
20.     private Node parent;
22.     // 子节点 1 --- *
23.     private Set children;
25.     public Set getChildren() {
26.         return children;
27.     }
29.     public void setChildren(Set children) {
30.         this.children = children;
31.     }
33.     public int getId() {
34.         return id;
35.     }
37.     public void setId(int id) {
38.         this.id = id;
39.     }
41.     public boolean isLeaf() {
42.         return leaf;
43.     }
45.     public void setLeaf(boolean leaf) {
46.         this.leaf = leaf;
47.     }
49.     public int getLevel() {
50.         return level;
51.     }
53.     public void setLevel(int level) {
54.         this.level = level;
55.     }
57.     public String getName() {
58.         return name;
59.     }
61.     public void setName(String name) {
62.         this.name = name;
63.     }
65.     public Node getParent() {
66.         return parent;
67.     }
69.     public void setParent(Node parent) {
70.         this.parent = parent;
71.     }
72. }

 

1.   <?xml version="1.0" ?> 
2.   <!DOCTYPE hibernate-mapping (View Source for full doctype...)> 
3. - <hibernate-mapping default-cascade="none" default-access="property" default-lazy="true" auto-import="true">
4. - <class name="com.bjsxt.hibernate.Node" table="t_node" mutable="true" polymorphism="implicit" dynamic-update="false" dynamic-insert="false" select-before-update="false" optimistic-lock="version">
5. - <id name="id">
6.   <generator class="native" /> 
7.   </id>
8.   <property name="name" unique="false" optimistic-lock="true" lazy="false" generated="never" /> 
9.   <property name="level" unique="false" optimistic-lock="true" lazy="false" generated="never" /> 
10.   <property name="leaf" unique="false" optimistic-lock="true" lazy="false" generated="never" /> 
11.   <many-to-one name="parent" column="pid" unique="false" update="true" insert="true" optimistic-lock="true" not-found="exception" embed-xml="true" /> 
12. - <set name="children" lazy="extra" inverse="true" sort="unsorted" mutable="true" optimistic-lock="true" embed-xml="true">
13.   <key column="pid" on-delete="noaction" /> 
14.   <one-to-many class="com.bjsxt.hibernate.Node" not-found="exception" embed-xml="true" /> 
15.   </set>
16.   </class>
17.   </hibernate-mapping>

 

1. package com.bjsxt.hibernate;
3. import java.io.File;
4. import java.util.Iterator;
5. import java.util.Set;
7. import org.hibernate.Session;
9. public class NodeManager {
11.     private static NodeManager nodeManager;
13.     private NodeManager() {
14.     }
16.     public static synchronized NodeManager getInstance() {
17.         if (nodeManager == null) {
18.             nodeManager = new NodeManager();
19.         }
21.         return nodeManager;
22.     }
24.     // 创建树型结构
25.     public void createTree(String dir) {
26.         Session session = HibernateUtils.getSession();
28.         try {
29.             session.beginTransaction();
31.             File root = new File(dir);
32.             saveTree(root, session, null, 0);
34.             session.getTransaction().commit();
35.         } catch (RuntimeException e) {
36.             e.printStackTrace();
37.             session.getTransaction().rollback();
38.         } finally {
39.             HibernateUtils.closeSession(session);
40.         }
41.     }
43.     // 递归创建一棵树
44.     private void saveTree(File file, Session session, Node parent, int level) {
46.         if (file == null || !file.exists()) {
47.             return;
48.         }
50.         boolean isLeaf = file.isFile();
52.         Node node = new Node();
53.         node.setName(file.getName());
54.         node.setLevel(level);
55.         node.setParent(parent);
56.         node.setLeaf(isLeaf);
57.         session.save(node);
59.         File[] subs = file.listFiles();
60.         if (subs != null && subs.length > 0) {
61.             for (int i = 0; i < subs.length; i++) {
62.                 saveTree(subs[i], session, node, level + 1);
63.             }
64.         }
65.     }
67.     public void printTree(int id) {
68.         Session session = HibernateUtils.getSession();
70.         try {
71.             session.beginTransaction();
73.             Node root = (Node) session.load(Node.class, id);
74.             printNode(root);
76.             session.getTransaction().commit();
77.         } catch (RuntimeException e) {
78.             e.printStackTrace();
79.             session.getTransaction().rollback();
80.         } finally {
81.             HibernateUtils.closeSession(session);
82.         }
83.     }
85.     private void printNode(Node node) {
87.         if (node == null) {
88.             return;
89.         }
90.         int level = node.getLevel();
91.         if (level > 0) {
92.             for (int i = 0; i < level; i++) {
93.                 System.out.print("  |");
94.             }
95.             System.out.print("--");
96.         }
98.         System.out.println(node.getName()
99.                 + (node.isLeaf() ? "" : "[" + node.getChildren().size() + "]"));
101.         Set children = node.getChildren();
102.         for (Iterator iter = children.iterator(); iter.hasNext();) {
103.             Node child = (Node) iter.next();
104.             printNode(child);
105.         }
106.     }
107. }