在学习Hibernate映射关系时，我们先来做一些准备工作。
1、建一个web项目，这里只是Hibernate映射关系的学习，只要导入一些Hibernate的必须包跟数据库连接包就Ok了。如下图：
hibernate所需jar包（这里用的是hibernate5.2，hibernate5.1以上版本要注意一个问题，下面会说）
数据库连接的jar包
这样一个项目就建好了，具体细节就不说了。
2、创建一个数据库。我这里创建的数据库的名字是：mys。（我也不知道为什么起这个名字），然后表呢，就通过演示关系时再建。
3、配置下主配置文件：hibernate.cfg.xml,具体如下：（下面的每一个实体映射文件都要到放到主配置文件中）
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<!--
#hibernate.dialect org.hibernate.dialect.MySQLDialect
#hibernate.dialect org.hibernate.dialect.MySQLInnoDBDialect
#hibernate.dialect org.hibernate.dialect.MySQLMyISAMDialect
#hibernate.connection.driver_class com.mysql.jdbc.Driver
#hibernate.connection.url jdbc:mysql:///test
#hibernate.connection.username gavin
#hibernate.connection.password
-->
<!-- 必填 -->
<!-- 数据库驱动 -->
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<!-- 数据库url -->
<property name="hibernate.connection.url">jdbc:mysql:///mys</property>
<!-- 数据库账号 -->
<property name="hibernate.connection.username">root</property>
<!-- 数据库密码-->
<property name="hibernate.connection.password">root</property>
<!-- 数据库方言
只针对某一个或者某几个数据库适用的数据库语法
sql99
DDL 数据库定义语言 数据库和表的增删查改
DCL 数据库控制语言 事务 权限
DML 数据库操纵语言 数据的增删查改
hibernate可以更好的去生成sql语句
-->
<!-- 注意：
如果你使用的是5.1以上的hibernate版本，需要自动建表且是InnoDB引擎，要修改方言，要加个5，如下所示：要修改方言为MySQL5InnoDBDialect
-->
<property name="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>
<!--
#hibernate.show_sql true
hibernate.format_sql true
-->
<!-- 可以在控制台打印生成的sql语句 -->
<property name="hibernate.show_sql">true</property>
<!-- 可以格式化在控制台打印生成的sql语句 -->
<property name="hibernate.format_sql">true</property>
<!--
## auto schema export 自动到处表结构 ，自动建表
#hibernate.hbm2ddl.auto create 每次启动都会自动建表，会覆盖以前的，会导致数据丢失(开发环境)
#hibernate.hbm2ddl.auto create-drop 每次关闭的时候，自动删表
#hibernate.hbm2ddl.auto update 当表不存在的时候，自动建表，存在的话，会去更新(推荐)
#hibernate.hbm2ddl.auto validate 校验，不会自动建表，它会去检查表的正误，如果错的话会报错
注意：如果你使用的是5.1以上的hibernate,需要自动建表且是InnoDB,要修改方言为MySQL5InnoDBDialect
-->
<!-- 注意：
如果你使用的是5.1以上的hibernate版本，需要自动建表且是InnoDB引擎，要修改方言，要加个5，以下是自动建表的。。
-->
<property name="hibernate.hbm2ddl.auto">update</property>
<!--
## specify a JDBC isolation level
#hibernate.connection.isolation 4
1
2
4
8
0000
0001 1
0010 2
0100 4
1000 8
-->
<property name="hibernate.connection.isolation">4</property>
<property name="hibernate.current_session_context_class">thread</property>
<!-- 导入src下的映射文件 -->
</session-factory >
</hibernate-configuration>
以上的配置文件也说明了一件hibernate5.1以上版本会出现的一个问题：
注意：如果你使用的是5.1以上的hibernate,需要自动建表且是InnoDB,要修改方言为MySQL5InnoDBDialect
4、创建一个获得session对象的工具类：HibernateUtils.java
package com.nieshenkuan.util;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
public class HibernateUtils {
static SessionFactory sf;
static {
Configuration conf=new Configuration().configure();
sf=conf.buildSessionFactory();
}
public static Session openSession() {
Session session = sf.openSession();
return session;
}
}
看一下整个的项目目录吧：
项目目录
准备工作做好了，现在开始进行一对一关系映射的学习：
一对一关系的概述
一对一关系看起来简单，其实也挺复杂的。其中关系就包含了四种，单向双向和主键关联外键关联。 什么意思呢，也就是包含了单向一对一主键关联、双向一对一主键关联，单向一对一外键关联，双向一对一外键关联， 这四种中，单双向就不用在说了把，就是看你业务需求来去设置是否是单双向，而外键关联也很简单，前面的一对多和多对多度是依靠外键关联关系来写的。那主键关联关系是怎么样的呢？其实跟外键关联差不多，唯一的区别就是，让一个类的主键当作外键使用来指向另一个关联类的主键，从而两个类的主键就达到了同步，也就是一致。你的主键是什么我的主键就是什么。如果这看不懂，那么就看下面的详细讲解的。
一、第一种：单向一对一主键关联
通过人和身份证这个一对一的例子来解释。
1、实体类的属性
person实体能查到idcard
2、数据库关系图
person中的id既是主键又是指向IdCard主键的外键。通过外键得特性，可以知道person的id和IdCard的主键id要相同，所以这才叫做主键关系。
image
3、创建表
person表创建：
DROP TABLE IF EXISTS `person`;
CREATE TABLE `person` (
`id` int(10) NOT NULL AUTO_INCREMENT,
`name` varchar(10) NOT NULL,
PRIMARY KEY (`id`),
CONSTRAINT `fk_person_idcard` FOREIGN KEY (`id`) REFERENCES `idcard` (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
idcard表创建：
DROP TABLE IF EXISTS `idcard`;
CREATE TABLE `idcard` (
`id` int(10) NOT NULL AUTO_INCREMENT,
`cardNo` varchar(10) NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
4、编写实体文件和实体映射文件
IdCard.java
package com.nieshenkuan.model;
/**
* 主键单向一对一关联
*
* @author NSK
*
*/
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;
}
}
IdCard.hbm.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.nieshenkuan.model">
<class name="IdCard" table="idcard">
<id name="id" column="id">
<!-- 主键生成策略 使用native，需要底层数据库自己设置主键的值哦，比如AUTO_INCREMENT -->
<generator class="native">
</generator>
</id>
<!-- 一些常规属性 -->
<property name="cardNo"></property>
</class>
</hibernate-mapping>
Person.java
package com.nieshenkuan.model;
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;
}
}
Person.hbm.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2017-12-28 11:28:55 by Hibernate Tools 3.5.0.Final -->
<hibernate-mapping package="com.nieshenkuan.model">
<class name="Person" table="person">
<id name="id" column="id">
<!-- 重点在这里。主键生成策略 因为主键跟外键是同一个，所以直接在这里申明该主键就是外键，并且指向了idCard这个类 -->
<generator class="foreign">
<param name="property">idCard</param>
</generator>
</id>
<!-- 一些常规属性 -->
<property name="name"></property>
<!--由于在申明主键的时候已经将关系写清楚了，所以在这里没有column这个属性。按平常的习惯，我们会在这里写上column="数据库中外键字段属性名称。" -->
<!--constrained属性：就是表明我们的主键当外键使用了。 这个属性两个作用，一是通知这种对应关系在上面已经写过了，所以这里才不需要写column，二是表明这种关系是什么，也就是主键当外键。
其实还有一个级联关系的作用，这里不做多说明，具体会在这章之后一起讲解，不然会让人感觉很混乱。 -->
<one-to-one name="idCard" constrained="true"></one-to-one>
</class>
</hibernate-mapping>
5、测试
@Test
public void testOneToOne() {
Session session = HibernateUtils.openSession();
Transaction transaction = session.beginTransaction();
// ---------------------------------------------
// 这里先添加一条测试数据
IdCard idCard = new IdCard();
idCard.setCardNo("11111111");
Person person = new Person();
person.setName("qqq");
person.setIdCard(idCard);
session.save(idCard);// 这个其实可以不用的，讲了级联就可以省略的，现在先保留下来，大神的话看看不说话就好哦
session.save(person);
// ----------------------------------------------
transaction.commit();
session.close();
}
/**
* 单向的一对一主键关联关系
*/
@Test
public void testOneToOne1() {
Session session = HibernateUtils.openSession();
Transaction transaction = session.beginTransaction();
// ---------------------------------------------
// Person person=session.get(Person.class, 1);
// System.out.println(person.getIdCard().getCardNo());
// 这样会报错，因为我们设置的是单向一对一，从person到Idcard，所以从idcard是查不到person。
// IdCard idCard = (IdCard)session.get(IdCard.class, 1);
// System.out.println(idCard.getPerson().getName());
// 但是这样就查得到一个人的idCard
Person person = (Person) session.get(Person.class, 1);
System.out.println(person.getIdCard().getCardNo());
// ----------------------------------------------
transaction.commit();
session.close();
}
二、第二种：双向一对一主键关联
1、实体类属性
这个图中双向箭头的意思是不管从那边查找，都能够找到对方，比如，person到Idcard：直接拿自己的主键值到对方表中查找主键值一样的，查找到了就将该记录放到自己的idCard属性中，就行了 idCard到person也是一样，拿主键值到对方表中查找主键值相同的。查找到了就将记录放到person属性变量中。
双向实体关系
2、数据库关系
双向数据库关系
跟单向一对一主键关系基本上一样，只需要在IdCard这个实体类上加上一个Person person来保存对应的person实例对象，并且在IdCard.hbm.xml中加上一个<one-to-one>的映射关系。具体看实体与实体映射文件的编写。
3、建表
表跟上面的表一样。不需要重新建。
4、实体与实体映射文件编写
IdCard.java
package com.nieshenkuan.model;
/**
* 主键一对一关联
* @author NSK
*
*/
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;
}
}
IdCard.hbm.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.nieshenkuan.model">
<class name="IdCard" table="idcard">
<id name="id" column="id">
<!-- 主键生成策略 使用native，需要底层数据库自己设置主键的值哦，比如AUTO_INCREMENT -->
<generator class="native">
</generator>
</id>
<!-- 一些常规属性 -->
<property name="cardNo"></property>
<!-- 这里只需要写这些就足够了，因为one-to-one默认使用的就是用主键跟关联类的主键进行比较，
本来就是主键关系，通过主键跟主键比较，就能达到目的，所以这个中没有column这个属性，
但是可以配置一些别的属性，不需要写column， -->
<one-to-one name="person"></one-to-one>
</class>
</hibernate-mapping>
Person.java
package com.nieshenkuan.model;
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;
}
}
Person.hbm.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2017-12-28 11:28:55 by Hibernate Tools 3.5.0.Final -->
<hibernate-mapping package="com.nieshenkuan.model">
<class name="Person" table="person">
<id name="id" column="id">
<!-- 重点在这里。主键生成策略 因为主键跟外键是同一个，所以直接在这里申明该主键就是外键，并且指向了idCard这个类 -->
<generator class="foreign">
<param name="property">idCard</param>
</generator>
</id>
<!-- 一些常规属性 -->
<property name="name"></property>
<!--由于在申明主键的时候已经将关系写清楚了，所以在这里没有column这个属性。按平常的习惯，我们会在这里写上column="数据库中外键字段属性名称。" -->
<!--constrained属性：就是表明我们的主键当外键使用了。 这个属性两个作用，一是通知这种对应关系在上面已经写过了，所以这里才不需要写column，二是表明这种关系是什么，也就是主键当外键。
其实还有一个级联关系的作用，这里不做多说明，具体会在这章之后一起讲解，不然会让人感觉很混乱。 -->
<one-to-one name="idCard" constrained="true"></one-to-one>
</class>
</hibernate-mapping>
注：这里只需要修改一下IdCard.java跟IdCard.hbm.xml文件，在IdCard.java中加一个Person实体，在IdCard.hbm.xml中添加一个
<!-- 这里只需要写这些就足够了，因为one-to-one默认使用的就是用主键跟关联类的主键进行比较，
本来就是主键关系，通过主键跟主键比较，就能达到目的，所以这个中没有column这个属性，
但是可以配置一些别的属性，不需要写column， -->
<one-to-one name="person"></one-to-one>
5、测试
/**
* 双向的一对一主键关联关系
*/
@Test
public void testOneToOne2() {
Session session = HibernateUtils.openSession();
Transaction transaction = session.beginTransaction();
// ---------------------------------------------
// 这里就可以从idcard对象查到person对象了
IdCard idCard = (IdCard) session.get(IdCard.class, 1);
System.out.println(idCard.getPerson().getName());
// 这里是从person对象查到idcard对象
Person person = (Person) session.get(Person.class, 1);
System.out.println(person.getIdCard().getCardNo());
// ----------------------------------------------
transaction.commit();
session.close();
}
注意：主键关系的一对一的缺点：不知道你们发现了没有，在增加实验数据的时候，必须得先有Idcard，才能有person.
三、第三种：单向一对一外键关联
理解了主键关联，这个外键关系非常简单，因为他就是多对一的一个特例，如果多端控制为1个的话，那不就是一对一了吗，这里要注意站的角度问题，多对一重点在多端，如果是一对多的话，重点在一端，一端本来就是1了，就没有所谓的特例了，所以还是要到多端去设置让他唯一，这样就打到了一对一关系，因此上面说的是多对一的一个特例，这样解释应该清楚了。如何设置多端唯一呢，通过一个属性 unique=ture。
1、来看看数据库关系图(跟一对多的数据库关系模型一样)
数据库一对一关系
2、实体类中属性
因为是单向一对一，从Person到IdCard，所以Person中多一个能存放IdCard实例对象的属性
实体一对一关系
3、建表（这里要把一开始建的两个表给删了。重新建）
person表：
DROP TABLE IF EXISTS `person`;
CREATE TABLE `person` (
`id` int(10) NOT NULL AUTO_INCREMENT,
`name` varchar(10) NOT NULL,
`cardId` int(10) NOT NULL,
PRIMARY KEY (`id`),
KEY `fk_person_idcard` (`cardId`),
CONSTRAINT `fk_person_idcard` FOREIGN KEY (`cardid`) REFERENCES `idcard` (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
idcard表：
DROP TABLE IF EXISTS `idcard`;
CREATE TABLE `idcard` (
`id` int(10) NOT NULL AUTO_INCREMENT,
`cardNo` varchar(10) NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
4、实体与实体映射文件的编写
IdCard.java
package com.nieshenkuan.model;
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;
}
}
IdCard.hbm.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.nieshenkuan.model">
<class name="IdCard" table="idcard">
<id name="id" column="id">
<!-- 主键生成策略 使用native，需要底层数据库自己设置主键的值哦，比如AUTO_INCREMENT -->
<generator class="native">
</generator>
</id>
<!-- 一些常规属性 -->
<property name="cardNo"></property>
</class>
</hibernate-mapping>
Person.java
package com.nieshenkuan.model;
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;
}
}
Person.hbm.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.nieshenkuan.model">
<class name="Person" table="person">
<id name="id" column="id">
<!-- 主键生成策略 -->
<generator class="native">
</generator>
</id>
<!-- 一些常规属性 -->
<property name="name"></property>
<!--跟多对一一样，只是增加了一个unique属性。这样就指定了这端为一了。 -->
<many-to-one name="idCard" column="cardId" unique="true"></many-to-one>
<!-- 这里name写的是many里面的（person对象）中的IdCard对象的名字，column是写外键字段 -->
</class>
</hibernate-mapping>
5、测试
/**
* 添加数据
*/
@Test
public void testOneToOne3() {
Session session = HibernateUtils.openSession();
Transaction transaction = session.beginTransaction();
// ---------------------------------------------
IdCard idCard = new IdCard();
idCard.setCardNo("11111111");
Person person = new Person();
person.setName("qqq");
person.setIdCard(idCard);
session.save(idCard);
session.save(person);
// ----------------------------------------------
transaction.commit();
session.close();
}
/**
*单向的： 查询数据
*/
@Test
public void testOneToOne4() {
Session session = HibernateUtils.openSession();
Transaction transaction = session.beginTransaction();
// ---------------------------------------------
// 但是这样就查得到一个人的idCard，只能从person对象中查到idcard对象，不能从idcard对象中查到person对象，所以是单向的
Person person = (Person) session.get(Person.class, 1);
System.out.println(person.getIdCard().getCardNo());
// ----------------------------------------------
transaction.commit();
session.close();
}
四、第四种：双向一对一外键关系
双向也很简单，只要改变两个地方，就在IdCard.java和IdCard.hbm.xml中加入这种映射关系就足够了。
1、实体类图
实体关系
2、数据库关系图还是跟单向一对一外键关系一样
数据库关系图
3、建表（这里就用上面的表，不用修改了）
4、实体与实体映射文件的编写
IdCard.java
package com.nieshenkuan.model;
public class IdCard {
private int id;
private String cardNo;
private Person person;//用来存放person对象，一对一关系
public Person getPerson() {
return person;
}
public void setPerson(Person person) {
this.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;
}
}
IdCard.hbm.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.nieshenkuan.model">
<class name="IdCard" table="idcard">
<id name="id" column="id">
<!-- 主键生成策略 使用native，需要底层数据库自己设置主键的值哦，比如AUTO_INCREMENT -->
<generator class="native">
</generator>
</id>
<!-- 一些常规属性 -->
<property name="cardNo"></property>
<!-- 要注意property-ref这个属性，很重要，关键的地方就在这里。
property-ref：指定关联类的属性名，这个属性将会和本类的主键相对应。如果没有指定，
会使用对方关联类的主键来跟本类的主键比较，这里要注意不是关联表中的外键字段名。如果不指定这个属性，那么
一对一默认会使用主键去做对比。相当于原本我们
是可以通过本类的主键去和关联类的外键比较，然后来找到对应记录的，但是这里一对一中没有
column属性，所以该方法行不通，因此就想出了这种办法，不跟外键比，也不能跟主键比(因为不是主键关系)，那么
就跟关联表中的一个属性比，也就是我们这个person中的idCard属性，为什么找得到呢，因为从person能找到idcard，那么
person中的idCard中就会有对应的值，我们跟该值比，也就能找到对应的person了。
class：person所在的类，这个也可以不写，hibernate会自动帮我们找到
-->
<one-to-one name="person" property-ref="idCard" class="Person"></one-to-one>
</class>
</hibernate-mapping>
Person.java
package com.nieshenkuan.model;
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;
}
}
Person.hbm.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.nieshenkuan.model">
<class name="Person" table="person">
<id name="id" column="id">
<!-- 主键生成策略 -->
<generator class="native">
</generator>
</id>
<!-- 一些常规属性 -->
<property name="name"></property>
<!--跟多对一一样，只是增加了一个unique属性。这样就指定了这端为一了。 -->
<many-to-one name="idCard" column="cardId" unique="true"></many-to-one>
<!-- 这里name写的是many里面的（person对象）中的IdCard对象的名字，column是写外键字段 -->
</class>
</hibernate-mapping>
5、测试
/**
* 双向的数据查询
*/
@Test
public void testOneToOne5() {
Session session = HibernateUtils.openSession();
Transaction transaction = session.beginTransaction();
// ---------------------------------------------
// 这里就可以从idcard对象查到person对象了
IdCard idCard = (IdCard)session.get(IdCard.class, 1);
System.out.println(idCard.getPerson().getName());;
// 这里就可以从person对象查到idcard对象了
Person person = (Person) session.get(Person.class, 1);
System.out.println(person.getIdCard().getCardNo());
// ----------------------------------------------
transaction.commit();
session.close();
}
五、总结
- 1、单向一对一主键关联、双向一对一主键关联、单向一对一外键关联、双向一对一外键关联的配置;
- 2、主键关联的特点：一个表中的主键就是外键，指向另一个表中的主键，所以两张表的主键是相同的，但是有一个缺点，就是必须依赖另一张表的主键，这在有些业务逻辑上是行不通的;
- 3、知道了单向一对一主键关联，那么双向一对一主键关联就非常的简单，其重点在主键id中的主键生成策略那块还有constrained属性的使用;
- 4、单向一对一外键关联其实就是多对一的一个特例，其中关键的地方在unique这个属性上面;
- 5、单向一对一外键关联知道后，双向一对一外键关联也非常简单，关键的地方就在<one-to-one>中property-ref的配置，注意这个的意思是配置关联类中的属性，而不是关联类中的外键字段名;
- 6、one-to-one默认是使用主键和主键进行比较来查询数据，所以其中并没有column这个属性。因为没有这个column属性，所以就外键关联中就需要用到第5点的property-ref的属性了;
个人觉得现实开发中不存在一对一的关系，如果是一对一的关系，那么我们将两张表合并成一张表岂不是更好。
