- 浏览: 100478 次
- 性别:
- 来自: 武汉
最新评论
-
zljerityzljerity:
<#assign ipage=page?number&g ...
freeMark全解 -
qiankai86:
...
freeMark全解
one-to-one 一对一主键关联映射_单向
一对一主键关联映射——关联的两个实体共享一个主键(让两个实体对象的id保持相同),这样可以避免多余的字段被创建 .
(单向关联Person---->IdCard)
类:
public class IdCard {
private Integer id;
private String idNo;
}
public class Person {
private Integer id;
private String name;
private IdCard idCard;
}
hbm.xml
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.model">
<class name="IdCard" table="idcard1" >
<id name="id" column="id" type="java.lang.Integer">
<generator class="native" />
</id>
<property name="idNo" column="id_no" type="java.lang.String" />
</class>
</hibernate-mapping>
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.zd.model">
<class name="Person" table="person1" >
<id name="id" column="id" type="java.lang.Integer">
<!-- person的主键来源idCard,也就是共享idCard的主键 -->
<generator class="foreign">
<param name="property">idCard</param>
</generator>
</id>
<property name="name" column="name" length="50" type="java.lang.String" />
<one-to-one name="idCard" ></one-to-one>
<!--one-to-one标签的含义,指示hibernate怎么加载它的关联对象,默认根据主键加载,
one-to-one的属性cascade=all ,即新增Person时,同时可新增idcard,
constrained="true", 表明当前主键上存在一个约束,person的主键作为外键参照了idCard
<one-to-one name="idCard" constrained="true"></one-to-one>
-->
</class>
</hibernate-mapping>
运用例子:
public void testSave1(){
Session session = null;
Transaction ta = null;
try{
session = HibernateUtil.getSession();
ta = session.beginTransaction();
IdCard idCard = new IdCard();
idCard.setIdNo("88888888888888");
Person p = new Person();
p.setName("Tom");
p.setIdCard(idCard);
//session.save(idCard); //可删除,因one-to-one 默认casedese=all
session.save(p); // 保存idCard, person2个。
ta.commit();
}catch(Exception e){
e.printStackTrace();
if(ta != null){
ta.rollback();
}
}finally{
//关闭session, user变为detached离线对象
HibernateUtil.closeSession(session);
}
}
Hibernate: insert into idcard1 (id_no) values (?)
Hibernate: insert into person1 (name, id) values (?, ?)
public void testGet1(){
Session session = null;
Transaction ta = null;
try{
session = HibernateUtil.getSession();
ta = session.beginTransaction();
Person p = (Person) session.get(Person.class, new Integer(2));
System.out.println("person.name=" + p.getName());
System.out.println("idCard.cardNo=" + p.getIdCard().getIdNo());
ta.commit();
}catch(Exception e){
e.printStackTrace();
if(ta != null){
ta.rollback();
}
}finally{
//关闭session, user变为detached离线对象
HibernateUtil.closeSession(session);
}
}
Hibernate: select person0_.id as id1_0_, person0_.name as name1_0_ from person1 person0_ where person0_.id=?
person.name=Tom
Hibernate: select idcard0_.id as id0_0_, idcard0_.id_no as id2_0_0_ from idcard1 idcard0_ where idcard0_.id=?
idCard.cardNo=88888888888888
===================================================================
戓要改为双向,修改以下:
public class IdCard {
private Integer id;
private String idNo;
private 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.zd.model">
<class name="IdCard" table="idcard1" >
<id name="id" column="id" type="java.lang.Integer">
<generator class="native" />
</id>
<property name="idNo" column="id_no" type="java.lang.String" />
<one-to-one name="person"></one-to-one>
</class>
</hibernate-mapping>
测试用例:
public void testGet2(){
Session session = null;
Transaction ta = null;
try{
session = HibernateUtil.getSession();
ta = session.beginTransaction();
IdCard ic = (IdCard)session.get(IdCard.class, new Integer(1));
System.out.println("IdCard.idNo =" + ic.getIdNo());
System.out.println("Person.name = " + ic.getPerson().getName());
ta.commit();
}catch(Exception e){
e.printStackTrace();
if(ta != null){
ta.rollback();
}
}finally{
//关闭session, user变为detached离线对象
HibernateUtil.closeSession(session);
}
}
执行一条sql语句,且是join, 因为one-to-one默认是fetch="join"
Hibernate: select idcard0_.id as id0_1_, idcard0_.id_no as id2_0_1_, person1_.id as id1_0_, person1_.name as name1_0_ from idcard1 idcard0_ left outer join person1 person1_ on idcard0_.id=person1_.id where idcard0_.id=?
IdCard.idNo =88888888888888
Person.name = Tom
若IdCard.hbm.xml 中<one-to-one name="person" fetch="select"></one-to-one> ,执行2条sql
Hibernate: select idcard0_.id as id0_0_, idcard0_.id_no as id2_0_0_ from idcard1 idcard0_ where idcard0_.id=?
Hibernate: select person0_.id as id1_0_, person0_.name as name1_0_ from person1 person0_ where person0_.id=?
IdCard.idNo =88888888888888
Person.name = Tom
================================
fetch取值"select",表示序列选择抓取,还有一个值是"join",表示采用外连接抓取。
一对一主键关联映射——关联的两个实体共享一个主键(让两个实体对象的id保持相同),这样可以避免多余的字段被创建 .
(单向关联Person---->IdCard)
类:
public class IdCard {
private Integer id;
private String idNo;
}
public class Person {
private Integer id;
private String name;
private IdCard idCard;
}
hbm.xml
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.model">
<class name="IdCard" table="idcard1" >
<id name="id" column="id" type="java.lang.Integer">
<generator class="native" />
</id>
<property name="idNo" column="id_no" type="java.lang.String" />
</class>
</hibernate-mapping>
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.zd.model">
<class name="Person" table="person1" >
<id name="id" column="id" type="java.lang.Integer">
<!-- person的主键来源idCard,也就是共享idCard的主键 -->
<generator class="foreign">
<param name="property">idCard</param>
</generator>
</id>
<property name="name" column="name" length="50" type="java.lang.String" />
<one-to-one name="idCard" ></one-to-one>
<!--one-to-one标签的含义,指示hibernate怎么加载它的关联对象,默认根据主键加载,
one-to-one的属性cascade=all ,即新增Person时,同时可新增idcard,
constrained="true", 表明当前主键上存在一个约束,person的主键作为外键参照了idCard
<one-to-one name="idCard" constrained="true"></one-to-one>
-->
</class>
</hibernate-mapping>
运用例子:
public void testSave1(){
Session session = null;
Transaction ta = null;
try{
session = HibernateUtil.getSession();
ta = session.beginTransaction();
IdCard idCard = new IdCard();
idCard.setIdNo("88888888888888");
Person p = new Person();
p.setName("Tom");
p.setIdCard(idCard);
//session.save(idCard); //可删除,因one-to-one 默认casedese=all
session.save(p); // 保存idCard, person2个。
ta.commit();
}catch(Exception e){
e.printStackTrace();
if(ta != null){
ta.rollback();
}
}finally{
//关闭session, user变为detached离线对象
HibernateUtil.closeSession(session);
}
}
Hibernate: insert into idcard1 (id_no) values (?)
Hibernate: insert into person1 (name, id) values (?, ?)
public void testGet1(){
Session session = null;
Transaction ta = null;
try{
session = HibernateUtil.getSession();
ta = session.beginTransaction();
Person p = (Person) session.get(Person.class, new Integer(2));
System.out.println("person.name=" + p.getName());
System.out.println("idCard.cardNo=" + p.getIdCard().getIdNo());
ta.commit();
}catch(Exception e){
e.printStackTrace();
if(ta != null){
ta.rollback();
}
}finally{
//关闭session, user变为detached离线对象
HibernateUtil.closeSession(session);
}
}
Hibernate: select person0_.id as id1_0_, person0_.name as name1_0_ from person1 person0_ where person0_.id=?
person.name=Tom
Hibernate: select idcard0_.id as id0_0_, idcard0_.id_no as id2_0_0_ from idcard1 idcard0_ where idcard0_.id=?
idCard.cardNo=88888888888888
===================================================================
戓要改为双向,修改以下:
public class IdCard {
private Integer id;
private String idNo;
private 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.zd.model">
<class name="IdCard" table="idcard1" >
<id name="id" column="id" type="java.lang.Integer">
<generator class="native" />
</id>
<property name="idNo" column="id_no" type="java.lang.String" />
<one-to-one name="person"></one-to-one>
</class>
</hibernate-mapping>
测试用例:
public void testGet2(){
Session session = null;
Transaction ta = null;
try{
session = HibernateUtil.getSession();
ta = session.beginTransaction();
IdCard ic = (IdCard)session.get(IdCard.class, new Integer(1));
System.out.println("IdCard.idNo =" + ic.getIdNo());
System.out.println("Person.name = " + ic.getPerson().getName());
ta.commit();
}catch(Exception e){
e.printStackTrace();
if(ta != null){
ta.rollback();
}
}finally{
//关闭session, user变为detached离线对象
HibernateUtil.closeSession(session);
}
}
执行一条sql语句,且是join, 因为one-to-one默认是fetch="join"
Hibernate: select idcard0_.id as id0_1_, idcard0_.id_no as id2_0_1_, person1_.id as id1_0_, person1_.name as name1_0_ from idcard1 idcard0_ left outer join person1 person1_ on idcard0_.id=person1_.id where idcard0_.id=?
IdCard.idNo =88888888888888
Person.name = Tom
若IdCard.hbm.xml 中<one-to-one name="person" fetch="select"></one-to-one> ,执行2条sql
Hibernate: select idcard0_.id as id0_0_, idcard0_.id_no as id2_0_0_ from idcard1 idcard0_ where idcard0_.id=?
Hibernate: select person0_.id as id1_0_, person0_.name as name1_0_ from person1 person0_ where person0_.id=?
IdCard.idNo =88888888888888
Person.name = Tom
================================
fetch取值"select",表示序列选择抓取,还有一个值是"join",表示采用外连接抓取。
发表评论
-
ofbiz 之entity实体
2014-03-25 18:16 938ofbiz 之entity实体 1. 实体定义文件 实体定 ... -
ofbiz迷你语言
2012-08-08 17:13 2297simple-map-processor 和 sim ... -
ofbiz之entity 实体解析
2012-08-08 17:12 1506ofbiz 之entity实体 1. 实体定义文件 实体定 ... -
ofbiz之旅-实体简介(中英译)
2012-08-09 09:34 1167OFBIZ ENTITY ENGINE COOKBOOK = ... -
OFBIz之旅[结构]
2012-08-08 17:03 1482OFBIz之旅[结构] 注意: 1,持久层,在OFBI ... -
java concurrent 探秘(2)
2011-08-08 14:21 912java concurrent 探秘(2) Blo ... -
java concurrent 探秘
2011-08-08 11:02 820java concurrent 探秘 我们都知道,在JD ... -
JavaScript验证正则表达式大全
2011-07-27 17:18 914上篇文章《JavaScript验证正则表达式大全》说的是jav ... -
JavaScript验证正则表达式大全
2011-07-27 17:17 827JavaScript验证正则表达式大全 JavaScript验 ... -
js 收集1
2011-01-14 09:49 10541.javascript的数组API Js代码 ... -
struts 核心解析
2010-12-03 14:25 2443一、概述 Struts2的核心是一个Fil ... -
Java类库中的集合类解析
2010-11-29 16:05 1085这篇我准备从源码的高度来看看集合中各个实现类的是如何组织我们存 ... -
jboss classloader机制以及scope配置
2010-11-29 15:06 17111. 概念介绍 UCL : org.jboss.mx. ... -
总结和对比一下(jboss,tomcat,jetty)容器的classloader机制
2010-11-29 14:58 1974总结和对比一下(jboss,tomcat,je ... -
jboss,tomcat,jetty 容器的classloader机制
2010-11-29 14:53 4572背景 前段时间一直在做应用容器的迁移,将公司的应用 ... -
Session,Cookie,jsessionid和Url重写
2010-11-29 12:55 1929Session,Cookie,jsessionid ... -
DWR work
2010-11-25 18:14 887这段时间较闲,研究了一 ... -
CXF jaxws spring configuration
2010-11-19 16:27 1592最近在cxf-zh中有人问及了有关Spring配置CXF Cl ... -
线程安全总结2
2010-11-17 16:48 815站内很多人都问我,所谓线程的“工作内存”到底是个什么东西? ... -
java线程安全总结1
2010-11-17 16:47 883最近想将java基础的一些 ...
相关推荐
本篇将重点讲解如何实现一对一主键关联映射的单向关联,并通过一个实际的例子来帮助理解。 在一对一主键关联映射中,两个实体共享同一个主键,这意味着它们在数据库中的记录具有相同的标识符。这种映射关系通常用于...
在Java的持久化框架...总结来说,Hibernate的一对一主键关联映射,尤其是双向关联,能有效地简化对象关系的映射,提高代码的可读性和维护性。然而,需要根据实际情况权衡其带来的性能影响,确保系统设计的高效性。
本教程聚焦于一对一(One-to-One)单向主键关联,这是一种特定类型的关系映射,其中一个实体类完全依赖于另一个实体类的主键。这里的"单向"意味着只有一个实体类知道这种关联,而另一个实体类并不包含对应的引用。 ...
在Java的持久化框架Hibernate中,一对一(One-to-One)关联关系是常见的一种实体关系映射。本主题将深入探讨如何使用Hibernate通过主键来实现一对一的单向关联关系,并提供相关的源码分析。 首先,我们需要理解一对...
在Java的持久化框架Hibernate中,一对一(One-to-One)关联映射是常见的关系数据库模型在对象模型中的体现。这种关联通常用于表示两个实体之间非常特殊的联系,比如一个人只有一个身份证,或者一个公司只有一个总部...
通过以上步骤,我们就可以在Hibernate中实现单向一对一主键映射。这个实例中的`hibernate_fifth_one2one_pk_1`文件可能包含了相关的代码示例或测试用例,供你参考和学习。理解并掌握一对一映射是提高Hibernate使用...
本文主要关注Hibernate中的一个核心概念——一对一(One-to-One)、一对多(One-to-Many)和多对一(Many-to-One)关联映射,特别是关于“一到多”单向和双向关联映射的配置心得。 首先,让我们了解“一到多”关联...
本教程将详细解释如何通过代码实现Hibernate的一对一主键关联。 首先,我们需要理解一对一关联的含义:在数据库中,如果一个表的记录只能与另一个表的唯一一条记录对应,这就构成了主键关联的一对一关系。例如,一...
关联映射主要包括四种类型:一对一(One-to-One)、一对多(One-to-Many)、多对一(Many-to-One)和多对多(Many-to-Many)。下面我们将逐一探讨这些关联映射的配置方法。 1. **一对一关联映射** - **主键关联**...
一对一主键关联是通过共享主键实现的,这意味着两个实体类共用同一个主键。在这种情况下,被引用的实体类(如 Address)不再有自己的独立主键生成策略,而是依赖于引用它的实体类(如 Person)生成主键。在 ...
在Java持久化框架Hibernate中,一对一(One-to-One)映射是对象关系映射的一种常见方式,用于表示两个实体之间一对一的关系。这种关系通常出现在一个实体的实例只能与另一个实体的单个实例相关联的情况。下面我们将...
在Java的持久化框架Hibernate中,一对一(One-to-One)关联是对象关系映射(ORM)中的一个重要概念,用于表示两个实体之间一对一的关系。在这个场景下,我们将讨论一种特殊的一对一关联方式——唯一外键关联(Single...
在Java的持久化框架Hibernate中,一对一(One-to-One)关系映射是一种常见的实体关联方式。基于外键的One-to-One映射是其中的一种实现方式,它通过在一方或双方实体的表中添加外键来建立关联。接下来,我们将深入...
在Hibernate中,一对一(One-to-One)映射是一种常见的关联关系,它表示两个实体之间存在一对一的对应关系。本篇文章将深入探讨Hibernate中的一对一外键单向关联。 首先,一对一外键关联指的是一个实体通过外键直接...
3. **第三种方式**:这是对唯一外键关联的一种变体,两个实体都包含对方的外键字段,但在配置文件中使用`<many-to-one>`标签,模拟一对一关联。 **二、一对多、多对一关联** 在选课系统中,一个教师可以教多个课程...
**标题:** Hibernate一对一关联映射 **描述:** 在Java开发中,Hibernate作为一款强大的对象关系映射(ORM)框架,极大地简化了数据库操作。一对一(OneToOne)关联映射是Hibernate提供的一种对象关系映射策略,它...
在Java的持久化框架Hibernate中,一对一(One-to-One)关联映射是常见的关系映射方式之一,尤其在处理数据库中的唯一外键关联时。这种映射方式允许在一个实体类中引用另一个实体类的唯一实例,形成一对一的关系。在...
`hibernate_one2one_pk_1`和`hibernate_one2one_pk_2`可能涉及主键级联,即两个表共享相同的主键,而`hibernate_one2one_ufk_1`和`hibernate_one2one_ufk_2`可能是通过外键实现的一对一关系。在Hibernate中,这需要...