回想一些我们在没有学习ssh的时候，我们建立数据库的表时，首先是数据库建模e-r图，然后再通过实体模型来建立关系模型，再建立相应的表。实体间存在三种关系，一对一，一对多（或者说多对一），多对多。而如今我们要根据类来映射相应的表，那只能是通过类与类之间的关系加上映射文件来映射数据库的表。我们学习uml建模，类与类之间存在五种关系，继承，实现，关联，依赖，聚合/组合，在hibernate中实体类之间的关系也是如此，对于不同的关系对应的代码实现我们已经很熟悉了，所以对于实体类是复习的知识。
hibernate的本质就是对象关系映射（objectrelational mapping），orm实现了将对象数据保存到数据库中，以前我们对关系表进行操作，执行增删改查等任务，现在我们不再对关系表进行操作，而是直接对对象操作。hibernate中的orm映射文件通常以.hbm.xml作为后缀。使用这个映射文件不仅易读，而且可以手工修改，也可以通过一些工具来生成映射文档。下面将对hibernate中的映射进行介绍。
hibernate映射分类，如下图所示。
1 基本类映射
根据实体类创建相应的表，这种简单的关系为hibernate基本映射。
user1实体类代码如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
|
//user实体。 public classuser1 { //用户编号。 private string id; //名字。 private string name; //密码。 private string password; //创建日期。 private date createtime; //失效时间。 private date expiretime; public string getid() { return id; } // publicvoid setid(string id) { // this.id= id; // } public string getname() { return name; } public void setname(string name) { this.name = name; } public string getpassword() { return password; } public void setpassword(stringpassword) { this.password = password; } public date getcreatetime() { return createtime; } public void setcreatetime(datecreatetime) { this.createtime = createtime; } public date getexpiretime() { return expiretime; } public void setexpiretime(dateexpiretime) { this.expiretime = expiretime; } } |
user1.hbm.xml映射文件如下所示：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
<hibernate-mapping package="com.bjpowernode.hibernate"> <class name="user1" table="t_user1"> <id name="id"column="user_id" length="32"access="field"> <generator class="uuid" /> </id> <!-- 设置主键不能重复和不能为空的属性. --> <property name="name" length="30"unique="true" not-null="true"/> <property name="password"/> <property name="createtime" type="date" column="create_time"/> <property name="expiretime"/> </class> </hibernate-mapping> |
通过user1.hbm.xml映射文件将user1对象转换为关系数据库中的表t_user1。
转换出的结果如下所示：
2 对象关系映射
2.1 多对一关联映射（单向）
例如用户和组的关系就是多对一的关系，多个用户对应一个组。
将实体映射成表，将对应的实体映射成表。对应的属性映射成表字段。
多对一关联映射是在多的一端来维护关联字段，在我们这个例子中也就是在用户一端来维护关系字段。
user.hbm.xml文件。
|
1
2
3
4
5
6
7
8
9
10
|
<hibernate-mapping package="org.hibernate.auction"> <class name="com.bjpowernode.hibernate.user" table="t_user" > <id name="id"> <generator class="native" /> </id> <property name="name"/> <many-to-one name="group" column="groupid"cascade="save-update"></many-to-one> </class> </hibernate-mapping> |
group.hbm.xml文件。
|
1
2
3
4
5
6
7
8
9
|
<hibernate-mapping package="org.hibernate.auction"> <class name="com.bjpowernode.hibernate.group" table="t_group"> <id name="id"> <generator class="native" /> </id> <property name="name"/> </class> </hibernate-mapping> |
在这里我们看的代码就看*.hbm.mlx代码，因为对于类之间的关联，在实现时，一个类作为另一个类的私有成员，这一点在学uml建模的时候我们都懂了，在这里主要看的是orm的m，也就是*.hbm.xml文件。
2.2 一对一关联映射
一对一关联映射在实际生活中是比较常见的，如人与家庭住址的关系，通过人这个对象可以找到他家庭住址相关的内容。
2.2.1 一对一映射（单向主键关联）
单向一对一主键关联，靠的是它们的主键相等，从person中能看到idcard，也就是把t_idcard中的主键拿过来当做t_pseron的主键。
xml文件中：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
<class name="com.bjpowernode.hibernate.person"table="t_person" > <id name="id"> <!-- 采用foreign生成策略，foreign会取得关联对象的标识 --> <generator class="foreign" > <!--property指的是关联对象。 --> <param name="property">idcard</param> </generator> </id> <property name="name"/> <!-- 一对一关联映射,主键关联. --> <!-- one-to-one标签指示hibernate如何加载其关联对象,默认根据主键加载. 也就是拿到关系字段值,根据对端的主键来加载关联对象. constrained="true",表示当前主键(person的主键)还是一个外键 . 参照了对端的主键(idcard的主键),也就是会生成外键约束语句. --> <one-to-one name="idcard" constrained="true"/> </class> |
|
1
2
3
4
5
6
7
8
9
|
<hibernate-mapping package="org.hibernate.auction"> <class name="com.bjpowernode.hibernate.idcard" table="t_idcard" > <id name="id"> <generator class="native" /> </id> <property name="cardno"/> </class> </hibernate-mapping> |
一对一的关系是通过one-to-one元素定义的。
2.2.2 一对一映射（双向主键关联）
一对一双向主键关联与一对一单向主键关联的区别就是，一对一单向主键关联，在person端能看到idcard，而idcard不能看到person端。而双向关联就是在idcard端也能看到person，也就是不但在person.hbm.xml中加上<one-to-one>标签，同时在idcard.hbm.xml文件中加上<one-to-one>标签。代码如下所示。
|
1
2
3
4
5
6
7
8
9
10
|
<hibernate-mapping package="org.hibernate.auction"> <class name="com.bjpowernode.hibernate.idcard" table="t_idcard" > <id name="id"> <generator class="native" /> </id> <property name="cardno"/> <one-to-one name="person"/> </class> </hibernate-mapping> |
2.2.3 一对一映射（单向唯一外键关联）
一对一单向唯一外键关联，也就是多对一关联的特例，把多的一端限制为一，就是一对一唯一外键关联。同多对一一样，在一端加入另一端的并采用<many-to-one>标签，通过unique="true"，这样来限制了多的一端为一。
先上代码。
idcard.hbm.xml
|
1
2
3
4
5
6
7
8
9
|
<hibernate-mapping package="org.hibernate.auction"> <class name="com.bjpowernode.hibernate.idcard" table="t_idcard" > <id name="id"> <generator class="native" /> </id> <property name="cardno"/> </class> </hibernate-mapping> |
person.hbm.xml
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
<hibernate-mapping package="org.hibernate.auction"> <class name="com.bjpowernode.hibernate.person" table="t_person" > <id name="id"> <!-- 采用foreign生成策略，foreign会取得关联对象的标识 --> <generator class="native" /> </id> <property name="name"/> <many-to-one name="idcard" unique="true"></many-to-one> </class> </hibernate-mapping> |
图如下所示：
在t_pserson端加上一个外键字段idcard，限制idcard的唯一性就是一对一唯一外键关联。
2.2.4 一对一映射（双向唯一外键关联）
一对一唯一外键单向关联我们已经了解了，双向反过来就是在没有的一端加上就可以了。
我们的idcard.hbm.xml中采用<one-to-one>标签。
|
1
2
3
4
5
6
7
8
9
10
|
<hibernate-mapping package="org.hibernate.auction"> <class name="com.bjpowernode.hibernate.idcard" table="t_idcard" > <id name="id"> <generator class="native" /> </id> <property name="cardno"/> <one-to-one name="person" property-ref="idcard"></one-to-one> </class> </hibernate-mapping> |
而person.hbm.xml同一对一唯一外键单向关联一样。
|
1
2
3
4
5
6
7
8
9
10
|
<class name="com.bjpowernode.hibernate.person" table="t_person" > <id name="id"> <!-- 采用foreign生成策略，foreign会取得关联对象的标识 --> <generator class="native" /> </id> <property name="name"/> <many-to-one name="idcard" unique="true"></many-to-one> </class> |
从上述中可以总结出，对于一对一关联映射，主键关联和唯一外键关联单向和双向产生出的表结构是一样的，不同的是在加载的时候不同。也就是一对一双向关联和一对一单向关联的相比，只是改变了一对一关联映射的加载，而没有改变存储。
2.3 一对多关联映射
2.3.1 一对多关联映射（单向）
上面我们介绍了多对一，我们反过来看一对多不就是多对一吗？那还用再进行不同的映射吗？有什么差别吗？一对多和多对一映射原理是一致的，存储是相同的，也就是生成的数据库的表是一样的，他们之间不同的是维护的关系不同。
他们之间不同点是维护的关系不同
- 多对一维护的关系是：多指向一的关系，有了此关系，加载多的时候可以将一加载上来。
- 一对多维护的关系是：一指向多的关系，有了此关系，在加载一的时候可以将多加载上来。
代码如下所示。
class.hbm.xml
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
<class name="com.bjpowernode.hibernate.classes" table="t_classes" > <id name="id"> <generator class="native" /> </id> <property name="name"/> <set name="students"> <!-- <keycolumn="classesid" not-null="true"/> --> <key column="classesid" /> <one-to-many class="com.bjpowernode.hibernate.student"/> </set> </class> |
students.hbm.xml
|
1
2
3
4
5
6
|
<class name="com.bjpowernode.hibernate.student" table="t_student" > <id name="id"> <generator class="native" /> </id> <property name="name"/> </class> |
从班级能看到学生，是班级来维护关系，不是学生来维护关系，学生不知道自己是哪个班，所以在存储学生的时候，班级的代码不知道。为了更新学生是哪个班级的要发出很多update语句来告诉学生是哪个班级的。当我们设置classesid not-null=“true”时，则将无法保存数据，解决办法我们改为双向关联映射。
2.3.2 一对多关联映射（双向）
为了解决一对多单向可能存在的问题，我们采用双向一对多，每一方都能维护对方。
一对多双向关联映射方式：
- 在一的一端的集合上采用<key>标签，在多的一端加入一个外键。
- 在多的一端采用<many-to-one>的标签
！~注意<key>标签和<many-to-one>标签加入字段保持一致，否则会产生数据混乱。
代码如下所示。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
<class name="com.bjpowernode.hibernate.classes" table="t_classes" > <id name="id"> <generator class="native" /> </id> <property name="name"/> <set name="students" inverse="true"> <!-- <keycolumn="classesid" not-null="true"/> --> <key column="classesid" /> <one-to-many class="com.bjpowernode.hibernate.student"/> </set> </class> |
|
1
2
3
4
5
6
7
|
<class name="com.bjpowernode.hibernate.student" table="t_student" > <id name="id"> <generator class="native" /> </id> <property name="name"/> <many-to-one name="classes"column="classesid"/> </class> |
注意：inverse属性
1、 inverse中文意思为相反的，反转。在hibernate中inverse可以用在一对多和多对多双向关联上，inverse默认是false，为false的时候表示本端可以维护关系，如果inverse为true，则本端不能维护关系，会交给另一端维护关系，本端失效，所以在一对多关联映射我们通常在多的一端维护关系，让一的一端失效。
2、inverse是控制方向上的反转，只影响存储。
比较一对多单向和双向映射，从存储结构上看没有什么区别，但是从配置文件上看，一对多双向比一对多单向，一对多双向关联的配置文件中在多的一端的配置文件上存在<many-to-one>相关配置，即保证多对一的映射。
2.4 多对多关联映射
2.4.1 多对多关联映射（单向）
多对多对象关系映射，需要加入一张新表完成基本映射。如下图所示。
代码。
role.hbm.xml
|
1
2
3
4
5
6
7
|
<class name="com.bjpowernode.hibernate.role" table="t_role"> <id name="id"> <generator class="native" /> </id> <property name="name"/> </class> |
user.hbm.xml
|
1
2
3
4
5
6
7
8
9
10
11
|
<class name="com.bjpowernode.hibernate.user" table="t_user" > <id name="id"> <generator class="native" /> </id> <property name="name"/> <set name="roles" table="t_user_role"> <key column="user_id"/> <many-to-many class="com.bjpowernode.hibernate.role" column="role_id"/> </set> </class> |
2.4.2 多对多关联映射（双向）
双向多对多对象关系映射，是两端都能将对方加载上来，双向都需要加上标签映射。
要注意：
- 生成中间表名必须一样
- 生成中间表字段必须一样
代码如下所示。
role.hbm.xml
|
1
2
3
4
5
6
7
8
9
10
11
|
<class name="com.bjpowernode.hibernate.role" table="t_role"> <id name="id"> <generator class="native" /> </id> <property name="name"/> <set name="users" table="t_user_role"> <key column="role_id"/> <many-to-many class="com.bjpowernode.hibernate.user" column="user_id"/> </set> </class> |
user.hbm.xml
|
1
2
3
4
5
6
7
8
9
10
11
|
<class name="com.bjpowernode.hibernate.user"table="t_user" > <id name="id"> <generator class="native" /> </id> <property name="name"/> <set name="roles" table="t_user_role"> <key column="user_id"/> <many-to-many class="com.bjpowernode.hibernate.role" column="role_id"/> </set> </class> |
区别：单向多对多和双向多对多存储结构没有任何的区别，但他们的映射文件是有区别的，加载过程是不同的。
3 关系映射总结
综上所述，可以看出，同一类映射，无论是单向还是双向，他们的存储结构是相同的，之所以映射文件不同，是因为加载时不同（在增删改时）。
无论是多对一、一对多、一对一还是多对一，a对b，a就是主动方，a主动想要了解b的情况，这样把b设置到a端。而双向，也就是a对b，a想了解b的信息，而b也想了解a的信息，那就要同时把a设置到b端了。
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持服务器之家。
原文链接：http://blog.csdn.net/lovesummerforever/article/details/20901011
