Hibernate关联映射1:一对一主键关联

最新推荐文章于 2018-12-18 14:34:25 发布
最新推荐文章于 2018-12-18 14:34:25 发布
阅读量1w 收藏 1
点赞数
分类专栏： ORM 文章标签： Hibernate Hibernate关联映射 Hibernate一对一关联
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a19881029/article/details/17481749
版权

2张表之间通过主键形成一对一映射关系，如一个人只能有一张身份证：

t_identity_card表建表语句：

CREATE TABLE `t_identity_card` (
  `id` int(11) NOT NULL,
  `identity` int(11) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=gb2312;

t_person表建表语句：

CREATE TABLE `t_person` (
  `id` int(11) NOT NULL,
  `name` varchar(255) NOT NULL,
  `age` int(11) NOT NULL,
  PRIMARY KEY (`id`),
  CONSTRAINT `FK_ID` FOREIGN KEY (`id`) REFERENCES `t_identity_card` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=gb2312;

hibernate.cfg.xml:

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
	"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
	"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
	<session-factory>
		<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
		<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
		<property name="connection.url">jdbc:mysql://localhost:3306/mydb</property>
		<property name="connection.username">root</property>
		<property name="connection.password">196428</property>
		
		<property name="hibernate.show_sql">true</property>
		
		<mapping resource="com/po/IdentityCard.hbm.xml" />
		<mapping resource="com/po/Person.hbm.xml" />
	</session-factory>
</hibernate-configuration>

单向一对一主键关联：

t_identity_card表：

public class IdentityCard implements Serializable {
	private static final long serialVersionUID = 1L;
	private int id;
	private int identity;
	private Person person;
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public int getIdentity() {
		return identity;
	}
	public void setIdentity(int identity) {
		this.identity = identity;
	}
	public Person getPerson() {
		return person;
	}
	public void setPerson(Person person) {
		this.person = person;
	}
}

由于t_identity_card表使用foreign主键生成策略，故在t_identity_card表的配置文件中必须配置主键生成表t_person，这样在向t_identity_card表中插入数据时才能找到所需的主键值，所以单向一对一主键关联中只有t_person<-t_identity_card，没有t_person->t_identity_card

<?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.po.IdentityCard" table="t_identity_card">
    	<id name="id" column="id" type="integer">
			<generator class="foreign">
				<param name="property">person</param>
			</generator>
		</id>
        <property name="identity" column="identity" type="integer"/>
        <one-to-one name="person" class="com.po.Person"/>
    </class>
</hibernate-mapping>

t_person表：

public class Person implements Serializable {
	private static final long serialVersionUID = 1L;
	private int id;
	private String name;
	private int age;
	
	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 int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
}
<?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.po.Person" table="t_person">
		<id name="id" column="id" type="integer">
			<generator class="assigned"/>
		</id>
		<property name="name" column="name" type="string"/>
        <property name="age" column="age" type="integer"/>
    </class>
</hibernate-mapping>

测试一下：

public class Test {
	public static void main(String[] args) {
		Configuration conf = new Configuration();
		SessionFactory sessionFactory = conf.configure().buildSessionFactory();
		Session session = sessionFactory.openSession();
		
		IdentityCard identityCard = new IdentityCard();
		identityCard.setIdentity(123456);
		Person person = new Person();
		person.setId(1);
		person.setName("sean");
		person.setAge(25);
		identityCard.setPerson(person);
		
		Transaction tran = session.beginTransaction();
		session.save(identityCard);
		tran.commit();
		
		IdentityCard identityCard2 = (IdentityCard)session.get(IdentityCard.class, 1);
		Person person2 = identityCard2.getPerson();
		System.out.println(person2.getName());
		
		session.close();
	}
}

测试结果为：

Hibernate: insert into t_identity_card (identity, id) values (?, ?)
sean

只向t_identity_card表中插入了数据，t_person表为空，由于没有设置关联关系的cascade属性，在持久化一张表的时候，并不会级联的持久化另一张表

将t_identity_card表的映射文件中的关联关系修改为：<one-to-one name="person" class="com.po.Person"cascade="all" />

Hibernate: select person_.id, person_.name as name1_, person_.age as age1_ 
from t_person person_ where person_.id=?
Hibernate: insert into t_identity_card (identity, id) values (?, ?)
Hibernate: insert into t_person (name, age, id) values (?, ?, ?)
sean

双向一对一主键关联：

这时需要对t_person表的配置做一些修改：

public class Person implements Serializable {
	private static final long serialVersionUID = 1L;
	private int id;
	private String name;
	private int age;
	private IdentityCard identityCard;//新增
	
	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 int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public IdentityCard getIdentityCard() {
		return identityCard;
	}
	public void setIdentityCard(IdentityCard identityCard) {
		this.identityCard = identityCard;
	}
}
<?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.po.Person" table="t_person">
		<id name="id" column="id" type="integer">
			<generator class="native"/>
		</id>
		<property name="name" column="name" type="string"/>
        <property name="age" column="age" type="integer"/>
    	<!--新增-->
    	<one-to-one name="identityCard" class="com.po.IdentityCard" cascade="all" />
    </class>
</hibernate-mapping>

测试一下：

public class Test {
	public static void main(String[] args) {
		Configuration conf = new Configuration();
		SessionFactory sessionFactory = conf.configure().buildSessionFactory();
		Session session = sessionFactory.openSession();
		
		IdentityCard identityCard = new IdentityCard();
		identityCard.setIdentity(123456);
		Person person = new Person();
		person.setId(1);
		person.setName("sean");
		person.setAge(25);
		
		identityCard.setPerson(person);
		person.setIdentityCard(identityCard);
		
		Transaction tran = session.beginTransaction();
		session.save(identityCard);
		tran.commit();
		
		Person person_tmp = (Person)session.get(Person.class, 1);
		IdentityCard id_card_tmp = person_tmp.getIdentityCard();
		System.out.println(id_card_tmp.getIdentity());
		
		id_card_tmp = (IdentityCard)session.get(IdentityCard.class, 1);
		person_tmp = id_card_tmp.getPerson();
		System.out.println(person_tmp.getName());
		
		session.close();
	}
}

测试结果为：

Hibernate: select person_.id, person_.name as name1_, person_.age 
as age1_ from t_person person_ where person_.id=?
Hibernate: insert into t_identity_card (identity, id) values (?, ?)
Hibernate: insert into t_person (name, age, id) values (?, ?, ?)
123456
sean

Hibernate首先持久化了identityCard对象，将测试代码中的session.save(identityCard)修改为session.save(person)，再次测试：

Hibernate: insert into t_person (name, age, id) values (?, ?, ?)
Exception in thread "main" org.hibernate.exception.ConstraintViolationException: 
Could not execute JDBC batch update
......
Caused by: java.sql.BatchUpdateException: Cannot add or update a child row:
a foreign key constraint fails (`mydb`.`t_person`, CONSTRAINT `FK_ID` 
FOREIGN KEY (`id`) REFERENCES `t_identity_card` (`id`))
......

Hibernate这次首先持久化了person对象，由于t_person表中的id字段建立了外键关系，故持久化失败，删除掉t_person表中id字段的外键关系之后，插入正常：

Hibernate: insert into t_person (name, age, id) values (?, ?, ?)
Hibernate: insert into t_identity_card (identity, id) values (?, ?)
123456
sean

可见Hibernate有时不是很智能，save的对象将会首先被持久化，这时要特别注意表上建立的关联关系

sean-zou
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
数据结构中：两个表的关联-表的主键
u011528810的专栏
09-10 9081
在现实的数据库应用中，数据保存在多个相关联的表中。基本上没有数据只存在一个表中的情况。小的应用系统一般也有十几个表，大型系统一般有上千个表。       我们以学生成绩查询为例来讲解表的关联。除了Student表，这里我们需要新建成绩表，表Grade：   Sno Cno Grade S01 C01 82
hibernate 联合主键关联
weixin_33759269的博客
12-17 83
package com.bjsxt.hibernate; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.Id; import javax.persistence.JoinColumn; import javax.pe...
主键关联、外键关联的区别
weixin_33774308的博客
02-16 1339
概念 主键关联是指的一个表的主键和另外一个表的主键关联外键关联是指的一个表的主键和另外一个表的非主键关联主键关联：   person_t:      　　person_id         primaryKey     　　address_id       non-primaryKey   address_t     　　 address_id        primaryKey     　　...
【Hibernate】Hibernate实体关系映射——主键相同的一对一关系
lmb55的专栏
06-20 2482
主键相同的一对一关系 由于两个实体类是一对一的关系，因此可设置两个实体类使用相同的主键。反过来，具有相同主键的实体被视为一对一的关系。这样两个表就省掉了外键关联。 以客户地址管理为例学习主键相同的一对一关系：一个客户对应一个地址，对应的实体之间使用相同的主键。 客户与地址之间是一对一的关系，并且两个实体的id是相同的。双方都有对方的引用。注意，两个数据库表之间没有关联关系，hibernate...
Hibernate一对一主键关联映射（双向关联）
03-06
标题"Hibernate一对一主键关联映射（双向关联）"中的"主键关联"指的是两个实体通过共享相同的主键来建立关联。"双向关联"则意味着在两个实体类中，都可以直接访问到对方的实例，即在实体A中有一个对实体B的引用，...
hibernate一对一主键关联映射（单项关联）
03-01
2. **配置映射**：在上面的代码中，我们使用了Hibernate的注解来描述一对一主键关联。`@OneToOne`注解表示一对一的关系，`mappedBy`属性指定了在对方实体中的关联字段。`@JoinColumn`用于指定外键列名，这里是`...
Hibernate一对一主键关联映射（单向关联）
03-05
总结来说，Hibernate中的一对一主键关联映射允许两个实体共享同一个主键，实现单向关联时只需在依赖方添加对另一方的引用。在实际应用中，应根据业务需求谨慎选择关联类型，以确保数据的完整性和一致性。
hibernate使用主键关联的一对一关系
10-07
总之，理解并正确实现Hibernate中的一对一主键关联对于优化数据模型和提高代码的可维护性至关重要。通过共享主键，我们可以确保数据的完整性和一致性，同时简化对象之间的交互。阅读提供的博客资源，结合本文的讲解...
hibernate一对一主键关联映射（双项关联）
03-01
在Java的持久化框架...总结来说，Hibernate的一对一主键关联映射，尤其是双向关联，能有效地简化对象关系的映射，提高代码的可读性和维护性。然而，需要根据实际情况权衡其带来的性能影响，确保系统设计的高效性。
一对一主键关联(视频)
03-20
NULL 博文链接：https://sanshi-lxl.iteye.com/blog/798444
【MyBatis学习10】关联关系association：1对1关联的三种方法
热门推荐
程序老兵的博客
03-19 1万+
本篇主要讲关联关系：一对一关系与一对多关系。 先建5个表： DROP TABLE IF EXISTS `category`; CREATE TABLE `category` ( `id` int(10) unsigned NOT NULL AUTO_INCREMENT, `catename` varchar(50) NOT NULL, PRIMARY KEY (`id`) ) ENG
Hibernate配置非主键关联
吾 爱 卧 龙 吟
01-21 2575
一段时间没使用过Hibernate了，对于Hibernate配置非主键关联方式基本遗忘了，现在整理一下： 一个 Area 对象对应多个 Nation 对象，以下配置双向多对一关联，其中各对象的属性分别为： // Area对象属性列表public class Area { private Integer id; private String areaCode; // 地区编码 priva
SSH框架之Hibernate的关联映射之一对多、多对一映射
一点一滴
12-19 1万+
关联映射之一对多、多对一映射 一、需求： 部门与员工 一个部门有多个员工 【一对多】 多个员工，属于一个部门 【多对一】 二、逻辑分析： 三、代码实现 1、javabean及映射文件的配置： 1）Employee.java、Employee.hbm.xml 2）Dept.java、Dept.hbm.xml
Hibernate一对一主键关联（基于annotation注解方式)
笑看人生的专栏
03-08 3514
标签： hibernate 主键 关联 映射 存储 级联 one-to-one 分类：hibernate3.3.2  hibernate中一对一的关联有两种方式：一种是采用外键关联，另外一种是采用主键关联。  最近项目中用到一对一主键双向关联，并且是基于注解的方式。期间遇到一些问题，现在贴出来探讨探讨。  一个丈夫(husband)对应一个妻子(wife)，主
1.一对一单向主键关联(人对身份证) 对象,hbm
09-16 380
package com.bjpowernode.hibernate; public class IdCard { private int id; private String cardNo; public int getId() { return id; } public void setId(int id) { this.id = id;
hibernate 基于主键的双向一对一关联映射(@OneToOne) 注解方式
qq_27886997的博客
12-18 2467
简介： 有时候会把一张大表拆分为两个小表，一个主表一个从表，从表的id根据主表生成，两表的id一样，所以称为共享id; 主表的id是自动生成的，也就是先新建几条主表信息，保存从表的时候再集。（主表）从表的id就会根据主表生成; 从表端，维护端（有外键方）： @Id @GenericGenerator（name =“pkGenerator”，strategy =“foreign”，     ...
Hive 关联主键数据倾斜的一种处理方法
10-18 762
记得之前用过一种办法，concat(a.col,'-',ceil(rand()*100)%20))，将记录数特别多的关联字段取模20，得到新字段a.col2；另外维护一张有20条记录的小表，小表的数据从0到19，用b表的关联字段关联这张小表得到新的字段b.col2，然后再用这个新字段b.col2关联a表的新字段a.col2 这样，相当于a表的值特别多的记录，分散为了20份，这个分为多少份可以根据实...
1对1关联关系映射
超胆孤侠
12-20 591
域模型关系数据模型 按照外键映射 按照主键映射 基于外键映射的 1-1 对于基于外键的1-1关联，其外键可以存放在任意一边，在需要存放外键一端，增加many-to-one元素。为many-to-one元素增加unique=“true” 属性来表示为1-1关联 <many-to-one name="manLover" class="com.school.ManLover" unique="true"

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值