服务器之家:专注于服务器技术及软件下载分享
分类导航

PHP教程|ASP.NET教程|JAVA教程|ASP教程|编程技术|正则表达式|C/C++|IOS|C#|Swift|Android|JavaScript|

服务器之家 - 编程语言 - JAVA教程 - hibernate中的对象关系映射

hibernate中的对象关系映射

2020-12-30 11:38动力节点 JAVA教程

hibernate中的ORM映射文件通常以.hbm.xml作为后缀。使用这个映射文件不仅易读,而且可以手工修改,也可以通过一些工具来生成映射文档,下文给大家详细的介绍hibernate中的对象关系映射,需要的朋友参考下吧

hibernate的本质就是对象关系映射(objectrelational mapping),orm实现了将对象数据保存到数据库中,以前我们对关系表进行操作,执行增删改查等任务,现在我们不再对关系表进行操作,而是直接对对象操作。hibernate中的orm映射文件通常以.hbm.xml作为后缀。使用这个映射文件不仅易读,而且可以手工修改,也可以通过一些工具来生成映射文档。下面将对hibernate中的映射进行介绍。

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。
转换出的结果如下所示:

hibernate中的对象关系映射

2 对象关系映射

2.1 多对一关联映射(单向)

例如用户和组的关系就是多对一的关系,多个用户对应一个组。

hibernate中的对象关系映射

将实体映射成表,将对应的实体映射成表。对应的属性映射成表字段。

多对一关联映射是在多的一端来维护关联字段,在我们这个例子中也就是在用户一端来维护关系字段。

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 一对一映射(单向主键关联)

hibernate中的对象关系映射

单向一对一主键关联,靠的是它们的主键相等,从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>

hibernate中的对象关系映射 

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>

图如下所示:

hibernate中的对象关系映射

在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>

hibernate中的对象关系映射 

从上述中可以总结出,对于一对一关联映射,主键关联和唯一外键关联单向和双向产生出的表结构是一样的,不同的是在加载的时候不同。也就是一对一双向关联和一对一单向关联的相比,只是改变了一对一关联映射的加载,而没有改变存储。

    2.3 一对多关联映射

2.3.1 一对多关联映射(单向)

上面我们介绍了多对一,我们反过来看一对多不就是多对一吗?那还用再进行不同的映射吗?有什么差别吗?一对多和多对一映射原理是一致的,存储是相同的,也就是生成的数据库的表是一样的,他们之间不同的是维护的关系不同。

他们之间不同点是维护的关系不同

*多对一维护的关系是:多指向一的关系,有了此关系,加载多的时候可以将一加载上来。

*一对多维护的关系是:一指向多的关系,有了此关系,在加载一的时候可以将多加载上来。

hibernate中的对象关系映射

代码如下所示。

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 一对多关联映射(双向)

为了解决一对多单向可能存在的问题,我们采用双向一对多,每一方都能维护对方。

hibernate中的对象关系映射 

一对多双向关联映射方式:

     *在一的一端的集合上采用<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 多对多关联映射(单向)

多对多对象关系映射,需要加入一张新表完成基本映射。如下图所示。

hibernate中的对象关系映射 

代码。

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 多对多关联映射(双向)

双向多对多对象关系映射,是两端都能将对方加载上来,双向都需要加上标签映射。
要注意:

*生成中间表名必须一样

*生成中间表字段必须一样

hibernate中的对象关系映射 

代码如下所示。

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  关系映射总结

综上所述,可以看出,同一类映射,无论是单向还是双向,他们的存储结构是相同的,之所以映射文件不同,是因为加载时不同(在增删改时)。

无论是多对一、一对多、一对一还是多对一,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

延伸 · 阅读

精彩推荐