hibernate关联映射:多对一 一对一 多对多 详解(转载)

最新推荐文章于 2021-02-07 04:08:21 发布
最新推荐文章于 2021-02-07 04:08:21 发布
阅读量88 收藏
点赞数
分类专栏： hibernate 文章标签： Hibernate SQL XML
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/abc9632147/article/details/83645348
版权
单向关联（Unidirectional associations）
多对一(many to one)

单向many-to-one关联是最常见的单向关联关系。 


<class name="Person">
    <id name="id" column="personId">
        <generator class="native"/>
    </id>
    <many-to-one name="address" 
        column="addressId"
        not-null="true"/>
</class>
<class name="Address">
    <id name="id" column="addressId">
        <generator class="native"/>
    </id>
</class>



create table Person ( personId bigint not null primary key, addressId bigint not null )
create table Address ( addressId bigint not null primary key )


一对一（one to one）

基于外键关联的单向一对一关联和单向多对一关联几乎是一样的。唯一的不同就是单向一对一关联中的外键字段具有唯一性约束。 


<class name="Person">
    <id name="id" column="personId">
        <generator class="native"/>
    </id>
    <many-to-one name="address" 
        column="addressId" 
        unique="true"
        not-null="true"/>
</class>
<class name="Address">
    <id name="id" column="addressId">
        <generator class="native"/>
    </id>
</class>



create table Person ( personId bigint not null primary key, addressId bigint not null unique )
create table Address ( addressId bigint not null primary key )


基于主键关联的单向一对一关联通常使用一个特定的id生成器。（请注意，在这个例子中我们掉换了关联的方向。） 


<class name="Person">
    <id name="id" column="personId">
        <generator class="native"/>
    </id>
</class>
<class name="Address">
    <id name="id" column="personId">
        <generator class="foreign">
            <param name="property">person</param>
        </generator>
    </id>
    <one-to-one name="person" constrained="true"/>
</class>



create table Person ( personId bigint not null primary key )
create table Address ( personId bigint not null primary key )


一对多（one to many）

基于外键关联的单向一对多关联是一种很少见的情况，并不推荐使用。 


<class name="Person">
    <id name="id" column="personId">
        <generator class="native"/>
    </id>
    <set name="addresses">
        <key column="personId" 
            not-null="true"/>
        <one-to-many class="Address"/>
    </set>
</class>
<class name="Address">
    <id name="id" column="addressId">
        <generator class="native"/>
    </id>
</class>



create table Person ( personId bigint not null primary key )
create table Address ( addressId bigint not null primary key, personId bigint not null )


我们认为对于这种关联关系最好使用连接表。
使用连接表的单向关联（Unidirectional associations with join tables）
. 一对多(one to many)

基于连接表的单向一对多关联 应该优先被采用。请注意，通过指定unique="true"，我们可以把多样性从多对多改变为一对多。 


<class name="Person">
    <id name="id" column="personId">
        <generator class="native"/>
    </id>
    <set name="addresses" table="PersonAddress">
        <key column="personId"/>
        <many-to-many column="addressId"
            unique="true"
            class="Address"/>
    </set>
</class>
<class name="Address">
    <id name="id" column="addressId">
        <generator class="native"/>
    </id>
</class>



create table Person ( personId bigint not null primary key )
create table PersonAddress ( personId not null, addressId bigint not null primary key )
create table Address ( addressId bigint not null primary key )


多对一（many to one）

基于连接表的单向多对一关联在关联关系可选的情况下应用也很普遍。 


<class name="Person">
    <id name="id" column="personId">
        <generator class="native"/>
    </id>
    <join table="PersonAddress" 
        optional="true">
        <key column="personId" unique="true"/>
        <many-to-one name="address"
            column="addressId" 
            not-null="true"/>
    </join>
</class>
<class name="Address">
    <id name="id" column="addressId">
        <generator class="native"/>
    </id>
</class>



create table Person ( personId bigint not null primary key )
create table PersonAddress ( personId bigint not null primary key, addressId bigint not null )
create table Address ( addressId bigint not null primary key )


一对一（one to one）

基于连接表的单向一对一关联非常少见，但也是可行的。 


<class name="Person">
    <id name="id" column="personId">
        <generator class="native"/>
    </id>
    <join table="PersonAddress" 
        optional="true">
        <key column="personId" 
            unique="true"/>
        <many-to-one name="address"
            column="addressId" 
            not-null="true"
            unique="true"/>
    </join>
</class>
<class name="Address">
    <id name="id" column="addressId">
        <generator class="native"/>
    </id>
</class>



create table Person ( personId bigint not null primary key )
create table PersonAddress ( personId bigint not null primary key, addressId bigint not null unique )
create table Address ( addressId bigint not null primary key )


多对多（many to many）

最后，还有 单向多对多关联. 


<class name="Person">
    <id name="id" column="personId">
        <generator class="native"/>
    </id>
    <set name="addresses" table="PersonAddress">
        <key column="personId"/>
        <many-to-many column="addressId"
            class="Address"/>
    </set>
</class>
<class name="Address">
    <id name="id" column="addressId">
        <generator class="native"/>
    </id>
</class>



create table Person ( personId bigint not null primary key )
create table PersonAddress ( personId bigint not null, addressId bigint not null, primary key (personId, addressId) )
create table Address ( addressId bigint not null primary key )



双向关联（Bidirectional associations）
一对多（one to many) / 多对一（many to one）

双向多对一关联 是最常见的关联关系。（这也是标准的父/子关联关系。） 


<class name="Person">
    <id name="id" column="personId">
        <generator class="native"/>
    </id>
    <many-to-one name="address" 
        column="addressId"
        not-null="true"/>
</class>
<class name="Address">
    <id name="id" column="addressId">
        <generator class="native"/>
    </id>
    <set name="people" inverse="true">
        <key column="addressId"/>
        <one-to-many class="Person"/>
    </set>
</class>



create table Person ( personId bigint not null primary key, addressId bigint not null )
create table Address ( addressId bigint not null primary key )


如果你使用List(或者其他有序集合类)，你需要设置外键对应的key列为 not null,让Hibernate来从集合端管理关联，维护每个元素的索引（通过设置update="false" and insert="false"来对另一端反向操作）。 


<class name="Person">
   <id name="id"/>
   ...
   <many-to-one name="address"
      column="addressId"
      not-null="true"
      insert="false"
      update="false"/>
</class>
<class name="Address">
   <id name="id"/>
   ...
   <list name="people">
      <key column="addressId" not-null="true"/>
      <list-index column="peopleIdx"/>
      <one-to-many class="Person"/>
   </list>
</class>


假若集合映射的<key>元素对应的底层外键字段是NOT NULL的，那么为这一key元素定义not-null="true"是很重要的。不要仅仅为可能的嵌套<column>元素定义not-null="true"，<key>元素也是需要的。
一对一（one to one）

基于外键关联的双向一对一关联也很常见。 


<class name="Person">
    <id name="id" column="personId">
        <generator class="native"/>
    </id>
    <many-to-one name="address" 
        column="addressId" 
        unique="true"
        not-null="true"/>
</class>
<class name="Address">
    <id name="id" column="addressId">
        <generator class="native"/>
    </id>
   <one-to-one name="person" 
        property-ref="address"/>
</class>



create table Person ( personId bigint not null primary key, addressId bigint not null unique )
create table Address ( addressId bigint not null primary key )



基于主键关联的一对一关联需要使用特定的id生成器。 


<class name="Person">
    <id name="id" column="personId">
        <generator class="native"/>
    </id>
    <one-to-one name="address"/>
</class>
<class name="Address">
    <id name="id" column="personId">
        <generator class="foreign">
            <param name="property">person</param>
        </generator>
    </id>
    <one-to-one name="person" 
        constrained="true"/>
</class>



create table Person ( personId bigint not null primary key )
create table Address ( personId bigint not null primary key )


使用连接表的双向关联（Bidirectional associations with join tables）
. 一对多（one to many） /多对一（ many to one）

基于连接表的双向一对多关联。注意inverse="true"可以出现在关联的任意一端，即collection端或者join端。 


<class name="Person">
    <id name="id" column="personId">
        <generator class="native"/>
    </id>
    <set name="addresses" 
        table="PersonAddress">
        <key column="personId"/>
        <many-to-many column="addressId"
            unique="true"
            class="Address"/>
    </set>
</class>
<class name="Address">
    <id name="id" column="addressId">
        <generator class="native"/>
    </id>
    <join table="PersonAddress" 
        inverse="true" 
        optional="true">
        <key column="addressId"/>
        <many-to-one name="person"
            column="personId"
            not-null="true"/>
    </join>
</class>



create table Person ( personId bigint not null primary key )
create table PersonAddress ( personId bigint not null, addressId bigint not null primary key )
create table Address ( addressId bigint not null primary key )


一对一（one to one）

基于连接表的双向一对一关联极为罕见，但也是可行的。 


<class name="Person">
    <id name="id" column="personId">
        <generator class="native"/>
    </id>
    <join table="PersonAddress" 
        optional="true">
        <key column="personId" 
            unique="true"/>
        <many-to-one name="address"
            column="addressId" 
            not-null="true"
            unique="true"/>
    </join>
</class>
<class name="Address">
    <id name="id" column="addressId">
        <generator class="native"/>
    </id>
    <join table="PersonAddress" 
        optional="true"
        inverse="true">
        <key column="addressId" 
            unique="true"/>
        <many-to-one name="person"
            column="personId" 
            not-null="true"
            unique="true"/>
    </join>
</class>



create table Person ( personId bigint not null primary key )
create table PersonAddress ( personId bigint not null primary key, addressId bigint not null unique )
create table Address ( addressId bigint not null primary key )


多对多（many to many）

最后，还有 双向多对多关联. 


<class name="Person">
    <id name="id" column="personId">
        <generator class="native"/>
    </id>
    <set name="addresses"  table="PersonAddress">
        <key column="personId"/>
        <many-to-many column="addressId"
            class="Address"/>
    </set>
</class>
<class name="Address">
    <id name="id" column="addressId">
        <generator class="native"/>
    </id>
    <set name="people" inverse="true"  table="PersonAddress">
        <key column="addressId"/>
        <many-to-many column="personId"
            class="Person"/>
    </set>
</class>



create table Person ( personId bigint not null primary key )
create table PersonAddress ( personId bigint not null, addressId bigint not null, primary key (personId, addressId) )
create table Address ( addressId bigint not null primary key )


7.6. 更复杂的关联映射

更复杂的关联连接极为罕见。 通过在映射文档中嵌入SQL片断，Hibernate也可以处理更为复杂的情况。比如，假若包含历史帐户数据的表定义了accountNumber, effectiveEndDate 和effectiveStartDate字段，按照下面映射： 


<properties name="currentAccountKey">
    <property name="accountNumber" type="string" not-null="true"/>
    <property name="currentAccount" type="boolean">
        <formula>case when effectiveEndDate is null then 1 else 0 end</formula>
    </property>
</properties>
<property name="effectiveEndDate" type="date"/>
<property name="effectiveStateDate" type="date" not-null="true"/>


那么我们可以对目前(current)实例(其effectiveEndDate为null)使用这样的关联映射: 


<many-to-one name="currentAccountInfo" 
        property-ref="currentAccountKey"
        class="AccountInfo">
    <column name="accountNumber"/>
    <formula>'1'</formula>
</many-to-one>


更复杂的例子,假想Employee和Organization之间的关联是通过一个Employment中间表维护的,而中间表中填充了很多历史雇员数据。那“雇员的最新雇主”这个关联（最新雇主就是startDate最后的那个）可以这样映射： 


<join>
    <key column="employeeId"/>
    <subselect>
        select employeeId, orgId 
        from Employments 
        group by orgId 
        having startDate = max(startDate)
    </subselect>
    <many-to-one name="mostRecentEmployer" 
            class="Organization" 
            column="orgId"/>
</join>


使用这一功能时可以充满创意，但通常更加实用的是用HQL或条件查询来处理这些情形。
abc9632147
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
mysql 一对多映射_Hibernate一对多映射关系详解（附带实例）
weixin_42615743的博客
01-27 490
在三种关联关系中，一对多(或多对一)是最为常见的一种关联关系，一对多映射关系是由“多”的一方指向“一”的一方。在表示“多”的一方的数据表中增加一个外键，指向“一”的一方的数据表的主键，“一”的一方称为主表，而“多”的一方称为从表。以班级和学生的关联关系为例，班级表与学生表的关联关系如图 1 所示。图 1班级表和学生表的关联关系在图 1 中，grade 表为班级表，id 为班级表的主键，name...
Hibernate一对多/多对一关系映射详解及相应的增删查改操作
MoLi blog
03-31 1万+
以客户与订单的关系为例 1.在实体模型类中绑定两者关系: 客户类: public class Customer { private Integer id;//客户id private String name;//客户名称 //一对多属性描述，一个客户有n个订单 private Set<Order> orders = new HashSet<Ord...
hibernate(三) 一对多映射关系
weixin_33850890的博客
11-29 61
　　　　序言 　　　　　　　前面两节讲了hibernate的两个配置文件和hello world！。还有hibernate的一级缓存和三种状态，基本上hibernate就懂一点了，从这章起开始一个很重要的知识点，hibernate的关系映射。一对一、一对多、多对多的讲解。，希望你们能从中学到东西，我也从中巩固自己的知识 　　　　　　　　计划： 　　　　　　　　　　　one to many：单向一对...
java hibernate 一对多和多对多映射关系总结
weixin_34378922的博客
07-23 66
one-to-many 一对多 package lt.demo6; import java.util.HashMap; import java.util.HashSet; import java.util.Set; public class Department { private Integer id; private String name; private ...
hibernate常用一对一、一对多、多对一、多对多映射关系真实例子(华南银行项目)...
davexin
07-19 166
本文主旨，不使用联合主键映射为单独的类。而采用主键自动生成。闲话少说，进入正题： 本文需要4张表，演示hibernate的一对一，一对多，多对一，多对多关系。 表名字如下， T_user, role , userrole,  T_group, 其中T_user与T_group为一对一关系，T_user与role 为多对多关系，通过userrole表关联，userrole表中除了有T_user, r...
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...
JPA注解详解与多对一关联映射
Charge8的博客
10-19 842
基于 hibernate-jpa-2.1-api ，mysql数据库 import javax.persistence.*; 一、JPA 基本注解: @Entity @Table(name="t_user") public class User { @Id @GeneratedValue(generator="h-uuid2") @GenericGenerator(name ...
mysql 一对多映射_在Hibernate中的一对多的关系的映射如何配置
weixin_34856548的博客
02-07 130
配置文件中映射元素详解对象关系的映射是用一个XML文档来说明的。映射文档可以使用工具来生成，如XDoclet，Middlegen和AndroMDA等。下面从一个映射的例子开始讲解映射元素，映射文件的代码如下。＜?xml version="1.0"?＞＜!--所有的XML映射文件都需要定义如下所示的DOCTYPE。Hibernate会先在它的类路径(classptah)中搜索DTD文件。--＞＜!D...
hibernate映射详解:一对一映射的两种实现方式
都市桃源
04-03 1086
hibernate映射详解,这里是一对一映射的单讲: 本例采用phone和simcard实例: phone和phone.hbm.xml: Phone类: package hibernate_onToOne; public class Phone { private int id; private String name; //一对一映射时不要实例化,因为数据库中没有对应的表,hib
Hibernate：many-to-one（多对一）关联映射详解
SirouW的博客
09-02 3799
理解多对一映射，并分3种情况，对many-to-one在Hibernate中的应用进行探索。
hibernate关联映射详解SSH 多对多，一对多关系对象映射
04-21
hibernate关联映射详解SSH 多对多，一对多关系对象映射
hibernate关联映射详解
06-29
hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,包含4个说明文档，分别详细解说了hibernate关联映射的...
hibernate对映射xml的一对多的双向关联详解
03-30
NULL 博文链接：https://hi-beijing.iteye.com/blog/1315150
hibernate one-to-one 一对一唯一外键关联映射_单向 and 双向
10-03
Hibernate 一对一唯一外键关联映射详解 Hibernate是一种流行的Java持久层框架，提供了多种关联映射方式，其中一对一唯一外键关联映射是一种常见的关联方式。在本文中，我们将详细介绍Hibernate一对一唯一外键关联...
Hibernate映射关联详解
10-17
映射一对多双向关联关系 1 Customers 类中加如set类型的 Orders属性，Orders类中加入Customer类型的customer属性。 2 测试时，建立两者一对多的双向关联关系。 Customers customer=new Customer(“Tom”,new ...
在树莓派4B上，在ubuntu20.04中设置包含ros节点的文件自启动
06-16
在树莓派4B上，在ubuntu20.04中设置包含ros节点的文件自启动
TLBB服务端综合工具
06-16
潇湘综合工具
数据库管理工具:dbeaver-ce-23.0.1-linux.gtk.aarch64-nojdk.tar.gz
06-16
1.DBeaver是一款通用数据库工具，专为开发人员和数据库管理员设计。 2.DBeaver支持多种数据库系统，包括但不限于MySQL、PostgreSQL、Oracle、DB2、MSSQL、Sybase、Mimer、HSQLDB、Derby、SQLite等，几乎涵盖了市场上所有的主流数据库。 3.支持的操作系统：包括Windows（2000/XP/2003/Vista/7/10/11）、Linux、Mac OS、Solaris、AIX、HPUX等。 4.主要特性： 数据库管理：支持数据库元数据浏览、元数据编辑（包括表、列、键、索引等）、SQL语句和脚本的执行、数据导入导出等。 用户界面：提供图形界面来查看数据库结构、执行SQL查询和脚本、浏览和导出数据，以及处理BLOB/CLOB数据等。用户界面设计简洁明了，易于使用。 高级功能：除了基本的数据库管理功能外，DBeaver还提供了一些高级功能，如数据库版本控制（可与Git、SVN等版本控制系统集成）、数据分析和可视化工具（如图表、统计信息和数据报告）、SQL代码自动补全等。
基于Boson的计算机网络实验：RIP和IGRP的配置
最新发布
06-16
基于Boson的计算机网络实验：RIP和IGRP的配置
hibernate映射一对一 一对多 多对多
09-07
在Hibernate中，对于一对一、一对多和多对多的关系，我们可以通过以下方式进行映射。 一对一关系：在Hibernate中，可以通过主键关联和外键关联来实现一对一关系的映射。主键关联是指两个实体之间的关联通过主键来...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值