`
wankunde
  • 浏览: 162944 次
  • 性别: Icon_minigender_1
  • 来自: 南京
社区版块
存档分类
最新评论

Hibernate的一对一关联实例<转>

    博客分类:
  • J2EE
阅读更多

Hibernate的一对一关联实例

Hibernate中的表的关联有一对一,一对多和多对多三种关联方式,在这篇笔记和接下来的笔记中,我将用我自己的实际例子来说明如何具体实施。
      我使用的Hibernate版本是2.1.8,在Hibernate的网站2.1.6版本的中文文档中有关一对一的关联有下面一段表述:

5.1.11. 一对一
持久化对象之间一对一的关联关系是通过one-to-one元素定义的。 

<one-to-one
        
name="propertyName"                                (1)
        class
="ClassName"                                  (2)
        cascade
="all|none|save-update|delete"              (3)
        constrained
="true|false"                           (4)
        outer-join
="true|false|auto"                       (5)
        property-ref
="propertyNameFromAssociatedClass"     (6)
        access
="field|property|ClassName"                  (7)
        
/>
(1) name: 属性的名字。 
 
(2) class (可选 - 默认是通过反射得到的属性类型):被关联的类的名字。 
 
(3) cascade(级联) (可选) 表明操作是否从父对象级联到被关联的对象。 
 
(4) constrained(约束) (可选) 表明该类对应的表对应的数据库表,和被关联的对象所对应的数据库表之间,通过一个外键引用对主键进行约束。这个选项影响save()和delete()在级联执行时的先后顺序(也在schema export tool中被使用)。 
 
(5) outer-join(外连接) (可选 - 默认为 自动): 当设置hibernate.use_outer_join的时候,对这个关联允许外连接抓取。 
 
(6) property-ref: (可选) 指定关联类的一个属性,这个属性将会和本外键相对应。如果没有指定,会使用对方关联类的主键。 
 
(7) access (可选 - 默认是 property): Hibernate用来访问属性的策略。 
 

有两种不同的一对一关联: 

主键关联 

惟一外键关联 

主键关联不需要额外的表字段;两行是通过这种一对一关系相关联的,那么这两行就共享同样的主关键字值。所以如果你希望两个对象通过主键一对一关联,你必须确认它们被赋予同样的标识值! 

比如说,对下面的Employee和Person进行主键一对一关联: 

<one-to-one name="person" class="Person"/>
<one-to-one name="employee" class="Employee" constrained="true"/>
现在我们必须确保PERSON和EMPLOYEE中相关的字段是相等的。我们使用一个特别的称为foreign的Hibernate标识符生成器策略: 

<class name="person" table="PERSON">
    
<id name="id" column="PERSON_ID">
        
<generator class="foreign">
            
<param name="property">employee</param>
        
</generator>
    
</id>
    
    
<one-to-one name="employee"
        class
="Employee"
        constrained
="true"/>
</class>
一个刚刚保存的Person实例被赋予和该Person的employee属性所指向的Employee实例同样的关键字值。 

另一种方式是一个外键和一个惟一关键字对应,上面的Employee和Person的例子,如果使这种关联方式,应该表达成: 

<many-to-one name="person" class="Person" column="PERSON_ID" unique="true"/>
如果在Person的映射加入下面几句,这种关联就是双向的: 

<one-to-one name"employee" class="Employee" property-ref="person"/>
      
      下面是我的一个一对一主键关联的例子,使用的数据库是MySQL 4.1.11:
      我有两个表:UserBasic和UserInfo,UserBasic记录的是用户的基本注册信息,UserInfo表记录的是用户的详细信息。表的结构如下:

 1CREATE TABLE IF NOT EXISTS UserBasic
 2(
 3   Guid                           INT                            NOT NULL AUTO_INCREMENT,
 4   Account                        VARCHAR(64)                    NOT NULL,
 5   Password                       VARCHAR(16)                    NOT NULL,
 6   Email                          VARCHAR(128)                   NOT NULL,
 7   PRIMARY KEY (Guid)
 8) TYPE=InnoDB;
 9
10CREATE TABLE IF NOT EXISTS UserInfo
11(
12   Guid                           INT                            NOT NULL,
13   Username                       VARCHAR(128),
14   Gender                         CHAR(1),
15   Birthday                       DATETIME,
16   PRIMARY KEY (Guid)
17) TYPE=InnoDB;
18
19ALTER TABLE UserInfo ADD CONSTRAINT UserInfoRFUserBasic FOREIGN KEY (Guid) 
20   REFERENCES UserBasic (Guid) ON DELETE CASCADE ON UPDATE RESTRICT;

      UserInfo的主键值和UserBasic的主键值是一样的,两个表是单向的一对一关系。UserBasic为主控方,UserInfo是被动方。
      用Middlegen生成的UserBasic.hbm.xml文件,修改后的内容如下:

  1<?xml version="1.0"?>
  2<!DOCTYPE hibernate-mapping PUBLIC
  3    "-//Hibernate/Hibernate Mapping DTD 2.0//EN"
  4    "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd" >
  5    
  6<hibernate-mapping>
  7<!-- 
  8    Created by the Middlegen Hibernate plugin 2.1
  9
 10    http://boss.bekk.no/boss/middlegen/
 11    http://www.hibernate.org/
 12-->
 13
 14<class 
 15    name="com.xxx.hibernate.UserBasic" 
 16    table="UserBasic"
 17    dynamic-update="true"
 18    dynamic-insert="true"
 19>
 20    <meta attribute="class-description" inherit="false">
 21       @hibernate.class
 22        table="UserBasic"
 23        dynamic-update="true"
 24        dynamic-insert="true"
 25    </meta>
 26
 27    <id
 28        name="guid"
 29        type="int"
 30        column="Guid"
 31    >
 32        <meta attribute="field-description">
 33           @hibernate.id
 34            generator-class="native"
 35            type="int"
 36            column="Guid"
 37
 38
 39        </meta>
 40        <generator class="native" />
 41    </id>
 42
 43    <property
 44        name="account"
 45        type="java.lang.String"
 46        column="Account"
 47        not-null="true"
 48        length="64"
 49    >
 50        <meta attribute="field-description">
 51           @hibernate.property
 52            column="Account"
 53            length="64"
 54            not-null="true"
 55        </meta>    
 56    </property>
 57    <property
 58        name="password"
 59        type="java.lang.String"
 60        column="Password"
 61        not-null="true"
 62        length="16"
 63    >
 64        <meta attribute="field-description">
 65           @hibernate.property
 66            column="Password"
 67            length="16"
 68            not-null="true"
 69        </meta>    
 70    </property>
 71    <property
 72        name="email"
 73        type="java.lang.String"
 74        column="Email"
 75        not-null="true"
 76        length="128"
 77    >
 78        <meta attribute="field-description">
 79           @hibernate.property
 80            column="Email"
 81            length="128"
 82            not-null="true"
 83        </meta>    
 84    </property>
 85
 86    <!-- Associations -->
 87  
 88    <!-- bi-directional one-to-one association to UserInfo -->
 89    <one-to-one
 90        name="userInfo"
 91        class="com.xxx.hibernate.UserInfo"
 92        cascade="save-update"
 93    >
 94        <meta attribute="field-description">
 95           @hibernate.one-to-one
 96               class="com.xxx.hibernate.UserInfo"
 97            cascade="save-update"
 98        </meta>
 99    </one-to-one>
100
101</class>
102</hibernate-mapping>

      由于在建立外键的时候就声明了ON DELETE CASCADE,所以在xml的配置文件中第97行声明为save-update。如果声明为all,那么在删除UserBasic表的数据时,会无谓的多出一条删除UserInfo的delete语句出来。
      UserInfo.hbm.xml文件的内容如下:

 1<?xml version="1.0"?>
 2<!DOCTYPE hibernate-mapping PUBLIC
 3    "-//Hibernate/Hibernate Mapping DTD 2.0//EN"
 4    "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd" >
 5    
 6<hibernate-mapping>
 7<!-- 
 8    Created by the Middlegen Hibernate plugin 2.1
 9
10    http://boss.bekk.no/boss/middlegen/
11    http://www.hibernate.org/
12-->
13
14<class 
15    name="com.xxx.hibernate.UserInfo" 
16    table="UserInfo"
17    dynamic-update="true"
18    dynamic-insert="true"
19>
20    <meta attribute="class-description" inherit="false">
21       @hibernate.class
22        table="UserInfo"
23        dynamic-update="true"
24        dynamic-insert="true"
25    </meta>
26
27    <id
28        name="guid"
29        type="int"
30        column="Guid"
31    >
32        <meta attribute="field-description">
33       
分享到:
评论

相关推荐

    hibernate一对一实例

    在这个“hibernate一对一实例”中,我们将深入探讨如何在Hibernate中实现一对一的映射,并通过具体的代码示例来帮助理解。 一、一对一关联的概念 一对一关联意味着一个实体只与另一个实体的一个实例相关联,反之...

    详解Hibernate一对一映射配置

    这里,Person和Address类共享同一主键`PERSON_ID`,表明它们一对一关联。 2. **单方外键关联(Unidirectional Foreign Key Join)** 在单方外键关联中,一个实体通过外键字段引用另一个实体。配置如下: ```xml ...

    Hibernate一对一,一对多,多对多实例

    一对一关联通常出现在两个实体之间存在唯一对应关系的情况,例如一个人只有一个身份证。在Hibernate中,可以通过在实体类的属性上使用`@OneToOne`注解来定义这种关系。此外,还需要通过`@PrimaryKeyJoinColumn`或`@...

    Hibernate的多对一和一对多操作实例

    本文将深入探讨Hibernate框架下“多对一”和“一对多”的关联关系,并通过一个具体示例来阐述其操作流程与实现细节。 ### Hibernate中的“多对一”和“一对多” 在数据库设计中,“多对一”(Many-to-One)和“一...

    hibernate一对一的关联关系demo

    在本示例中,我们将深入探讨如何在Hibernate中实现一对一关联关系,并通过两种主要的方式进行演示:外键形式和共用主键形式。 1. 外键形式的一对一关联关系: 在这种模式下,一方实体拥有外键,指向另一方实体的...

    hibernate一对一主键关联映射(单项关联)

    - **唯一性约束**:在数据库层面,为了确保一对一关联,通常需要添加唯一性约束。例如,`IdCard`表的`person_id`列应具有唯一性约束。 以上就是关于Hibernate中一对一主键关联映射(单项关联)的详细解释。通过这种...

    hibernate一对一关联关系

    本资源主要探讨的是“hibernate一对一关联关系”。 一对一关联关系在现实世界中很常见,比如一个人只有一个身份证,或者一个公司的总部只有一个。在Hibernate中,设置一对一关联关系可以帮助我们更好地管理和操作...

    Hibernate关联关系配置

    `class`属性指定了一对一关联的另一端实体类型,`column`属性则指定了外键字段。 #### 三、自身一对多关系配置示例 自身一对多关系是指一个实体与自身形成的一对多关系,例如目录树结构。这里给出一个简单的配置...

    Hibernate ORM - 一对一主键关联关系

    - **外键约束**:在一对一关联中,如果不使用共享主键,可以创建外键约束,但这样就不再是真正的“主键关联”。 - **懒加载与立即加载**:默认情况下,关联对象会在加载主对象时一同加载,这称为“立即加载”。若...

    Hibernate一对一主键关联映射(双向关联)

    通过这种方式,Hibernate会自动处理一对一关联的主键同步,确保数据的一致性。双向关联使得在任何一方都可以方便地获取到关联的另一方,提高了代码的可读性和易用性。 总结来说,Hibernate中的一对一主键关联映射是...

    hibernate主键一对一关联映射代码示例

    一对一关联意味着在一个实体中,每个实例都唯一对应另一个实体的实例。这种关联可以通过共享主键(primary key)或外键(foreign key)来实现。共享主键方式更为简洁,是两个表的主键相同,这里我们将主要讨论这种...

    Hibernate一对一唯一外键关联映射(单向关联)

    在一对一关联中,外键通常放在关系的“从”方,即依赖于另一方的实体。唯一外键关联映射时,外键字段在数据库中设置为主键约束,确保每个值都是唯一的,这样就能保证一对一的关系。 ### 2. 创建实体类 假设我们有...

    Hibernate一对多关联实例

    本文将详细解析" Hibernate一对多关联实例 ",并涵盖关联的保存(save)、删除(delete)、查询(select)和更新(update)操作。 一、一对多关联概念 在数据库设计中,一对多关联表示一个表中的记录可以与另一个表中的多个...

    hibernate自身关联一对多实例(树形结构)

    本文将深入探讨“Hibernate自身关联一对多实例(树形结构)”这一主题,这在构建具有层次结构的数据模型时尤其常见,例如组织结构、地区树或者商品分类等。 首先,我们需要理解Hibernate的核心概念。Hibernate允许...

    hibernate 教程

    一对一&lt;br&gt;5.1.12. 组件(component), 动态组件(dynamic-component)&lt;br&gt;5.1.13. 子类(subclass)&lt;br&gt;5.1.14. 连接的子类(joined-subclass)&lt;br&gt;5.1.15. map, set, list, bag&lt;br&gt;5.1.16. 引用(import)&lt;br&gt;5.2. ...

    hibernate配置文件详解

    -- 一对多关联关系 --&gt; &lt;set name="cities" table="cities" inverse="true"&gt; &lt;key column="province_id" /&gt; &lt;one-to-many class="com.Hibernate.City" /&gt; &lt;/set&gt; &lt;/class&gt; &lt;/hibernate-mapping&gt; ``` 在该文件...

    hibernate多对一关联demo

    在上述博客文章中,作者分享了一个关于Hibernate多对一关联的实例。在数据库设计中,多对一关联意味着一个实体(如部门)可以与多个其他实体(如员工)相关联,而每个其他实体只能对应到这个单一的实体。例如,在...

    hibernate一对一之唯一外键关联(双向关联)

    - 虽然一对一关联提供了便利,但过多的一对一关联可能会影响性能,因为每次查询可能涉及多个表,增加数据库访问的复杂性。因此,应谨慎设计实体间的关系。 8. **实例应用** - 在实际项目中,一对一关联常用于用户...

    Hibernate对象关系

    一对一关联是指数据库中的两个表通过主键或外键的方式直接关联起来的一种关系。 **场景** 假设我们有两个类`Foo`和`Bar`,其中`Foo`有一个属性指向唯一的`Bar`对象。 **HIBERNATE映射** 对于一对一的映射,可以...

Global site tag (gtag.js) - Google Analytics