【HIbernate框架学习】：Hibernate对象关系映射之一对一关联映射（一）

最新推荐文章于 2025-03-23 15:24:45 发布
最新推荐文章于 2025-03-23 15:24:45 发布
阅读量1.9k 收藏 4
点赞数 1
分类专栏： Hibernate SSH框架学习之路 文章标签： Hibernate ORM框架 Hibernate框架 架构设计 框架
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/erlian1992/article/details/53523406
版权
本文详细介绍了在软件开发中一对一关联映射的概念及其两种实现策略：主键关联和唯一外键关联。通过具体实例展示了单向及双向一对一主键关联映射的实现方式，包括实体类的设计与Hibernate配置。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

        一对一关联映射在实际生活中是比较常见的，如人与身份证的关系，通过人这个对象可以找到身份证相关的信

息，也可以通过身份证这个对象找到人相关的信息。

       有两种策略可以实现一对一的关联映射：

       主键关联：即让两个对象具有相同的主键值，以表明它们之间的一一对应的关系；数据库表不会有额外的字段来

维护它们之间的关系，仅通过表的主键来关联；

       唯一外键关联：外键关联，本来是用于多对一的配置，但是如果加上唯一的限制之后，也可以用来表示一对一关

联关系。

       

      单向一对一主键关联映射

      我们先来假设一个场景，从Person中能看到IdCard，也就是把idCard数据表中的主键拿过来当做person表的主

键，单向一对一主键关联映射的实现就是它们的主键相等。一对一关联映射是通过在一方（Person）的对象关系配置

文件加入<one-to-one>元素定义的。这里的方向是由Person--->IdCard。

      如下图所示：

      

      下面我们来实现：

       Person实体类：

package com.demo.domain;

public class Person {

	private int id;
	private String name;
	//在一方添加另一方的引用
	private IdCard idCard;

	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;
	}

	public IdCard getIdCard() {
		return idCard;
	}

	public void setIdCard(IdCard idCard) {
		this.idCard = idCard;
	}

	@Override
	public String toString() {
		return "Person [id=" + id + ", name=" + name + ", idCard=" + idCard + "]";
	}
	
}

       Person对象关系映射配置文件：

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
	"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
	"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
	<class name="com.demo.domain.Person" table="person">
		<id name="id">
			<!-- 采用foreign生成策略，forgeign会取得关联对象的标识 -->
			<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>

       IdCard实体类：

package com.demo.domain;

public class IdCard {
	
	private int id;
	private String cardNo;

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getCardNo() {
		return cardNo;
	}

	public void setCardNo(String cardNo) {
		this.cardNo = cardNo;
	}

	@Override
	public String toString() {
		return "IdCard [id=" + id + ", cardNo=" + cardNo + "]";
	}
	
}

       IdCard对象关系映射配置文件：

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
	"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
	"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
	<class name="com.demo.domain.IdCard" table="idCard">
		<id name="id">
			<generator class="native"/>
		</id>
		<property name="cardNo"/>
	</class>
</hibernate-mapping>

       测试类代码：

package com.demo.test;

import org.hibernate.Session;

import com.demo.domain.HibernateUtils;
import com.demo.domain.IdCard;
import com.demo.domain.Person;

import junit.framework.TestCase;

/**
 * 单向一对一关联映射（Person-->IdCard）
 * @author Administrator
 * @date 2016年12月8日
 */
public class One2OneTest extends TestCase {

	public void testSave1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();
			
			IdCard idCard = new IdCard();
			idCard.setCardNo("1111111");
			
			Person person = new Person();
			person.setName("张三");
			//建立单向一对一主键映射关联
			person.setIdCard(idCard);
			
			//没有抛出TransientObjectException
			//是由一对一关联映射的特性决定的，它必须先保存关联对象IdCard
			//这样它采用foreign映射策略才能取得关联对象的标识
			//也就是它默认了cascade属性
			session.save(person);
			
			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}	
	
	public void testSave2() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();
			
			IdCard idCard = new IdCard();
			idCard.setCardNo("2222222");
			
			Person person = new Person();
			person.setName("李四");
			//建立单向一对一主键映射关联
			person.setIdCard(idCard);
			
			//只能将IdCard保存，不能将Person保存
			//因为关系的维护端在Person端，IdCard不知道Person的存在
			session.save(idCard);
			
			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}
	
	public void testLoad() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();
			
			Person person = (Person)session.load(Person.class, 1);
			System.out.println("person.name=" + person.getName());
			System.out.println("person.cardNo=" + person.getIdCard().getCardNo());
			
			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}	
	
}

       testSave1()方法：

       控制台输出：

       

       数据库显示：

       

        testSave2()方法：

       控制台输出：

       

       数据库显示：

       

        tesLoad()方法：

       控制台输出：

       

       

       双向一对一主键关联映射

       我们先来假设一个场景，双向一对一主键关联映射与单向一对一主键关联映射的区别就是，单向一对一关联映

射，在person端能看到idCard，而idCard不能看到Person端。而双向一对一关联映射就是在idCard端也能看到

person，也就是不但在Person.hbm.xml中加上<one-to-one>标签，同时在IdCard.hbm.xml文件中加上<one-to-one>标

签。

       如下图所示：

       

       我们来实现：

       Person实体类：同单向一对一主键关联映射的Person实体类一样

       Person对象关系映射配置文件：同单向一对一主键关联映射的Person对象关系映射配置文件一样

       IdCard实体类：

package com.demo.domain;

public class IdCard {
	
	private int id;
	private String cardNo;
	//在一方加入另一方的引用
	private Person person;

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getCardNo() {
		return cardNo;
	}

	public void setCardNo(String cardNo) {
		this.cardNo = cardNo;
	}

	public Person getPerson() {
		return person;
	}

	public void setPerson(Person person) {
		this.person = person;
	}

	@Override
	public String toString() {
		return "IdCard [id=" + id + ", cardNo=" + cardNo + ", person=" + person + "]";
	}
	
}

       IdCard对象关系映射配置文件：

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
	"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
	"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
	<class name="com.demo.domain.IdCard" table="idCard">
		<id name="id">
			<generator class="native"/>
		</id>
		<property name="cardNo"/>
		
		<!-- 一对一关联映射 --> 
                <one-to-one name="person" /> 
		
	</class>
</hibernate-mapping>

       测试类代码：

package com.demo.test;

import org.hibernate.Session;

import com.demo.domain.HibernateUtils;
import com.demo.domain.IdCard;
import com.demo.domain.Person;

import junit.framework.TestCase;

/**
 * 双向一对一关联映射（Person<--->IdCard）
 * @author Administrator
 * @date 2016年12月8日
 */
public class One2OneTest extends TestCase {

	public void testSave1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();
			
			IdCard idCard = new IdCard();
			idCard.setCardNo("1111111");
			
			Person person = new Person();
			person.setName("张三");
			//建立一对一关联映射
			person.setIdCard(idCard);
			
			//没有抛出TransientObjectException
			//是由一对一关联映射的特性决定的，它必须先保存关联对象IdCard
			//这样它采用foreign映射策略才能取得关联对象的标识
			//也就是它默认了cascade属性
			//保存Person对象
			session.save(person);
			
			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}	
	
	public void testSave2() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();
			
			Person person = new Person();
			person.setName("李四");

			IdCard idCard = new IdCard();
			idCard.setCardNo("2222222");
			//建立一对一关联映射
			idCard.setPerson(person);
			
			//保存IdCard对象
			session.save(idCard);//人是不会保存进入数据库的，想要保存需要加：person.setIdCard(idCard);
			
			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}
	
	public void testLoad1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();
			Person person = (Person)session.load(Person.class, 1);
			System.out.println("person.name=" + person.getName());
			System.out.println("person.cardNo=" + person.getIdCard().getCardNo());
			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}		
	
	public void testLoad2() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();
			IdCard idCard = (IdCard)session.load(IdCard.class, 1);
			System.out.println("idCard.cardNo=" + idCard.getCardNo());
			System.out.println("idCard.person.name=" + idCard.getPerson().getName());
			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}
	
}

       testSave1()方法

       控制台输出：

       

       数据库显示：

       

       testSave2()方法

       控制台输出：

       

       数据库显示：

       

       testLoad1()方法

       控制台输出：

       

       testLoad2()方法

       控制台输出：

       

       对于双向一对一主键关联映射一直没想明白，在IdCard对象关系映射文件中的<one-to-one>元素中设置了级联属

性为all，保存idCard对象时候，还是保存不了person对象，不知道原因是什么？待解决



      
Hibernate对象关联映射
zhangfengBX的博客
10-15 893
对象关系映射（Object Relational Mapping，简称ORM）是一种为了解决面向对象与关系数据库存在的互不匹配的现象的技术。多对一单向关系映射：student-classespublic class Classes implements Serializable{ private Integer cid; private String cname; priva
Hibernate对象映射
marvin
09-03 318
•@Entity 映射实体类 •@Id 映射生成主键 •@Table 映射表格 •@Column 映射表格列 •@Transient 定义暂态属性 @Entity与@Table • @Entity(name="EntityName") •必须 ,name 为可选 , 对应数据库中一的个表 •@Table(name="") •可选 ,...
Hibernate对象对应关系总结
11-22
本文主要介绍了对象之间的对应关系，包含对象之间一对一，一对多双向，多对多的关系，另外简单介绍了二级缓存和分页
ORM——对象关系映射
最新发布
weixin_45778846的博客
03-23 1281
ORM框架通过其强大的抽象能力，显著提升了数据库操作的效率和安全性。尽管存在一些性能和学习成本方面的考量，但在大多数业务场景下，ORM框架的优势远大于其局限性。选择适合项目需求的ORM框架，遵循最佳实践进行开发，将帮助开发者构建出高效、健壮的数据访问层。对于现代应用程序开发而言，掌握ORM框架已成为每个开发者的必备技能。
hibernate对象关系映射（基于注解）
sunmun的专栏
07-14 1445
1.OneToOne关系映射 OneToOne即一对一映射，
Hibernate对象关系映射（一）
kiven
11-30 2546
Hibernate 的本质是对象关系映射，ORM实现了将对象的变化保存到数据库中。以前我们对关系表操作，执行增CRUD。现在我们不在对关系表进行操作，而是直接对对象操作。对象关系的映射有以下几种 基本图形 图1 一对一映射 分两种情况 主键 唯一外键 1主键  两个对象具有相同的主键，不再有额外字段维护他们的关系 图2  Person 和Card之间，他们的
Hibernate之对象关系映射
yfy的博客
01-20 405
一、一对多关联关系 1.单向n-1 单向n-1关联只需从n的一端可以访问1的一端 Hibernate使用&lt;many-to-one&gt;元素来映射多对一关联关系 &lt;!--     映射多对一的关联关系。 使用 many-to-one 来映射多对一的关联关系     name: 多这一端关联的一那一端的属性的名字     class: 一那一端的属性对应...
hibernate一对多关联映射学习小结
08-29
Hibernate一对多关联映射学习小结 Hibernate是一种流行的Java持久层框架，它提供了强大的对象关系映射（ORM）功能，能够将Java对象与关系数据库中表之间建立映射关系。Hibernate的关联映射是其核心功能之一，可以将...
hibernate中的对象关系映射
08-29
除了基本类映射，Hibernate还支持更复杂的对象关系映射，如多对一、一对多、多对多等关联映射。 1. **多对一关联映射（单向）** 在这种映射中，一个实体类（如`User`）可以关联到另一个实体类的一个实例（如`Group...
Hibernate：一个对象/关系映射器工具-开源
04-13
Hibernate是一个对象/关系映射器工具。 它在Java应用程序中非常流行，并且实现了Java Persistence API。 Hibernate ORM使开发人员可以更轻松地编写其数据在应用程序进程中无法使用的应用程序。 作为对象/关系映射...
Java的Hibernate框架中一对多的单向和双向关联映射
09-02
在Java的Hibernate框架中，一对多关联映射是一种常见的数据模型关系，用于表示一个实体（如班级）可以与多个其他实体（如学生）相关联。这种关系映射可以帮助简化数据库操作，使得在Java代码中处理这些关系变得更加...
Hibernate （开放源代码的对象关系映射框架）
草原印象的博客
04-03 963
Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用...
Hibernate-对象关系映射框架
THE CHOSEN 1
09-29 852
Hibernate简介 hibernate是一个开源的ORM（对象关系映射）框架，也是一个持久层的框架，它对JDBC做了非常轻量级的封装。 Hibernate核心（六大接口+两个配置文件） Configuration：负责配置并启动Hibernate SessionFactory：负责初始化Hibernate Session：负责持久化对象的CRUD操作 Transaction：负责事
Hibernate是一个开放源代码的对象关系映射框架（ORM）
热门推荐
Sunshine的专栏
02-26 1万+
Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate是一个优秀的持久化框架 什么是持久化：将程序数据在瞬时状态和持久状态之间转换的机制 瞬时状态：保存在内存的程序数据，程序退出后，数据就消失了，称为瞬时状态 持久状态：保存在磁盘上的程序数据，程序退出后依然存在，称
Hibernate关联映射
qq_24826133的专栏
10-15 153
关联映射 这里的关联映射指的是对象之间的关系,并不是指数据库的关系,而是当对象之间处于下列关系之一时,数据库表该如何映射，编程上该如何处理 常见的映射 一对一:单向,双向 一对多:单向,双向(和多对一双向相同) 多对一:单向,双向(一对多双向和多对一双向是一样的) 多对多:单向,双向 1 一对一（单向）基于外键关联映射 和单向多对一关联几乎是一样的。唯一不同的就是单向一对一关联中的外键...
Hibernate 一对一关系
tangbin0505的博客
08-26 245
在需要添加外键字段(cid)的表student（从表）对应的类中 定义一个属性Contact contact 在其setter方法上增加 @OneToOne @JoinColumn(name="cid",unique=true) 这样只能实现单向一对一的关系 如果想实现双向一对一的关系 主表contact对应的类中 定义一个属性Student student 在其setter方法上增加 @O...
hibernate之映射关系一对一（2种方式）
e生态_修身_互联网知识分享
01-05 885
Hibernate实体关系映射   a) 一对一 i. 共享主键一对一方式：实现两个表或对象使用同一主键的值、通过主键映射方式实现一对一的关联 1. 使用范围：一般确定一对一的关系不变化，比如：用户登录（账号和密码）、用户详细信息（名称、性别、。。。） 2. 创建表： create table t_user( u_id varchar(255), u_name varchar(25
Hibernate （开源对象关系映射框架）
weixin_30419799的博客
06-09 1039
一、基本介绍1、它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm（对象关系映射）框架，hibernate可以自动生成SQL语句，自动执行； Hibernate可以应用在任何使用JDBC的场合。 2、持久化层：处理关系型数据库（数据存储层）和模型对象（object,业务逻辑模型）的映射关系的代码方法（ORM)3、Hibernate是一个基于JDBC的主...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值