上篇文章我們對持久化對象進行的學習，瞭解了它的三種不同的狀態並通過它完成對數據庫的映射操作。但這都是基於單張表的操作，如果兩張或者兩張以上的表之間存在某種關聯，我們又該如何利用持久化對象進行操作呢？本篇主要介紹的關聯映射就是針對有着某種關聯的多張表的各種操作，主要涉及內容如下：
- 組合主鍵的映射
- 組件的映射
- 單向多對一的映射
- 單向一對多的映射
- 雙向一對多的映射
- 級聯映射
一、組合主鍵的映射操作
根據我們的上篇文章，對於單一主鍵，在對象映射配置文件中使用 id標籤即可完成配置。但是，往往有些主鍵並不是單一的，它可能由多個字段組合，那麼此時就不能使用 id標籤進行指定了。例如，我們有一張scores表，該表有三個字段，uid表示學生id，sub表示學生考試的學科，score表示該門考試成績。那麼確定一個學生的某門考試成績就需要uid和usub，此時它們就是scores表的主鍵，因爲它能唯一確定一行數據。
/*定義scores實體類*/
public class Scores {
private Score scoreId; //主鍵
private int score;
//省略get，set方法
}
public class Score implements Serializable {
private int userId;
private String sub;
//省略get，set方法
}在這裏，我們定義scores實體類，我們將主鍵封裝成一個類score，該類必須繼承接口Serializable ，最好還能實現它的兩個方法equals和hashcode。然後就是我們的實體映射配置文件的編寫：
<class name="DbClasses.Scores" table="scores">
<composite-id name="scoreId" class="DbClasses.Score">
<key-property name="userId" column="userId"></key-property>
<key-property name="sub" column="sub"></key-property>
</composite-id>
<property name="score" column="score"></property>
</class>對於組合主鍵，我們使用標籤composite-id來配置，name和class屬性分別指定主鍵類在實體類中的名稱及其位置。該標籤下的key-property標籤則是用來指定主鍵成員對應於數據表中的具體字段的。我們運行程序，看看Hibernate爲我們創建的表中是否有一個組合主鍵：
顯然，在我們的scores表中，userId和sub的組合構成了該表的主鍵。這就是組合主鍵在Hibernate中的配置情況，組合主鍵還是比較常見的。
二、組件映射
這裏將要介紹的組件映射和上述介紹的主鍵映射名稱相似，但確實完全不同的概念，需要予以區別。假設我們有一張person表：
person表中有主鍵id，name，age字段，還有三個地址字段（往往一個人有多個地址，我們要分別進行保存）。但是這樣的一個表結構對應於我們的實體類如下：
public class Person {
private int id;
private String name;
private int age;
private String address1;
private String address2;
private String address3;
//省略get，set方法
}對於這樣的實體類來說，我們覺得他對於地址字段的處理是冗餘的，假如某個人有十個地址，難道要在我們的實體類中配置十個屬性嗎？顯然是不合理的，Hibernate允許我們像主鍵映射一樣將所有的地址字段抽象出來一個類。
public class Person {
private int id;
private String name;
private int age;
private Address address;
//省略get，set方法
}
public class Address {
private String address1;
private String address2;
private String address3;
//省略get，set方法
}重點在於我們的實體映射文件的配置，
<class name="DbClasses.Person" table="person">
<id name="id" column="id">
<generator class="native"></generator>
</id>
<property name="name" column="name"></property>
<property name="age" column="age"></property>
<!--映射的一個組件屬性-->
<component name="address" class="DbClasses.Address">
<property name="address1" column="address1"></property>
<property name="address2" column="address2"></property>
<property name="address3" column="address3"></property>
</component>
</class>實體類中其他的屬性照常配置，對於這個Address類型的屬性，我們使用component標籤進行配置，name和class分別指定組件名和其位置，在該標籤下，使用property標籤配置組件的成員對應於數據表中的字段。然後我們刪除表，重新看看這次Hibernate爲我們生成的表結構：
顯然結果是一樣的，我們使用組件映射的一個好處就在於在這個實體類中，對於數據表結構顯得非常清晰，代碼的封裝性更好，方便查錯。
三、單向多對一的映射
以上介紹的兩種基本映射並不屬於我們本篇將要介紹的關聯映射，關聯映射就是指在處理多張有關聯的表時，我們的實體類的配置。所謂的多對一就是指，其中一張表的主鍵是另一張表的外鍵，例如：
我們有一張Student表，一張grade表，其中grade表的主鍵id是Student表的外鍵（grade），Student中的多條記錄對應於grade的一條記錄，所以這種表的關聯又被稱作多對一的關聯關係。下面我們看看如何通過對實體類的配置達到構建這種多對一的數據表關聯。
public class Student {
private int uId;
private String name;
private int age;
private Grade grade;
//省略get，set方法
}public class Grade {
private int id;
private String grade;
//省略get，set方法
}Student和Grade分別對應不同數據庫表的兩個實體類，但是Student實體類中有一個屬性grade指向實體類Grade。實體類映射配置文件如下：
<class name="DbClasses2.Student" table="student">
<id name="uId" column="uid">
<generator class="native"></generator>
</id>
<property name="name"></property>
<property name="age"></property>
<many-to-one name="grade" class="DbClasses2.Grade" column="grade_id"></many-to-one>
</class>
<class name="DbClasses2.Grade" table="grade">
<id name="id" column="id">
<generator class="native"></generator>
</id>
<property name="grade" column="grade"></property>
</class>Grade實體類的配置沒什麼變化，Student中使用many-to-one標籤將本實體類中屬性grade配置指向另一個實體類Grade，並用column指定外鍵名稱。也就是當Hibernate根據映射配置文件創建數據表的時候，發現屬性grade指向的是一個實體類Grade，於是把Grade表的主鍵關聯到grade字段上。我們先運行程序看看HIbernate是否爲我們創建了這種外鍵關聯，然後通過插入數據進一步理解Hibernate在底層爲我們做的事情。
顯然，在分別創建Student和Grade表之後，Hibernate又向數據庫發送了一條alter語句，該語句負責添加外鍵關聯。下面我們看看能否利用外鍵獲取到Grade表中的成績。
/*首先向表中插入信息*/
Student student = new Student();
student.setName("single");
student.setAge(21);
Grade grade = new Grade();
grade.setGrade("優秀");
student.setGrade(grade);
session.save(grade);
session.save(student);我們知道，一個實體類的對象對應於數據表的一條記錄，那麼grade代表Grade表的一條記錄，而該對象作爲屬性值被賦值給Student中的grade屬性則表示它將自己的引用交給了Student的外鍵字段，也就是說student這條記錄可以通過外鍵字段找到grade代表的這條記錄。有點繞，但是學過數據庫原理的應該不難理解。下面我們看，如何利用外鍵獲取對應的Grade表中的一條完整記錄。
Student student = (Student)session.get(Student.class,1);
Grade grade = student.getGrade();
System.out.println(grade.getId()+":"+grade.getGrade());輸出結果：
1:優秀顯然，我們通過Student返回的grade對象代表的就是基於Student外鍵字段值在Grade表中的一條數據。
四、單向一對多的映射
單向many-to-one關聯是最常見的單向關聯關係，其邏輯也趨近與我們的Sql語言，還算比較好理解。而對於單向一對多的映射則是其的一個逆向的邏輯，相對而言比較難以理解。這個多對一和一對多之間有個很明顯的區別，對於多對一的情況，我們在得到Student對象代表的一條數據記錄時，可以利用外鍵得到相對應Grade表中的一條記錄。但是反過來，如果我們想知道對於Grade表的某條記錄究竟有多少Student表記錄予以對應呢？起碼這是多對一無法直接解決的，那麼我們的一對多則着重解決的就是這麼一個問題。
所謂的一對多就是利用一的一方完成這種外鍵關聯的構建。我們先看實體類的定義：
/*student實體類的定義*/
public class Student {
private int uId;
private String name;
private int age;
//省略get，set方法
}public class Grade {
private int id;
private String grade;
//用於給其他表映射外鍵
private Set<Student> students = new HashSet<Student>(0);
//省略get，set方法
}這裏我們使用set集合，其實無論是list或者map都是可以的，旨在保存多的一方的記錄。看似毫無關聯的兩張表卻可以通過配置文件完成外鍵關聯操作。有關Student實體的映射配置部分代碼和平常是一樣的，沒有變動此處不再貼出，我們主要看Grade實體類的映射配置代碼：
<class name="DbClasses2.Grade" table="grade">
<id name="id" column="id">
<generator class="native"></generator>
</id>
<property name="grade"/>
<set name="students">
<key column="grade_id"></key>
<one-to-many class="DbClasses2.Student"></one-to-many>
</set>
</class>在Grade的實體類映射配置文件中，set標籤用於配置屬性students 。也就是說，當Hibernate加載到這裏的時候，兩張表單獨創建完成之後，我要回到這裏來，這裏有一個一對多的外鍵需要更新，該外鍵的表載體在Student中，外鍵的名稱是grade_id，於是它就會去更新Student的表結構，爲它添加外鍵的引用，而引用的表就是Grade。這裏還看不出set的作用，我們先看Hibernate爲我們創建的表關聯是否正確，然後通過存取數據來感受set的作用。
顯然，Hibernate是先單獨創建兩張表，然後發送alter語句添加外鍵引用。那究竟set有什麼用呢？它裏面裝的又是什麼呢？
假設兩張表中有如下信息：
下面我們通過程序獲取成績爲優秀的所有Student。這一點在多對一映射中是做不到的。多對一隻能知道某個學生的成績是什麼，但是無法直接知道成績爲什麼的所有學生。
Grade grade = (Grade)session.get(Grade.class,1);
Set<Student> students = grade.getStudents();
//遍歷輸出所有學生姓名
Iterator<Student> iterator = students.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next().getName());
}輸出結果：
從Hibernate的日誌輸出中，我們可以很顯然的看出來，首先Hibernate向數據庫發送第一條select語句查詢id爲1的grade記錄，然後默默的又一次發送select語句，不過這次是Student表，查詢所有grade_id爲1的記錄並通過反射全部添加到set集合中。於是我們可以遍歷輸出所有Student信息。
五、雙向一對多的映射
雙向一對多或者雙向多對一都是一個意思，這種形式的關聯映射操作就是上述的兩種映射的結合，在多的一段配置多對一映射，在一的一段配置一對多映射。這樣，我們既可以從多的一端通過外鍵獲取到一的一端的詳細記錄又可以從一的一端通過自己的主鍵獲取到多的一端的所有對應記錄。這種方式比較簡單，此處不再贅述，我們最後看看兩個關鍵字cascade和inverse的含義和用法。
六、級聯映射
我們首先看級聯操作，級聯就是在兩張具有關聯關係的表操作的時候，通過操作其中一張表級聯的更新了另一張表。先看個例子：
<many-to-one name="grade" class="DbClasses2.Grade" column="grade_id" cascade="save-update" />我們在多的一端配置cascade等於save-update，意味着我們在多的一端進行save和update的時候，數據會自動更新到Grade表中。
Student stu1 = new Student();
stu1.setName("single");
stu1.setAge(21);
Grade grade = new Grade();
grade.setGrade("優秀");
stu1.setGrade(grade);
//session.save(grade);
session.save(stu1);上述的這段代碼完成的是一個插入操作，如果沒有設置級聯的話，該段程序必然報錯，因爲grade表中無任何數據，而student代表的一條記錄的grade_id的字段卻被強行插入數值1，自然會報錯（外鍵1在grade表中找不到）。但是我們配置了級聯就不一樣了，Hibernate會先保存grade到數據庫中，然後再插入student這條記錄。從Hibernate的輸出日誌中也可以看出來：
當然，除了可以在多的一端配置級聯，我們也可以在一的一端配置級聯，讓一的一端也可以級聯的操作多的一端。例如：
<set name="students" cascade="save-update">
<key column="grade_id"></key>
<one-to-many class="DbClasses2.Student"></one-to-many>
</set>給一的一端配置級聯，然後我麼通過級聯來保存多的一端的數據。
Grade grade = new Grade();
grade.setGrade("優秀");
Student stu1 = new Student();
stu1.setName("single");
stu1.setAge(21);
Student stu2 = new Student();
stu2.setName("cyy");
stu2.setAge(20);
grade.getStudents().add(stu1);
grade.getStudents().add(stu2);
//session.save(stu1);sesion.save(stu2);
session.save(grade);這段代碼在沒有配置級聯的狀態下，必然會報錯。首先Hibernate根據配置文件創建了兩張表及其之間的關聯關係。執行save的時候會將grade保存到數據表中，然後Hibernate會查看自己set集合中對應的多端的記錄並根據這些記錄去更新多端表中的外鍵值，當然如果沒有保存到student表中，自然會報錯。我們看看級聯是怎麼做的：
顯然，在保存好grade之後，立馬將自己set集合中的Student記錄插入到Student表中，然後通過update語句更新他們的外鍵值。而沒有設置級聯的話，第二三條Sql語句是沒有的，報錯那也是自然的。關於級聯，只要理解了它的本質，這些操作也都是可以理解的，本質上就是在做插入或者修改操作的時候如果發現自己代表的這條記錄中有外部關聯表的內容，那麼則先完成對外部表的更新。這就是級聯，級聯的操作和自己關聯的外部表，當然cascade也不止這一個參數值：
cascade="all|none|save-update|delete"其中，none表示不級聯，all表示所有操作都級聯，save-update 表示保存和修改操作進行級聯，delete表示刪除的時候級聯刪除。本質都類似，此處不再贅述。
至此，有關關聯映射的第一部分介紹完了，下篇將繼續介紹未完的其他關聯映射的操作。總結不到之處，望指出！