双向一对多对关联映射
我们先来假设一个场景,从班级的角度看,班级和学生的关系就是一对多的关系,也就是一个班级有多个学生,
学生属于某个班级;从学生的角度看,学生和班级的关系就是多对一的关系。也就是多个学生属于一个班级。学生和
班级之间的关系是双向多对一关联关系,也称为双向一对多关联关系。为了解决一对多单向可能存在的问题,我们采
用向一对多,每一方都能维护对方。双向一对多关联映射方式:在一的一端的集合上采用<key>标签,在多的一端加
入一个外键;在多的一端采用<many-to-one>的标签,注意<key>标签和<many-to-one>标签加入字段保持一
致,否则会产生数据混乱。
如下图所示(一个组有多个用户,多个用户属于一个组):
Student实体类:
package com.demo.entity;
import java.io.Serializable;
@SuppressWarnings("serial")
public class Student implements Serializable {
private int sid;
private String sname;
private String sex;
//在多方定义一个一方的引用
private Grade grade;
public int getSid() {
return sid;
}
public void setSid(int sid) {
this.sid = sid;
}
public String getSname() {
return sname;
}
public void setSname(String sname) {
this.sname = sname;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public Grade getGrade() {
return grade;
}
public void setGrade(Grade grade) {
this.grade = grade;
}
public Student() {
super();
}
public Student(String sname, String sex) {
super();
this.sname = sname;
this.sex = sex;
}
}
Student实体类的对象关系映射文件:
<?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>
<class name="com.demo.entity.Student" table="t2_student">
<id name="sid" column="sid" type="java.lang.Integer">
<generator class="increment"></generator>
</id>
<property name="sname" type="java.lang.String">
<column name="sname" length="20" not-null="true"></column>
</property>
<property name="sex">
<column name="sex"></column>
</property>
<!-- 配置多对一关联关系 -->
<many-to-one name="grade" class="com.demo.entity.Grade" column="gid" cascade="all"></many-to-one>
</class>
</hibernate-mapping>
Grade实体类:
package com.demo.entity;
import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;
@SuppressWarnings("serial")
public class Grade implements Serializable {
private int gid;
private String gname;
private String gdesc;
//在一方定义一个多方的集合
private Set<Student> students = new HashSet<Student>();
public int getGid() {
return gid;
}
public void setGid(int gid) {
this.gid = gid;
}
public String getGname() {
return gname;
}
public void setGname(String gname) {
this.gname = gname;
}
public String getGdesc() {
return gdesc;
}
public void setGdesc(String gdesc) {
this.gdesc = gdesc;
}
public Set<Student> getStudents() {
return students;
}
public void setStudents(Set<Student> students) {
this.students = students;
}
public Grade() {
super();
}
public Grade(int gid, String gname, String gdesc) {
super();
this.gid = gid;
this.gname = gname;
this.gdesc = gdesc;
}
public Grade(String gname, String gdesc) {
super();
this.gname = gname;
this.gdesc = gdesc;
}
}
Grade实体类的对象关系映射文件:
<?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>
<class name="com.demo.entity.Grade" table="t2_grade">
<id name="gid" column="gid" type="java.lang.Integer">
<generator class="increment"></generator>
</id>
<property name="gname" type="java.lang.String">
<column name="gname" length="20" not-null="true"></column>
</property>
<property name="gdesc">
<column name="gdesc"></column>
</property>
<!-- 配置一对多关联关系,设置inverse属性为true,由多方维护关联关系 -->
<!-- 当进行保存和更新时,级联操作所关联的对象 -->
<set name="students" table="t2_student" inverse="true" cascade="save-update">
<!-- 指定关联的外键列 -->
<key column="gid"></key>
<one-to-many class="com.demo.entity.Student"/>
</set>
</class>
</hibernate-mapping>
测试类:
package com.demo.test;
import java.util.Set;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;
import com.demo.entity.Grade;
import com.demo.entity.Student;
import com.demo.util.HibernateUtil;
/**
* 双向多对一(学生<--->班级)
* 实际上建立了双向多对一,也称为双向一对多
* 既可以方便的由学生查找到对应的班级信息,也可以方便的由班级查询到其所包含的学生信息
* @author Administrator
* @date 2016年12月8日
*/
public class TestMany2One2 {
//将学生添加到班级
@Test
public void testSave1(){
Session session = HibernateUtil.getSession();
Transaction transaction= session.beginTransaction();
Grade g=new Grade("Java一班","Java软件开发一班");
Student stu1=new Student("张三", "男");
Student stu2=new Student("李四", "男");
//设置关联关系(双向多对一)
g.getStudents().add(stu1);
g.getStudents().add(stu2);
stu1.setGrade(g);
stu2.setGrade(g);
session.save(g);
//抛出TransientObjectException
//因为Student不是Persistent状态的对象,它是Transient状态的对象
transaction.commit();
HibernateUtil.closeSession(session);
}
//将学生添加到班级
@Test
public void testSave2(){
Session session = HibernateUtil.getSession();
Transaction transaction= session.beginTransaction();
Grade g=new Grade("Java一班","Java软件开发一班");
Student stu1=new Student("张三", "男");
Student stu2=new Student("李四", "男");
//设置关联关系(双向多对一)
g.getStudents().add(stu1);
g.getStudents().add(stu2);
stu1.setGrade(g);
stu2.setGrade(g);
session.save(stu1);
session.save(stu2);
session.save(g);
//可以成功保存数据
//但是会发出多余的update语句来维持关系
transaction.commit();
HibernateUtil.closeSession(session);
}
//将学生添加到班级
@Test
public void testSave3(){
Session session = HibernateUtil.getSession();
Transaction transaction= session.beginTransaction();
Grade g=new Grade("Java一班","Java软件开发一班");
Student stu1=new Student("张三", "男");
Student stu2=new Student("李四", "男");
//设置关联关系(双向多对一)
g.getStudents().add(stu1);
g.getStudents().add(stu2);
stu1.setGrade(g);
stu2.setGrade(g);
session.save(g);//级联操作,需要使用cascade属性
transaction.commit();
HibernateUtil.closeSession(session);
}
//查询班级中包含的学生
@Test
public void testLoad1(){
Session session = HibernateUtil.getSession();
Student stu = (Student) session.get(Student.class, 1);
System.out.println(stu.getSid()+","+stu.getSname()+","+stu.getSex());
Grade g = stu.getGrade();
System.out.println(g.getGid()+","+g.getGname()+","+g.getGdesc());
}
//查询班级中包含的学生
@Test
public void testLoad2(){
Session session = HibernateUtil.getSession();
Grade grade = (Grade) session.get(Grade.class, 1);
System.out.println(grade.getGname()+","+grade.getGdesc());
Set<Student> students = grade.getStudents();
for(Student stu:students){
System.out.println(stu.getSname()+","+stu.getSex());
}
}
}
testSave1()方法:
Junit测试失败:
testSave2()方法:
控制台显示:
数据库显示:
testSave3()方法:
控制台显示:和testSave()2方法显示一样
数据库显示:和testSave2()方法显示的一样
testLoad1()方法:
控制台显示:
testLoad2()方法:
控制台显示:
在一的一端维护关系存在缺陷,因为多的一端Student不知道Grade的存在(也就是Student没有维护与Grade
的关系),所以在保存Student的时候关系字段gid是为null的,如果将该关系字段设置为非空,则将无法保存数据另
外因为Student不维护关系,而Grade维护关系,Grade就会发出多余的update语句,保证Grade和Student有关
系,这样加载Grade的时候才可以把该Grade对应的学生加载上来。采用双向一对多关联映射的目的主要是为了主要
是为了解决一对多单向关联的缺陷而不是需求驱动的。