一对一(one-to-one)实例(Person-IdCard)
一对一的关系在数据库中表示为主外关系.例如.人和身份证的关系.每个人都对应一个身份证号.我们应该两个表.一个是关于人信息的表(Person).别外一个是身份证相关信息的表(id_card).id_card表的主键对应该Person表的主键id,也是Person表的外键.有人才能有身份证.所以此例中Person是主表,id_card表为从表。
hibernate的一对一关系有两种形式,一种是共享主键方式,另一种是唯一外键方式.
一、共享主键方式实现一对一
1. 实体类设计如下:
Person类:
- package com.reiyen.hibernate.domain;
- public class Person {
- private int id;
- private String name;
- private IdCard idCard;
- //setter和getter方法
- }
IdCard类:
- package com.reiyen.hibernate.domain;
- public class IdCard {
- private int id;
- private Date authorizeDate;
- private Person person;
- //setter和getter方法
- }
2.映射文件:
Person.hbm.xml文件如下:
- <?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="com.reiyen.hibernate.domain">
- <class name="Person" >
- <id name="id" >
- <generator class="native" />
- </id>
- <property name="name" />
- <one-to-one name="idCard" />
- </class>
- </hibernate-mapping>
IdCard.hbm.xml文件如下:
- <?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="com.reiyen.hibernate.domain">
- <class name="IdCard" table="id_card">
- <id name="id">
- <!-- id_card的主键来源person,也就是共享idCard的主键 -->
- <generator class="foreign">
- <param name="property">person</param>
- </generator>
- </id>
- <property name="authorizeDate" column="authorize_date" />
- <!-- one-to-one标签的含义,指示hibernate怎么加载它的关联对象,默认根据主键加载,
- constrained="true", 表明当前主键上存在一个约束,id_card的主键作为外键参照了person -->
- <one-to-one name="person" constrained="true"></one-to-one>
- </class>
- </hibernate-mapping>
3. 在hibernate.cfg.xml文件中注册映射文件:
- <mapping resource="com/reiyen/hibernate/domain/Person.hbm.xml" />
- <mapping resource="com/reiyen/hibernate/domain/IdCard.hbm.xml" />
4.测试类如下:
- public class One2One {
- public static void main(String[] args) {
- Person person = add();
- System.out.println("peron name:" + person.getName());
- }
- static Person add(){
- Session session = null;
- Transaction tran = null;
- try {
- session = HibernateUtil.getSession();
- IdCard idCard = new IdCard();
- idCard.setAuthorizeDate(new Date());
- Person p = new Person();
- p.setName("person1");
- p.setIdCard(idCard); // 1
- idCard.setPerson(p); // 2
- tran = session.beginTransaction();
- session.save(p);
- session.save(idCard);
- tran.commit();
- return p;
- } finally {
- if (session != null)
- session.close();
- }
控制台打印信息如下所示:
Hibernate: insert into Person (name) values (?)
Hibernate: insert into id_card (authorize_date, id) values (?, ?)
person name : person1
数据库表id_card的创建语句如下所示:(重点注意红色字体部分)
DROP TABLE IF EXISTS `test`.`id_card`;
CREATE TABLE `test`.`id_card` (
`id` int(11) NOT NULL,
`authorize_date` datetime DEFAULT NULL,
PRIMARY KEY (`id`),
KEY `FK627C1FB4284AAF67` (`id`),
CONSTRAINT `FK627C1FB4284AAF67` FOREIGN KEY (`id`) REFERENCES `person` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
数据库中记录如下所示:
mysql> select * from person;
+----+---------+
| id | name |
+----+---------+
| 1 | person1 |
+----+---------+
1 row in set (0.00 sec)
mysql> select * from id_card;
+----+---------------------+
| id | authorize_date |
+----+---------------------+
| 1 | 2010-03-23 01:07:25 |
+----+---------------------+
1 row in set (0.00 sec)
在测试时一定要注意写上这句代码:
- idCard.setPerson(p);
这是让从对象关联上它所从属的主对象。如果没有这句话,则会抛出如下异常:
org.hibernate.id.IdentifierGenerationException: attempted to assign id from null one-to-one property: person
5. 查询测试,测试类如下:
- public class One2One {
- public static void main(String[] args) {
- query(1);
- }
- static void query(Integer id){
- Session session = null;
- try {
- session = HibernateUtil.getSession();
- Person person = (Person)session.get(Person.class, id);//4
- System.out.println(person.getIdCard().getAuthorizeDate());//3
- //IdCard idCard = (IdCard)session.get(IdCard.class, id); //1
- //System.out.println(idCard.getPerson().getName()); //2
- } finally {
- if (session != null)
- session.close();
- }
- }
- }
执行此测试类时,控制台打印信息如下所示:
Hibernate: select person0_.id as id3_1_, person0_.name as name3_1_, idcard1_.id as id4_0_, idcard1_.authorize_date as authorize2_4_0_ from Person person0_
left outer join id_card idcard1_ on
person0_.id=idcard1_.id where person0_.id=?
2010-03-23 21:46:07.0
从打印的SQL语句可以看出,一对一关系查询主对象时,然后得到主对象中的从属对象,通过left join一次就把查询结果查询出来了,因为从对象从属于主对象。而一对多,多对一关系时,从打印的SQL语句可知,它经过了两次查询才将查询结果查询出来。这是它们的区别。如果一对一关系中先查询从属对象,然后得到从属中的主对象时(即把上面测试类中的注释1, 2都去掉再运行),控制台打印信息如下:
Hibernate: select idcard0_.id as id4_0_, idcard0_.authorize_date as authorize2_4_0_ from id_card idcard0_ where idcard0_.id=?
Hibernate: select person0_.id as id3_1_, person0_.name as name3_1_, idcard1_.id as id4_0_, idcard1_.authorize_date as authorize2_4_0_ from Person person0_ left outer join id_card idcard1_ on person0_.id=idcard1_.id where person0_.id=?
person1
从打印的SQL可以看出,这种先查从对象,然后得到从属对象中的主对象,要经过两次查询才能得到查询结果。
如果只把测试程序中注释1去掉运行,则只会执行上面两次查询中的第一次查询。
6.one-to-one(元素)懒加载分析:
必须同时满足下面的三个条件时才能实现懒散加载:1).lazy!=false (lazy缺省方式就!=false)2).constrained=true 3).fetch=select(fetch缺省方式即为select)
(因为主表不能有constrained=true,所以主表没有懒加载功能)。能够懒加载的对象都是被改写过的代理对象,当相关联的session没有关闭时,访问这些懒加载对象(代理对象)的属性(getId和getClass除外)时,hibernate会初始化这些代理,或用Hibernate.initialize(proxy)来初始化代理对象;当相关联的session关闭后,再访问懒加载的对象将会出现异常。
测试:(1).注释掉查询测试程序中标记为3的语句,运行程序,控制台打印信息如下:
Hibernate: select person0_.id as id4_1_, person0_.name as name4_1_, idcard1_.id as id5_0_, idcard1_.authorize_date as authorize2_5_0_ from Person person0_
left outer join id_card idcard1_ on person0_.id=idcard1_.id where person0_.id=?
说明查询主对象Person时没有懒加载特性,因此它通过left outer join id_card表,同时把它的从对象IdCard也查询出来了。那为什么一对一中查询主对象时,不能实现懒加载呢??大家可以看看person表的结构,你从表结构中根本不能决断出Person对象有没有相应的IdCard对象,所以它无法给setIdCard赋值(hibernate不能想当然的认为你有值,给你new一个代理对象给它),所以它一定要去查询相关联的对象表,看是否有与此Person对应的IdCard记录。而如果查询的是从对象IdCard时,因为idcard中的id是一个person表的一个外键,所以它必定有一个相对应的Person对象(因为有constrained=true),所以它可以先返回给你一个代理对象,当你真正需要Person对象的数据时,它再去查询数据库。
(2).注释掉查询测试程序中标记为3,4的语句,同进将标记为1的语句前的注释去掉再运行程序,控制台打印信息如下:
Hibernate: select idcard0_.id as id5_0_, idcard0_.authorize_date as authorize2_5_0_ from id_card idcard0_ where idcard0_.id=?
从打印信息可以看出,查询从对象IdCard时实现了懒加载功能,因为它只查询了IdCard对象,而关联的Person对象它没有进行查询。
(3).如果在(2)基础上将标记为2的语句前的注释也去掉再运行程序,控制台打印信息如下:
Hibernate: select idcard0_.id as id5_0_, idcard0_.authorize_date as authorize2_5_0_ from id_card idcard0_ where idcard0_.id=?
Hibernate: select person0_.id as id4_1_, person0_.name as name4_1_, idcard1_.id as id5_0_, idcard1_.authorize_date as authorize2_5_0_ from Person person0_ left outer join id_card idcard1_ on person0_.id=idcard1_.id where person0_.id=?
person1
它就进行了两次查询,将IdCard关联的Person对象也进行了查询。因为访问这些懒加载对象(代理对象)的属性(getId和getClass除外)时,hibernate会初始化这些代理.
(4).如果修改IdCard.hbm.xml映射文件,增加fetch="join",如下所示:
- <one-to-one name="person" constrained="true" fetch="join"/>
再按(2)进行测试,此时控制台打印信息如下:
Hibernate: select idcard0_.id as id5_1_, idcard0_.authorize_date as authorize2_5_1_, person1_.id as id4_0_, person1_.name as name4_0_ from id_card idcard0_
inner join Person person1_ on idcard0_.id=person1_.id where idcard0_.id=?
此时查询从对象IdCard时也不再懒加载了,通过inner join一次性将主从对象都查询出来。
(5).如果修改IdCard.hbm.xml映射文件,增加lazy="false",如下所示:
- <one-to-one name="person" constrained="true" lazy="false" />
再按(2)进行测试,此时控制台打印信息如下:
Hibernate: select idcard0_.id as id5_0_, idcard0_.authorize_date as authorize2_5_0_ from id_card idcard0_ where idcard0_.id=?
Hibernate: select person0_.id as id4_1_, person0_.name as name4_1_, idcard1_.id as id5_0_, idcard1_.authorize_date as authorize2_5_0_ from Person person0_ left outer join id_card idcard1_ on person0_.id=idcard1_.id where person0_.id=?
虽然也不实现懒加载功能,一次性将主从对象都查询出来,但此时是经过两次查询才得到结果。
如果修改IdCard.hbm.xml映射文件,增加lazy="proxy",如下所示,与缺省时一样的效果,因为缺省时,lazy是=proxy
- <one-to-one name="person" constrained="true" lazy="proxy" />
如果修改IdCard.hbm.xml映射文件,如下所示,则lazy(懒加载失效),此时效果如测试(4)。
- <one-to-one name="person" constrained="true" lazy="proxy" fetch="join"/>
二、唯一外键方式实现一对一
基于外键的one-to-one可以描述为多对一。
hibernate一对一唯一外键关联映射(双向关联Person<---->IdCard)
一对一唯一外键双向关联,需要在另一端(person),添加<one-to-one>标签,指示hibernate如何加载
其关联对象,默认根据主键加载idcard,外键关联映射中,因为两个实体采用的是idcard的外键维护的关系, 所以不能指定主键加载idcard,而要根据idcard的外键加载,所以采用如下映射方式:
<one-to-one name="idcard" property-ref="person"/>
IdCard.hbm.xml的映射文件如下:
- <?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="com.itcast.hibernate.domain">
- <class name="IdCard" table="id_card">
- <id name="id">
- <generator class="native" />
- </id>
- <property name="authorizeDate" column="authorize_date" />
- <!-- 指定多的一端的unique=true,这样就限制了多的一端的多重性为一
- 通过这种手段映射一对一唯一外键关联 -->
- <many-to-one name="person" column="person_id" unique="true" />
- </class>
- </hibernate-mapping>
Person.hbm.xml的映射文件如下:
- <?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="com.itcast.hibernate.domain">
- <class name="Person" >
- <id name="id" >
- <generator class="native" />
- </id>
- <property name="name" />
- <!-- 没有下面的one-to-one标签也行,但那样就变成了单向关联(IdCard ----》 Person) ,也就是当知道IdCard后,能找到它属于的对应的人,但知道某人后,却无法找到相对应的IdCard-->
- <one-to-one name="idCard" property-ref="person"/>
- </class>
- </hibernate-mapping>
实体类不用修改,还是用上面的测试类进行测试即可。
保存测试类运行后,相对共享主键方式的one-to-one,id_card表的结构发生了变化,表结构如下所示:
DROP TABLE IF EXISTS `test`.`id_card`;
CREATE TABLE `test`.`id_card` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`authorize_date` datetime DEFAULT NULL,
`person_id` int(11) DEFAULT NULL,
PRIMARY KEY (`id`),
UNIQUE KEY `person_id` (`person_id`),
KEY `FK627C1FB45B253C91` (`person_id`),
CONSTRAINT `FK627C1FB45B253C91` FOREIGN KEY (`person_id`)
REFERENCES `person` (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
数据库表中记录如下:
mysql> select * from person;
+----+---------+
| id | name |
+----+---------+
| 1 | person1 |
+----+---------+
1 row in set (0.00 sec)
mysql> select * from id_card;
+----+---------------------+-----------+
| id | authorize_date | person_id |
+----+---------------------+-----------+
| 1 | 2010-03-23 22:40:38 | 1 |
+----+---------------------+-----------+
1 row in set (0.00 sec)
如果Person.hbm.xml映射文件中没有<one-to-one/>这一项的话,运行测试:
- Person person = (Person)session.get(Person.class, id);
- System.out.println(person.getIdCard().getAuthorizeDate());
会抛出如下异常:
java.lang.NullPointerException
因为这种关系成了IdCard--->Person的单向关联了。知道了Person,找不到对应的IdCard.
当运行如下测试时:
- Person person = (Person)session.get(Person.class, id);
- System.out.println(person.getIdCard());
控制台会打印出Person相对应的IdCard为null.
但如果得到了IdCard,却能找到相应的Person.测试如下:
- IdCard idCard = (IdCard)session.get(IdCard.class, id);
- System.out.println(idCard.getPerson().getName());
能得到正常的结果,person name为person1.
总结: 在缺省情况下,hibernate只有在一对一关联中,查询主对象时,是进行关联查询一次得到查询结果,其它(多对多、多对一、一对多、一对一查询从对象)的查询都是分两次查询得到查询结果。
hibernate 一对一(One-to-One)的更多相关文章
-
hibernate一对一外键双向关联
关联是类(类的实例)之间的关系,表示有意义和值得关注的连接. 本系列将介绍Hibernate中主要的几种关联映射 Hibernate一对一主键单向关联Hibernate一对一主键双向关联Hiberna ...
-
hibernate一对一外键单向关联
关联是类(类的实例)之间的关系,表示有意义和值得关注的连接. 本系列将介绍Hibernate中主要的几种关联映射 Hibernate一对一主键单向关联Hibernate一对一主键双向关联Hiberna ...
-
hibernate一对一主键双向关联
关联是类(类的实例)之间的关系,表示有意义和值得关注的连接. 本系列将介绍Hibernate中主要的几种关联映射 Hibernate一对一主键单向关联Hibernate一对一主键双向关联Hiberna ...
-
hibernate一对一主键单向关联
关联是类(类的实例)之间的关系,表示有意义和值得关注的连接. 本系列将介绍Hibernate中主要的几种关联映射 Hibernate一对一主键单向关联Hibernate一对一主键双向关联Hiberna ...
-
HIBERNATE一对一双向外键联合主键关联
HIBERNATE一对一双向外键联合主键关联: 一. 创建主键类:这个主键必须实现serializedable接口和重写其中的hashCode方法和equals方法:为主键类添加一个叫做@Embedd ...
-
Hibernate一对一主键映射
Hibernate一对一主键映射 ------------------------------ -- ...
-
Hibernate一对一外键映射
Hibernate 一对一外键映射 ------------------------------ ----- ...
-
hibernate一对一关联
hibernate一对一主键关联 一对一主键关联指的是两个表通过主键形成的一对一映射. 数据表要求:A表的主键也是B表的主键同时B表的主键也是A表的外键 sql: create table peopl ...
-
Hibernate 一对一关联关系
双向一对一关联关系: 域模型: 例如,部门只有一个部门经理,一个经理也只能管理一个部门.即,Department 中有一个Manager的引用,Manager 中又有一个Department 的引用. ...
随机推荐
-
读书笔记--编程珠玑II
学化学的应该都知道chemdraw,这是一款专门绘制化学结构的软件,什么苯环.双键各种word难以搞定的分子式,你可以轻松的用chemdraw完成,可以称得上化学工作者居家旅行必备的良药.其实早在19 ...
-
cocos2d-x ScrollView、TableView
转自:http://codingnow.cn/cocos2d-x/1024.html 在游戏和应用中经常要实现左右滑动展示游戏帮助.以列表显示内容的UI效果,就像android中的Gallery和Li ...
-
使用mongodb存取lbs数据
1,在mongodb中创建lbs_db数据库,collection名称lbs_info,要使用lbs查询功能,需要对二维数据列建立索引 db.lbs_info.ensureIndex( { locs ...
-
测试开发Python培训:实现屌丝的图片收藏愿望(小插曲)
测试开发Python培训:实现屌丝的图片收藏愿望(小插曲) 男学员在学习python的自动化过程中对于爬虫很感兴趣,有些学员就想能收藏一些图片,供自己欣赏.作为讲师只能是满足愿望,帮助大家实现对美的追 ...
-
Painter&#39;s Problem poj1681 高斯消元法
Painter's Problem Time Limit: 1000MS Memory Limit: 10000K Total Submissions: 4420 Accepted: 2143 ...
-
Ubuntu install flash
Software&Updates - Other Software - Canonical Parners sudo apt install adobe-flashplugin
-
20165305 苏振龙 《Java 程序设计》第一次测试总结
第一个代码运行结果截图 功能:从1到5305进行求和 第二个代码运行结果截图 代码托管 第三个代码运行结果截图 (1)源文件的名字为Person.java (2)生成2个字节码文件,名字为Person ...
-
windows下,怎么轻易拷贝一个文件的完整路径?
1. 到目录下,复制文件 2. win+R ,打开"运行"输入框 3.ctrl+v
-
tornado登陆装饰器
tornado作为鼎鼎大名的web异步框架,用来作为高性能服务器以及web框架都是首选.自从python3.4加入了asyncio原生协程后,tornado的最新版本也开始使用了原生的协程.定义协程函 ...
-
scrapy框架爬取小说信息
1.爬取目标网站:http://www.zhaoxiaoshuo.com/all.php?c=0&o=0&s=0&f=2&l=0&page=1 2.爬取目标网站 ...