版權聲明：本文為博主原創文章，未經博主允許不得轉載。如需轉載請聲明：【轉自 http://blog.csdn.net/xiaoxian8023 】

在上一篇博客《一口一口吃掉Hibernate（四）——多對一單向關聯映射》中，介紹了多對一的關聯映射，今天就反過來說一下一對多的單向關聯映射。

可能有人會對這2篇博客的題目有點混淆不清，跟日常說的關系有點不同。我們日常說的比如父子關系，夫妻關系都是說的雙向關系，而現在討論的則是單向關系，所以也就有了多對一和一對多的說法。

二者的關系其實很簡單，只是角度不同而已。比如說學生和班級的關系。如果從學生角度來看，是多對一的關系。而從班級角度來看，則是一對多的關系。說法很簡單，但是在對象和關系的建立卻是不一樣的。

先看一下一對多的類圖（貌似好多人的聚合關系都畫錯了）：

hibernate對於一對多的關系的處理，是通過操作Class端，間接操作或者自動操作Student端。比如添加，我直接添加Class端的數據，多個Student就會被添加自動添加進去。也可以通過這個Class獲取到所有對應的學生信息。跟著我來配置一下吧：

首先定義實體類【Class】【Student】

1. package com.bjpowernode.hibernate;
3. import java.util.Set;
5. /**
6. * 班級類
7. * @author Longxuan
8. *
9. */
10. public class Class {
12. private int id;
14. private String name;
16. private Set<Student> students;
18. public Set<Student> getStudents() {
19. return students;
20. }
22. public void setStudents(Set<Student> students) {
23. this.students = students;
24. }
26. public int getId() {
27. return id;
28. }
30. public void setId(int id) {
31. this.id = id;
32. }
34. public String getName() {
35. return name;
36. }
38. public void setName(String name) {
39. this.name = name;
40. }
41. }
44. package com.bjpowernode.hibernate;
46. /**
47. * 學生類
48. * @author Longxuan
49. *
50. */
51. public class Student {
53. private int id;
55. private String name;
57. public int getId() {
58. return id;
59. }
61. public void setId(int id) {
62. this.id = id;
63. }
65. public String getName() {
66. return name;
67. }
69. public void setName(String name) {
70. this.name = name;
71. }
74. }

Hibernate提供了one-to-many來簡化一對多的映射關系。不用我們自己再去實現，只需要在映射文件中進行配置即可：

1. <?xml version="1.0"?>
2. <!DOCTYPE hibernate-mapping PUBLIC
3. "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
4. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
5. <hibernate-mapping package="com.bjpowernode.hibernate">
6. <class name="Student" table="t_student">
7. <id name="id">
8. <generator class="native"/>
9. </id>
10. <property name="name"/>
11. </class>
13. <class name="Class" table="t_class">
14. <id name="id">
15. <generator class="native"/>
16. </id>
17. <property name="name"/>
18. <!-- 設置Set,用於關聯多個學生 -->
19. <set name="students">
20. <!-- 在t_student表中創建外鍵classid，與本表的id對應 -->
21. <key column="classid"></key>
22. <one-to-many class="Student"></one-to-many>
23. </set>
24. </class>
26. </hibernate-mapping>

測試類【One2ManyTest】：

1. package com.bjpowernode.hibernate;
3. import java.util.HashSet;
4. import java.util.Iterator;
5. import java.util.Set;
6. import junit.framework.TestCase;
7. import org.hibernate.Session;
8. import org.hibernate.Transaction;
10. public class One2ManyTest extends TestCase {
12. public void testSave2() {
13. Session session = null;
14. try {
15. session = HibernateUtils.getSession();
16. session.beginTransaction();
18. Student student1 = new Student();
19. student1.setName("張三");
20. //必須先將student1轉化為Persistent狀態，否則會拋TransientObjectException
21. session.save(student1);
23. Student student2 = new Student();
24. student2.setName("李四");
25. //必須先將student1轉化為Persistent狀態，否則會拋TransientObjectException
26. session.save(student2);
28. Class classes = new Class();
29. classes.setName("提高班");
31. Set<Student> students = new HashSet<Student> ();
32. students.add(student1);
33. students.add(student2);
34. classes.setStudents(students);
36. //可以成功保存數據。
37. //先添加數據，將關系字段設置為null，再用update語句來更新關系字段
38. //但是會發出多余的update語句來維持關系。
39. session.save(classes);
40. session.getTransaction().commit();
42. }catch(Exception e) {
43. e.printStackTrace();
44. session.getTransaction().rollback();
45. }finally {
46. HibernateUtils.closeSession(session);
47. }
48. }

執行測試前： ，執行測試後：

雖然最後的結果跟多對一一樣，但是根據sql語句，就可以看出，一對多是先添加student，classid為null，等添加了class以後，再執行update語句，把classid更新上去。這樣同時可能會暴露一個問題：如果student的classid設置了not-null="true"，則會拋PropertyValueException異常。所以不太推薦使用一對多。

通過上面的例子，我們可以看出，其實一對多關聯映射和多對一關聯映射映射原理是一致的，都是在多的一端加入一個外鍵，指向一的一端。

它們的區別在於維護的關系不同：

• 多對一維護的關系是：多指向一的關系，有了此關系，在加載多的時候可以先將一加載上來
• 一對多維護的關系是：一指向多的關系，有了此關系，在加載一的時候可以先將多加載上來

在一的一端維護關系存在缺陷：

• 因為多的一端Student不知道Class的存在（也就是Student沒有維護與Class的關系）所以在保存Student的時候關系字段classid是為null的，如果將該關系字段設置為非空，則將無法保存數據
• 另外因為Student不維護關系，而Class維護關系，Class就會發出多余的update語句，保證Class和Student有關系，這樣加載Class的時候才可以把該Class對應的學生加載上來

一口一口吃掉Hibernate（五）——一對多單向關聯映射