个人中心
文章发布
退出
作者热门文章
- ubuntu12.04环境下使用kvm ioctl接口实现最简单的虚拟机
- Ubuntu 通过无线网络安装Ubuntu Server启动系统后连接无线网络的方法
- 在Ubuntu上搭建网桥的方法
- ubuntu 虚拟机上网方式及相关配置详解
25
4
CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.
这篇CFSDN的博客文章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
|
//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
|
<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
|
<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
|
<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
19
20
21
22
23
24
25
26
27
|
<
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
>
<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
|
<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
|
<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
|
<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
|
<
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
14
15
16
17
18
19
20
|
<
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
>
<
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
|
<
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
|
<
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 关系映射总结 。
综上所述，可以看出，同一类映射，无论是单向还是双向，他们的存储结构是相同的，之所以映射文件不同，是因为加载时不同（在增删改时）.
无论是多对1、一对多、一对一还是多对一，a对b，a就是主动方，a主动想要了解b的情况，这样把b设置到a端。而双向，也就是a对b，a想了解b的信息，而b也想了解a的信息，那就要同时把a设置到b端了 。
以上所述是小编给大家介绍的hibernate中的对象关系映射，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对我网站的支持！ 。
原文链接：http://blog.sina.com.cn/s/blog_9c6852670102wvig.html 。
最后此篇关于hibernate中的对象关系映射的文章就讲到这里了,如果你想了解更多关于hibernate中的对象关系映射的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。
25
4
0
请看一下我的代码。 int main () { Program* allcommand = new Program; allcommand->addCommand("add", new
因此，当我遇到调试断言时，我正在编写代码。现在我很想知道为什么这段代码不起作用: for(Model::MeshMap::iterator it = obj1->GetMeshes().begin()
这是我上一个问题的延续 Group, Sum byType then get diff using Java streams . 按照建议，我应该作为单独的线程发布，而不是更新原始线程。 因此，通过我
我正在实现一些非常适合 map 的代码。但是，我要迭代的列表中有大量对象，所以我的问题是哪种方法是解决此问题的最佳方法: var stuff = $.map(listOfMyObjects, some
我正在尝试创建一个包含不同类的成员函数指针的映射。成员函数都具有相同的签名。为了做到这一点，我所有的类都继承了一个 Object 类，它只有默认构造函数、虚拟析构函数和一个虚拟 ToString()
这个问题在这里已经有了答案: 关闭 11 年前。 Possible Duplicate: how do you make a heterogeneous boost::map? 有可能在 C++ 中
我有一个 Mysql 查询，请检查以下内容: SELECT `tbl_classSubjects`.`classID` , `tbl_classSubjects`.`sectionID` , `tbl
抱歉，这可能是一个基本问题。 JNA直接映射和接口(interface)映射有什么区别？ 我的解释是否正确: 直接映射 : 直接使用库对象(如 Java 中的静态 main) 接口(interface
在 Twitter's Scala school collections section ，它们显示了一个带有偏函数作为值的 Map: // timesTwo() was defined earlie
很难说出这里问的是什么。这个问题是模棱两可的、模糊的、不完整的、过于宽泛的或修辞的，无法以目前的形式得到合理的回答。如需帮助澄清这个问题以便重新打开它，visit the help center .
据我了解，从 scala stdlib 声明一个映射并没有将其专门用于原始类型。我要的不是付出装箱/拆箱的代价，而是同时拥有scala map 的接口(interface)。一个明显的选择是使用 tr
如何为这样的 JSON 响应创建对象映射，它只是一个整数数组: [ 565195, 565309, 565261, 565515, 565292, 565281, 566346, 5
是否可以为 DTO 对象创建映射然后查询它们 而不是域？如果不解释为什么？ 如果我需要几个 dtos 怎么办？ DTos 是只读的 ID 由 NH 自动生成 将来这些 dtos 将设置映射到链接的 d
我有一个返回的函数(常规代码) [words: "one two", row: 23, col: 45] 在 Scala 中，我将上面更改为 Scala Map，但随后我被迫将其声明为 Map[Str
我有一组与 Vanilla 磅蛋糕烘焙相关的数据(200 行)，具有 27 个特征，如下所示。标签caketaste是衡量烤蛋糕的好坏程度，由 bad(0) 定义, neutral(1) , good
我有试图映射到新代码的遗留代码。 OLD_PERSON pid sid name age NEW_PERSON pid sid fid age RESOLVE_PERSON pid fid statu
我有一个表，其中一个字段可以指向其他 3 个表之一中的外键，具体取决于鉴别器值是什么(Project、TimeKeep 或 CostCenter。通常这是用子类实现的，我想知道我有什么 注意子类名称与
我有一个类型 [ST s (Int, [Int])] 的绑定(bind)我正在尝试申请runST使用映射到每个元素，如下所示: name :: [ST s (Int, [Int])] --Of Cou
在我正在进行的项目中，我有以下实体:分析师、客户 和承包商。每个都继承自基类 User。 public abstract class User { public virtual int Id
我想知道是否可以在 Vim 中创建一个映射(对于普通模式)，允许用户在映射执行之前输入。 我想为我最常用的 grep 命令创建一个快捷方式的映射。我希望命令允许输入我正在搜索的内容，然后在输入时执行。
我是一名优秀的程序员,十分优秀！