我的NHibernate之路（3）---表间多对多配置篇

　　本节要点：

　　　　1、如何配置表之间多对多的关系

　　　　2、多表之间如何进行操作

　　对于关系型数据库，表之间也多对多的关系也很常见的。在我们实际开发过程中如何进行正确的映射的配置，以及所关联的表之间是如何操作的？这是本文讲述的重点。

　　开发环境：VS2008 SP1　　使用的NHibernate版本：NHibernate-2.1.2.GA-bin。

　　将上节讨论的学生表与班级表再进行深层次的引入：如果构建一个学生选课的数据库，还需要什么表？表之间的关系如何对应？还是通过LINQ的截图说说表的字段以及表之间的关系【不讨论LINQ与Nhibernate之间的关系，免得又有朋友误解】。图如下：

　　

　　通过图，可以很清楚的看出四张表见的关系。不过我主要说的是下面三张表。

　　对于学生来说，他可以选择多门课程。对于课程来说，多个学生也可以选择同一门课程。对于学生实体类和课程实体类，他们之间就是一种多对多的关系。顺便给出下面三张表之间的外键。students表与SelectCourse：引用列【ID】与被引用列【Students】，外键名：FK_SelectCourse_Students。Course表与SelectCourse表：引用列【ID】与被引用列【CourseID】，外键名：FK_SelectCourse_Course。被引用类那么他们之间的映射关系如何?

　　通过上节的说明，一对多是在映射文件中通过one-to-many表示的。大家很自然想到多对多就是通过many-to-many来表示。有了一对多配置的基础，我就说说其中重要的。

　　Stuents表的映射文件：  

 

1 <? xml version = " 1.0 " encoding = " utf-8 " ?>
2   < hibernate - mapping xmlns = " urn:nhibernate-mapping-2.2 " >
3 < class name = " MultiToMultiModel.Student, MultiToMultiModel " table = " Students " >
4 < id name = " Id " type = " Int32 " unsaved - value = " 0 " >
5 < column name = " ID " length = " 4 " sql - type = " int " not - null = " true " unique = " true "
 index = " PK_Students " />
6 < generator class = " native " />
7 </ id >
8 < property name = " Name " type = " String " >
9 < column name = " Name " length = " 50 " sql - type = " varchar " not - null = " false " />
10 </ property >
11 < property name = " Phone " type = " String " >
12 < column name = " Phone " length = " 15 " sql - type = " varchar " not - null = " false " />
13 </ property >
14 < many - to - one name = " Class " class = " MultiToMultiModel.Class, MultiToMultiModel " >
15 < column name = " ClassID " length = " 4 " sql - type = " int " not - null = " false " />
16 </ many - to - one >
17
18 < bag name = " Courses " generic = " true " table = " SelectCourse " >
19 < key column = " StudentID " foreign - key = " FK_SelectCourse_Students " not - null = " false " ></ key >
20 < many - to - many column = " CourseID " foreign - key = " FK_SelectCourse_Course "
class = " MultiToMultiModel.Course,MultiToMultiModel " ></ many - to - many >
21 </ bag >
22 </ class >
23   </ hibernate - mapping >
24  

　　Students对应的实体类:

 

代码

1
2   using System;
3   using System.Collections.Generic;
4   using System.Collections;
5
6
7   namespace MultiToMultiModel
8 {
9 #region Student
10
11 /// <summary>
12 /// Student object for NHibernate mapped table 'Students'.
13 /// </summary>
14   public class Student
15 {
16 #region Member Variables
17
18 protected int _id;
19 protected string _name;
20 protected string _phone;
21 protected Class _class;
22 // protected IList _studentSelectCourses;
23   protected IList < Course > _courses;
24 #endregion
25
26 #region Constructors
27
28 public Student() { }
29
30 public Student( string name, string phone, Class _class )
31 {
32 this ._name = name;
33 this ._phone = phone;
34 this ._class = _class;
35 }
36
37 #endregion
38
39 #region Public Properties
40
41 public virtual int Id
42 {
43 get { return _id;}
44 set {_id = value;}
45 }
46
47 public virtual string Name
48 {
49 get { return _name; }
50 set
51 {
52 if ( value != null && value.Length > 50 )
53 throw new ArgumentOutOfRangeException( " Invalid value for Name " , value, value.ToString());
54 _name = value;
55 }
56 }
57
58 public virtual string Phone
59 {
60 get { return _phone; }
61 set
62 {
63 if ( value != null && value.Length > 15 )
64 throw new ArgumentOutOfRangeException( " Invalid value for Phone " , value, value.ToString());
65 _phone = value;
66 }
67 }
68
69 public virtual Class Class
70 {
71 get { return _class; }
72 set { _class = value; }
73 }
74
75 public virtual IList < Course > Courses
76 {
77 get
78 {
79 if (_courses == null )
80 {
81 _courses = new List < Course > ();
82 }
83 return _courses;
84 }
85 set { _courses = value; }
86 }
87 #endregion
88
89 }
90
91 #endregion
92 }
93  

 

 

　　Course表对应的映射文件:

1 <? xml version = " 1.0 " encoding = " utf-8 " ?>
2   < hibernate - mapping xmlns = " urn:nhibernate-mapping-2.2 " >
3 < class name = " MultiToMultiModel.Course, MultiToMultiModel " table = " Course " >
4 < id name = " Id " type = " Int32 " unsaved - value = " 0 " >
5 < column name = " ID " length = " 4 " sql - type = " int " not - null = " true " unique = " true " index = " PK_Course " />
6 < generator class = " native " />
7 </ id >
8 < property name = " CourseName " type = " String " >
9 < column name = " CourseName " length = " 50 " sql - type = " varchar " not - null = " false " />
10 </ property >
11 < property name = " Teacher " type = " String " >
12 < column name = " Teacher " length = " 50 " sql - type = " varchar " not - null = " false " />
13 </ property >
14 < property name = " Time " type = " DateTime " >
15 < column name = " `Time` " length = " 8 " sql - type = " datetime " not - null = " false " />
16 </ property >
17 < property name = " Address " type = " String " >
18 < column name = " Address " length = " 50 " sql - type = " varchar " not - null = " false " />
19 </ property >
20
21 < bag name = " Students " generic = " true " table = " SelectCourse " >
22 < key column = " CourseID " foreign - key = " FK_SelectCourse_Course " not - null = " false " ></ key >
23 < many - to - many column = " StudentID " class = " MultiToMultiModel.Student,MultiToMultiModel "
 foreign - key = " FK_SelectCourse_Students " ></ many - to - many >
24 </ bag >
25 </ class >
26   </ hibernate - mapping >
27

　　对应的实体类：

1 using System;
2   using System.Collections.Generic;
3   using System.Collections;
4
5
6   namespace MultiToMultiModel
7 {
8 #region Course
9
10 /// <summary>
11 /// Course object for NHibernate mapped table 'Course'.
12 /// </summary>
13   public class Course
14 {
15 #region Member Variables
16
17 protected int _id;
18 protected string _courseName;
19 protected string _teacher;
20 protected DateTime _time;
21 protected string _address;
22 protected IList < Student > _students;
23
24
25 #endregion
26
27 #region Constructors
28
29 public Course() { }
30
31 public Course( string courseName, string teacher, DateTime time, string address )
32 {
33 this ._courseName = courseName;
34 this ._teacher = teacher;
35 this ._time = time;
36 this ._address = address;
37 }
38
39 #endregion
40
41 #region Public Properties
42
43 public virtual int Id
44 {
45 get { return _id;}
46 set {_id = value;}
47 }
48
49 public virtual string CourseName
50 {
51 get { return _courseName; }
52 set
53 {
54 if ( value != null && value.Length > 50 )
55 throw new ArgumentOutOfRangeException( " Invalid value for CourseName " , value, value.ToString());
56 _courseName = value;
57 }
58 }
59
60 public virtual string Teacher
61 {
62 get { return _teacher; }
63 set
64 {
65 if ( value != null && value.Length > 50 )
66 throw new ArgumentOutOfRangeException( " Invalid value for Teacher " , value, value.ToString());
67 _teacher = value;
68 }
69 }
70
71 public virtual DateTime Time
72 {
73 get { return _time; }
74 set { _time = value; }
75 }
76
77 public virtual string Address
78 {
79 get { return _address; }
80 set
81 {
82 if ( value != null && value.Length > 50 )
83 throw new ArgumentOutOfRangeException( " Invalid value for Address " , value, value.ToString());
84 _address = value;
85 }
86 }
87
88 public virtual IList < Student > Students
89 {
90 get
91 {
92 if (_students == null )
93 {
94 _students = new List < Student > ();
95 }
96 return _students;
97 }
98 set { _students = value; }
99 }
100
101 #endregion
102
103
104 }
105
106 #endregion
107 }
108  

 

 

　　对于实体类，就不用说了。主要说说映射文件中的<bag>节点的配置。

　　bag：对象集合。集合中的元素可以重复。相当于.Net中的IList或者IList<T>。当然对应的name是相应实体类的属性了。

　　我个人最为关键的的是KEY、与many-to-mnay两个阶段的配置与理解。首先对于两个实体类，我应该建立他们各自的映射文件，这是最基本的。我就以Course表来说。它与Students表多对多的关系是通过SelectCourse表建立的。要给Course实体类建立与Students的映射关系，唯一的途径就是通过SelectCourse表上的外键FK_SelectCourse_Course。而外键FK_SelectCourse_Course是引用的Course表的主键。

　　所以对key节点：他对应的column【对应表的列明，这里就不再具体多说】当然是CourseID。

　　对于many-to-many节点,我是这样理解的。既然是多对多。第一个many指的当然是它自己，即Course，另外一个显然是针对Students。那么Students与Course建立对应关系的唯一途径也只有通过引用在它的主键上建立的外键FK_SelectCourse_Students。后面对应的是实体类Students对应的程序集以及指明Course多对多的实体类Student。

　　映射文件小结：

key节点：是对于映射文件对应的实体类所说的。
many - to - many：是对多对多中另外“多”的一方说的

　　映射文件的介绍与说明就到这。下面说说它们之间该如何做操作。我仅仅以添加为例进行说明。

　　添加的需求说明：我希望为一个学生添加他所选的课程，并将此学生添加到一个新的班级中【课程也要求新添加到课程表】。还是直接上代码较为直接：

 

代码

1 // 申明对象
2   Class cls = new Class();
3 Student stu = new Student();
4 Course c = new Course();
5
6 SelectCourse _selectCourse = new SelectCourse();
7
8
9 cls.ClassCode = " 03510236 " ;
10 cls.ClassStudentses.Add(stu);
11 cls.StudentsAmount = 36 ;
12
13 stu.Class = cls;
14 stu.Name = " teau " ;
15 stu.Phone = " 0897658 " ;
16 stu.Courses = new List < Course > ();
17 stu.Courses.Add(c);
18
19
20 c.Address = " Beijing " ;
21 c.CourseName = " C++ " ;
22 c.Students = new List < Student > ();
23 c.Students.Add(stu);
24 c.Teacher = " Tao " ;
25 c.Time = DateTime.Now;
26
27 _selectCourse.Course = c;
28 _selectCourse.Student = stu;
29
30
31 ClassBLL cBLl = new ClassBLL();
32 CourseBLL courseBLL = new CourseBLL();
33 try
34 {
35 if (cBLl != null && cls != null )
36 {
37 ClassBLL.AddClass(cls);
38 CourseBLL.AddCourse(c);
39 SelectCourseBLL.AddSelectCourse(_selectCourse);
40 }
41 }
42 catch (Exception ex)
43 {
44 throw ex;
45 }

 

 

 

　　上述添加需求的代码时候就这些，其中关于业务实体类通过ISession会话操作数据库的代码就不再给出。相信只要了解Nhibernate基础只是的都能知道是如何操作的。

　　说了这么多，多对多的映射到这就说完了。我个人觉得多对多的问题也就是通过中间结构构成的多对多。假如在本例中，我们要完成上述例子中的添加需求，能不能不通过多对多的关系操作呢？我觉得一点问题也没有。因为对Studet表与SelectCourse表，它们对应的实体关系之间就是一对多的关系。同样对SelectCourse实体与Course实体，它们之间也是一对多的关系。如果我们把Student与Course的关系分开来看，其实就是两个一对多的过程。通过一对多的关系也可以解决。

　　总结：多对多的关系是Nhibernate映射配置中比较难也比较绕的一部分【我个人觉得】。但是只要理解其中key和many-to-many各自配置的作用，以及为何是通过这样配置的，问题也就迎刃而解了。

　　就写到这了，希望对各位有所帮组，若有理解或者表述有误的也希望大侠们踊跃拍砖！