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

        单向一对对关联映射

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

学生属于某个班级。在数据库中，可以通过添加主外键的关联，表现单向一对多的关系，在学生表添加一个外键，指

向班级表；HIbernate框架中通过在一方持有多方的集合的实现，即在一的一端使用set元素表示持有多的一端的对

象。

       如下图所示（一个组有多个用户）：

       

       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;

	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 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="t_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>	
	</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 Grade() {
		super();
	}

	public Set<Student> getStudents() {
		return students;
	}

	public void setStudents(Set<Student> students) {
		this.students = students;
	}

	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="t_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>
		
		<!-- 配置单向一对多关联关系 -->
		<set name="students" table="t_student">
			<!-- 指定关联的外键列 -->
			<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 TestOne2Many {
	
	//将学生添加到班级
	@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);
		
		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);
			
			session.save(g);
			session.save(stu1);
			session.save(stu2);
			
			//可以成功保存数据
			//但是会发出多余的update语句来维持关系
			
			transaction.commit();
			HibernateUtil.closeSession(session);
		}
		
	//查询班级中包含的学生
	@Test
	public void testLoad(){
		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()方法

       控制台输出：

       

       数据库显示：

       
       testLoad()方法

       控制台输出：

       

       应该是因为学生是一对多关系中的多方，外键约束是设置在一方中的，所以是要删除班级则需要先删除关联的学

生信息，删除一个学生则不需要。

       从班级能看到学生，是班级来维护关系，不是学生来维护关系，学生不知道自己是哪个班，所以在存储学生的时

候，班级的代码不知道。为了更新学生是哪个班级的要发出很多update语句来告诉学生是哪个班级的。当我们设置

classesid not-null=“true”时，则将无法保存数据，解决办法我们改为双向关联映射。

       单向一对多关联映射和单向多对一关联映射原理是一致的，存储是相同的，也就是生成的数据库的表是一样的，

他们之间不同的是维护的关系不同。单向一对多关联映射维护的关系是：一指向多的关系，有了此关系，在加载一的

时候可以将多加载上来。