Hibernate多对多怎么实现

本篇内容主要讲解“Hibernate多对多怎么实现”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“Hibernate多对多怎么实现”吧!

假設現在有User與Server兩個類別，一個User可以被授權使用多台Server，而在Server上也記錄授權使用它的使用者，就User與Server兩者而言即使多對多的關係。

在程式設計時，基本上是不建議直接在User與Server之間建立多對多關係，這會使得User與Server相互依賴，通常會透過一個中介類別來維護兩者之間的多對多關係，避免兩者的相互依賴。

如果一定要直接建立User與Server之間的多對多關係，Hibernate也是支援的，基本上只要您瞭解之前介紹的幾個實體映射，建立多對多關聯在配置上並不困難。

先看一下我們設計的User與Server類別：

java 代码

1. package onlyfun.caterpillar;

3. import java.util.*;

5. publicclass User {

6. privatelong id;

7. private String name;

8. private Set servers = new HashSet();

10. publiclong getId() {

11. return id;

12. }

13. publicvoid setId(long id) {

14. this.id = id;

15. }

16. public String getName() {

17. return name;

18. }

19. publicvoid setName(String name) {

20. this.name = name;

21. }

22. public Set getServers() {

23. return servers;

24. }

26. publicvoid setServers(Set servers) {

27. this.servers = servers;

28. }

29. }

java 代码

1. package onlyfun.caterpillar;

3. import java.util.*;

5. publicclass Server {

6. privatelong id;

7. private String address;

8. private Set users = new HashSet();

10. publiclong getId() {

11. return id;

12. }

13. publicvoid setId(long id) {

14. this.id = id;

15. }

16. public String getAddress() {

17. return address;

18. }

19. publicvoid setAddress(String address) {

20. this.address = address;

21. }

22. public Set getUsers() {

23. return users;

24. }

25. publicvoid setUsers(Set users) {

26. this.users = users;

27. }

28. }

這邊各使用HashSet來保存彼此的關係，在多對多關係映射上，我們可以建立單向或雙向關係，這邊直接介紹雙向關係映射，並藉由設定inverse="true"，將關係的維護交由其中一方來維護，這麼作的結果，在原始碼的撰寫上，也比較符合Java的物件關係維護，也就是雙方都要設置至對方的參考。

首先來看看User.hbm.xml：

xml 代码

1. xmlversion="1.0"?>

3. PUBLIC "-//Hibernate/Hibernate Mapping DTD//EN"

4. "Http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">

6. <hibernate-mapping>

8. <classname="onlyfun.caterpillar.User"table="USER">

10. <idname="id"column="USER_ID"unsaved-value="0">

11. <generatorclass="increment"/>

12. id>

14. <propertyname="name">

15. <columnname="NAME"length="16"not-null="true"/>

16. property>

18. <setname="servers"

19. table="USER_SERVER"

20. cascade="save-update">

22. <keycolumn="USER_ID"/>

23. <many-to-manyclass="onlyfun.caterpillar.Server"

24. column="SERVER_ID"/>

25. set>

27. class>

29. hibernate-mapping>

在資料庫中，資料表之間的多對多關係是透過一個中介的資料表來完成，例如在這個例子中，USER資料表與USER_SERVER資料表是一對多，而USER_SERVER對SERVER是多對一，從而完成USER至SERVER的多對多關係，在USER_SERVER資料表中，將會有USER_ID與SERVER_ID共同作為主鍵，USER_ID作為一個至USER的外鍵參考，而SERVER_ID作為一個至SERVER的外鍵參考。

來看看Server.hbm.xml映射文件：

xml 代码

1. xmlversion="1.0"?>

3. PUBLIC "-//Hibernate/Hibernate Mapping DTD//EN"

4. "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">

6. <hibernate-mapping>

8. <classname="onlyfun.caterpillar.Server"table="SERVER">

10. <idname="id"column="SERVER_ID"unsaved-value="0">

11. <generatorclass="increment"/>

12. id>

14. <propertyname="address"type="string"/>

16. <setname="users"

17. table="USER_SERVER"

18. inverse="true"

19. cascade="save-update">

21. <keycolumn="SERVER_ID"/>

22. <many-to-manyclass="onlyfun.caterpillar.User"

23. column="USER_ID"/>

24. set>

25. class>

27. hibernate-mapping>

設置上與User.hbm.xml是類似的，只是增加了inverse="true"，表示將關係的維護交由另一端，注意我們在User與Server的cascade都是設置為save-update，在多對多的關係中，all、delete等cascade是沒有意義的，因為多對多中，並不能因為父物件被刪除，而造成被包括的子物件被刪除，因為可能還有其它的父物件參考至這個子物件。

我們使用下面這個程式來測試：

java 代码

1. import onlyfun.caterpillar.*;

2. import net.sf.hibernate.*;

3. import net.sf.hibernate.cfg.*;

5. publicclass HibernateTest {

6. publicstaticvoid main(String[] args) throws HibernateException {

7. SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();

9. Server server1 = new Server();

10. server1.setAddress("PC-219");

11. Server server2 = new Server();

12. server2.setAddress("PC-220");

13. Server server3 = new Server();

14. server3.setAddress("PC-221");

16. User user1 = new User();

17. user1.setName("caterpillar");

18. User user2 = new User();

19. user2.setName("momor");

21. user1.getServers().add(server1);

22. user1.getServers().add(server2);

23. user1.getServers().add(server3);

24. server1.getUsers().add(user1);

25. server2.getUsers().add(user1);

26. server3.getUsers().add(user1);

28. user2.getServers().add(server1);

29. user2.getServers().add(server3);

30. server1.getUsers().add(user2);

31. server3.getUsers().add(user2);

33. Session session = sessionFactory.openSession();

34. Transaction tx= session.beginTransaction();

35. session.save(user1);

36. session.save(user2);

38. tx.commit();

39. session.close();

41. sessionFactory.close();

42. }

43. }

注意由於設定了inverse="true"，所以必須分別設定User與Server之間的相互參考，來看看實際上資料庫中是如何儲存的：

select * FROM USER

+---------+-------------+
| USER_ID | NAME |
+---------+-------------+
| 1 | caterpillar |
| 2 | momor |
+---------+-------------+

select * FROM USER_SERVER

+-----------------+--------------+
| SERVER_ID | USER_ID |
+-----------------+--------------+
| 1 | 1 |
| 2 | 1 |
| 3 | 1 |
| 1 | 2 |
| 2 | 2 |
+-----------------+--------------+

select * FROM SERVER

+-----------------+------------+
| SERVER_ID | address |
+-----------------+------------+
| 1 | PC-219 |
| 2 | PC-221 |
| 3 | PC-220 |
+-----------------+-------------+

到此，相信大家对“Hibernate多对多怎么实现”有了更深的了解，不妨来实际操作一番吧！这里是编程网网站，更多相关内容可以进入相关频道进行查询，关注我们，继续学习！