?????上篇文章我們對持久化對象進行的學(xué)習(xí)，了解了它的三種不同的狀態(tài)并通過它完成對數(shù)據(jù)庫的映射操作。但這都是基于單張表的操作，如果兩張或者兩張以上的表之間存在某種關(guān)聯(lián)，我們又該如何利用持久化對象進行操作呢？本篇主要介紹的關(guān)聯(lián)映射就是針對有著某種關(guān)聯(lián)的多張表的各種操作，主要涉及內(nèi)容如下：

• 組合主鍵的映射
• 組件的映射
• 單向多對一的映射
• 單向一對多的映射
• 雙向一對多的映射
• 級聯(lián)映射

一、組合主鍵的映射操作
?????根據(jù)我們的上篇文章，對于單一主鍵，在對象映射配置文件中使用 id標(biāo)簽即可完成配置。但是，往往有些主鍵并不是單一的，它可能由多個字段組合，那么此時就不能使用 id標(biāo)簽進行指定了。例如，我們有一張scores表，該表有三個字段，uid表示學(xué)生id，sub表示學(xué)生考試的學(xué)科，score表示該門考試成績。那么確定一個學(xué)生的某門考試成績就需要uid和usub，此時它們就是scores表的主鍵，因為它能唯一確定一行數(shù)據(jù)。

/*定義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 ，最好還能實現(xiàn)它的兩個方法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>

對于組合主鍵，我們使用標(biāo)簽composite-id來配置，name和class屬性分別指定主鍵類在實體類中的名稱及其位置。該標(biāo)簽下的key-property標(biāo)簽則是用來指定主鍵成員對應(yīng)于數(shù)據(jù)表中的具體字段的。我們運行程序，看看Hibernate為我們創(chuàng)建的表中是否有一個組合主鍵：

這里寫圖片描述

顯然，在我們的scores表中，userId和sub的組合構(gòu)成了該表的主鍵。這就是組合主鍵在Hibernate中的配置情況，組合主鍵還是比較常見的。

二、組件映射
?????這里將要介紹的組件映射和上述介紹的主鍵映射名稱相似，但確實完全不同的概念，需要予以區(qū)別。假設(shè)我們有一張person表：

這里寫圖片描述

person表中有主鍵id，name，age字段，還有三個地址字段（往往一個人有多個地址，我們要分別進行保存）。但是這樣的一個表結(jié)構(gòu)對應(yīng)于我們的實體類如下：

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標(biāo)簽進行配置，name和class分別指定組件名和其位置，在該標(biāo)簽下，使用property標(biāo)簽配置組件的成員對應(yīng)于數(shù)據(jù)表中的字段。然后我們刪除表，重新看看這次Hibernate為我們生成的表結(jié)構(gòu)：

這里寫圖片描述

顯然結(jié)果是一樣的，我們使用組件映射的一個好處就在于在這個實體類中，對于數(shù)據(jù)表結(jié)構(gòu)顯得非常清晰，代碼的封裝性更好，方便查錯。

三、單向多對一的映射
?????以上介紹的兩種基本映射并不屬于我們本篇將要介紹的關(guān)聯(lián)映射，關(guān)聯(lián)映射就是指在處理多張有關(guān)聯(lián)的表時，我們的實體類的配置。所謂的多對一就是指，其中一張表的主鍵是另一張表的外鍵，例如：

這里寫圖片描述

我們有一張Student表，一張grade表，其中g(shù)rade表的主鍵id是Student表的外鍵（grade），Student中的多條記錄對應(yīng)于grade的一條記錄，所以這種表的關(guān)聯(lián)又被稱作多對一的關(guān)聯(lián)關(guān)系。下面我們看看如何通過對實體類的配置達到構(gòu)建這種多對一的數(shù)據(jù)表關(guān)聯(lián)。

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分別對應(yīng)不同數(shù)據(jù)庫表的兩個實體類，但是Student實體類中有一個屬性grade指向?qū)嶓w類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標(biāo)簽將本實體類中屬性grade配置指向另一個實體類Grade，并用column指定外鍵名稱。也就是當(dāng)Hibernate根據(jù)映射配置文件創(chuàng)建數(shù)據(jù)表的時候，發(fā)現(xiàn)屬性grade指向的是一個實體類Grade，于是把Grade表的主鍵關(guān)聯(lián)到grade字段上。我們先運行程序看看HIbernate是否為我們創(chuàng)建了這種外鍵關(guān)聯(lián)，然后通過插入數(shù)據(jù)進一步理解Hibernate在底層為我們做的事情。

這里寫圖片描述

顯然，在分別創(chuàng)建Student和Grade表之后，Hibernate又向數(shù)據(jù)庫發(fā)送了一條alter語句，該語句負(fù)責(zé)添加外鍵關(guān)聯(lián)。下面我們看看能否利用外鍵獲取到Grade表中的成績。

/*首先向表中插入信息*/
Student student = new Student();
student.setName("single");
student.setAge(21);

Grade grade = new Grade();
grade.setGrade("優(yōu)秀");

student.setGrade(grade);

session.save(grade);
session.save(student);

我們知道，一個實體類的對象對應(yīng)于數(shù)據(jù)表的一條記錄，那么grade代表Grade表的一條記錄，而該對象作為屬性值被賦值給Student中的grade屬性則表示它將自己的引用交給了Student的外鍵字段，也就是說student這條記錄可以通過外鍵字段找到grade代表的這條記錄。有點繞，但是學(xué)過數(shù)據(jù)庫原理的應(yīng)該不難理解。下面我們看，如何利用外鍵獲取對應(yīng)的Grade表中的一條完整記錄。

Student student = (Student)session.get(Student.class,1);
Grade grade = student.getGrade();
System.out.println(grade.getId()+":"+grade.getGrade());

輸出結(jié)果：

1:優(yōu)秀

顯然，我們通過Student返回的grade對象代表的就是基于Student外鍵字段值在Grade表中的一條數(shù)據(jù)。

四、單向一對多的映射
?????單向many-to-one關(guān)聯(lián)是最常見的單向關(guān)聯(lián)關(guān)系，其邏輯也趨近與我們的Sql語言，還算比較好理解。而對于單向一對多的映射則是其的一個逆向的邏輯，相對而言比較難以理解。這個多對一和一對多之間有個很明顯的區(qū)別，對于多對一的情況，我們在得到Student對象代表的一條數(shù)據(jù)記錄時，可以利用外鍵得到相對應(yīng)Grade表中的一條記錄。但是反過來，如果我們想知道對于Grade表的某條記錄究竟有多少Student表記錄予以對應(yīng)呢？起碼這是多對一無法直接解決的，那么我們的一對多則著重解決的就是這么一個問題。

?????所謂的一對多就是利用一的一方完成這種外鍵關(guān)聯(lián)的構(gòu)建。我們先看實體類的定義：

/*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都是可以的，旨在保存多的一方的記錄。看似毫無關(guān)聯(lián)的兩張表卻可以通過配置文件完成外鍵關(guān)聯(lián)操作。有關(guān)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標(biāo)簽用于配置屬性students 。也就是說，當(dāng)Hibernate加載到這里的時候，兩張表單獨創(chuàng)建完成之后，我要回到這里來，這里有一個一對多的外鍵需要更新，該外鍵的表載體在Student中，外鍵的名稱是grade_id，于是它就會去更新Student的表結(jié)構(gòu)，為它添加外鍵的引用，而引用的表就是Grade。這里還看不出set的作用，我們先看Hibernate為我們創(chuàng)建的表關(guān)聯(lián)是否正確，然后通過存取數(shù)據(jù)來感受set的作用。

這里寫圖片描述

顯然，Hibernate是先單獨創(chuàng)建兩張表，然后發(fā)送alter語句添加外鍵引用。那究竟set有什么用呢？它里面裝的又是什么呢？
假設(shè)兩張表中有如下信息：

這里寫圖片描述

下面我們通過程序獲取成績?yōu)閮?yōu)秀的所有Student。這一點在多對一映射中是做不到的。多對一只能知道某個學(xué)生的成績是什么，但是無法直接知道成績?yōu)槭裁吹乃袑W(xué)生。

Grade grade = (Grade)session.get(Grade.class,1);
Set<Student> students = grade.getStudents();
//遍歷輸出所有學(xué)生姓名
Iterator<Student> iterator = students.iterator();
while(iterator.hasNext()){
            System.out.println(iterator.next().getName());
}

輸出結(jié)果：

這里寫圖片描述

從Hibernate的日志輸出中，我們可以很顯然的看出來，首先Hibernate向數(shù)據(jù)庫發(fā)送第一條select語句查詢id為1的grade記錄，然后默默的又一次發(fā)送select語句，不過這次是Student表，查詢所有g(shù)rade_id為1的記錄并通過反射全部添加到set集合中。于是我們可以遍歷輸出所有Student信息。

五、雙向一對多的映射
?????雙向一對多或者雙向多對一都是一個意思，這種形式的關(guān)聯(lián)映射操作就是上述的兩種映射的結(jié)合，在多的一段配置多對一映射，在一的一段配置一對多映射。這樣，我們既可以從多的一端通過外鍵獲取到一的一端的詳細記錄又可以從一的一端通過自己的主鍵獲取到多的一端的所有對應(yīng)記錄。這種方式比較簡單，此處不再贅述，我們最后看看兩個關(guān)鍵字cascade和inverse的含義和用法。

六、級聯(lián)映射
?????我們首先看級聯(lián)操作，級聯(lián)就是在兩張具有關(guān)聯(lián)關(guān)系的表操作的時候，通過操作其中一張表級聯(lián)的更新了另一張表。先看個例子：

<many-to-one name="grade" class="DbClasses2.Grade" column="grade_id" cascade="save-update" />

我們在多的一端配置cascade等于save-update，意味著我們在多的一端進行save和update的時候，數(shù)據(jù)會自動更新到Grade表中。

Student stu1 = new Student();
stu1.setName("single");
stu1.setAge(21);

Grade grade = new Grade();
grade.setGrade("優(yōu)秀");

stu1.setGrade(grade);

//session.save(grade);
session.save(stu1);

上述的這段代碼完成的是一個插入操作，如果沒有設(shè)置級聯(lián)的話，該段程序必然報錯，因為grade表中無任何數(shù)據(jù)，而student代表的一條記錄的grade_id的字段卻被強行插入數(shù)值1，自然會報錯（外鍵1在grade表中找不到）。但是我們配置了級聯(lián)就不一樣了，Hibernate會先保存grade到數(shù)據(jù)庫中，然后再插入student這條記錄。從Hibernate的輸出日志中也可以看出來：

這里寫圖片描述

當(dāng)然，除了可以在多的一端配置級聯(lián)，我們也可以在一的一端配置級聯(lián)，讓一的一端也可以級聯(lián)的操作多的一端。例如：

<set name="students" cascade="save-update">
      <key column="grade_id"></key>
      <one-to-many class="DbClasses2.Student"></one-to-many>
</set>

給一的一端配置級聯(lián)，然后我么通過級聯(lián)來保存多的一端的數(shù)據(jù)。

Grade grade = new Grade();
grade.setGrade("優(yōu)秀");

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);

這段代碼在沒有配置級聯(lián)的狀態(tài)下，必然會報錯。首先Hibernate根據(jù)配置文件創(chuàng)建了兩張表及其之間的關(guān)聯(lián)關(guān)系。執(zhí)行save的時候會將grade保存到數(shù)據(jù)表中，然后Hibernate會查看自己set集合中對應(yīng)的多端的記錄并根據(jù)這些記錄去更新多端表中的外鍵值，當(dāng)然如果沒有保存到student表中，自然會報錯。我們看看級聯(lián)是怎么做的：

這里寫圖片描述

顯然，在保存好grade之后，立馬將自己set集合中的Student記錄插入到Student表中，然后通過update語句更新他們的外鍵值。而沒有設(shè)置級聯(lián)的話，第二三條Sql語句是沒有的，報錯那也是自然的。關(guān)于級聯(lián)，只要理解了它的本質(zhì)，這些操作也都是可以理解的，本質(zhì)上就是在做插入或者修改操作的時候如果發(fā)現(xiàn)自己代表的這條記錄中有外部關(guān)聯(lián)表的內(nèi)容，那么則先完成對外部表的更新。這就是級聯(lián)，級聯(lián)的操作和自己關(guān)聯(lián)的外部表，當(dāng)然cascade也不止這一個參數(shù)值：

cascade="all|none|save-update|delete"

其中，none表示不級聯(lián)，all表示所有操作都級聯(lián)，save-update 表示保存和修改操作進行級聯(lián)，delete表示刪除的時候級聯(lián)刪除。本質(zhì)都類似，此處不再贅述。

至此，有關(guān)關(guān)聯(lián)映射的第一部分介紹完了，下篇將繼續(xù)介紹未完的其他關(guān)聯(lián)映射的操作。總結(jié)不到之處，望指出！