Hibernate基于配置文件（十二）一对一双向关联映射

最新推荐文章于 2024-08-04 11:07:52 发布
最新推荐文章于 2024-08-04 11:07:52 发布
阅读量86 收藏
点赞数
分类专栏： 框架@Hibernate 文章标签： java 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/schy_hqh/article/details/84528981
版权

一对一关联关系，当需要对2个对象进行独立对待时，分2个类来完成映射

 

主键关联映射，没有额外字段维护关联，id值保持一致

package org.leadfar.hibernate.model;


public class Person {
	private long id;
	private String name;
	private IdCard idcard;
	
	Person(){}
	
	public long getId() {
		return id;
	}
	public IdCard getIdcard() {
		return idcard;
	}

	public String getName() {
		return name;
	}
	public void setId(long id) {
		this.id = id;
	}
	public void setIdcard(IdCard idcard) {
		this.idcard = idcard;
	}
	public void setName(String name) {
		this.name = name;
	}

	
}

 

<?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 
	package="org.hibernate.auction">
	<class name="org.leadfar.hibernate.model.Person" table="t_persons" >
		<!-- id为数据库标识，作为主键 -->
		<id name="id">
			<generator class="native"/>
		</id>
		<property name="name"/>
		<!-- 根据本方id到t_idcard中寻找id值相同的那条记录 -->
		<one-to-one name="idcard"> </one-to-one>
		
	</class>
	
</hibernate-mapping>

 

package org.leadfar.hibernate.model;


public class IdCard {
	private long id;
	private String sn;
    private Person person;
    
    IdCard() {}
	public long getId() {
		return id;
	}
	public Person getPerson() {
		return person;
	}
	
	
	public String getSn() {
		return sn;
	}
	public void setId(long id) {
		this.id = id;
	}
	public void setPerson(Person person) {
		this.person = person;
	}
	public void setSn(String sn) {
		this.sn = sn;
	}

}

 

<?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 
	package="org.hibernate.auction">
	<class name="org.leadfar.hibernate.model.IdCard" table="t_idcard" >
		
		<id name="id">
			<!-- 使用foreign表示本记录的id值依赖于对方的id值 -->
			<generator class="foreign">
			<!-- 表示被依赖的对象(通过对象可以映射到表中某条记录，从而得到id) -->
			<param name="property">person</param>
			</generator>
		</id>
		<property name="sn" not-null="true" unique="true"></property>
		<!--constraint表示外键具有约束条件，即idcard存在时不能删除对应的person -->
		<!-- one-to-one表示根据自己的id到对方表中寻找相同id值的记录 -->
		<one-to-one name="person" constrained="true"></one-to-one>
		
	</class>
	
</hibernate-mapping>

 

测试

package org.leadfar.hibernate.model;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

import junit.framework.TestCase;

public class OneToOneTest extends TestCase {
	
	public void oneToOne_save() {
		Configuration cfg = new Configuration().configure();
		SessionFactory sf = cfg.buildSessionFactory();
		Session session = sf.openSession();
		
		try {
			session.beginTransaction();
			/**
			 *配置文件映射方式：one-to-one idCard的id生成策略为foreign,参考Person的id属性来设置自己的id（两者id保存一致）
			 *先有Person，再有IdCard，其中IdCard的id属性生成需要参考Person中的id
			 *所以，必需先保存Person，再保存IdCard
			 */
			
			Person p1 = new Person();
			p1.setName("张三1");
			Person p2 = new Person();
			p2.setName("张三2");
			Person p3 = new Person();
			p3.setName("张三3");
			session.save(p1);
			session.save(p2);
			session.save(p3);
			
			
			IdCard idcard = new IdCard();
			idcard.setSn("21938404320997903");
			idcard.setPerson(p3);//通过p3找到数据库中对应的id，然后作为idcard记录的id
			
			session.save(idcard);
			
			
			session.getTransaction().commit();
		} catch(Exception e) {
			session.getTransaction().rollback();
			e.printStackTrace();
		} finally {
			session.close();
		}
	}
	
	//根据Person获取idCard
	public void oneToOne_load01() {
		Configuration cfg = new Configuration().configure();
		SessionFactory sf = cfg.buildSessionFactory();
		Session session = sf.openSession();
		
		try {
			session.beginTransaction();
			
			Person p1 = (Person)session.load(Person.class, 3L);//如果id为long类型，则需要加L后缀
			IdCard idcard = p1.getIdcard();
			System.out.println(p1.getName()+","+idcard.getSn());
			
			session.getTransaction().commit();
		} catch(Exception e) {
			session.getTransaction().rollback();
			e.printStackTrace();
		} finally {
			session.close();
		}
	}
	//根据idCard获取Person
	public void oneToOne_load02() {
		Configuration cfg = new Configuration().configure();
		SessionFactory sf = cfg.buildSessionFactory();
		Session session = sf.openSession();
		
		try {
			session.beginTransaction();
			
			IdCard idcard = (IdCard)session.load(IdCard.class, 3L);
			Person person = idcard.getPerson();
			System.out.println(idcard.getSn()+","+person.getName());
			
			session.getTransaction().commit();
		} catch(Exception e) {
			session.getTransaction().rollback();
			e.printStackTrace();
		} finally {
			session.close();
		}
	}
}

 

 

唯一外键关联映射，在其中一端使用1个字段记录对方的id

package org.leadfar.hibernate.model;


public class Person {
	private long id;
	private String name;
	private IdCard idcard;
	
	Person(){}
	
	public long getId() {
		return id;
	}
	public IdCard getIdcard() {
		return idcard;
	}

	public String getName() {
		return name;
	}
	public void setId(long id) {
		this.id = id;
	}
	public void setIdcard(IdCard idcard) {
		this.idcard = idcard;
	}
	public void setName(String name) {
		this.name = name;
	}

	
}

 

<?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 
	package="org.hibernate.auction">
	<class name="org.leadfar.hibernate.model.Person" table="t_persons" >
		<!-- 外键关联时，id生成策略任意皆可，因为不是通过id进行关联的 -->
		<id name="id">
			<generator class="assigned">
			</generator>
		</id>
		<property name="name"/>
		<!-- property-ref="person"说明映射的时候将参考对方的person属性字段来映射，而不是通过对方的主键id来映射的！-->
		<!-- 如果不指定property-ref="person" 将会根据对方的id主键进行映射，就不是通过外键来映射了！一定要搞清楚！！-->
		<one-to-one name="idcard" property-ref="person"> </one-to-one>
		
	</class>
	
</hibernate-mapping>

 

package org.leadfar.hibernate.model;


public class IdCard {
	private long id;
	private String sn;
    private Person person;
    
    IdCard() {}
	public long getId() {
		return id;
	}
	public Person getPerson() {
		return person;
	}
	
	
	public String getSn() {
		return sn;
	}
	public void setId(long id) {
		this.id = id;
	}
	public void setPerson(Person person) {
		this.person = person;
	}
	public void setSn(String sn) {
		this.sn = sn;
	}

}

 

<?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 
	package="org.hibernate.auction">
	<class name="org.leadfar.hibernate.model.IdCard" table="t_idcard" >
		<!-- 外键关联时，id生成策略任意皆可，因为不是通过id进行关联的 -->
		<id name="id">
			<generator class="assigned"/>
		</id>
		<property name="sn" not-null="true" unique="true"></property>
		<!-- unique=true 将many-to-one 限制为一对一关系 -->
		<!-- 外键将使用many-to-one中的属性，即person属性将作为外键被使用 -->
		<!-- 也就是说，IdCard一端将通过person属性去获取Person -->
		<!-- 而且，Person一端如果要使用person字段映射到本表的话，就必须使用property-ref=person -->
		<!-- 这样双方才能通过唯一的person进行双向关联映射 -->
		<many-to-one name="person" unique="true" column="personid"></many-to-one>
		
	</class>
	
</hibernate-mapping>

 

测试

package org.leadfar.hibernate.model;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

import junit.framework.TestCase;

public class OneToOneTest extends TestCase {
	public void oneToOne_save() {
		Configuration cfg = new Configuration().configure();
		SessionFactory sf = cfg.buildSessionFactory();
		Session session = sf.openSession();
		
		try {
			session.beginTransaction();
			/**
			 *one-to-one 外键关联映射 
			 *1.先保存Person (one-to-one)Idcard中的person字段值需要参考person表的主键id
			 *<one-to-one name="idcard" property-ref="person"> </one-to-one>
			 *
			 *2.再保存IdCard，其中IdCard中的person属性将使用前面保存的Person对象 (many-to-one)
			 *<many-to-one name="person" unique="true" column="personid"></many-to-one>
			 */
			
			Person p1= new Person();
			p1.setId(1L);
			p1.setName("1abc");
			session.save(p1);
			
			Person p2= new Person();
			p2.setId(2L);
			p2.setName("2abc");
			session.save(p2);
			
			Person p3= new Person();
			p3.setId(3L);
			p3.setName("3abc");
			session.save(p3);
			
			
			IdCard idcard1 = new IdCard();
			idcard1.setId(2L);
			idcard1.setSn("11111111111");
			idcard1.setPerson(p1);//关联关系一定不要丢
			session.save(idcard1);
			
			IdCard idcard2 = new IdCard();
			idcard2.setId(3L);
			idcard2.setSn("22222222222");
			idcard2.setPerson(p2);//关联关系一定不要丢
			session.save(idcard2);
			
			IdCard idcard3 = new IdCard();
			idcard3.setId(4L);
			idcard3.setSn("33333333333");
			idcard3.setPerson(p3);//关联关系一定不要丢
			session.save(idcard3);
			
			session.getTransaction().commit();
		} catch(Exception e) {
			session.getTransaction().rollback();
			e.printStackTrace();
		} finally {
			session.close();
		}
	}
	
	//根据Person获取idCard
	public void oneToOne_load01() {
		Configuration cfg = new Configuration().configure();
		SessionFactory sf = cfg.buildSessionFactory();
		Session session = sf.openSession();
		
		try {
			session.beginTransaction();
			
			Person p1 = (Person)session.load(Person.class, 2L);//如果id为long类型，则需要加L后缀
			IdCard idcard = p1.getIdcard();
			System.out.println(p1.getName()+","+idcard.getSn());
			
			session.getTransaction().commit();
		} catch(Exception e) {
			session.getTransaction().rollback();
			e.printStackTrace();
		} finally {
			session.close();
		}
	}
	//根据idCard获取Person
	public void oneToOne_load02() {
		Configuration cfg = new Configuration().configure();
		SessionFactory sf = cfg.buildSessionFactory();
		Session session = sf.openSession();
		
		try {
			session.beginTransaction();
			
			IdCard idcard = (IdCard)session.load(IdCard.class, 2L);
			Person person = idcard.getPerson();
			System.out.println(idcard.getSn()+","+person.getName());
			
			session.getTransaction().commit();
		} catch(Exception e) {
			session.getTransaction().rollback();
			e.printStackTrace();
		} finally {
			session.close();
		}
	}
}

 

 

 

schy_hqh
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
hibernate一对一的单向和双向关系
zyljjf的博客
05-22 3714
单向和双向的区别单向的意思：保存的关系维护者，做的任何操作，都会影响，另外一个实体。操作包含 4种 增加 删除  修改 查询双向的意思：可以随便通过一方去操作另外一方@Data  get 和set 方法 重写hashcode 和equals方法 重写toString方法如： mouth类是关系非维护者 Person2是关系维护者单向关联：如：在关系维护端添加@OneToOne(cascade = ...
Hibernate双向一对一关联映射(注解版)
05-05
Hibernate双向一对一关联映射(注解版)
Hibernate 双向关联
哈哈__哈哈的专栏
09-15 103
不管是啥关联，只要是双向，都必须用到mappedBy   关联：一对一双向，一对多双向，多对一双向
Hibernate一对一关联映射配置
weixin_30654583的博客
09-06 52
一、一对一关联 Hibernate提供了两种映射一对一关联关系的方式：按照外键映射和按照主键映射。下面以员工账号和员工档案表为例，介绍这两种映射方式，并使用这两种映射方式分别完成以下持久化操作： (1)保存员工档案的同时分配给员工一个账号。 (2)加载员工档案的同时加载账号信息。 按照外键映射： 关系图： ①创建实体类：Resume、Users 并封装属性 public ...
hibernate中的一对一双向主键关联的配置以及注意事项
苝花向暖丨楠枝向寒
05-13 228
package hibernate.pojo; import java.io.Serializable; public class EmpVo{ private int empid; private String empname; private String cardno; private String sex; private int age; private String...
hibernate关联映射(注解) —— 基于外键的双向一对一关联映射(@OneToOne)
R15的博客
06-21 1041
hibernate基于注解的一对多关联使用@OneToOne注解。 注意：需要引入的为： javax.persistence.OneToOne 维护端(有外键方)： //不要忘记加 unique = true，否则和多对一一样！ @OneToOne(fetch = FetchType.EAGER)//设置加载 @Cascade(CascadeType.SAVE_UPDATE)//设置级联...
【Hibernate】——双向关联映射
相由心生-心随相改~
12-31 648
双向关联（Bidirectional associations）     一对多（one to many) / 多对一（many to one）     双向多对一关联 是最常见的关联关系。（这也是标准的父/子关联关系。） <many-to-one name="address" column=
hibernate双向一对一主键关联映射XML与注解版
fendo
05-05 1922
qqqq
hibernate 持久化对象
码农之道
05-18 564
//瞬时对象  Person person = new Person();      Session session =sessionFactory.getCurrentSession();  session.setName("liuzhao");  session.save(person);  //持久对象  person.getName();        session.close();
hibernate映射配置文件（xxx.hbm.xml）内容及作用
热门推荐
大仝小韩
07-20 1万+
hibernate映射配置文件用于配置与数据库表之间的映射关系，（通过配置映射关系，在启动项目的时候，hibernate就会生成相对应的数据表，但是数据库得自己建）
No connection properties specified - the user must supply JDBC connections 的解决办法
del1214的专栏
09-18 8311
照hibernate官网的例子写了一下， 其中setProperty时是按xml时写的那种缩写比如hibernate.dialect 写成dialect hibernate.connection.username写成connection.username 这样会提示
一对一主键双向关联(用代码控制级联删除)
世范水晶
05-21 295
一、下面的代码可以运行。 1、数据库脚本 --oracle数据库-- 删除表DROP TABLE idcard ;DROP TABLE person ; -- 创建表CREATE TABLE person( id VARCHAR2(32) PRIMARY KEY , name VARCHAR2(20) NOT NULL , age NUMBER) ;CREATE TABLE idcard( ...
枚举工具类
qq_43049583的博客
08-04 217
java枚举工具类
等待唤醒机制两种实现方法-阻塞队列
最新发布
泰勒今天想展开的博客
08-04 209
桌子上有面条-》吃货执行桌子上没面条-》生产者制造执行。
社区养老服务小程序的设计
Karen198的博客
07-31 613
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
Springboot+Websocket+Security+Vue 实现弹幕推送功能
Gemini1995的博客
08-01 563
【代码】Springboot+Websocket+Security+Vue 实现弹幕推送功能。
JavaSE面向对象进阶
qq_45348840的博客
07-30 528
需求：在实际开发中，经常会遇到一些数组使用的工具类;请按照如下要求编写一个数组的工具类：ArrayUtil提供一个工具类方法printArr,用于返回整数数组的内容。返回的字符串格式如：[10,20,50,34,100 ]（只考虑整数数组，且只考虑一维数组)提供这样一个工具方法getAerage,用于返回平均分。（只考虑浮点型数组，且只考虑一维数组)定义一个测试类TestDemo,调用该工具类的工具方法，并返回结果。// 私有化构造方法// 定义静态方法，方便调用。i++) {
花几千上万学习Java，真没必要！（三十五）
wehpd的博客
07-30 703
集合之Map
26.jdk源码阅读之ConcurrentLinkedQueue
前端、移动端、后端源码级底层原理分享
07-29 1015
ConcurrentLinkedQueue 是 Java 中提供的一个基于无界非阻塞算法的线程安全队列。它是一个适用于高并发环境的队列实现，基于链表结构。
Hibernate一对一双向关联映射详解
"该资源是关于信息系统软件设计的，特别是针对Hibernate框架的程序设计知识的讲解，主要聚焦在对象-关系映射（ORM）中的一对一和多对一关联关系的映射技术。" 在信息系统软件设计中，Hibernate是一个非常重要的ORM...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值