Hibernate学习_009_一对一关联映射

最新推荐文章于 2024-07-23 10:45:25 发布
最新推荐文章于 2024-07-23 10:45:25 发布
阅读量381 收藏
点赞数
分类专栏： Hibernate 文章标签： hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010001838/article/details/39480339
版权

首先，关系映射，这里并不是指的数据库表之间的关联关系，关系数据库无非就是table，而table之间的关系就只有一种就是，外键关联！，而在Hibernate中指的关联关系值得是对象之间的关联关系，而且指的是一种数量上的关系。主要有七大类：一对一单项，一对一双向，一对多单项，一对多双向，多对一单项，多对多单项，多对多双向。

还有一个要特别说明的就是，无论什么关联，一般我们不是讨论的数据库表的模型，而是说明的是编程模型，比方说我们在对一对一时，不管是单向，还是双向，其实数据库应该是没有区别的，有区别的应该只是我们的程序逻辑。

本文主要讲一对一关联，包括：1、一对一单向外键关联 2、一对一双向外键关联 3、一对一单向主键关联 4、一对一双向主键关联

1：一对一单项外键关联

1.1：Annotation版本

设置两个类：Husband 和Wife。

@Entity
public class Husband {
	private int id;
	private String name;
	private Wife wife;
	@Id
	@GeneratedValue
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@OneToOne
	@JoinColumn(name="wifeId")
	public Wife getWife() {
		return wife;
	}
	public void setWife(Wife wife) {
		this.wife = wife;
	}
}
@Entity
public class Wife {
	private int id;
	private String name;
	@Id
	@GeneratedValue
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}
我们在Husband中 使用OneToOne表示这是一个一对一的关联，这样会在我们的表husband中添加一个字段，wifeId，它引用的是我们wife表的一个ID。这样我们从Husband就可以找到对应的Wife，但是从Wife却不可以找到对应的Husband。看数据库生成的语句如下所示： 

19:45:27,522 DEBUG SchemaExport:377 - 
    create table Husband (
        id integer not null auto_increment,
        name varchar(255),
        wifeId integer,
        primary key (id)
    )
19:45:27,581 DEBUG SchemaExport:377 - 
    create table Wife (
        id integer not null auto_increment,
        name varchar(255),
        primary key (id)
    )
19:45:27,637 DEBUG SchemaExport:377 - 
    alter table Husband 
        add index FKAEEA401B9E920219 (wifeId), 
        add constraint FKAEEA401B9E920219 
        foreign key (wifeId) 
        references Wife (id)
19:45:27,773  INFO SchemaExport:268 - schema export complete
1.2 ：Xml 版本（不建议使用，xml过于繁琐，用的不多）

此版本代码很简单，将上面类中所有的Annotation去掉，添加两个xml文件：Husband.hbm.xml和Wife.hbm.xml接口，生成的数据库一模一样。

Husband.hbm.xml

<hibernate-mapping package="com.zxb.model">
   <class name="Husband" table="husband" dynamic-update="true">
        <id name="id" column="id">
        	<generator class="identity"></generator>
        </id>
        <property name="name" column="name" /> 
        <many-to-one name="wife" column="wife_id" unique="true"></many-to-one>
   </class>
</hibernate-mapping>
在这里我们发现，在一对一单向外键关联中，我们使用的是many-to-one，然后加上unique=“true”来约束成one-to-one的。

Wife.hbm.xml

<hibernate-mapping package="com.zxb.model">
   <class name="Wife" table="wife" dynamic-update="true">
        <id name="id" column="id">
        	<generator class="identity"></generator>
        </id>
        <property name="name" column="name" /> 
   </class>
</hibernate-mapping>

2：一对一双向外键关联

首先说明，如果在Husband中都有外键字段的话，那么这种设计本身就是一种失败的设计。数据库库设计的本身就不合理。下面讲解只有一个外键的双向外键关联。

2.1：Annotation方式：

继续上面的例子，既然是双向的关联，那么从wife出发要可以找到husband，那么wife中就一定要有husband的引用，前面我们说明，不管怎么变，我们的关联映射不是针对数据库的结构的，而是针对变成模型的，所以，我们Husband类不变，生成的数据库表也没有任何变化，唯一的变化在于Wife类中多了一个husband的引用。代码如下：

@Entity
public class Wife {
	private int id;
	private String name;
	private Husband husband;
	@Id
	@GeneratedValue
	public int getId() {
		return id;
	}
	public String getName() {
		return name;
	}
	@OneToOne(mappedBy="wife")
	public Husband getHusband() {
		return husband;
	}
	public void setHusband(Husband husband) {
		this.husband = husband;
	}
	public void setId(int id) {
		this.id = id;
	}
	public void setName(String name) {
		this.name = name;
	}
}
在上面的类中，我们加入了一个husband的引用，而是用OneToOne来标记一对一关系，但是为了避免数据库表中出现两个外键字段，我们在这里加入了一个mappedBy，（记住，凡是涉及到双向的关联，必然会设置mappedBy，虽然不是必须，但是这是一个最佳实践！），表明我们的关联关系在Husband中设置了，而且Husband是根据Husband的wife属性来设置的。

2.2：xml版本：

由于我们相对于一对一单向的只改变了Wife类，所以我们一对一双向外键关联也只需要在一对一单向外键关联的基础上改变一下wife的xml文件即可。注意，我们在husband中使用的是many-to-one，在wife.hbm.xml中我们使用的是one-to-one，同时，充当我们在Annotation中的mappedBy的是property-ref属性。代码如下：

<hibernate-mapping package="com.zxb.model">
   <class name="Wife" table="wife" dynamic-update="true">
        <id name="id" column="id">
        	<generator class="identity"></generator>
        </id>
        <property name="name" column="name" /> 
        <one-to-one name="husband" property-ref="wife"></one-to-one>
   </class>
</hibernate-mapping>

3.一对一单向主键关联（从来不使用！！！）

3.1：Annotation版本：

此种类型，是不需要添加任何字段的，Husband类的主键直接参考Wife类的主键。代码如下：

@Entity
public class Husband {
	private int id;
	private String name;
	private Wife wife;
	@Id
	@GeneratedValue
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@OneToOne
	@PrimaryKeyJoinColumn(name="wife_id")
	public Wife getWife() {
		return wife;
	}
	public void setWife(Wife wife) {
		this.wife = wife;
	}
}
@Entity
public class Wife {
	private int id;
	private String name;
	@Id
	@GeneratedValue
	public int getId() {
		return id;
	}
	public String getName() {
		return name;
	}
	public void setId(int id) {
		this.id = id;
	}
	public void setName(String name) {
		this.name = name;
	}
}
测试输出如下： 

20:41:34,076 DEBUG SchemaExport:377 - 
    create table Husband (
        id integer not null auto_increment,
        name varchar(255),
        primary key (id)
    )
20:41:34,253 DEBUG SchemaExport:377 - 
    create table Wife (
        id integer not null auto_increment,
        name varchar(255),
        primary key (id)
    )
20:41:34,400  INFO SchemaExport:268 - schema export complete

可以发现，Wife类没有任何改变，只是在Husband中的wife不再是用@JoinColum来标注，而是使用@PrimaryKyeJoinColumn来标注即可。但是，从输出来看，一对一单向主键关联并没有起作用。这也是是hibernate的一个bug!!

3.2:XML版本：

此种版本下，Husband类中有wife的引用，可以根据husband的id找到对应的wife，但是由于是单向，所以，在Wife类中没有husband的引用，虽然Husband中主键参照了Wife的主键，但是从wife是不可以找到对应的husband的。

对应的xml配置文件如下：

Wife.hbm.xml:

<hibernate-mapping package="com.zxb.model">
   <class name="Wife" table="wife" dynamic-update="true">
        <id name="id" column="id">
        	<generator class="identity"></generator>
        </id>
        <property name="name" column="name" /> 
   </class>
</hibernate-mapping>
Husband.hbm.xml： 

<hibernate-mapping package="com.zxb.model">
   <class name="Husband" table="husband" dynamic-update="true">
        <id name="id" column="id">
        	<generator class="foreign">
        		<param name="property">wife</param> 
        	</generator>
        </id>
        <property name="name" column="name" /> 
        <one-to-one name="wife" constrained="true"></one-to-one>
   </class>
</hibernate-mapping>
在上面的Husband中，主键的生成器是foreign，并且在one-to-one中，我们配置了constrained=“true”来约束Husband类的主键参考的是Wife的主键。

运行测试代码：生成表的语句如下：可以发现，一对一单向主键关联下的主键约束在xml环境下是可以测试通过的。

20:52:43,121 DEBUG SchemaExport:377 - 
    create table husband (
        id integer not null,
        name varchar(255),
        primary key (id)
    )
20:52:43,186 DEBUG SchemaExport:377 - 
    create table wife (
        id integer not null auto_increment,
        name varchar(255),
        primary key (id)
    )
20:52:43,253 DEBUG SchemaExport:377 - 
    alter table husband 
        add index FK4BB1A83BCD89D348 (id), 
        add constraint FK4BB1A83BCD89D348 
        foreign key (id) 
        references wife (id)
20:52:43,419  INFO SchemaExport:268 - schema export complete


4.一对一双向 向主键关联（不重要）

4.1:Annotation方式：

很简单，在wife类中也加一个husband的引用，同时也加上@PrimaryKeyJoinColumn即可。此处只给出改变了的wife类（重申一遍，生成的数据库没有任何其他变化，但是反映在我们编程模型中就会有差别。）

@Entity
public class Wife {
	private int id;
	private String name;
	private Husband husband;
	@Id
	@GeneratedValue
	public int getId() {
		return id;
	}
	public String getName() {
		return name;
	}
	@OneToOne
	@PrimaryKeyJoinColumn
	public Husband getHusband() {
		return husband;
	}
	public void setHusband(Husband husband) {
		this.husband = husband;
	}
	public void setId(int id) {
		this.id = id;
	}
	public void setName(String name) {
		this.name = name;
	}
}
运行测试代码结果： 

21:04:55,286 DEBUG SchemaExport:377 - 
    create table Husband (
        id integer not null auto_increment,
        name varchar(255),
        primary key (id)
    )
21:04:55,339 DEBUG SchemaExport:377 - 
    create table Wife (
        id integer not null auto_increment,
        name varchar(255),
        primary key (id)
    )
21:04:55,399  INFO SchemaExport:268 - schema export complete

4.2:XML方式：

Wife.hbm.xml:

<hibernate-mapping package="com.zxb.model">
   <class name="Wife" table="wife" dynamic-update="true">
        <id name="id" column="id">
        	<generator class="identity"></generator>
        </id>
        <property name="name" column="name" /> 
        <one-to-one name="husband" property-ref="wife"></one-to-one>
   </class>
</hibernate-mapping>
Husband.hbm.xml: 
<hibernate-mapping package="com.zxb.model">
   <class name="Husband" table="husband" dynamic-update="true">
        <id name="id" column="id">
        	<generator class="foreign">
        		<param name="property">wife</param> 
        	</generator>
        </id>
        <property name="name" column="name" /> 
        <one-to-one name="wife" constrained="true"></one-to-one>
   </class>
</hibernate-mapping>
运行如上代码，可以发现，约束条件可以成功的建立。









forDreamPersist
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【SSH进阶之路】Hibernate映射——多对一单向关联映射（四）
努力+坚持，而且还很年轻
10-22 3万+
基本映射是对一个实体进行映射，关联映射就是处理多个实体之间的关系，将关联关系映射到数据库中，所谓的关联关系在对象模型中有一个或多个引用。
Hibernate关联映射1:一对一主键关联
热门推荐
怀揣梦想，努力前行
12-28 1万+
一对一关联包含2种类型：1，主键关联；2，唯一外键关联 1，主键关联： 2张关联表通过主键形成一对一映射关系，如一个人只能有一张身份证 CREATE TABLE `t_identity_card` ( `id` int(11) NOT NULL, `identity` int(11) NOT NULL, PRIMARY KEY (`id`) ) ENGINE=Inno
Hibernate的关联关系映射之一对多映射
u011301372的博客
10-18 442
JavaWEB中一对多的设计及建表原则 导入SQL的建表语句 创建数据库：create database hibernate_day03 编写客户和联系人的JavaBean程序（注意一对多的编写规则） 客户的JavaBean如下 public class Customer { private Long cust_id; private String cust_name; p...
13. Hibernate 一对一关联映射
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-23 849
本文和大家一起聊聊关联映射。什么是关联映射；如何实现一对一关联映射。
006——hibernate一对一关联映射
msj_god_boy的博客
07-17 1021
一对一关联映射有两种方式：主键关联和外键关联 以夫妻为例（Husband----Wife） 单向关联实体类： Husband.java package com.java.hibernate; public class Husband { private int id; private String name; private Wife wife; public Wi
hibernate关联映射(一对多)
mockingbirds的专栏
06-14 1123
这篇博客将会给大家带来hibernate的关联映射的学习。在现实生活中，不仅只是一对一的映射关系，更多的是一对多，多对多等。一对多单项关联映射这里我以网盘为例，一个用户可以拥有多个文件，及用户和文件之间是一对多的关系。 user实体类：public class Users { private int uid; private String uname; //用户上传的所有文
Hibernate总结--一对一关联查询
qq_25011427的博客
10-30 1310
在Hibernate查询中存在一对多，多对一，多对多、一对一关系，本篇就简单的对一对一查询进行总结， 一对一关联查询有两种方式，一个是基于外键的一个是基于主键的 一、基于外键的  1.sql语句    CREATE TABLE `manger` (          `MGR_ID` int(2) NOT NULL,          `MGR_NAME` varchar(30) DEFA...
Hibernate关联映射一对多--多方添加数据
NULL
04-10 1523
bean类 user对象的实体类 package com.hp.bean; /** * @author xiao * 创建的时间:2018年1月31日 * @parameter 用户表 * @return 无返回值 */ import java.util.HashSet; import java.util.Set; public class UserBean { private ...
Hibernate_映射_关联关系_一对一映射1__映射基础
辐_射的博客
05-08 406
Hibernate之一对一关联映射
梦想起飞的地方，必须用心去经营
10-30 2008
Hibernate中一对一关联映射共分为两种，一种是一对一主键关联映射，另一种是一对一唯一外键关联映射。下面简单介绍一下这两种关联映射。 一对一主键关联映射 一对一主键关联映射的两个实体有相同的ID。这种映射又分为单向一对一关联主键映射和双向一对一主键关联映射。 单向一对一主键关联映射 实例类图 映射文件IdCard.hbm.xml
hibernate一对多关联映射学习小结
08-29
Hibernate一对多关联映射学习小结 Hibernate是一种流行的Java持久层框架，它提供了强大的对象关系映射（ORM）功能，能够将Java对象与关系数据库中表之间建立映射关系。Hibernate的关联映射是其核心功能之一，可以将...
深入解析Java的Hibernate框架中的一对一关联映射
09-02
下面我们将深入探讨如何在Hibernate中设置和理解一对一关联映射。 首先，我们来看一下示例中的两个实体类：TUser和TPassport。这两个类分别代表用户和护照，它们之间可能存在一对一的关联，即一个用户对应一个唯一...
Hibernate教程05_关系映射之一对一双向外键关联
04-13
在Hibernate中，一对一关联的配置主要通过注解或XML配置文件完成。对于双向关联，我们需要在两个实体类中分别设置相应的属性和关联注解。 在实体类A中，我们将添加一个类型为B的属性，并使用`@OneToOne`注解来指定...
Hibernate多对一单项关联
08-29
多对一关联映射的映射原理是指在“多”的一端维护关联关系，在“多”的一端加入一个外键，指向“一”的一端。多的一端持有一的一端的引用，即在“多”的一端加外键，指向“一”的一端。 实例 ---- 例如，多个用户...
Hibernate教程07_关系映射之一对一双向主键关联
04-13
在" Hibernate教程07_关系映射之一对一双向主键关联"中，我们将学习如何设置这种关联。首先，我们需要创建两个实体类，例如`Employee`和`Department`。在每个类中，我们都需要定义主键字段，并用`@Id`注解标记。然后...
Hibernate学习_001_模拟hibernate的实现
forDream的专栏
08-05 767
前言：本人菜鸟一只，但是web
Hibernate学习_005_Hibernate 中关于SessionFactory、Session接口的理解
forDream的专栏
08-13 668
SessionFactory,Session作为Hibernate中的两个核心接口，几乎所有涉及到数据库的操作都必须通过这两个接口来实现。 简言之，SessionFactory 就是Session的工场，我们可以将SessionFactory看做是一个具体数据库在内存的映射，也可以将SessionFactory看作是一个具体数据库对应的连接池。而我们每次通过Session来操作数据，可以将Ses
Hibernate学习_020_一级缓存+二级缓存+三级缓存（查询缓存）
forDream的专栏
11-23 589
Hibernate中存在三种缓存： 1：一级缓存：Session级别的缓存，Iterate（）
Hibernate学习_017_Hibernate查询语言（QL）的几点说明
forDream的专栏
10-06 552
doing...
Hibernate一对一关联测试及映射实战
在本篇关于一对一关联测试运行的文章中，主要探讨了如何使用Hibernate框架来处理实体之间的关联关系，特别是在一对一关联场景下。作者通过一个具体的例子——Citizen（公民）与Card（身份证）的映射，展示了如何在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值