006——hibernate一对一关联映射

最新推荐文章于 2021-11-24 00:31:54 发布
最新推荐文章于 2021-11-24 00:31:54 发布
阅读量1k 收藏 1
点赞数
分类专栏： Hibernate 文章标签： hibernate 一对一关联映射
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/msj_god_boy/article/details/51931231
版权

一对一关联映射有两种方式：主键关联和外键关联

以夫妻为例（Husband----Wife）

单向关联实体类：

Husband.java

package com.java.hibernate;

public class Husband {
	
	private int id;
	
	private String name;
	
	private Wife wife;

	public Wife getWife() {
		return wife;
	}

	public void setWife(Wife wife) {
		this.wife = wife;
	}

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

Wife.java

package com.java.hibernate;

public class Wife {

	private int id;
	
	private String name;

	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.java

package com.java.hibernate;

public class Husband {
	
	private int id;
	
	private String name;
	
	private Wife wife;

	public Wife getWife() {
		return wife;
	}

	public void setWife(Wife wife) {
		this.wife = wife;
	}

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

Wife.java

package com.java.hibernate;

public class Wife {

	private int id;
	
	private String name;
	
	private Husband husband;

	public Husband getHusband() {
		return husband;
	}

	public void setHusband(Husband husband) {
		this.husband = husband;
	}

	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映射文件：

<?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.java.hibernate.Husband" table="t_husband">
		<id name="id">
			<!-- 采用foreign生成策略，forgeign会取得关联对象的标识 -->
			<generator class="foreign">
				<!-- property只关联对象 -->
				<param name="property">wife</param>
			</generator>		
		</id>
		<property name="name"></property>
		<!-- 
			one-to-one指示hibernate如何加载其关联对象，默认根据主键加载
			也就是拿到关系字段值，根据对端的主键来加载关联对象
		
			constrained="true表示，当前主键(husband的主键)还是一个外键
			参照了对端的主键（wife的主键），也就是会生成外键约束语句
		 -->
		<one-to-one name="wife" constrained="true"/>
	</class>
</hibernate-mapping>
Wife映射文件： 
<?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.java.hibernate.Wife" table="t_wife">
		<id name="id">
			<generator class="native"></generator>
		</id>
		<property name="name"></property>
	</class>
</hibernate-mapping>
测试类 
package com.java.hibernate;

import junit.framework.TestCase;

import org.hibernate.Session;

public class Test extends TestCase{
	
	public void testSave1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();
			
			Wife wife = new Wife();
			wife.setName("昆凌");
			
			Husband husband = new Husband();
			husband.setName("周杰伦");
			//建立关联
			husband.setWife(wife);
			//没有抛出TransientObjectException
			//是由一对一关联映射的特性决定的，它必须先保存关联对象wife
			//这样它采用foreign映射策略才能取得关联对象的标识
			//也就是它默认了cascade属性
			session.save(husband);
			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();
			
			Wife wife = new Wife();
			wife.setName("昆凌");
			
			Husband husband = new Husband();
			husband.setName("周杰伦");
			//建立关联
			husband.setWife(wife);
			//只能将IdCard保存，不能将Person保存
			//因为关系的维护端在Person端，IdCard不知道Person的存在
			session.save(wife);
			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();
			Husband husband = (Husband)session.load(Husband.class, 1);
			System.out.println("husband.name=" + husband.getName());
			System.out.println("husband.wife=" + husband.getWife().getName());
			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}
	
}

双向主键关联：

参照单向主键关联，只需修改Wife映射文件：

<?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.java.hibernate.Wife" table="t_wife">
		<id name="id">
			<generator class="native"></generator>
		</id>
		<property name="name"></property>
		<one-to-one name="husband"></one-to-one>
	</class>
</hibernate-mapping>
测试类： 
package com.java.hibernate;

import junit.framework.TestCase;

import org.hibernate.Session;

public class Test extends TestCase {
	
	public void testLoad() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();
			
			Wife wife = (Wife) session.load(Wife.class, 1);
			System.out.println(wife.getName());
			System.out.println(wife.getHusband().getName());
			
			session.getTransaction().commit();
		} catch (Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		} finally {
			HibernateUtils.closeSession(session);
		}
		
	}
	
}

单向外键关联：

一对一唯一外键关联映射其实是多对一的特例，采用<many-to-one>标签来映射，指定多的一端unique为true，这样就限制了多的一端的多重性唯一，就是这样来映射的。

Husband映射文件

<?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.java.hibernate.Husband" table="t_husband">
		<id name="id">
			<generator class="native"></generator>
		</id>
		<property name="name"></property>
		<many-to-one name="wife" unique="true"></many-to-one>
	</class>
</hibernate-mapping>

Wife映射文件

<?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.java.hibernate.Wife" table="t_wife">
		<id name="id">
			<generator class="native"></generator>
		</id>
		<property name="name"></property>
	</class>
</hibernate-mapping>

测试类

package com.java.hibernate;

import junit.framework.TestCase;

import org.hibernate.Session;

public class Test extends TestCase{
	
	public void testSave1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();
			
			Wife wife = new Wife();
			wife.setName("昆凌");
			
			Husband husband = new Husband();
			husband.setName("周杰伦");
			//建立关联
			husband.setWife(wife);
			//抛出TransientObjectException
			//因为IdCard为Transient状态
			session.save(husband);
			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();
			
			Wife wife = new Wife();
			wife.setName("昆凌");
			session.save(wife);
			
			Husband husband = new Husband();
			husband.setName("周杰伦");
			//建立关联
			husband.setWife(wife);
		
			session.save(husband);
			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();
			Husband husband = (Husband)session.load(Husband.class, 2);
			System.out.println("husband.name=" + husband.getName());
			System.out.println("husband.wife=" + husband.getWife().getName());
			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}
	
}

双向外键关联：

一对一唯一外键关联双向采用<one-to-one>标签映射，必须指定<one-to-one>标签中的property-ref属性为关系字段的名称

参照单向外键关联，只需修改Wife映射 文件

<?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.java.hibernate.Wife" table="t_wife">
		<id name="id">
			<generator class="native"></generator>
		</id>
		<property name="name"></property>
		<one-to-one name="husband" property-ref="wife"></one-to-one>
	</class>
</hibernate-mapping>
测试类： 

package com.java.hibernate;

import junit.framework.TestCase;

import org.hibernate.Session;

public class Test extends TestCase {
	
	public void testLoad() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();
			
			Wife wife = (Wife) session.load(Wife.class, 1);
			System.out.println(wife.getName());
			System.out.println(wife.getHusband().getName());
			
			session.getTransaction().commit();
		} catch (Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		} finally {
			HibernateUtils.closeSession(session);
		}
		
	}
	
}

MsjGodBoy
关注
专栏目录
【SSH进阶之路】Hibernate映射——多对一单向关联映射（四）
努力+坚持，而且还很年轻
10-22 3万+
基本映射是对一个实体进行映射，关联映射就是处理多个实体之间的关系，将关联关系映射到数据库中，所谓的关联关系在对象模型中有一个或多个引用。
Hibernate入门第十讲——Hibernate的一对多关联映射
李阿昀的博客
04-13 1万+
Hibernate关联映射——一对多（多对一）我们以客户(Customer)与订单(Order)为例来讲解Hibernate关联映射中的一对多关联关系。 首先肯定是搭建好Hibernate的开发环境，我在此也不过多赘述，读者自行实践。接着在src目录下创建一个cn.itheima.oneToMany包，并在该包下创建两个实体类，如下： 客户类// 客户 ---- 一的一方 public class
007——hibernate一对多关联映射
msj_god_boy的博客
07-18 261
本次以Teacher和Student为例 一对多关联映射：有单向一对多关联映射和双向一对多关联映射 一对多关联映射和多对一关联映射映射原理是一致的，都是在多的一端加入一个外键，指向一的一端 它们的区别在于维护的关系不同： 多对一维护的关系是：多指向一的关系，有了此关系，在加载多的时候可以将一加载上来 一对多维护的关系是：一指向多的关系，有了此关系，在加载一的时候可以将多加载上
Hibernate（五）:Hibernate映射——一对一单向关联映射
zjkC050818的博客
05-16 407
本文转载自：http://blog.csdn.net/jiuqiyuliang/article/details/40350515 【SSH进阶之路】Hibernate基本原理（一） ，小编介绍了hibernate的基本原理以及它的核心，采用对象化的思维操作关系型数据库。 【SSH进阶之路】Hibernate搭建开发环境+简单实例（二），小编搭建了基本Hibernate的开发
04.Hibernate映射关系(一对一)
ycjcson的博客
01-01 357
04.类与(.hbm.xml)的详解、一张表拆分成两个类、一对一 一、类与(.hbm.xml)的详解 1.类 import java.util.Date; /** * 学生信息 * @author Java53 */ public class StudentInfo { private Integer stuId; private String stuNo; private String stuName; private String stuSex; private Date stuBirt
【Hibernate】一对多关联映射
颗粒归仓
01-10 425
前两篇博客介绍了多对一和一对一关联映射，这篇博客介绍一对多关联映射，它的原理和多对一关联映射的原理是一样的，都是在多的一端加入一个外键，指向一的一端。下面详细介绍相关内容： 一、单向一对多     一对多的关系我们用学生和班级来说，一个班级有多个学生，多个学生可能属于一个班级，他们的对象模型和关系模型如下：     在进行关系映射时需要在一的一端添加标签，另外还需要在一的一端
JavaEE第七次实验——Hibernate关联关系映射
qq_46015650的博客
11-24 596
实验七 Hibernate关联关系映射——登录用户的地址管理 一、基础实验——多对一/一对多关联 （一）实验目的 掌握 Hibernate 关联关系映射的基本概念，理解关联的方向和数量，重点理 解双向一对多/多对一的关联关系，及其在实际应用中的体现； 学习 Hibernate 框架处理一对多/多对一关联关系的方法，掌握关联关系中持 久化类的实现方法、以及相应 Hibernate 映射文件的配置方案； 能在实际应用中通过 Hibernate 建立正确的一对多/多对一关联关系映射，并 以面向对象的方式进行数据
Hibernate入门第一讲——Hibernate框架的快速入门
热门推荐
李阿昀的博客
08-04 12万+
Hibernate框架介绍什么是Hibernate我们可以从度娘上摘抄这样有关Hibernate的介绍： Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。Hibernate可以
010——hibernate具体表继承：每个子类一个表
msj_god_boy的博客
07-18 1004
具体表继承：这种策略是使用joined-subclass标签来定义子类的。父类、子类，每个类都对应一张数据库表。在父类对应的数据库表中，实际上会存储所有的记录，包括父类和子类的记录；在子类对应的数据库表中，这个表只定义了子类中所特有的属性映射的字段。子类与父类，通过相同的主键值来关联。 实现这种策略的时候，有如下步骤： 父类用普通的标签定义即可父类不再需要定义discriminat
021——hibernateDML操作
msj_god_boy的博客
07-22 479
实体类以及映射文件参考015篇 测试类： package test; import junit.framework.TestCase; import org.hibernate.Session; import com.java.hibernate.HibernateUtils; import com.java.hibernate.Student; public class DMLQue
014——hibernate的悲观锁和乐观锁
msj_god_boy的博客
07-19 415
举例： 初始化类： package com.java.hibernate; import org.hibernate.Session; public class InitData { public static void main(String[] args) { Session session = null; try { session = HibernateU
008——hibernate多对多关联映射
msj_god_boy的博客
07-18 385
多对多关联映射分为单向多对多关联映射和双向多对多关联映射 单向多对多关联映射（单向User--------->Role）： 具体映射： 实体类： User.java package com.java.hibernate; import java.util.Set; public class User { private int id; privat
020——hibernate对象导航查询
msj_god_boy的博客
07-22 349
实体类及映射文件参考015篇 测试类： package test; import java.util.Iterator; import java.util.List; import junit.framework.TestCase; import org.hibernate.Session; import com.java.hibernate.HibernateUtils; impor
002——hibernate的介绍&优缺点&工作流程
msj_god_boy的博客
07-16 290
对象关系映射（Object Relation Mapping，ORM）：是一种用来完成从对象模型到归安息模型的映射技术。简单地说，就是一种把应用程序中的对象数据持久化到关系数据库表的一种技术。 ORM产品： JBoos：Hibernate框架Oracle：TopLinkApache：OJBSun：JDO Hibernate的介绍： 它是连接Java应用程序和关系数据库的中间
001——在myeclipse中添加user library
msj_god_boy的博客
07-16 282
步骤以图片的形式展示：
011——hibernate类表继承：每个具体类一个表
msj_god_boy的博客
07-18 272
类表继承：这种策略是使用union-subclass标签来定义子类的。每个子类对应一张表，而且这个表的信息是完备的，即包含了所有从父类继承下来的属性映射的字段（这就是它跟joined-subclass的不同之处，joined-subclass定义的子类的表，只包含子类特有属性映射的字段）。实现这种策略的时候，有如下步骤：父类用普通标签定义即可，子类用标签定义，在定义union-subclass的时
015——hibernate简单属性查询
msj_god_boy的博客
07-21 269
初始化数据类（向数据库中导入数据）： package com.java.hibernate; import java.text.SimpleDateFormat; import java.util.Date; import org.hibernate.Session; public class InitData { public static void main(String[] ar
012——hibernate之集合映射
msj_god_boy的博客
07-19 262
实体类： package com.java.hibernate; import java.util.ArrayList; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; public class CollectionMapping { private
Hibernate一对一关联测试及映射实战
总结起来，文章详细介绍了如何在Hibernate中处理一对一关联，包括配置映射文件、设置级联行为以及实际的数据库操作。通过这些步骤，开发人员能够有效地管理数据模型和关联操作，确保数据的一致性和完整性。在实际...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值