【HIbernate框架学习】：Hibernate对象关系映射之双向一对多关联映射

        双向一对多对关联映射

        我们先来假设一个场景，从班级的角度看，班级和学生的关系就是一对多的关系，也就是一个班级有多个学生，

学生属于某个班级；从学生的角度看，学生和班级的关系就是多对一的关系。也就是多个学生属于一个班级。学生和

班级之间的关系是双向多对一关联关系，也称为双向一对多关联关系。为了解决一对多单向可能存在的问题，我们采

用向一对多，每一方都能维护对方。双向一对多关联映射方式：在一的一端的集合上采用<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对应的学生加载上来。采用双向一对多关联映射的目的主要是为了主要

是为了解决一对多单向关联的缺陷而不是需求驱动的。