【Hibernate框架】关联映射（一对一关联映射）

最新推荐文章于 2023-04-11 21:44:51 发布
最新推荐文章于 2023-04-11 21:44:51 发布
阅读量326 收藏
点赞数
分类专栏： Hibernate

一、整理思路

hibernate的相关的关联映射，直接上图：


这张图，就是整个Hibernate的关联映射的一个大致思路。

二、名词解释

1、单向关联：很简单，就是一个对象依赖于另一个对象。
2、双向关联：两个对象互相依赖。

三、一对一（one-to-one）关联映射

所谓的一对一，大白话理解就是一个物件拥有的某种附属物件能而且只能拥有一件。举个例子就是作为学生，一个学生只能拥有一个有效的学生证，一个堂堂正正的中国公民也只能拥有一张有效的身份证。这就是一对一。接下来，我们就利用在职学生为例，说一下一对一映射。
在Hibernate中有两种方式能实现一对一映射，分别是：
1、主键关联；
2、唯一外键关联。

四、逐一介绍

4.1、一对一单向关联映射

4.1.1、一对一单向关联映射——主键关联
核心：一个对象依赖于另一个对象。举例：根据学生，找到对应的有效学生证。

表设计：



Po对象设计：
StudentCard.Java:

public class StudentCard {
	private int id;
	private String cardNo;
	//getter, setter方法
}
Student.java: 
public class Student {
	private int id;
	private String name;
	private StudentCard studentCard;
	//getter, setter方法	
}
映射文件：
StudentCard.hbm.xml 
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.hib.domain" >
    <class name="StudentCard" table="studentCard">
        <id name="id">
            <generator class="native"/>
        </id>
        <property name="cardNo"/>
    </class>
</hibernate-mapping>
Student.hbm.xml 
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.hib.domain">
    <class name="Student" table="student">
        <id name="id" type="int">
            <generator class="foreign">
                <param name="property">studentCard</param>
            </generator>
        </id>
        <property name="name"/>
        <one-to-one name="studentCard" constrained="true"/>
    </class>
</hibernate-mapping>
分析：核心<one-to-one name="studentCard" constrained="true"/>，表示一个Student对应一个StudentCard。constrained=”true”表示t_student表的主键上同时有个外键指向被关联的表（t_studentCard）的主键，会对表t_student创建约束，约束t_student的id只能跟studentCard的主键一样,也就是说，Student上的id既是主键也是外键。
测试： 
@Test
public void testSaveStudent() {
	Session session = HibernateUtils.getSession();
	Transaction tx = session.beginTransaction();

	StudentCard studentCard = new StudentCard();
	studentCard.setCardNo("12050242013");
	Student student = new Student();
	student.setName("david");
	student.setStudentCard(studentCard);
	session.save(student);

	tx.commit();
	session.close();
}
这时，会先插入一条StudentCard信息，然后再插入Student信息：

4.1.2、一对一单向关联映射——唯一外键关联
核心：唯一外键关联，就是给一对一关联关系中某个对象加一个外键。举例：给Student表添加一个外键，指向StudentCard的主键，而且外键唯一，这样也就达到了一对一映射的效果。
Po对象设计：
StudentCard.java:

public class StudentCard {
	private int id;
	private String cardNo;
	//getter, setter方法
}
Student.java: 
public class Student {
	private int id;
	private String name;
	private StudentCard studentCard;
	//getter, setter方法
}
StudentCard.hbm.xml 
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.hib.domain" >
    <class name="StudentCard" table="studentCard">
        <id name="id">
            <generator class="native"/>
        </id>
        <property name="cardNo"/>
    </class>
</hibernate-mapping>
Student.hbm.xml 
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.hib.domain">
    <class name="Student" table="student">
        <id name="id" type="int">
            <generator class="foreign">
                <param name="property">studentCard</param>
            </generator>
        </id>
        <property name="name"/>
        <many-to-one name="studentCard" unique="true"/><!--unique="true"会对此外键生成唯一约束-->
    </class>
</hibernate-mapping>
分析：
这里与主键关联还有点不一样，t_student的主键生成策略是native，不再以未见形式关联到t_studentCard的主键，用<many-to-one>标签与t_idcard建立多对一的关系，这样就可以在t_student中生成一个外键关联到t_studentCard的主键。
这时候如果还用上面的测试代码进行测试，就会报错：“org.hibernate.TransientObjectException: object references an unsaved transient instance”
因为t_student的主键生成策略是native，和t_studentCard无关，而studentCard并没有变成TransientObject，所以，我们必须要先将studentCard变成持久化对象： 
@Test
public void testSaveStudent() {

	Session session = HibernateUtils.getSession();
	Transaction tx = session.beginTransaction();

	StudentCard studentCard = new StudentCard();
	studentCard.setCardNo("12050242013");
	session.save(studentCard);
	Student student = new Student();
	student.setName("david");
	student.setStudentCard(studentCard);
	session.save(student);

	tx.commit();
	session.close();
}

4.2、一对一双向关联映射

4.2.1一对一双向关联映射——主键关联
核心：两个对象之间，相互依赖
Po对象
StudentCard.java 
public class StudentCard {
	private int id;
	private String cardNo;
	private Student student;
	//getter, setter方法
}
Student.java 
public class Student {
	private int id;
	private String name;
	private StudentCard studentCard;
	//getter, setter方法
}
Student.java配置文件：
StudentCard.hbm.xml 
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.hib.domain">
    <class name="StudentCard" table="studentCard">
        <id name="id">
            <generator class="native"/>
        </id>
        <property name="cardNo"/>
        <one-to-one name="student" fetch="join"/>
        <!--fetch值为select时，可以实现懒加载，而且这里constrained不能为true，否则会两张表主键相互依赖，导致死循环-->
    </class>
</hibernate-mapping>
Student.hbm.xml 
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.hib.domain">
    <class name="Student" table="student">
        <id name="id" type="int">
            <generator class="foreign">
                <param name="property">studentCard</param>
            </generator>
        </id>
        <one-to-one name="studentCard" constrained="true"/>
        <property name="name"/>
    </class>
</hibernate-mapping>
测试如上，我们查出Student时，Student.studentCard可以获取学生证信息。当我们查出StudentCard时，StudentCard.student可以获取学生信息。但是也正是因为他们之间是这种关系，没有相互的约束，所以当我们执行： 
@Test
public void testSaveStudentCard() {

	Session session = HibernateUtils.getSession();
	Transaction tx = session.beginTransaction();

	Student student = new Student();
	student.setName("kennth");
	StudentCard studentCard = new StudentCard();
	studentCard.setStudent(student);
	
	session.save(studentCard);
	tx.commit();
	session.close();
}
session只会save（studentCard），而不会save（student）;
4.2.2一对一双向关联映射——唯一外键关联
直接上配置了：
Po对象设计：
StudentCard.java 

public class StudentCard {
	private int id;
	private String cardNo;
	private Student student;
	//getter, setter方法
}
Student.java 
public class Student {
	private int id;
	private String name;
	private StudentCard studentCard;
	//getter, setter方法
}
配置文件：
StudentCard.hbm.xml 
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.hib.domain">
    <class name="StudentCard" table="studentCard">
        <id name="id">
            <generator class="native"/>
        </id>
        <property name="cardNo"/>
        <one-to-one name="student" property-ref="studentCard"/>
    </class>
</hibernate-mapping>

Student.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.hib.domain">
    <class name="Student" table="student">
        <id name="id" type="int">
            <generator class="foreign">
                <param name="property">studentCard</param>
            </generator>
        </id>
        <one-to-one name="studentCard" constrained="true"/>
        <property name="name"/>
    </class>
</hibernate-mapping>
一张身份证只对应一位公民，所以用<one-to-one>标签，property-ref="studentCard"指t_studentCard的主键与t_student中的studentCard字段对应。
到此，关于一对一映射的相关知识告一段落，但是大家要知道，唯一外键关联其实就是多对一关联的一种特殊情况，所以当我们需求变了，要求有一对一变成多对一的时候，我们该怎么办呢？其实很简单，直接把外键唯一的约束干掉就可以了，是不是方便很多呢？
转自：http://www.cnblogs.com/DoubleEggs/p/6254922.html
csdn_kenneth
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
关联映射
每天都得进步一点点
09-18 1220
 关联映射 所谓关联映射即:即对象之间有引用关系。在数据库中如果要建立两张表的关联关系，就需要外键来连接它们，数据库表之间的关系是没有方向性的，彼此都是透明。而在java程序中如果要使两个类建立关系的话，那么就需要使用属性组合引用对方来产生关联，java程序中的关联是有方向性的，如果没有双向管理那么彼此是不透明的。   一对多、多对一（单向） 多对一:案列为User ---->Gro
hibernate一对多关联映射学习小结
08-29
在Hibernate中，一对多关联映射和多对一关联映射的区别在于维护的关系不同。多对一关联映射中，多的一端维护一的一端的关系，在加载多的一端时，可以将一的一端加载上来。一对多关联映射中，一的一端维护多的一端的...
关联关系映射
YunGi_Baby的博客
12-24 170
1.将数据表导入数据库中 2.通过mybatis-generator插件生成dao、mapper、model 1）配置mybatis-generator插件生成文件位置 2）修改generatorConfig.xml配置文件的生成目录(mapper和model)及对应生成关系 3.修改Customer、Order实体类 1）实现序列化接口 2）建立实体映射关联关系（一对多、多对一） #一对多：一个...
深入解析Java的Hibernate框架中的一对一关联映射
09-02
总之，Java的Hibernate框架提供了一对一关联映射机制，允许开发者在对象模型和数据库表之间建立一对一的对应关系。通过在实体类和映射文件中设置适当的属性和标签，可以方便地管理这种关联，实现对象的级联操作和...
Java的Hibernate框架中一对多的单向和双向关联映射
09-02
在Java的Hibernate框架中，一对多关联映射是一种常见的数据模型关系，用于表示一个实体（如班级）可以与多个其他实体（如学生）相关联。这种关系映射可以帮助简化数据库操作，使得在Java代码中处理这些关系变得更加...
Hibernate映射解析之关联映射详解
08-31
Hibernate是Java开发中常用的持久层框架，它简化了数据库操作，其中关联映射是实现对象关系映射的关键部分。关联映射允许我们将对象之间的关联关系映射到数据库的表结构中，使得对象模型和数据库模型能够无缝对接。...
一对一双向关联映射
10-31
在Java持久化框架Hibernate中，一对一双向关联映射是一种重要的数据对象关系映射策略，它允许我们在数据库中的两个实体之间建立一对一的关系，并且在Java对象模型中可以从任一侧访问另一侧的对象。这种映射方式增加...
Mybatis关联映射
11-07
Mybatis关联映射 Mybatis关联映射 Mybatis关联映射 Mybatis关联映射 Mybatis关联映射
关系映射
qq_30946041的博客
08-03 449
根据学习到的资料缕一缕，hibernate的映射关系大致分为以下三种： 1.一对一 2.一对多 3.多对多 附上cfg配置 <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://www.hibernate.org/dtd/
hibernate一对一的两种实现方式
u011004598的专栏
11-27 123
重点掌握hibernate一对一的两种实现方式： 1、共用主键的方式(两个表中使用相同的主键) 2、通过外键的方式(在身份证的这张表里有一个外键字段关联到人这张表的主键字段)【退化了的一对多关联】...
MyBatis 关联映射
m0_52861684的博客
11-17 2866
MyBatis 关联映射，实现数据的一对一、一对多、多对多查询，同时对嵌套查询和嵌套结果集两种配置方法分别进行了演示。
MyBatis关联映射
最新发布
qq_49873907的博客
04-11 845
对于MyBatis环境配置可以参考我另外两篇博客MyBatis基础环境配置MyBatis动态SQL在关系型数据库中，表与表之间存在着3种关联映射关系，分别为一对一、一对多、多对多。一个数据表中的一条记录最多可以与另一个数据表中的一条记录相关。列如学生与学号就属于一对一关系。主键数据表中的一条记录可以与另外一个数据表任意数量的记录相关，另外一个数据表中的一条记录只能与主键数据表中的某一条记录相关。列如班级与学生就属于一对多关系。
Hibernate关联映射（一对多/多对多）
热门推荐
知飞翀的博客
11-22 1万+
3.  Hibernate关联映射 上接Hibernate持久化类：https://blog.csdn.net/biggerchong/article/details/84260707 目录 3.  Hibernate关联映射 3.1 数据库表之间的关系 3.1.1 一对多关系 3.1.2 多对多关系 3.1.3 一对一关系（实际开发中使用较少） 3.2 实战Hibernate...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值