16-Hibernate多对多映射关系详解（附带实例）

多对多的关联关系映射可以使用学生和课程的关联关系为例进行讲解。通常情况下，为了方便数据的维护，多对多的关系都会产生一张中间表。学生表与课程表的关系如图 1 所示。

图 1 学生表和课程表关系

在图 1 中，各个表的字段意思如下：

• students 表为学生表，id 为学生表的主键，sname 表示学生名称。
• course 表为课程表，id 为课程表的主键，cname 表示课程名称。
• s_c 表为中间表，cid 和 sid 表示外键。

由于一个学生可以学习多门课程，而一门课程也可以被多个学生学习，由此可知，学生和课程的关系是多对多关系。这种关系需要在学生类和课程类中分别以集合的方式引入对方的对象，并在映射文件中通过 标签进行映射。

为了让读者更好地掌握多对多关联关系映射，下面通过具体的案例演示学生和课程之间多对多关联关系的使用。具体步骤如下。

1. 创建实体类

1）创建学生实体类。

在 src 目录下创建一个名为 com.mengma.manytomany 的包，在该包下创建一个 Students 类，编辑后如下所示。

1. package com.mengma.manytomany;
2. 
   
3. import java.util.HashSet;
4. import java.util.Set;
5. 
   
6. public class Students {
7. private Integer id; // 学生id
8. private String sname; // 学生姓名
9. 
   
10. // 一门课程都可以被多个学生学习
11. private Set courses = new HashSet();
12. 
    
13. public Integer getId() {
14. return id;
15. }
16. 
    
17. public void setId(Integer id) {
18. this.id = id;
19. }
20. 
    
21. public String getSname() {
22. return sname;
23. }
24. 
    
25. public void setSname(String sname) {
26. this.sname = sname;
27. }
28. 
    
29. public Set getCourses() {
30. return courses;
31. }
32. 
    
33. public void setCourses(Set courses) {
34. this.courses = courses;
35. }
36. }

上述代码中，courses 是一个集合类型，用于表示一个学生可以学习多门课程。

2）创建课程实体类。

在 com.mengma.manytomany 包下创建一个名为 Course 的类，编辑后如下所示。

1. package com.mengma.manytomany;
2. 
   
3. import java.util.HashSet;
4. import java.util.Set;
5. 
   
6. public class Course {
7. private Integer id; // 课程id
8. private String cname; // 课程名称
9. 
   
10. // 一个学生可以学习多门课程
11. private Set students = new HashSet();
12. 
    
13. public Integer getId() {
14. return id;
15. }
16. 
    
17. public void setId(Integer id) {
18. this.id = id;
19. }
20. 
    
21. public String getCname() {
22. return cname;
23. }
24. 
    
25. public void setCname(String cname) {
26. this.cname = cname;
27. }
28. 
    
29. public Set getStudents() {
30. return students;
31. }
32. 
    
33. public void setStudents(Set students) {
34. this.students = students;
35. }
36. 
    
37. }

上述代码中，students 是一个集合类型，用于表示一门课程可以被多个学生学习。

2. 创建映射文件

1）创建学生实体类映射文件。

在 com.mengma.manytomany 包下创建一个名为 Students.hbm.xml 的映射文件，编辑后如下所示。

1. <?xml version=”1.0” encoding=”UTF-8”?>
2. <!DOCTYPE hibernate-mapping PUBLIC “-//Hibernate/Hibernate Mapping DTD 3.0//EN”
3. “http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
5. <class name=”com.mengma.onetomany.Students” table=”students”>
6. <id name=”id” column=”id”>
7. <generator class=”native” />
9. <property name=”sname” column=”sname” length=”40” />
10. <set name=”courses” table=”s_c”>
11. <key column=”sid” />
12. <many-to-many class=”com.mengma.manytomany.Course”
13. column=”cid” />

上述代码中，使用 标签描述被映射类中的 Set 集合对象，与一对多配置方式不同的是，在 标签中多了一个 table 属性，该属性表示中间表的名称。

在 标签内， 标签的 column 属性用于描述 students 表在中间表中的外键名称， 标签用于表示两个持久化类多对多的关联关系，其中 column 属性用于描述 course 表在中间表中的外键名称。

2）创建课程实体类映射文件。

在 com.mengma.manytomany 包下创建一个名为 Course.hbm.xml 的映射文件，如下所示。

1. <?xml version=”1.0” encoding=”UTF-8”?>
2. <!DOCTYPE hibernate-mapping PUBLIC “-//Hibernate/Hibernate Mapping DTD 3.0//EN”
3. “http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
5. <class name=”com.mengma.onetomany.Course” table=”sourse”>
6. <id name=”id” column=”id”>
7. <generator class=”native” />
9. <property name=”cname” column=”cname” length=”40” />
10. <set name=”students” table=”s_c”>
11. <key column=”cid” />
12. <many-to-many class=”com.mengma.manytomany.Students”
13. column=”sid” />

上述代码中可以看出，Course.hbm.xml 与 Students.hbm.xml 的配置以及属性所表示的含义相同，可参考理解。

3. 添加映射信息

在 hibernate.cfg.xml 配置文件中添加 Students.hbm.xml 和 Course.hbm.xml 映射文件信息，具体如下所示：

4. 创建测试类

在 com.mengma.manytomany 包下创建一个名为 ManyToManyTest 的类，编辑后如下所示。

1. package com.mengma.manytomany;
2. 
   
3. import org.hibernate.classic.Session;
4. import org.junit.Test;
5. 
   
6. import com.mengma.utils.HibernateUtils;
7. 
   
8. public class ManyToManyTest {
9. // 添加数据
10. @Test
11. public void test1() {
12. Session session = HibernateUtils.getSession();
13. session.beginTransaction();
14. // 创建两个学生
15. Students s1 = new Students();
16. s1.setSname(“张三”);
17. Students s2 = new Students();
18. s2.setSname(“李四”);
19. // 创建两门科目
20. Course c1 = new Course();
21. c1.setCname(“Java基础入门”);
22. Course c2 = new Course();
23. c2.setCname(“MySQL基础入门”);
24. // 学生关联科目
25. s1.getCourses().add(c1);
26. s2.getCourses().add(c1);
27. 
    
28. s1.getCourses().add(c2);
29. s2.getCourses().add(c2);
30. // 存储
31. session.save(c1);
32. session.save(c2);
33. session.save(s1);
34. session.save(s2);
35. session.getTransaction().commit();
36. session.close();
37. }
38. 
    
39. }

上述代码中，首先创建两个学生对象和两门课程对象，然后用学生对课程进行关联，这就是多对多的单向关联。对于多对多的双向关联教程后面会结合反转的知识进行讲解，这里不再过多赘述。

5. 运行程序并查看结果

使用 JUnit 测试运行 test1() 方法，运行成功后，分别查询 students 表、course 表和 s_c 表，查询结果如图 2 所示。

图 2 查询结果

从图 2 的查询结果中可以看出，students 表和 course 表的主键分别作为了中间表的外键。由于是两个学生分别学习两门课程，所以可以看到 s_c 表总共有四条记录。