hibernate树形结构_hibernate 树形结构-CSDN博客

本文链接：https://blog.csdn.net/javahuangfang/article/details/7972239

树形结构：也就是目录结构，有父目录、子目录、文件等信息，而在程序中树形结构只是称为节点。
一棵树有一个根节点，而根节点也有一个或多个子节点，而一个子节点有且仅有一个父节点(当前除根节点外)，而且也存在一个或多个子节点。
也就是说树形结构，重点就是节点，也就是我们需要关心的节点对象。
节点：一个节点有一个ID、一个名称、它所属的父节点(根节点无父节点或为null)，有一个或多的子节点等其它信息。
Hibernate将节点抽取出成实体类，节点相对于父节点是“多对一”映射关系，节点相对于子节点是“一对多”映射关系。
一、节点实体类：
[java]
/** * 节点*/
public class Node {
private int id; //标识符
private String name; //节点名称
private int level; //层次，为了输出设计
private boolean leaf; //是否为叶子节点，这是为了效率设计，可有可无
//父节点：因为多个节点属于一个父节点，因此用hibernate映射关系说是“多对一”
private Node parent;
//子节点：因为一个节点有多个子节点，因此用hibernate映射关系说是“一对多”
private Set children;

public int getId() {return id;}
public void setId(int id) {this.id = id;}
public String getName() {return name;}
public void setName(Stringname) { this.name = name;}
public int getLevel() { return level;}
public void setLevel(int level) {this.level = level;}
public boolean isLeaf() {return leaf;}
public void setLeaf(boolean leaf) {this.leaf = leaf;}
public Node getParent() {return parent;}
public void setParent(Nodeparent) {this.parent = parent;}
public SetgetChildren() {return children;}
public void setChildren(Setchildren) {this.children = children;}
}

二、 xml方式：映射文件：

[html]
<class name="com.wjt276.hibernate.Node" table="t_node">
<id name="id" column="id">
<generator class="native"/>
</id>
<property name="name"/>
<property name="level"/>
<property name="leaf"/>
<!— 一对多：加入一个外键，参照当前表t_node主键，而属性parent类型为Node，也就是当前类，则会在同一个表中加入这个字段，参照这个表的主键-->
<many-to-one name="parent" column="pid"/>

<set name="children" lazy="extra"inverse="true">
<key column="pid"/>
<one-to-many class="com.wjt276.hibernate.Node"/>
</set>
</class>

三、 annotation注解
因为树型节点所有的数据，在数据库中只是存储在一个表中，而对于实体类来说，节点对子节点来说是一对多的关系，而对于父节点来说是多对一的关系。因此可以在一个实体类中注解。如下
[java]
@Entity
public class Node {
private int id; // 标识符
private String name; // 节点名称
private int level; // 层次，为了输出设计
private boolean leaf; // 是否为叶子节点，这是为了效率设计，可有可无
// 父节点：因为多个节点属于一个父节点，因此用hibernate映射关系说是“多对一”
private Node parent;
// 子节点：因为一个节点有多个子节点，因此用hibernate映射关系说是“一对多”
private Set<Node> children = newHashSet<Node>();
@Id
@GeneratedValue
public int getId() {return id;}
@OneToMany(mappedBy="parent")
public Set<Node>getChildren() {return children;}
@ManyToOne
@JoinColumn(name="pid")
public Node getParent() {return parent;}
}

四、测试代码：
[java]
public class NodeTest extends TestCase {
//测试节点的存在
public void testSave1(){
NodeManage.getInstanse().createNode("F:\\hibernate\\hibernate_training_tree");
}
//测试节点的加载
public void testPrintById(){
NodeManage.getInstanse().printNodeById(1);
}}

五、相应的类代码：
[java]
public classNodeManage {
private static NodeManage nodeManage= newNodeManage();
private NodeManage(){}//因为要使用单例，所以将其构造方法私有化
//向外提供一个接口
public static NodeManage getInstanse(){
return nodeManage;
}
/**
* 创建树
*@param filePath 需要创建树目录的根目录
*/
public void createNode(String dir) {
Session session = null;
try {
session =HibernateUtils.getSession();
session.beginTransaction();

File root = new File(dir);
//因为第一个节点无父节点，因为是null
this.saveNode(root, session, null,0);

session.getTransaction().commit();
} catch (HibernateException e) {
e.printStackTrace();
session.getTransaction().rollback();
} finally {
HibernateUtils.closeSession(session);
}}
/**
* 保存节点对象至数据库
*@param file 节点所对应的文件
*@param session session
*@param parent 父节点
*@param level 级别
*/
public void saveNode(File file, Sessionsession, Node parent, int level) {
if (file == null ||!file.exists()){return;}
//如果是文件则返回true,则表示是叶子节点，否则为目录，非叶子节点
boolean isLeaf = file.isFile();
Node node = new Node();
node.setName(file.getName());
node.setLeaf(isLeaf);
node.setLevel(level);
node.setParent(parent);

session.save(node);

//进行循环迭代子目录
File[] subFiles = file.listFiles();
if (subFiles != null &&subFiles.length > 0){
for (int i = 0; i <subFiles.length ; i++){
this.saveNode(subFiles[i],session, node, level + 1);
}}}
/**
* 输出树结构
*@param id
*/
public void printNodeById(int id) {

Session session = null;

try {
session =HibernateUtils.getSession();
session.beginTransaction();

Node node =(Node)session.get(Node.class, 1);

printNode(node);

session.getTransaction().commit();
} catch (HibernateException e) {
e.printStackTrace();
session.getTransaction().rollback();
} finally {
HibernateUtils.closeSession(session);
}
}
private void printNode(Node node) {
if (node == null){ return; }
int level = node.getLevel();
if (level > 0){
for (int i = 0; i < level; i++){
System.out.print(" |");
}
System.out.print("--");
}
System.out.println(node.getName() +(node.isLeaf() ? "" : "[" + node.getChildren().size() +"]"));
Set children = node.getChildren();
for (Iterator iter =children.iterator(); iter.hasNext(); ){
Node child = (Node)iter.next();
printNode(child);
}}}

作业-学生、课程、分数的映射关系
一、设计
1、实体类(表)
2、导航(编程方便)
a) 通过学生取出学生所先的课程
b) 但是通过课程取出学该课程的学生不好。学的学生太多
c) 确定编程的方式
3、可以利用联合主键映射可以，
a) 学生生成一个表
b) 课程生成一个表
c) 再生成一个表，主键是联合主键(学生ID、课程ID) + 学生共生成一个表
4、也可以利用一对多，多对多都可以(推荐)
a) 学生生成一个表
b) 课程生成一个表
c) 分数生成一个表，并且有两个外键，分别指向学生、课程表
二、代码：
* 课程
[java]
@Entity
public class Course {
private int id;
private String name;
@Id
@GeneratedValue
public int getId() {return id;}
public void setId(int id) { this.id = id;}
public String getName() {return name;}
public void setName(Stringname) {this.name = name;}
}

* 分数
[java]
@Entity
@Table(name = "score")
public class Score {
private int id;
private int score;
private Student student;
private Course course;
@Id
@GeneratedValue
public int getId() {return id;}
@ManyToOne
@JoinColumn(name = "student_id")
public StudentgetStudent() {return student;}
@ManyToOne
@JoinColumn(name = "score_id")
public Course getCourse(){ return course;}
public int getScore() { return score;}
public void setScore(int score) {this.score = score;}
public void setStudent(Studentstudent) {this.student = student;}
public void setCourse(Coursecourse) {this.course = course;}
public void setId(int id) { this.id = id;}
}

* 学生通过课程可以导航到分数
[java]
@Entity
public class Student {
private int id;
private String name;
private Set<Course> courses = newHashSet<Course>();
@Id
@GeneratedValue
public int getId() {return id;}
@ManyToMany
@JoinTable(name = "score", //此表就是Score实体类在数据库生成的表叫score
joinColumns= @JoinColumn(name = "student_id"),
inverseJoinColumns= @JoinColumn(name = "course_id")
)
public Set<Course>getCourses() {return courses;}
public voidsetCourses(Set<Course> courses) {this.courses = courses;}
public void setId(int id) { this.id = id;}
public String getName() {return name;}
public void setName(Stringname) {this.name = name;}
}