第四节：班级学生一对多映射实现（双向）
查询班级的时候能够获取所有的学生；
在上一节的基础之上；我们在Class端也保存学生的关系；
com.cy.model.Class:
public class Class {
private long id;
private String name;
private Set<Student> students = new HashSet<Student>();
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Set<Student> getStudents() {
return students;
}
public void setStudents(Set<Student> students) {
this.students = students;
}
}
Class.hbm.xml:
<hibernate-mapping package="com.cy.model">
<class name="Class" table="t_class">
<id name="id" column="classId">
<generator class="identity"></generator>
</id>
<property name="name" column="className"></property>
<set name="students" cascade="save-update">
<!-- key外键，column是对应Student表的外键classId
就是many-to-one中的column；
-->
<key column="classId"></key>
<!-- class就是students属性，对应的集合中装的类Student -->
<one-to-many class="com.cy.model.Student"/>
</set>
</class>
</hibernate-mapping>
com.cy.model.Student还和之前一样：
package com.cy.model;
public class Student {
private long id;
private String name;
private Class c;
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Class getC() {
return c;
}
public void setC(Class c) {
this.c = c;
}
@Override
public String toString() {
return "Student [id=" + id + ", name=" + name + "]";
}
}
Student.hbm.xml还和之前一样：
<hibernate-mapping package="com.cy.model">
<class name="Student" table="t_student">
<id name="id" column="stuId">
<generator class="identity"></generator>
</id>
<property name="name" column="stuName"></property>
<many-to-one name="c" column="classId" class="com.cy.model.Class" cascade="save-update"></many-to-one>
</class>
</hibernate-mapping>
测试代码StudentTest:
@Test
public void testSaveClassAndStudent() {
Class c = new Class();
c.setName("08计本"); Student s1 = new Student();
s1.setName("张三");
Student s2 = new Student();
s2.setName("李四"); c.getStudents().add(s1);
c.getStudents().add(s2); //这里因为保存Class时，class引用了临时状态的s1、s2；会保存失败
//必须在Class.hbm.xml中配置<set name="students" cascade="save-update"级联保存更新才可以。
session.save(c);
} /**
* 通过班级端，查找学生
*/
@Test
public void getStudentsByClass() {
Class c = (Class) session.get(Class.class, Long.valueOf(2));
Set<Student> students = c.getStudents(); Iterator<Student> it = students.iterator();
while(it.hasNext()){
Student s = it.next();
System.out.println(s);
} //Student [id=1, name=李四]
//Student [id=2, name=张三]
}
保存成功！查询成功！
发出的sql：
第五节：inverse 属性
inverse属性主要是在一对多、多对一双向关系中，由一端来维护主外键关系；
测试代码：
@Test
public void testAdd(){
Class c=new Class();
c.setName("09计本"); Student s1=new Student();
s1.setName("王五"); session.save(c);
session.save(s1);
} @Test
public void testInverse(){
/**
* Class和Student都是从session中获取的，都已经是持久化对象；
* 对着两个持久化对象进行学生设置班级、班级也设置学生
* 持久化对象设置关系，hibernate session检测到之后就会进行持久化操作（同步数据库）
*/
Class c=(Class)session.get(Class.class, Long.valueOf(1));
Student s=(Student)session.get(Student.class, Long.valueOf(1)); s.setC(c);
c.getStudents().add(s); /**
* 可以看到学生设置班级、班级添加学生，两端都维护了这个关系，都维护了这个外键。
引入inverse属性，只在某一端维护这个主外键关系。通常是在多的一端（one-to-many）设置inverse属性。
这里就是在学生Student端添加inverse=true属性
*/
}
1.先执行testAdd，再执行testInverse：
由于对student、class两个持久化的对象进行，互设关系的操作，hibernate session检测到之后就会进行持久化操作（同步数据库）：
确实数据库发现已经设置了外键关系，打印：
两端都来维护这个关系，发出两条sql语句，有点冗余，引入inverse：
Class.hbm.xml:
<hibernate-mapping package="com.cy.model">
<class name="Class" table="t_class">
<id name="id" column="classId">
<generator class="identity"></generator>
</id>
<property name="name" column="className"></property>
<set name="students" cascade="save-update" inverse="true">
<!-- key外键，column是对应Student表的外键classId
就是many-to-one中的column；
-->
<key column="classId"></key>
<!-- class就是students属性，对应的集合中装的类Student -->
<one-to-many class="com.cy.model.Student"/>
</set>
</class>
</hibernate-mapping>
2.再次先执行testAdd，再执行testInverse：
只有一条sql了，只在多的一方来维护这个外键关系；
第六节：级联删除
删除班级的时候，我们把学生也删掉；
/**
* 级联删除
* 删除班级的时候，级联删除学生
*/
@Test
public void testDeleteClassCascade(){
Class c=(Class)session.get(Class.class, Long.valueOf(1));
session.delete(c);
}
默认是不能级联删除的，因为删除class的时候，classId被student表外键关联；
会报错：
设置cascade=delete就可以级联删除了；
修改Class.hbm.xml配置如下：
<hibernate-mapping package="com.cy.model">
<class name="Class" table="t_class">
<id name="id" column="classId">
<generator class="identity"></generator>
</id>
<property name="name" column="className"></property>
<set name="students" cascade="delete" inverse="true">
<key column="classId"></key>
<one-to-many class="com.cy.model.Student"/>
</set>
</class>
</hibernate-mapping>
console：
注：级联删除是一个危险的操作，企业开发一般是不允许的；很可能导致其他业务数据的丢失。。。
第七节：一对多双向自身关联关系映射
例如使用在菜单上，使用节点来模拟：
com.cy.model.Node：
package com.cy.model; import java.util.HashSet;
import java.util.Set; public class Node {
private long id;
private String name; private Node parentNode; //它的父节点
private Set<Node> childNodes = new HashSet<Node>(); //它的子节点 public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Node getParentNode() {
return parentNode;
}
public void setParentNode(Node parentNode) {
this.parentNode = parentNode;
}
public Set<Node> getChildNodes() {
return childNodes;
}
public void setChildNodes(Set<Node> childNodes) {
this.childNodes = childNodes;
} }
Node.hbm.xml:
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.cy.model">
<class name="Node" table="t_node">
<id name="id" column="nodeId">
<generator class="native"></generator>
</id>
<property name="name" column="nodeName"></property> <many-to-one name="parentNode" column="parentId" class="com.cy.model.Node" cascade="save-update"></many-to-one> <set name="childNodes" inverse="true">
<key column="parentId"></key>
<one-to-many class="com.cy.model.Node"/>
</set>
</class>
</hibernate-mapping>
将Node.hbm.xml加入hibernate.cfg.xml中mapping配置；
测试代码：
package com.cy.service; import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.junit.After;
import org.junit.Before;
import org.junit.Test; import com.cy.model.Node;
import com.cy.util.HibernateUtil; public class NodeTest {
private SessionFactory sessionFactory = HibernateUtil.getSessionFactory();
private Session session; @Before
public void setUp() throws Exception {
session = sessionFactory.openSession();
session.beginTransaction();
} @After
public void tearDown() throws Exception {
session.getTransaction().commit();
session.close();
} @Test
public void testSaveMenu() {
Node node=new Node();
node.setName("根节点"); Node subNode1=new Node();
subNode1.setName("子节点1"); Node subNode2=new Node();
subNode2.setName("子节点2"); subNode1.setParentNode(node);
subNode2.setParentNode(node); session.save(subNode1);
session.save(subNode2);
}
}
结果：
