第 7 章 关联关系映射

最新推荐文章于 2024-10-10 23:42:47 发布
最新推荐文章于 2024-10-10 23:42:47 发布
阅读量83 收藏 1
点赞数
文章标签： java python
原文链接：https://my.oschina.net/airship/blog/1635675
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

第 7 章 关联关系映射

7.1. 介绍

7.2. 单向关联（Unidirectional associations）

7.2.1. 多对一（many-to-one）

7.2.2. 一对一（One-to-one）

7.2.3. 一对多（one-to-many）

7.3. 使用连接表的单向关联（Unidirectional associations with join tables）

7.3.1. 一对多（one-to-many）

7.3.2. 多对一（many-to-one）

7.3.3. 一对一（One-to-one）

7.3.4. 多对多（many-to-many）

7.4. 双向关联（Bidirectional associations）

7.4.1. 一对多（one to many)/多对一（many to one）

7.4.2. 一对一（One-to-one）

7.5. 使用连接表的双向关联（Bidirectional associations with join tables）

7.5.1. 一对多（one to many)/多对一（many to one）

7.5.2. 一对一（one to one）

7.5.3. 多对多（many-to-many）

7.6. 更复杂的关联映射

7.1. 介绍

关联关系映射通常情况是最难配置正确的。在这个部分中，我们从单向关系映射开始，然后考虑双向关系映射，逐步讲解典型的案例。在所有的例子中，我们都使将用 Person 和 Address。

我们根据映射关系是否涉及连接表以及多样性（multiplicity）来划分关联类型。

在传统的数据建模中，允许为 Null 值的外键被认为是一种不好的实践，因此我们所有的例子中都使用不允许为 Null 的外键。这并不是 Hibernate的 要求，即使你删除掉不允许为 Null 的约束，Hibernate 映射一样可以工作的很好。

7.2. 单向关联（Unidirectional associations）

7.2.1. 多对一（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 )

7.2.2. 一对一（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 )

7.2.3. 一对多（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 )

我们认为对于这种关联关系最好使用连接表。

7.3. 使用连接表的单向关联（Unidirectional associations with join tables）

7.3.1. 一对多（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 )

7.3.2. 多对一（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 )

7.3.3. 一对一（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 )

7.3.4. 多对多（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 )

7.4. 双向关联（Bidirectional associations）

7.4.1. 一对多（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" 和 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> 元素也是需要的。

7.4.2. 一对一（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 )

7.5. 使用连接表的双向关联（Bidirectional associations with join tables）

7.5.1. 一对多（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 )

7.5.2. 一对一（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 )

7.5.3. 多对多（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 或条件查询来处理这些情况。

转载于:https://my.oschina.net/airship/blog/1635675

weixin_33827731
关注
第九章 MyBatis的关联映射
weixin_46066900的博客
05-21 2517
单选题 1、下面关于Java对象之间的关联关系描述正确的是（）3分 A、一对一的关系就是在本类和对方类中定义同一个类型的对象 B、一对多的关系：就是一个A类类型对应多个B类类型的情况 C、多对多的关系只需要在一方的类中引入另一方类型的集合 D、多对多关联关系需要在本类中引入本类的集合 参考答案 :B 2、下面属性中不属于元素属性的是（）3分 A、property B、column C、ofType D、javaType 参考答案 :C 答案说明 :ofType是元素的属性 3、在Java中，以下有关类的关联
第4章 MyBatis的关联映射和缓存机制
小猪宝宝的博客
08-29 2570
在实际开发中，对数据库的操作常常会涉及到多张表，针对多表之间的操作，MyBatis提供了关联映射，通过关联映射可以很好地处理表与表、对象与对象之间的关联关系。此外，在实际开发中经常需要合理地利用MyBatis缓存来加快数据库查询，进而有效地提升数据库性能。本章将对MyBatis的关联映射以及MyBatis缓存机制进行详细讲解。 .......................................
关联关系映射
Social_awesome的博客
05-19 404
什么是关联关系映射？ 关联关系是指类之间的引用关系，如果类A与类B关联，那么类A将被定义成类B的属性。 例如： public class Address{ private String name; } public class B{ private String sid; private Float score; private Address address; } 关联关系的分类：一对一，一对多，多对一，多对多 一对多：一本书对应多种书本类型，例如：西游记 -&
Java三大框架之——Hibernate关联映射与级联操作
weixin_34320724的博客
11-26 269
什么是Hibernate中的关联映射？ 　　简单来说Hibernate是ORM映射的持久层框架，全称是（Object Relational Mapping），即对象关系映射。 　　它将数据库中的表映射成对应的对象，以对象的形式展现，这样我们就可以通过映射的对象来对数据库中的数据进行间接的操作。 　　关联映射是将数据库中的表映射成与之相对应的对象，当你对这个对象进行操作的时候，Hibernat...
JavaEE第4章 MyBatis的关联映射
qq_51916863的博客
12-16 978
MyBatis的关联映射
第九章 关系映射 集合关联映射
笨笨个人笔记
06-08 1521
基本上所有集合关联映射都是在一对多,多对多操作的时候使用。 1、set 我们之前在做一对多操作的时候，多的一方就是一个set. 一对多的例子：http://blog.csdn.net/p_3er/article/details/9036921 实体类中： private Set employees; 对应的映射文件：
第九章 关系映射 组件关联映射
笨笨个人笔记
06-08 1496
组件是针对同一张表中的字段进行映射,作用是将字段多的一张表分成多个实体类来表示。 如：name与user user表中有first_name及last_name。在实体类中，自定义一个Name类来表示first_name与last_name; Name实体类： package cn.framelife.mvc.entity; public class Name { privat
Mybatis@Results关联映射详解
Bnana博客
10-22 970
Mybatis@Results关联映射详解 关系搭建 Mybatis 关联映射 Mybatis 多表映射教程 Mybatis 教程 表映射 重复上述步骤在表二表三里分别创建table2 tabl3 table4 的映射在Mapper层定义如下 关系搭建 创建四张需要关联在一起的表 在第一张表创建需要关联的第二章关系实体集合 例如： create table table1( private int id;//编号 private String name;//名称 }
Java EE之第9章MyBatis的关联映射
大马戏团的一头猪的博客
07-27 643
第9章 MyBatis的关联映射9.1关联关系概述9.2一对一 在实际的开发中，对数据库的操作常常会涉及多张表，这在面向对象中就涉及了对象与对象之间的关联关系。针对多表之间的操作，MyBatis提供了关联映射，通过关联映射就可以很好地处理对象与对象之间的关联关系 9.1关联关系概述 在关系型数据库中，多表之间存在着三种关联关系，分别为一对一，一对多和多对多，这三种关联关系的具体说明如下： （1）一...
第9章Mybatis映射篇之结果映射
05-11
Mybatis还支持关联映射，如一对多、多对一的关系映射。例如，如果`User`类还有一对多的`Address`关系，可以使用`<collection>`标签： ```xml <!-- ... --> <!-- ... --> ``` 此外，Mybatis提供了自动...
JavaEE企业级应用开发教程——第四章 MyBatis的关联映射和缓存机制（黑马程序员第二版）（SSM）
m0_62096596的博客
03-13 1530
JavaEE企业级应用开发教程——第四章 MyBatis的关联映射和缓存机制（黑马程序员第二版）（SSM）
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1254
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
【JAVA开源】基于Vue和SpringBoot的高校学科竞赛平台
杨荧的CSDN博客
10-10 923
教师功能有个人中心，题目类型管理，竞赛题库管理，竞赛类型管理，竞赛信息管理，报名信息管理，竞赛评分管理，参赛名单管理，晋级名单管理，获奖名单管理，竞赛总结管理，报销清单管理，成绩申诉管理，参赛信息管理，参赛信息管理，往年成绩管理，获奖情况管理。
JDK1.0主要特性
FoolRabbit的专栏
10-06 368
JDK1.0主要特性。
初学java练习题【1】
最新发布
lxt135744的博客
10-10 67
【代码】初学java练习题【1】
Netty 相比原生IO模型的优势
lssffy的博客
10-09 382
Java提供了多种I/O模型，每种模型都有其适用的场景和特点，随着网络应用需求的变化，I/O模型也在不断发展。阻塞I/O（BIO，Blocking I/O）传统的I/O模型，使用简单，但每次I/O操作都会阻塞线程。每个请求需要独立的线程来处理，这在并发请求较少时问题不大，但在高并发情况下，线程资源将成为瓶颈。非阻塞I/O（NIO，Non-Blocking I/O）引入了多路复用技术，一个线程可以处理多个连接，避免了BIO中每个连接占用一个线程的问题。通过Selector。
JAVA开源项目 旅游管理系统 计算机毕业设计
as230627的博客
10-03 1414
旅游管理系统基于Springboot框架、JAVA编程语言、MYSQL数据库开发完成，“操作简单，功能实用”这是本软件设计的核心理念，本系统力求创造最好的用户体验。
Spring Boot新闻推荐系统设计与实现
2402_85758936的博客
10-04 1230
目前，界面设计已经成为对软件质量进行评价的一条关键指标，一个好的用户界面可以使用户使用系统的信心和兴趣增加，从而使工作效率提高，JSP技术是将JAVA语言作为脚本语言的，JSP网页给整个服务器端的JAVA库单元提供了一个接口用来服务HTTP的应用程序。一旦输入系统的数据不正确，那么处理后的输出就会扩大这些错误，因此输入的数据的准确性对整个系统的性能起着决定性意义。输出是由电脑对输入的基本信息进行解决，生成高质量的有效信息，并使之具有一定的格式，提供给管理者使用，这是输出设计的主要责任和目标。
JPA关联映射与二级缓存实战
关系维护端负责管理关联关系，通常是"多"的一端。 4. **双向一对一关联**： 在这种关联中，两个实体之间有且仅有一个实例与另一个实例相对应。为了实现双向一对一，我们需要在双方都使用`@OneToOne`注解，但只在一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值