一对多也是分为两种：
- 单向一对多
- 双向一对多
先来看一下公用的实体类
classes实体类
package entity;
import java.util.Set;
public class Classes {
private int id;
private String className;
private Set<Student> student;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getClassName() {
return className;
}
public void setClassName(String className) {
this.className = className;
}
public Set<Student> getStudent() {
return student;
}
public void setStudent(Set<Student> student) {
this.student = student;
}
}
student实体类（单向的时候没有class这个属性）
package entity;
public class Student {
private int id;
private String name;
private Classes classes;
public Classes getClasses() {
return classes;
}
public void setClasses(Classes classes) {
this.classes = classes;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
单向一对多
classes.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="entity">
<class name="Classes" dynamic-update="true" >
<id name="id">
<generator class="native"/>
</id>
<property name="className" />
<set name="student" cascade="delete">
<!-- 这里的column是指数据库中student表中会添加外键classid，关联classes表的主键 -->
<key column="classid"></key>
<one-to-many class="Student" />
</set>
</class>
</hibernate-mapping>
student.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="entity">
<class name="Student" dynamic-update="true">
<id name="id">
<generator class="native"/>
</id>
<property name="name" />
</class>
</hibernate-mapping>
单元测试：
package entity;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import org.hibernate.classic.Session;
import junit.framework.TestCase;
import util.hibernateUtil;
/**
* 单向一对多（项目名称写错了，应该是一对多）
* 测试目的：
* 1. 新增数据，是否会级联保存？什么时候发出sql语句？
* 2. 查询数据，会不会级联查询？
* 3. 删除数据，会不会级联删除？
* @author arkulo
*
*/
public class testManytoone extends TestCase {
// 新增数据
public void test1() {
Session session = null;
try {
session = hibernateUtil.getSession();
session.beginTransaction();
Student st1 = new Student();
st1.setName("张三");
Student st2 = new Student();
st2.setName("李四");
Student st3 = new Student();
st3.setName("王五");
// 这里必须先保存三个student，否则它们没有ID，最后会抛异常
// 这是sql执行的顺序
// Hibernate: insert into Student (name) values (?)
// Hibernate: insert into Student (name) values (?)
// Hibernate: insert into Student (name) values (?)
// Hibernate: insert into Classes (className) values (?)
// Hibernate: update Student set classid=? where id=?
// Hibernate: update Student set classid=? where id=?
// Hibernate: update Student set classid=? where id=?
session.save(st1);
session.save(st2);
session.save(st3);
// 这属于在one的一方维护关系
Set<Student> set = new HashSet<Student>();
set.add(st1);
set.add(st2);
set.add(st3);
Classes cl = new Classes();
cl.setClassName("一年级三班");
cl.setStudent(set);
session.save(cl);
session.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
} finally {
hibernateUtil.closeSession(session);
}
}
// 查询数据
public void test2() {
test1();
System.out.println("-------------------------------------------------");
Session session = null;
try {
session = hibernateUtil.getSession();
session.beginTransaction();
// 发出两条sql语句
// 如果没有缓存的情况下，这里的iterate会产生n+1问题
Iterator st = session.createQuery("from Classes").iterate();
while (st.hasNext()) {
Classes cl = (Classes) st.next();
System.out.println("班级：" + cl.getClassName());
Set<Student> students = cl.getStudent();
Iterator<Student> it = students.iterator();
while (it.hasNext()) {
Student s = it.next();
System.out.println("用户名：" + s.getName());
}
}
session.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
} finally {
hibernateUtil.closeSession(session);
}
}
// 删除数据
public void test3() {
test1();
System.out.println("-------------------------------------------------");
Session session = null;
try {
session = hibernateUtil.getSession();
session.beginTransaction();
// 再不设置级联的情况下，删除classes，是否会删除student的记录
Classes cl = (Classes) session.get(Classes.class, 1);
System.out.println("班级名称:" + cl.getClassName());
Set<Student> students = cl.getStudent();
Iterator<Student> it = students.iterator();
while (it.hasNext()) {
Student s = it.next();
System.out.println("学生姓名：" + s.getName());
}
System.out.println("------------------------------------------");
// 不设置级联关系为delete的情况下，删除classes，会自动的把student表中的classid字段设置为null
// 设置级联关系为delete后，sql语句顺序为下：
// Hibernate: update Student set classid=null where classid=?
// Hibernate: delete from Student where id=?
// Hibernate: delete from Student where id=?
// Hibernate: delete from Student where id=?
// Hibernate: delete from Classes where id=?
// 可以看出，即使设置了级联为delete，也会先更新classid字段为null，然后在删除student，最后删除classes
session.delete(cl);
session.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
} finally {
hibernateUtil.closeSession(session);
}
}
}
双向一对多
classes.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="entity">
<class name="Classes" dynamic-update="true" >
<id name="id">
<generator class="native"/>
</id>
<property name="className" />
<set name="student" cascade="delete" inverse="true">
<!-- 这里的column是指数据库中student表中会添加外键classid，关联classes表的主键 -->
<key column="classid"></key>
<one-to-many class="Student" />
</set>
</class>
</hibernate-mapping>
student.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="entity">
<class name="Student" dynamic-update="true">
<id name="id">
<generator class="native"/>
</id>
<property name="name" />
<many-to-one name="classes" column="classid"></many-to-one>
</class>
</hibernate-mapping>
单元测试：
package entity;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import org.hibernate.classic.Session;
import junit.framework.TestCase;
import util.hibernateUtil;
/**
* 双向一对多（一般情况下，不推荐在one的一方维护关系）
*
* 测试目的
* 0. 使many方的设置失效，由one方维护关系
* 1. 新增数据，是否会级联保存？什么时候发出sql语句？
* 2. 查询数据，会不会级联查询？
* 3. 删除数据，会不会级联删除？
* @author arkulo
*
*/
public class testManytoone extends TestCase {
// 新增数据
public void test1() {
Session session = null;
try {
session = hibernateUtil.getSession();
session.beginTransaction();
Classes cl = new Classes();
cl.setClassName("一年级三班");
session.save(cl);
// 这是在many端维护的关系，比较简单，起码不用中间还需要一个set集合
Student st1 = new Student();
st1.setName("张三");
st1.setClasses(cl);
session.save(st1);
session.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
} finally {
hibernateUtil.closeSession(session);
}
}
// 查询数据
public void test2() {
test1();
System.out.println("-------------------------------------------------");
Session session = null;
try {
session = hibernateUtil.getSession();
session.beginTransaction();
// 发出两条sql语句
// 如果没有缓存的情况下，这里的iterate会产生n+1问题
Iterator st = session.createQuery("from Classes").iterate();
while (st.hasNext()) {
Classes cl = (Classes) st.next();
System.out.println("班级：" + cl.getClassName());
Set<Student> students = cl.getStudent();
Iterator<Student> it = students.iterator();
while (it.hasNext()) {
Student s = it.next();
System.out.println("用户名：" + s.getName());
}
}
session.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
} finally {
hibernateUtil.closeSession(session);
}
}
// 删除数据
public void test3() {
test1();
System.out.println("-------------------------------------------------");
Session session = null;
try {
session = hibernateUtil.getSession();
session.beginTransaction();
// 再不设置级联的情况下，删除classes，是否会删除student的记录
Classes cl = (Classes) session.get(Classes.class, 1);
System.out.println("班级名称:" + cl.getClassName());
Set<Student> students = cl.getStudent();
Iterator<Student> it = students.iterator();
while (it.hasNext()) {
Student s = it.next();
System.out.println("学生姓名：" + s.getName());
}
System.out.println("------------------------------------------");
// 不设置级联关系为delete的情况下，删除classes，系统会提示外键关联并抛出异常
// 在student映射文件上设置级联为delete，系统也会报错，因为这里我们删除的是classes
// 在classes上设置级联关系为delete后，sql语句顺序为下：
// Hibernate: delete from Student where id=?
// Hibernate: delete from Classes where id=?
// 这样就实现了级联删除
session.delete(cl);
session.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
} finally {
hibernateUtil.closeSession(session);
}
}
}
