一、單向一對多

前篇文章中曾經對多對一的關係展開了討論，其中主要使用的是<many-to-one>的關係，在多的一端維護一的一端，那和今天要討論的一對多的關係它們之間是否有關聯呢？在關係和對象模型中存在了一對多關係所以理所當然就會有多對一的關係，Hibernate同樣提供了一對多關係的標籤<one-to-many>。

一對多關係的對象模型在日常生活中也經常看到，就拿學生和班級來說，一個班級裏有多個學生，所以班級和學生的關係是一對多的關係，映射到對象模型中，如下圖：

對象模型說明了這種一對多的關係是由一的一端來維護的，那麼映射成關係模型就是一個班級字段下面會有多個學生，這樣就形成了一對多的關係，通過班級能夠查詢獲得學生信息，對應的關係模型如下圖：

1、基本配置

有了對象模型接下來就讓它們映射爲對應的關係代碼，在進行關係映射時需要在一的一端添加<one-to-many>標籤，另外還需要在一的一端添加Set屬性，它支持延遲加載，然後在映射文件添加set標籤，並指明一對多的關係，這樣就能夠在一的一端查詢獲取多的一端。

Classes類及映射文件

它是模型中最重要的一端，在該端需要添加對應的set屬性，並在配置文件中添加set標籤，在set標籤中配置相應的<one-to-many>對象，具體Classes.java對象代碼如下：

[java] view plain copy print ?

<pre name="code" class="java">package com.src.hibernate;
import java.util.Set;
public class Classes {
private int id;
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;
}
private String name;
//Set支持延遲加載
private Set students;
public Set getStudents() {
return students;
}
public void setStudents(Set students) {
this.students = students;
}
}

<pre name="code" class="java">package com.src.hibernate;

import java.util.Set;

public class Classes {
	private int id;
	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;
	}
	private String name;
	
	//Set支持延遲加載
	private Set students;
	public Set getStudents() {
		return students;
	}
	public void setStudents(Set students) {
		this.students = students;
	}
}

Classes對象中使用了set屬性，但是隻是說明了延遲加載的屬性，並沒有爲屬性配置對應的對象，屬性的對象是要在映射文件中來配置的，需要添加set標籤，並在set標籤中添加<one-to-many>標籤，具體如下代碼：

[html] view plain copy print ?

<?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>
<class name="com.hibernate.Classes" table="t_classes">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<set name="students">
<key column="classesid"></key>
<one-to-many class="com.hibernate.Student"></one-to-many>
</set>
</class>
</hibernate-mapping>

<?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>
	<class name="com.hibernate.Classes" table="t_classes">
		<id name="id">
			<generator class="native"/>
		</id>
		<property name="name"/>
		<set name="students">
			<key column="classesid"></key>
			<one-to-many class="com.hibernate.Student"></one-to-many>
		</set>
	</class>
</hibernate-mapping>

對應的Student對象中的代碼和映射文件不需要什麼特殊的配置，只需要按照通常的寫法編寫即可，具體的配置方法不再詳述，很簡單。配置好後需要生成對應的SQL語句，將對象模型轉化爲關係模型時Hibernate生成相應的語句如下：

[sql] view plain copy print ?

alter table t_student drop foreign key FK4B9075705E0AFEFE
drop table if exists t_classes
drop table if exists t_student
create table t_classes (id integer not null auto_increment, name varchar(255), primary key (id))
create table t_student (id integer not null auto_increment, name varchar(255), classesid integer, primary key (id))
alter table t_student add index FK4B9075705E0AFEFE (classesid), add constraint FK4B9075705E0AFEFE foreign key (classesid) references t_classes (id)

alter table t_student drop foreign key FK4B9075705E0AFEFE
drop table if exists t_classes
drop table if exists t_student
create table t_classes (id integer not null auto_increment, name varchar(255), primary key (id))
create table t_student (id integer not null auto_increment, name varchar(255), classesid integer, primary key (id))
alter table t_student add index FK4B9075705E0AFEFE (classesid), add constraint FK4B9075705E0AFEFE foreign key (classesid) references t_classes (id)

生成的對應的關係模型如下圖：

　對比SQL語句和關係模型，相應的表之間的關聯是通過外鍵來維護的，首先是創建兩張表，並指定表的主鍵，最後添加一對多的外鍵關聯關係。

2、基本操作

在對數據庫的操作無非是讀和寫兩種，修改也屬於寫的一種，接下來看看是如何向數據庫中寫入和讀取操作的。

寫入數據

寫入數據需要注意的是一對多的關係，所以在添加的時候需要添加多個學生類，另外由於在classes中添加了對應的set屬性，所以在添加Student對象時應該使用HashSet來添加，這樣既可實現一對多的關係，具體如下代碼：

[java] view plain copy print ?

public void testSave2(){
Session session=null;
try{
session=HibernateUtils.getSession();
session.beginTransaction();
Student student1=new Student();
student1.setName("zhangsan");
session.save(student1);
Student student2=new Student();
student2.setName("lisi");
session.save(student2);
Classes classes=new Classes();
classes.setName("ClassOne");
Set students=new HashSet();
students.add(student1);
students.add(student2);
classes.setStudents(students);
//可以成功保存數據
//但是會發出多餘的update語句來維持關係，因爲是一對多的原因
session.save(classes);
session.getTransaction().commit();
}catch(Exception e){
e.printStackTrace();
session.getTransaction().rollback();
}finally{
HibernateUtils.closeSession(session);
}
}

public void testSave2(){
	Session session=null;
	try{
		session=HibernateUtils.getSession();
		session.beginTransaction();
		
		Student student1=new Student();
		student1.setName("zhangsan");
		session.save(student1);
		
		Student student2=new Student();
		student2.setName("lisi");
		session.save(student2);
		
		Classes classes=new Classes();
		classes.setName("ClassOne");
		
		Set students=new HashSet();
		students.add(student1);
		students.add(student2);
		
		classes.setStudents(students);
		//可以成功保存數據
		//但是會發出多餘的update語句來維持關係，因爲是一對多的原因
		session.save(classes);
		session.getTransaction().commit();
	}catch(Exception e){
		e.printStackTrace();
		session.getTransaction().rollback();
	}finally{
		HibernateUtils.closeSession(session);
	}
}

那麼運行上面的測試用例生成的對應的數據寫入到數據庫中後如下圖：

讀取數據

寫入操作相對簡單，只需要把所有加載的對象都添加到Transient狀態下，運行相應的方法就可以插入內容，但是對應的讀取操作就會稍微複雜點，因爲需要迭代獲取所有的學生對象，所以這種一對多的關係效率並不很高，具體代碼如下：

[java] view plain copy print ?

package com.test.hibernate;
import java.util.Iterator;
import java.util.Set;
import com.src.hibernate.*;
import junit.framework.TestCase;
import org.hibernate.Session;
public class One2ManyTest extends TestCase {
public void testLoad1(){
Session session=null;
try{
session=HibernateUtils.getSession();
session.beginTransaction();
//獲取主鍵爲5的班級信息
Classes classes=(Classes)session.load(Classes.class,5);
//打印班級信息
System.out.println("classes.name="+classes.getName());
//設置學生集合，通過班級加載學生集合
Set students=classes.getStudents();
//迭代集合，打印集合中學生的信息
for(Iterator iter=students.iterator();iter.hasNext();){
Student student=(Student)iter.next();
System.out.println("student.name="+student.getName());
}
session.getTransaction().commit();
}catch(Exception e){
e.printStackTrace();
session.getTransaction().rollback();
}finally{
HibernateUtils.closeSession(session);
}
}
}

package com.test.hibernate;

import java.util.Iterator;
import java.util.Set;
import com.src.hibernate.*;
import junit.framework.TestCase;
import org.hibernate.Session;

public class One2ManyTest extends TestCase {
	public void testLoad1(){
		Session session=null;
		try{
			session=HibernateUtils.getSession();
			session.beginTransaction();
			
			//獲取主鍵爲5的班級信息
			Classes classes=(Classes)session.load(Classes.class,5);
			//打印班級信息
			System.out.println("classes.name="+classes.getName());
			//設置學生集合，通過班級加載學生集合
			Set students=classes.getStudents();
			//迭代集合，打印集合中學生的信息
			for(Iterator iter=students.iterator();iter.hasNext();){
				Student student=(Student)iter.next();
				
				System.out.println("student.name="+student.getName());
			}
			
			session.getTransaction().commit();
		}catch(Exception e){
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally{
			HibernateUtils.closeSession(session);
		}
	}
}

生成的相應的語句及信息如下語句：

[sql] view plain copy print ?

Hibernate: select classes0_.id as id1_0_, classes0_.name as name1_0_ from t_classes classes0_ where classes0_.id=?
classes.name=ClassOne
Hibernate: select students0_.classesid as classesid1_, students0_.id as id1_, students0_.id as id0_0_, students0_.name as name0_0_ from t_student students0_ where students0_.classesid=?
student.name=lisi
student.name=zhangsan

Hibernate: select classes0_.id as id1_0_, classes0_.name as name1_0_ from t_classes classes0_ where classes0_.id=?
classes.name=ClassOne
Hibernate: select students0_.classesid as classesid1_, students0_.id as id1_, students0_.id as id0_0_, students0_.name as name0_0_ from t_student students0_ where students0_.classesid=?
student.name=lisi
student.name=zhangsan

結語

一對多的關係也是經常用到的，但是這種關係在加載時效率會不高，因爲需要維護的數據較多，所以不建議使用一對多的關係，可以考慮多對一的關係，這樣在加載時其實是一種一對一的關係，加載的效率較高，關係和對象模型得到了優化。這裏只是討論了單向的一對多，下篇文章討論雙向的關聯關係。

【Hibernate步步爲營】--（一對多映射）之單向關聯

一、單向一對多

1、基本配置

2、基本操作

結語

C#開源的兩款功能強大的錄屏神器

認知提升的方法

螞蟻面試：Springcloud核心組件的底層原理，你知道多少？

設計模式 - 觀察者模式(Observer Pattern) 詳解

hibernate.cfg.xml配置文件分析

【Hibernate步步爲營】--（一對多映射）之雙向關聯

createQuery與createSQLQuery區別、hibernate分頁

設計模式 - 觀察者模式(Observer Pattern) Java內置使用方法

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結