hibernate對於數據庫的操作，全部利用面向對象的思維來理解和實現的。一般的單獨表的映射，相信大家都沒有問題，但是對於一些表之間的特殊關系，Hibernate提供了一些獨特的方式去簡化它。

今天就來說說多對一的關聯映射。

數據庫中有多對一的關系，Hibernate自然也有對象的多對一的關聯關系。比如用戶和用戶組，一個用戶只屬於一個組，一個組有多名用戶。我們就可以說用戶和用戶組的關系就是多對一的關系。用對象的uml圖表示一下：

在Hibernate中如何來實現呢？首先定義這兩個實體類：

1. package com.bjpowernode.hibernate;
3. /**
4. * 用戶組
5. * @author Longxuan
6. *
7. */
8. public class Group {
10. private int id;
11. private String name;
12. public int getId() {
13. return id;
14. }
15. public void setId(int id) {
16. this.id = id;
17. }
18. public String getName() {
19. return name;
20. }
21. public void setName(String name) {
22. this.name = name;
23. }
24. }
28. package com.bjpowernode.hibernate;
30. /**
31. * 用戶類
32. * @author Longxuan
33. *
34. */
35. public class User {
37. private int id;
39. private String name;
41. private Group group;
43. public Group getGroup() {
44. return group;
45. }
47. public void setGroup(Group group) {
48. this.group = group;
49. }
51. public int getId() {
52. return id;
53. }
55. public void setId(int id) {
56. this.id = id;
57. }
59. public String getName() {
60. return name;
61. }
63. public void setName(String name) {
64. this.name = name;
65. }
67. }

hibernate.cfg.xml配置文件：

1. <!DOCTYPE hibernate-configuration PUBLIC
2. "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
3. "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
5. <hibernate-configuration>
6. <session-factory name="foo">
8. <property name="hibernate.dialect" >org.hibernate.dialect.MySQLDialect</property>
9. <property name="hibernate.show_sql">true</property><!-- 設置是否顯示生成sql語句 -->
10. <property name="hibernate.format_sql">false</property><!-- 設置是否格式化sql語句-->
12. <mapping resource="com/bjpowernode/hibernate/Tables.hbm.xml" />
13. </session-factory>
14. </hibernate-configuration>

hibernate.properties配置文件:

1. ## MySQL
3. hibernate.dialect org.hibernate.dialect.MySQLDialect
4. #hibernate.dialect org.hibernate.dialect.MySQLInnoDBDialect
5. #hibernate.dialect org.hibernate.dialect.MySQLMyISAMDialect
6. hibernate.connection.driver_class com.mysql.jdbc.Driver
7. hibernate.connection.url jdbc:mysql://localhost:3306/hibernate_many2one
8. hibernate.connection.username root
9. hibernate.connection.password root

這是最基礎的準備工作，多對一映射在對數據進行更改時，會有一些限制。當沒有該用戶組時，添加用戶，就會出錯，當該用戶組有用戶時，刪除該用戶組也會報錯。

我們當然可以按一般的方法來做。添加的時候，先手動添加組，再添加用戶。刪除時，先刪除所有的用戶，再刪除用戶組。但是Hibernate為我們提供了一種便捷的方式——many-to-one。在映射文件hbm.xml中配置後，就可以不用再想那些限制了。Hibernate會自動添加上所引用的數據。

給出映射文件：

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>
7. <class name="com.bjpowernode.hibernate.User" table="t_user">
8. <id name="id">
9. <generator class="native" />
10. </id>
11. <property name="name"></property>
12. <many-to-one name="group" column="groupid" cascade="save-update"></many-to-one>
13. </class>
15. <class name="com.bjpowernode.hibernate.Group" table="t_group">
16. <id name="id">
17. <generator class="native" />
18. </id>
19. <property name="name"></property>
20. </class>
22. </hibernate-mapping>

配置了many-to-one會自動在t_user表中創建外鍵groupid，與t_group的id映射。

many-to-one標簽用到了cascade，指定兩個對象之間的操作聯動關系，對一個對象執行了操作之後，對其指定的級聯對象也需要執行相同的操作。其屬性值如下：

• all：在所有的情況下都執行級聯操作；
• none：在所有情況下都不執行級聯操作；
• save-update：在保存和更新的時候執行級聯操作；、
• delete：在刪除的時候執行級聯操作。

測試類Many2OneTest：

1. package com.bjpowernode.hibernate;
3. import junit.framework.TestCase;
5. import org.hibernate.Session;
7. public class Many2OneTest extends TestCase {
9. /**
10. * 測試添加用戶
11. */
12. public void testSave3(){
13. Session session = null;
14. try{
15. session = HibernateUtils.getSession();
16. session.beginTransaction();
18. Group group = new Group();
19. group.setName("提高班");
21. User user1 = new User();
22. user1.setName("張三");
23. user1.setGroup(group);
25. User user2 = new User();
26. user2.setName("李四");
27. user2.setGroup(group);
29. //普通方法 ：必須先保存group，再保存user
30. //配置了many-to-one 則不用再手動save group了。
31. //session.save(group);
32. session.save(user1);
33. session.save(user2);
35. session.getTransaction().commit();
36. }catch(Exception e){
37. e.printStackTrace();
38. session.getTransaction().rollback();
39. }finally{
40. HibernateUtils.closeSession(session);
41. }
42. }
44. }

結果圖：

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

用many-to-one進行配置後，hibernate會自動去添加外鍵，而我們做的任何操作都不需要去考慮它的結構，也不用手動去維護這個關系，關系由Hibernate自動維護。這就是Hibernate的魅力所在。

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