Hibernate关联映射

最新推荐文章于 2024-08-25 21:18:14 发布
最新推荐文章于 2024-08-25 21:18:14 发布
阅读量282 收藏 1
点赞数
文章标签： 数据 hibernate 映射

以简单的两个类为例：
User(int id, String name)
Group(int id, String name)

没有关联关系时的关系模型：
t_user(id int pk, name varchar)
t_group(id int pk, name varchar)

一、多对一和一对多关联映射（多个用户有相同的组）

这几种关联映射后的关系模型是相同的：
t_user(id int pk, name varchar, gid int fk->t_group(id))
t_group(id int pk, name varchar)

1、多对一单向关联

实体模型：
bean.User(int id, String name, Group group)
bean.Group(int id, String name)

?
1
2
3
4
5
6
7
8
9
10
<!-- bean/User.hbm.xml -->
  
< hibernate-mapping >
     < class name="bean.User" table="t_user">
         < id name="id">< generator class="native"/></ id >
         < property name="name"/>
         <!-- 使用<many-to-one>映射多对一关系。导出ddl时将自动生成一个外键 -->
         < many-to-one name="group" column="gid"/>
     </ class >
</ hibernate-mapping >
?
1
2
3
4
5
6
7
8
<!-- bean/Group.hbm.xml -->
  
< hibernate-mapping >
     < class name="bean.Group" table="t_group">
         < id name="id">< generator class="native"/></ id >
         < property name="name"/>
     </ class >
</ hibernate-mapping >
2、一对多单向关联（几乎不用）

实体模型：
bean.User(int id, String name)
bean.Group(int id, String name, Set users)

?
1
2
3
4
5
6
7
8
<!-- bean/User.hbm.xml -->
  
< hibernate-mapping >
     < class name="bean.User" table="t_user">
         < id name="id">< generator class="native"/></ id >
         < property name="name"/>
     </ class >
</ hibernate-mapping >
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<!-- bean/Group.hbm.xml -->
  
< hibernate-mapping >
     < class name="bean.Group" table="t_group">
         < id name="id">< generator class="native"/></ id >
         < property name="name"/>
         <!-- 使用<set>映射集合 -->
         < set name="users">
             <!-- 使用<key>指定引用至自身的外键表（t_user）中的外键 -->
             < key column="gid"/>
             <!-- 使用<one-to-many>映射一对多关系 -->
             < one-to-many class="bean.User"/>
         </ set >
     </ class >
</ hibernate-mapping >

为Group加入集合也可以使用List（<list>），注意不能指定类型是具体的HashSet或ArrayList，只能是接口Set或List。
集合标签可以使用order-by属性指定排序：

?
1
< set name="users" order-by="id desc">
3、双向关联

实体模型：
bean.User(int id, String name, Group group)
bean.Group(int id, String name, Set users)

?
1
2
3
4
5
6
7
8
9
10
<!-- bean/User.hbm.xml -->
  
< hibernate-mapping >
     < class name="bean.User" table="t_user">
         < id name="id">< generator class="native"/></ id >
         < property name="name"/>
         <!-- 使用<many-to-one>映射多对一关系。导出ddl时将自动生成一个外键 -->
         < many-to-one name="group" column="gid"/>
     </ class >
</ hibernate-mapping >
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<!-- bean/Group.hbm.xml -->
  
< hibernate-mapping >
     < class name="bean.Group" table="t_group">
         < id name="id">< generator class="native"/></ id >
         < property name="name"/>
         <!-- 使用<set>映射集合 -->
         < set name="users">
             <!-- 使用<key>指定引用至自身的外键表（t_user）中的外键 -->
             < key column="gid"/>
             <!-- 使用<one-to-many>映射一对多关系 -->
             < one-to-many class="bean.User"/>
         </ set >
     </ class >
</ hibernate-mapping >

双向关联中，为<set>加入”inverse=true”可以反转维护关系：Hibernate将放弃从一的一端维护。意思就是user和group的关系必须使用user维护，操作group时Hibernate将不维护这个关系。

?
1
< set name="users" inverse="true">

操作group的示例：

?
1
2
3
4
5
6
7
8
9
10
11
12
session.beginTransaction();
User user = new User();
user.setName( "张三" );
  
Group group = new Group();
group.setName( "admin" );
group.setUsers( new HashSet());
group.getUsers().add(user);
  
session.save(user);
session.save(group);
session.getTransaction().commit();

没有配置inverse=”true”时，Hibernate输出了添加user和group，并更新user的语句：

Hibernate: insert into t_user (name, gid) values (?, ?)
Hibernate: insert into t_group (name) values (?)
Hibernate: update t_user set gid=? where id=?
而配置了inverse=”true”后，Hibernate仅仅输出了添加user和group的语句，并没有更新user，放弃了关系的维护：
Hibernate: insert into t_user (name, gid) values (?, ?)
Hibernate: insert into t_group (name) values (?)
此时应该从user端维护关系：
?
1
2
3
4
5
6
7
8
9
10
11
session.beginTransaction();
Group group = new Group();
group.setName( "admin" );
  
User user = new User();
user.setName( "张三" );
user.setGroup(group);
  
session.save(group);
session.save(user);
session.getTransaction().commit();

因为外键列在t_user表中，从group端维护需要操作多表，所以从user端维护关系更加合理，效率也更高。上面的代码输出两条SQL语句，插入数据的同时也维护了关系：

Hibernate: insert into t_group (name) values (?)
Hibernate: insert into t_user (name, gid) values (?, ?)

 

二、一对一关联映射（每个用户独有一个组）

依照映射方法不同，可分为主键关联映射和唯一外键关联映射。主键关联是维护两张表的主键一致，如有必要还可以在主键上再加上外键约束；唯一外键关联则类似于多对一关联，为表加入一个外键列，不过一对一关联会同时将这个外键加上唯一约束。

1、主键关联映射

主键关联生成的关系模型：
t_user(id int pk fk->t_group(id), name varchar)
t_group(id int pk, name varchar)

1.1、主键单向关联

实体模型：
bean.User(int id, String name, Group group)
bean.Group(int id, String name)

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<!-- bean/User.hbm.xml -->
  
< hibernate-mapping >
     < class name="bean.User" table="t_user">
         < id name="id">
             <!-- 指定主键生成策略为外键 -->
             < generator class="foreign">
                 <!-- 指定要参照的属性 -->
                 < param name="property">group</ param >
             </ generator >
         </ id >
         < property name="name"/>
         <!-- 使用<one-to-one>映射一对一关系。 -->
         < one-to-one name="group">
     </ class >
</ hibernate-mapping >
?
1
2
3
4
5
6
7
8
<!-- bean/Group.hbm.xml -->
  
< hibernate-mapping >
     < class name="bean.Group" table="t_group">
         < id name="id">< generator class="native"/></ id >
         < property name="name"/>
     </ class >
</ hibernate-mapping >

主键关联由Hibernate维护，不依赖数据库。如果需要在数据库端也生成外键约束，可以使用constrained：

?
1
< one-to-one name="group" constrained="true"/>

1.2、主键双向关联

实体模型：
bean.User(int id, String name, Group group)
bean.Group(int id, String name, User user)

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<!-- bean/User.hbm.xml -->
  
< hibernate-mapping >
     < class name="bean.User" table="t_user">
         < id name="id">
             <!-- 指定主键生成策略为外键 -->
             < generator class="foreign">
                 <!-- 指定要参照的属性 -->
                 < param name="property">group</ param >
             </ generator >
         </ id >
         < property name="name"/>
         <!-- 使用<one-to-one>映射一对一关系。 -->
         < one-to-one name="group">
     </ class >
</ hibernate-mapping >
?
1
2
3
4
5
6
7
8
9
10
<!-- bean/Group.hbm.xml -->
  
< hibernate-mapping >
     < class name="bean.Group" table="t_group">
         < id name="id">< generator class="native"/></ id >
         < property name="name"/>
         <!-- 使用<one-to-one>映射一对一关系 -->
         < one-to-one name="user"/>
     </ class >
</ hibernate-mapping >

 

2、唯一外键关联映射

唯一外键关联生成的关系模型：
t_user(id int pk, name varchar, gid int fk->t_group(id))
t_group(id int pk, name varchar)

2.1、唯一外键单向关联

实体模型：
bean.User(int id, String name, Group group)
bean.Group(int id, String name)

?
1
2
3
4
5
6
7
8
9
10
11
12
<!-- bean/User.hbm.xml -->
  
< hibernate-mapping >
     < class name="bean.User" table="t_user">
         < id name="id">
             < generator class="native"/>
         </ id >
         < property name="name"/>
         <!-- 为<many-to-one>加上unique就变成了一对一 -->
         < many-to-one name="group" unique="true" column="gid"/>
     </ class >
</ hibernate-mapping >
?
1
2
3
4
5
6
7
8
<!-- bean/Group.hbm.xml -->
  
< hibernate-mapping >
     < class name="bean.Group" table="t_group">
         < id name="id">< generator class="native"/></ id >
         < property name="name"/>
     </ class >
</ hibernate-mapping >

2.2、唯一外键双向关联

实体模型：
bean.User(int id, String name, Group group)
bean.Group(int id, String name, User user)

?
1
2
3
4
5
6
7
8
9
10
11
12
<!-- bean/User.hbm.xml -->
  
< hibernate-mapping >
     < class name="bean.User" table="t_user">
         < id name="id">
             < generator class="native"/>
         </ id >
         < property name="name"/>
         <!-- 为<many-to-one>加上unique就变成了一对一 -->
         < many-to-one name="group" unique="true" column="gid"/>
     </ class >
</ hibernate-mapping >
?
1
2
3
4
5
6
7
8
9
10
<!-- bean/Group.hbm.xml -->
  
< hibernate-mapping >
     < class name="bean.Group" table="t_group">
         < id name="id">< generator class="native"/></ id >
         < property name="name"/>
         <!-- 使用<one-to-one>映射一对一 -->
         < one-to-one name="user"/>
     </ class >
</ hibernate-mapping >

三、多对多关联映射（每个用户拥有多个组，每个组也有多个用户）

多对多关联映射关系使用中间表表示。导出关系模型时Hibernate将自动生成复合主键以及外键约束。

关系模型：
t_user(id int pk, name varchar)
t_group(id int pk, name varchar)
t_user_group(userid int fk->t_user(id), groupid int fk->t_group(id), pk(userid, groupid))

1、多对多单向关联

实体模型：
bean.User(int id, String name, Set groups)
bean.Group(int id, String name)

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<!-- bean/User.hbm.xml -->
  
< hibernate-mapping >
     < class name="bean.User" table="t_user">
         < id name="id">
             < generator class="native"/>
         </ id >
         < property name="name"/>
         <!-- 使用<set>映射集合，在多对多关系中，Hibernate将生成第三张表 -->
         < set name="groups" table="t_user_group">
             <!-- 使用<key>指定引用至自身的外键表（t_user_group）中的外键 -->
             < key column="userid"/>
             <!-- 使用<many-to-many>映射多对多关系，column指定另一端在表t_user_group中的列 -->
             < many-to-many class="bean.Group" column="groupid"/>
         </ set >
     </ class >
</ hibernate-mapping >
?
1
2
3
4
5
6
7
8
<!-- bean/Group.hbm.xml -->
  
< hibernate-mapping >
     < class name="bean.Group" table="t_group">
         < id name="id">< generator class="native"/></ id >
         < property name="name"/>
     </ class >
</ hibernate-mapping >
1、多对多单向关联

实体模型：
bean.User(int id, String name, Set groups)
bean.Group(int id, String name, Set users)

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<!-- bean/User.hbm.xml -->
  
< hibernate-mapping >
     < class name="bean.User" table="t_user">
         < id name="id">
             < generator class="native"/>
         </ id >
         < property name="name"/>
         <!-- 使用<set>映射集合，在多对多关系中，Hibernate将生成第三张表 -->
         < set name="groups" table="t_user_group">
             <!-- 使用<key>指定引用至自身的外键表（t_user_group）中的外键 -->
             < key column="userid"/>
             <!-- 使用<many-to-many>映射多对多关系，column指定另一端在表t_user_group中的列 -->
             < many-to-many class="bean.Group" column="groupid"/>
         </ set >
     </ class >
</ hibernate-mapping >
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<!-- bean/Group.hbm.xml -->
  
< hibernate-mapping >
     < class name="bean.Group" table="t_group">
         < id name="id">
             < generator class="native"/>
         </ id >
         < property name="name"/>
         <!-- 使用<set>映射集合，在多对多关系中，Hibernate将生成第三张表 -->
         < set name="users" table="t_user_group">
             <!-- 使用<key>指定引用至自身的外键表（t_user_group）中的外键 -->
             < key column="group"/>
             <!-- 使用<many-to-many>映射多对多关系，column指定另一端在表t_user_group中的列 -->
             < many-to-many class="bean.User" column="userid"/>
         </ set >
     </ class >
</ hibernate-mapping >

多对多的双向关联同样可以在不想要维护关系的一端的<set>里设置inverse=”true”；但是必须有一端可以维护，也就是说只可以设置一个。

YYWX24
关注
Hibernate 关联映射
04-21
这可能是测试Hibernate关联映射的一个示例项目或者类。通常，这样的测试会包含各种关联映射的实例，如实体类的定义，配置文件或注解，以及测试用例，用于验证关联映射是否按预期工作。 **详细知识讲解：** 1. **一...
hibernate关联映射
04-19
**Hibernate关联映射详解** 在Java的持久化框架中，Hibernate是一个非常强大的工具，它使得开发者可以更加方便地处理数据库操作。其中，关联映射是Hibernate的核心特性之一，它允许我们将对象模型与关系数据库模型...
Hibernate关联映射（非常详细）
youandme520的专栏
02-12 1659
在前面的学习中，我们所涉及的都是基于单表的操作，但在实际的开发过程中，基本上都是同时对多张表的操作，且这些表都存在一定的关联关系。 Hibernate 是一款基于 ORM 设计思想的框架，它将关系型数据库中的表与我们 Java 实体类进行映射，表中的记录对应实体类的对象，而表中的字段对应着实体类中的属性。Hibernate 进行增删改查等操作时，不再直接操作数据库表，而是对与之对应的实体类对象进行处理。那么，Hibernate 是如何处理多表关联问题的呢？本节我们针对此问题进行介绍。 关联映射 在关系型
6.Hibernate关联映射（多对一、双向一对多、双向多对多）
相互学习 共同进步
04-29 338
类与类之间最普遍的关系就是关联关系，而且关联是有方向的。 以部门表（Depe）与员工表（Emp）为例： ①一个部门下有多个员工，而一个员工只能属于一个部门。 ②从Emp到Dept的关联是多对一关联，这就意味着每个Emp对象只会引用一个Dept对象 ③从而Dept到Emp是一对多的关联，这就意味着每个Dept对象会引用一组Emp对象 因此，在Emp类中应该定义一个Dept类型的属性，来引用所关联的Dept对象；而在Dept类中一个定义个一个集合类型的属性，来引用所有关联的Emp对象。
Hibernate关联映射（一对多/多对多）
热门推荐
知飞翀的博客
11-22 1万+
3.  Hibernate关联映射 上接Hibernate持久化类：https://blog.csdn.net/biggerchong/article/details/84260707 目录 3.  Hibernate关联映射 3.1 数据库表之间的关系 3.1.1 一对多关系 3.1.2 多对多关系 3.1.3 一对一关系（实际开发中使用较少） 3.2 实战Hibernate...
Hibernate关联映射属性介绍
lavimer
06-16 770
如下关联映射文件：
Hibernate关联映射+级联操作
敲得码黛
06-21 639
Hibernate关联映射简述：    在关系型数据库中，通过外键来建立起表与表之间的关系， 而Hibernate通过关联映射把这种关系映射到了实体之中。关联映射用来处理表与表之间的关系，并且把表与表之间的主外键关系映射到实体中。                                   1.单向一对多、单向多对一2.双向一对多3.多对多4.一对一...
hibernate关联映射(一对多)
mockingbirds的专栏
06-14 1135
这篇博客将会给大家带来hibernate的关联映射的学习。在现实生活中，不仅只是一对一的映射关系，更多的是一对多，多对多等。一对多单项关联映射这里我以网盘为例，一个用户可以拥有多个文件，及用户和文件之间是一对多的关系。 user实体类：public class Users { private int uid; private String uname; //用户上传的所有文
Hibernate 关联映射配置文件
秋水の歌的专栏
07-25 552
1、one-to-one one-to-one表示一对一关联，元素的常用shu
hibernate关联映射注解及@JoinColumn的用法
JokerZhan的博客
12-15 2943
1、一对一单项外键（比如实体People和实体IDCard，一个人对应一个身份证号，反之） @OneToOne（cascade=CAscadeType.ALL）全级联关系 @JoinColumn（name="pid",unique=true）被控类的外键写到主控类中，且唯一 ps：保存时应该先保存外键对象，再保存主表对象，这是因为数据库相关约束的原因 2、一对一双向外键 主控方配置不变 被控方添...
spring+hibernate 关联映射
我的博客
01-26 611
ORM 对象关系映射，即将数据库中的表数据映射成对象。 本文讨论hibernate的注解式实体映射 1、一对一(one to one) 用户  与  用户扩展信息 （T_USR ----- T_USERINFO） @OneToOne注释五个属性：targetEntity、cascade、fetch、optional 和mappedBy targetEnti
Hibernate关联映射.rar
01-14
本教程“Hibernate关联映射.rar”聚焦于Hibernate中的关联映射，特别是多对一和一对多的关系映射，非常适合初学者了解和实践。 首先，我们要理解什么是关联映射。在数据库中，表与表之间存在各种关系，如一对一、一...
hibernate关联映射实例
09-01
本文将深入探讨“hibernate关联映射实例”中的关键知识点，包括一对多、多对多和继承映射，这些都是Hibernate中至关重要的概念。 1. **一对多关联映射**： 在现实世界中，一个实体可能会与多个其他实体相关联，...
Web安全：SQL注入实战测试.（扫描 + 测试）
网络安全领域___专研者.
08-25 1126
SQL注入就是 有些恶意用户在提交查询请求的过程中 将SQL语句插入到请求内容中，同时程序的本身对用户输入的内容过于相信，没有对用户插入的SQL语句进行任何的过滤，从而直接被SQL语句直接被服务端执行，导致数据库的原有信息泄露，篡改，甚至被删除等风险。
OBS-Studio-30.2.3-Windows.zip
最新发布
09-23
OBS-Studio-30.2.3-Windows.zip
ChanjeeDlnaTool-v1.0 推送电脑上的文件到安卓电视大屏，实现音视频播放和apk安装
09-23
详情参考：https://blog.csdn.net/title71/article/details/142462255?spm=1001.2014.3001.5501 文件里面含有视频使用教程 一.windows+Android大屏 使用投送教程： 准备 0.电视机和电脑要在同一网络下面 1.使用u盘安装chanjeeDlnaTool.apk到电视机 2.将Windows软件拷贝到合适目录，将.mp4 /.flac /.jpg ...文件拷贝到软件目录的www/files文件夹下面 投送 1.打开Android电视机大屏的刚安装的软件，找到左上角显示的电视机的ip地址 2.双击打开Windows软件的ChanjeeDlnaTool.exe文件，有弹窗提示防火墙网络，请点击允许 3.在Windows软件的ip地址栏输入Android电视机大屏上面的ip地址，并在Windows软件点击认证 4.认证完成后Windows软件下方蓝字会提示Binging successful 就说明绑定成功，此时就可以在Windows软件选择本地文件向Android大屏投送文件了
CODESYS是PLC软件编程工具.docx
09-23
CODESYS是一款功能强大的PLC（可编程逻辑控制器）软件编程工具，广泛应用于工业自动化领域。以下是对CODESYS的详细介绍： 一、基本概述 定义：CODESYS是Controlled Development System的缩写，是可编程逻辑控制PLC的完整开发环境。 开发商：CODESYS软件商是德国Smart software solution GmbH，该公司位于德国巴伐利亚州肯普腾市。 最新版本：CODESYS V3（国内PLC用户使用的版本多为CODESYS V2.3）。V3版本在软件架构上有了很大的改善，朝安全软件的方向发展，正在申请TUV关于EN 61508的SIL认证。 二、主要特点 开放性：CODESYS是一个开放的软件平台，允许第三方开发者在其上开发定制化的解决方案，适应不同厂商的PLC设备，具有很高的灵活性和扩展性。 跨平台：CODESYS可以运行在多种不同的操作系统上，包括Windows、Linux和嵌入式系统（RTOS），提高了开发效率和可移植性。 多语言支持：支持IEC61131-3标准下的IL、ST、FBD、LD、CFC、SFC六种PLC编程语言，用
广西中医药大学在湖南2021-2024各专业最低录取分数及位次表.pdf
09-23
全国各大学在湖南2021-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
Hibernate关联映射详解：从基础到租房系统应用
本资源是一份名为"02-Hibernate 关联映射.pdf"的PDF电子书，主要讲解了Hibernate框架中的关联映射...通过这份资料，读者可以深入理解Hibernate关联映射在实际项目中的运用，提升数据库操作的灵活性和代码组织的清晰度。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值