一对多也是分为两种：
- 单向一对多
- 双向一对多
先来看一下公用的实体类
classes实体类
package entity;
import java.util.Set;
public class Classes {
private int id;
private String className;
private Set 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 getStudent() {
return student;
}
public void setStudent(Set 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
student.hbm.xml
单元测试：
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 set = new HashSet();
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 students = cl.getStudent();
Iterator 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 students = cl.getStudent();
Iterator 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
student.hbm.xml
单元测试：
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 students = cl.getStudent();
Iterator 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 students = cl.getStudent();
Iterator 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);
}
}
}