Hibernate之 对象/关系数据库映射基础(Basic O/R Mapping)

来源:互联网 发布:协同过滤算法应用 编辑:程序博客网 时间:2024/03/29 06:01

6.1. 映射定义(Mapping declaration)

对象和关系数据库之间的映射通常是用一个XML文档(XML document)来定义的。这个映射文档被设计为易读的, 并且可以手工修改。映射语言是以Java为中心,这意味着映射文档是按照持久化类的定义来创建的, 而非表的定义。

请注意,虽然很多Hibernate用户选择手写XML映射文档,但也有一些工具可以用来生成映射文档, 包括XDoclet,Middlegen和AndroMDA。

让我们从一个映射的例子开始:

<?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="eg">        <class name="Cat"             table="cats"            discriminator-value="C">                                <id name="id">                        <generator class="native"/>                </id>                <discriminator column="subclass"                      type="character"/>                <property name="weight"/>                <property name="birthdate"                    type="date"                     not-null="true"                     update="false"/>                <property name="color"                    type="eg.types.ColorUserType"                    not-null="true"                    update="false"/>                <property name="sex"                    not-null="true"                     update="false"/>                <property name="litterId"                    column="litterId"                    update="false"/>                <many-to-one name="mother"                    column="mother_id"                    update="false"/>                <set name="kittens"                    inverse="true"                    order-by="litter_id">                        <key column="mother_id"/>                        <one-to-many class="Cat"/>                </set>                <subclass name="DomesticCat"                    discriminator-value="D">                        <property name="name"                             type="string"/>                </subclass>        </class>        <class name="Dog">                <!-- mapping for Dog could go here -->        </class></hibernate-mapping>

我们现在开始讨论映射文档的内容。我们只描述Hibernate在运行时用到的文档元素和属性。 映射文档还包括一些额外的可选属性和元素,它们在使用schema导出工具的时候会影响导出的数据库schema结果。 (比如, not-null 属性。)

6.1.1. Doctype

所有的XML映射都需要定义如上所示的doctype。DTD可以从上述URL中获取, 从hibernate-x.x.x/src/net/sf/hibernate目录中、 或hibernate.jar文件中找到。Hibernate总是会首先在它的classptah中搜索DTD文件。 如果你发现它是通过连接Internet查找DTD文件,就对照你的classpath目录检查XML文件里的DTD声明。

6.1.2. hibernate-mapping

这个元素包括一些可选的属性。schemacatalog属性, 指明了这个映射所连接(refer)的表所在的schema和/或catalog名称。 假若指定了这个属性,表名会加上所指定的schema和catalog的名字扩展为全限定名。假若没有指定,表名就不会使用全限定名。 default-cascade指定了未明确注明cascade属性的Java属性和 集合类Hibernate会采取什么样的默认级联风格。auto-import属性默认让我们在查询语言中可以使用 非全限定名的类名。

<hibernate-mapping         schema="schemaName"                          (1)         catalog="catalogName"                        (2)         default-cascade="cascade_style"              (3)         default-access="field|property|ClassName"    (4)         default-lazy="true|false"                    (5)         auto-import="true|false"                     (6)         package="package.name"                       (7) />
(1)

schema (可选): 数据库schema的名称。

(2)

catalog (可选): 数据库catalog的名称。

(3)

default-cascade (可选 - 默认为 none): 默认的级联风格。

(4)

default-access (可选 - 默认为 property): Hibernate用来访问属性的策略。可以通过实现PropertyAccessor接口 自定义。

(5)

default-lazy (可选 - 默认为 true): 指定了未明确注明lazy属性的Java属性和集合类, Hibernate会采取什么样的默认加载风格。

(6)

auto-import (可选 - 默认为 true): 指定我们是否可以在查询语言中使用非全限定的类名(仅限于本映射文件中的类)。

(7)

package (可选): 指定一个包前缀,如果在映射文档中没有指定全限定的类名, 就使用这个作为包名。

假若你有两个持久化类,它们的非全限定名是一样的(就是两个类的名字一样,所在的包不一样--译者注), 你应该设置auto-import="false"。假若说你把一个“import过”的名字同时对应两个类, Hibernate会抛出一个异常。

注意hibernate-mapping 元素允许你嵌套多个如上所示的 <class>映射。但是最好的做法(也许一些工具需要的)是一个 持久化类(或一个类的继承层次)对应一个映射文件,并以持久化的超类名称命名,例如: Cat.hbm.xmlDog.hbm.xml,或者如果使用继承,Animal.hbm.xml

6.1.3. class

你可以使用class元素来定义一个持久化类:

<class        name="ClassName"                              (1)        table="tableName"                             (2)        discriminator-value="discriminator_value"     (3)        mutable="true|false"                          (4)        schema="owner"                                (5)        catalog="catalog"                             (6)        proxy="ProxyInterface"                        (7)        dynamic-update="true|false"                   (8)        dynamic-insert="true|false"                   (9)        select-before-update="true|false"             (10)        polymorphism="implicit|explicit"              (11)        where="arbitrary sql where condition"         (12)        persister="PersisterClass"                    (13)        batch-size="N"                                (14)        optimistic-lock="none|version|dirty|all"      (15)        lazy="true|false"                             (16)        entity-name="EntityName"                      (17)        check="arbitrary sql check condition"         (18)        rowid="rowid"                                 (19)        subselect="SQL expression"                    (20)        abstract="true|false"                         (21)        entity-name="EntityName"                      (22)        node="element-name"                           (23)/>
(1)

name (可选): 持久化类(或者接口)的Java全限定名。 如果这个属性不存在,Hibernate将假定这是一个非POJO的实体映射。

(2)

table (可选 - 默认是类的非全限定名): 对应的数据库表名。

(3)

discriminator-value (可选 - 默认和类名一样): 一个用于区分不同的子类的值,在多态行为时使用。它可以接受的值包括 nullnot null

(4)

mutable (可选,默认值为true): 表明该类的实例是可变的或者可变的。

(5)

schema (可选): 覆盖在根<hibernate-mapping>元素中指定的schema名字。

(6)

catalog (可选): 覆盖在根<hibernate-mapping>元素中指定的catalog名字。

(7)

proxy (可选): 指定一个接口,在延迟装载时作为代理使用。 你可以在这里使用该类自己的名字。

(8)

dynamic-update (可选, 默认为 false): 指定用于UPDATE 的SQL将会在运行时动态生成,并且只更新那些改变过的字段。

(9)

dynamic-insert (可选, 默认为 false): 指定用于INSERT的 SQL 将会在运行时动态生成,并且只包含那些非空值字段。

(10)

select-before-update (可选, 默认为 false): 指定Hibernate除非确定对象真正被修改了(如果该值为true-译注),否则不会执行SQL UPDATE操作。在特定场合(实际上,它只在一个瞬时对象(transient object)关联到一个 新的session中时执行的update()中生效),这说明Hibernate会在UPDATE 之前执行一次额外的SQL SELECT操作,来决定是否应该执行 UPDATE

(11)

polymorphism(多态) (可选, 默认值为 implicit (隐式) ): 界定是隐式还是显式的使用多态查询(这只在Hibernate的具体表继承策略中用到-译注)。

(12)

where (可选) 指定一个附加的SQLWHERE 条件, 在抓取这个类的对象时会一直增加这个条件。

(13)

persister (可选): 指定一个定制的ClassPersister

(14)

batch-size (可选,默认是1) 指定一个用于 根据标识符(identifier)抓取实例时使用的"batch size"(批次抓取数量)。

(15)

optimistic-lock(乐观锁定) (可选,默认是version): 决定乐观锁定的策略。

(16)

lazy (optional): 通过设置lazy="false", 所有的延迟加载(Lazy fetching)功能将未被激活(disabled)。

(17)

entity-name (可选): Hibernate3允许一个类进行多次映射( 默认情况是映射到不同的表),并且允许使用Maps或XML代替Java层次的实体映射 (也就是实现动态领域模型,不用写持久化类-译注)。 更多信息请看第 5.4 节 “动态模型(Dynamic models)” and 第 19 章 XML映射

(18)

check (可选): 这是一个SQL表达式, 用于为自动生成的schema添加多行(multi-row)约束检查

(19)

rowid (可选): Hibernate可以使用数据库支持的所谓的ROWIDs,例如: Oracle数据库,如果你设置这个可选的rowid, Hibernate可以使用额外的字段rowid实现快速更新。ROWID是这个功能实现的重点, 它代表了一个存储元组(tuple)的物理位置。

(20)

subselect (可选): 它将一个不可变(immutable)并且只读的实体映射到一个数据库的 子查询中。它用于实现一个视图代替一张基本表,但是最好不要这样做。更多的介绍请看下面内容。

(21)

abstract (可选): 用于在<union-subclass>的继承结构 (hierarchies)中标识抽象超类。

(22)

entity-name (可选, 默认为类名): 显式指定实体名

若指明的持久化类实际上是一个接口,这也是完全可以接受的。 之后你可以用<subclass>来指定该接口的实际实现类。 你可以持久化任何static(静态的)内部类。 你应该使用标准的类名格式来指定类名,比如:Foo$Bar

不可变类,mutable="false"不可以被应用程序更新或者删除。 这可以让Hibernate做一些小小的性能优化。

可选的proxy属性允许延迟加载类的持久化实例。 Hibernate开始会返回实现了这个命名接口的CGLIB代理。当代理的某个方法被实际调用的时候, 真实的持久化对象才会被装载。参见下面的“用于延迟装载的代理”。

Implicit (隐式)的多态是指,如果查询时给出的是任何超类、该类实现的接口或者该类的 名字,都会返回这个类的实例;如果查询中给出的是子类的名字,则会返回子类的实例。 Explicit (显式)的多态是指,只有在查询时给出明确的该类名字时才会返回这个类的实例; 同时只有在这个<class>的定义中作为<subclass> 或者<joined-subclass>出现的子类,才会可能返回。 在大多数情况下,默认的polymorphism="implicit"都是合适的。 显式的多态在有两个不同的类映射到同一个表的时候很有用。(允许一个“轻型”的类,只包含部分表字段)。

persister属性可以让你定制这个类使用的持久化策略。 你可以指定你自己实现 org.hibernate.persister.EntityPersister的子类,你甚至可以完全从头开始编写一个 org.hibernate.persister.ClassPersister接口的实现, 比如是用储存过程调用、序列化到文件或者LDAP数据库来实现。 参阅org.hibernate.test.CustomPersister,这是一个简单的例子 (“持久化”到一个Hashtable)。

请注意dynamic-updatedynamic-insert的设置并不会继承到子类, 所以在<subclass>或者<joined-subclass>元素中可能 需要再次设置。这些设置是否能够提高效率要视情形而定。请用你的智慧决定是否使用。

使用select-before-update通常会降低性能。如果你重新连接一个脱管(detache)对象实例 到一个Session中时,它可以防止数据库不必要的触发update。 这就很有用了。

如果你打开了dynamic-update,你可以选择几种乐观锁定的策略:

  • version(版本检查) 检查version/timestamp字段

  • all(全部) 检查全部字段

  • dirty(脏检查)只检察修改过的字段

  • none(不检查)不使用乐观锁定

我们非常强烈建议你在Hibernate中使用version/timestamp字段来进行乐观锁定。 对性能来说,这是最好的选择,并且这也是唯一能够处理在session外进行操作的策略(例如: 在使用Session.merge()的时候)。

对Hibernate映射来说视图和表是没有区别的,这是因为它们在数据层都是透明的( 注意:一些数据库不支持视图属性,特别是更新的时候)。有时你想使用视图,但却不能在数据库 中创建它(例如:在遗留的schema中)。这样的话,你可以映射一个不可变的(immutable)并且是 只读的实体到一个给定的SQL子查询表达式:

<class name="Summary">    <subselect>        select item.name, max(bid.amount), count(*)        from item        join bid on bid.item_id = item.id        group by item.name    </subselect>    <synchronize table="item"/>    <synchronize table="bid"/>    <id name="name"/>    ...</class>

定义这个实体用到的表为同步(synchronize),确保自动刷新(auto-flush)正确执行, 并且依赖原实体的查询不会返回过期数据。<subselect>在属性元素 和一个嵌套映射元素中都可见。

6.1.4. id

被映射的类必须定义对应数据库表主键字段。大多数类有一个JavaBeans风格的属性, 为每一个实例包含唯一的标识。<id> 元素定义了该属性到数据库表主键字段的映射。

<id        name="propertyName"                                          (1)        type="typename"                                              (2)        column="column_name"                                         (3)        unsaved-value="null|any|none|undefined|id_value"             (4)        access="field|property|ClassName"                            (5)        node="element-name|@attribute-name|element/@attribute|.">        <generator class="generatorClass"/></id>
(1)

name (可选): 标识属性的名字。

(2)

type (可选): 标识Hibernate类型的名字。

(3)

column (可选 - 默认为属性名): 主键字段的名字。

(4)

unsaved-value (可选 - 默认为一个字段判断(sensible)的值): 一个特定的标识属性值,用来标志该实例是刚刚创建的,尚未保存。 这可以把这种实例和从以前的session中装载过(可能又做过修改--译者注) 但未再次持久化的实例区分开来。

(5)

access (可选 - 默认为property): Hibernate用来访问属性值的策略。

如果 name属性不存在,会认为这个类没有标识属性。

unsaved-value 属性很重要!如果你的类的标识属性不是默认为 正常的Java默认值(null或零),你应该指定正确的默认值。

还有一个另外的<composite-id>定义可以访问旧式的多主键数据。 我们强烈不建议使用这种方式。

6.1.4.1. Generator

可选的<generator>子元素是一个Java类的名字, 用来为该持久化类的实例生成唯一的标识。如果这个生成器实例需要某些配置值或者初始化参数, 用<param>元素来传递。

<id name="id" type="long" column="cat_id">        <generator class="org.hibernate.id.TableHiLoGenerator">                <param name="table">uid_table</param>                <param name="column">next_hi_value_column</param>        </generator></id>

所有的生成器都实现net.sf.hibernate.id.IdentifierGenerator接口。 这是一个非常简单的接口;某些应用程序可以选择提供他们自己特定的实现。当然, Hibernate提供了很多内置的实现。下面是一些内置生成器的快捷名字:

increment

用于为long, short或者int类型生成 唯一标识。只有在没有其他进程往同一张表中插入数据时才能使用。 在集群下不要使用。

identity

对DB2,MySQL, MS SQL Server, Sybase和HypersonicSQL的内置标识字段提供支持。 返回的标识符是long, short 或者int类型的。

sequence

在DB2,PostgreSQL, Oracle, SAP DB, McKoi中使用序列(sequence), 而在Interbase中使用生成器(generator)。返回的标识符是long, short或者 int类型的。

hilo

使用一个高/低位算法高效的生成long, short 或者 int类型的标识符。给定一个表和字段(默认分别是是 hibernate_unique_keynext_hi)作为高位值的来源。 高/低位算法生成的标识符只在一个特定的数据库中是唯一的。

seqhilo

使用一个高/低位算法来高效的生成long, short 或者 int类型的标识符,给定一个数据库序列(sequence)的名字。

uuid

用一个128-bit的UUID算法生成字符串类型的标识符, 这在一个网络中是唯一的(使用了IP地址)。UUID被编码为一个32位16进制数字的字符串。

guid

在MS SQL Server 和 MySQL 中使用数据库生成的GUID字符串。

native

根据底层数据库的能力选择identity, sequence 或者hilo中的一个。

assigned

让应用程序在save()之前为对象分配一个标示符。这是 <generator>元素没有指定时的默认生成策略。

select

通过数据库触发器选择一些唯一主键的行并返回主键值来分配一个主键。

foreign

使用另外一个相关联的对象的标识符。通常和<one-to-one>联合起来使用。

6.1.4.2. 高/低位算法(Hi/Lo Algorithm)

hiloseqhilo生成器给出了两种hi/lo算法的实现, 这是一种很令人满意的标识符生成算法。第一种实现需要一个“特殊”的数据库表来保存下一个可用的“hi”值。 第二种实现使用一个Oracle风格的序列(在被支持的情况下)。

<id name="id" type="long" column="cat_id">        <generator class="hilo">                <param name="table">hi_value</param>                <param name="column">next_value</param>                <param name="max_lo">100</param>        </generator></id>
<id name="id" type="long" column="cat_id">        <generator class="seqhilo">                <param name="sequence">hi_value</param>                <param name="max_lo">100</param>        </generator></id>

很不幸,你在为Hibernate自行提供Connection时无法使用hilo。 当Hibernate使用JTA获取应用服务器的数据源连接时,你必须正确地配置 hibernate.transaction.manager_lookup_class

6.1.4.3. UUID算法(UUID Algorithm )

UUID包含:IP地址,JVM的启动时间(精确到1/4秒),系统时间和一个计数器值(在JVM中唯一)。 在Java代码中不可能获得MAC地址或者内存地址,所以这已经是我们在不使用JNI的前提下的能做的最好实现了。

6.1.4.4. 标识字段和序列(Identity columns and Sequences)

对于内部支持标识字段的数据库(DB2,MySQL,Sybase,MS SQL),你可以使用identity关键字生成。 对于内部支持序列的数据库(DB2,Oracle, PostgreSQL, Interbase, McKoi,SAP DB), 你可以使用sequence风格的关键字生成。 这两种方式对于插入一个新的对象都需要两次SQL查询。

<id name="id" type="long" column="person_id">        <generator class="sequence">                <param name="sequence">person_id_sequence</param>        </generator></id>
<id name="id" type="long" column="person_id" unsaved-value="0">        <generator class="identity"/></id>

对于跨平台开发,native策略会从identity, sequencehilo中进行选择,选择哪一个,这取决于底层数据库的支持能力。

6.1.4.5. 程序分配的标识符(Assigned Identifiers)

如果你需要应用程序分配一个标示符(而非Hibernate来生成),你可以使用assigned 生成器。这种特殊的生成器会使用已经分配给对象的标识符属性的标识符值。 这个生成器使用一个自然键(natural key,有商业意义的列-译注)作为主键,而不是使用一个代理键( surrogate key,没有商业意义的列-译注)。

当选择assigned生成器时,除非有一个version或timestamp属性,或者你定义了 Interceptor.isUnsaved(),否则需要让Hiberante使用 unsaved-value="undefined",强制Hibernatet查询数据库来确定一个实例是瞬时的(transient) 还是脱管的(detached)。

6.1.4.6. 触发器实现的主键生成器(Primary keys assigned by triggers)

仅仅用于遗留的schema中 (Hibernate不能使用触发器生成DDL)。

<id name="id" type="long" column="person_id">        <generator class="select">                <param name="key">socialSecurityNumber</param>        </generator></id>

在上面的例子中,类定义了一个命名为socialSecurityNumber的唯一值属性, 它是一个自然键(natural key),命名为person_id的代理键(surrogate key) 的值由触发器生成。

6.1.5. composite-id

<composite-id        name="propertyName"        class="ClassName"        unsaved-value="undefined|any|none"        access="field|property|ClassName"        node="element-name|."        >        <key-property name="propertyName" type="typename" column="column_name"/>        <key-many-to-one name="propertyName class="ClassName" column="column_name"/>        ......</composite-id>

For a table with a composite key, you may map multiple properties of the class as identifier properties. The <composite-id> element accepts <key-property> property mappings and <key-many-to-one> mappings as child elements.

如果表使用联合主键,你可以映射类的多个属性为标识符属性。 <composite-id>元素接受<key-property> 属性映射和<key-many-to-one>属性映射作为子元素。

<composite-id>        <key-property name="medicareNumber"/>        <key-property name="dependent"/></composite-id>

你的持久化类必须重载equals()hashCode()方法,来实现组合的标识符的相等判断。 实现Serializable接口也是必须的。

不幸的是,这种组合关键字的方法意味着一个持久化类是它自己的标识。除了对象自己之外, 没有什么方便的“把手”可用。你必须自己初始化持久化类的实例,在使用组合关键字load() 持久化状态之前,必须填充他的联合属性。我们会在第 9.4 节 “组件作为联合标识符(Components as composite identifiers)”章中说明一种 更加便捷的方法,把联合标识实现为一个独立的类,下面描述的属性只对这种备用方法有效:

  • name (可选):一个组件类型,持有复合标识(参见下一节)。

  • class (可选 - 默认为通过反射(reflection)得到的属性类型) : 作为联合标识的组件类名(参见下一节)。

  • unsaved-value (可选 - 默认为 undefined): 如果设置为any,就表示瞬时(transient)实例应该被重新初始化,或者如果 设置为none,则表示该实例是脱管对象。最好在所有的情况下都保持默认的值。

6.1.6. 鉴别器(discriminator)

在"一棵对象继承树对应一个表"的策略中,<discriminator>元素是必需的, 它定义了表的鉴别器字段。鉴别器字段包含标志值,用于告知持久化层应该为某个特定的行创建哪一个子类的实例。 如下这些受到限制的类型可以使用: string, character, integer, byte, short, boolean, yes_no, true_false.

<discriminator        column="discriminator_column"                      (1)        type="discriminator_type"                          (2)        force="true|false"                                 (3)        insert="true|false"                                (4)        formula="arbitrary sql expression"                 (5)/>
(1)

column (可选 - 默认为 class) 鉴别器字段的名字

(2)

type (可选 - 默认为 string) 一个Hibernate字段类型的名字

(3)

force(强制) (可选 - 默认为 false) "强制"Hibernate指定允许的鉴别器值,就算取得的所有实例都是根类的。

(4)

insert (可选 - 默认为true) 如果你的鉴别器字段也是映射为复合标识(composite identifier)的一部分,则需将 这个值设为false。(告诉Hibernate在做SQL INSERT 时不包含该列)

(5)

formula (可选) 一个SQL表达式,在类型判断(判断是父类还是具体子类-译注)时执行。可用于基于内容的鉴别器。

鉴别器字段的实际值是根据<class><subclass>元素中 的discriminator-value属性得来的。

force属性仅仅是在表包含一些未指定应该映射到哪个持久化类的时候才是有用的。 这种情况不会经常遇到。

使用formula属性你可以定义一个SQL表达式,用来判断一个行数据的类型。

<discriminator    formula="case when CLASS_TYPE in ('a', 'b', 'c') then 0 else 1 end"    type="integer"/>

6.1.7. 版本(version)(可选)

<version>元素是可选的,表明表中包含附带版本信息的数据。 这在你准备使用 长事务(long transactions)的时候特别有用。(见后)

<version        column="version_column"                                      (1)        name="propertyName"                                          (2)        type="typename"                                              (3)        access="field|property|ClassName"                            (4)        unsaved-value="null|negative|undefined"                      (5)        node="element-name|@attribute-name|element/@attribute|."/>
(1)

column (可选 - 默认为属性名): 指定持有版本号的字段名。

(2)

name: 持久化类的属性名。

(3)

type (可选 - 默认是 integer): 版本号的类型。

(4)

access (可选 - 默认是 property): Hibernate用于访问属性值的策略。

(5)

unsaved-value (可选 - 默认是undefined): 用于标明某个实例时刚刚被实例化的(尚未保存)版本属性值,依靠这个值就可以把这种情况 和已经在先前的session中保存或装载的脱管(detached)实例区分开来。 (undefined指明使用标识属性值进行判断。)

版本号必须是以下类型:long, integer, short, timestamp或者calendar

一个脱管(detached)实例的version或timestamp不能为空(null),因为Hibernate不管 unsaved-value指定为何种策略,它将分离任何属性为空的version或timestamp 实例为瞬时(transient)实例。 避免Hibernate中的传递重附(transitive reattachment)问题的一个简单方法是 定义一个不能为空的version或timestamp属性,特别是在人们使用程序分配的标识符(assigned identifiers) 或复合主键时非常有用!

6.1.8. timestamp (optional)

可选的<timestamp>元素指明了表中包含时间戳数据。 这用来作为版本的替代。时间戳本质上是一种对乐观锁定的一种不是特别安全的实现。当然, 有时候应用程序可能在其他方面使用时间戳。

<timestamp        column="timestamp_column"                                    (1)        name="propertyName"                                          (2)        access="field|property|ClassName"                            (3)        unsaved-value="null|undefined"                               (4)        node="element-name|@attribute-name|element/@attribute|."/>
(1)

column (可选 - 默认为属性名): 持有时间戳的字段名。

(2)

name: 在持久化类中的JavaBeans风格的属性名, 其Java类型是 Date 或者 Timestamp的。

(3)

access (可选 - 默认是 property): Hibernate用于访问属性值的策略。

(4)

unsaved-value (可选 - 默认是null): 用于标明某个实例时刚刚被实例化的(尚未保存)版本属性值,依靠这个值就可以把这种情况和 已经在先前的session中保存或装载的脱管(detached)实例区分开来。(undefined 指明使用标识属性值进行这种判断。)

注意,<timestamp><version type="timestamp">是等价的。

6.1.9. property

<property>元素为类定义了一个持久化的,JavaBean风格的属性。

<property        name="propertyName"                                          (1)        column="column_name"                                         (2)        type="typename"                                              (3)        update="true|false"                                          (4)        insert="true|false"                                          (4)        formula="arbitrary SQL expression"                           (5)        access="field|property|ClassName"                            (6)        lazy="true|false"                                            (7)        unique="true|false"                                          (8)        not-null="true|false"                                        (9)        optimistic-lock="true|false"                                 (10)        node="element-name|@attribute-name|element/@attribute|."/>
(1)

name: 属性的名字,以小写字母开头。

(2)

column (可选 - 默认为属性名字): 对应的数据库字段名。 也可以通过嵌套的<column>元素指定。

(3)

type (可选): 一个Hibernate类型的名字。

(4)

update, insert (可选 - 默认为 true) : 表明用于UPDATE 和/或 INSERT 的SQL语句中是否包含这个被映射了的字段。这二者如果都设置为false 则表明这是一个“外源性(derived)”的属性,它的值来源于映射到同一个(或多个) 字段的某些其他属性,或者通过一个trigger(触发器)或其他程序。

(5)

formula (可选): 一个SQL表达式,定义了这个计算 (computed) 属性的值。计算属性没有和它对应的数据库字段。

(6)

access (可选 - 默认值为 property): Hibernate用来访问属性值的策略。

(7)

lazy (可选 - 默认为 false): 指定 指定实例变量第一次被访问时,这个属性是否延迟抓取(fetched lazily)( 需要运行时字节码增强)。

(8)

unique (可选): 使用DDL为该字段添加唯一的约束。 此外,这也可以用作property-ref的目标属性。

(9)

not-null (可选): 使用DDL为该字段添加可否为空(nullability)的约束。

(10)

optimistic-lock (可选 - 默认为 true): 指定这个属性在做更新时是否需要获得乐观锁定(optimistic lock)。 换句话说,它决定这个属性发生脏数据时版本(version)的值是否增长。

typename 可以是如下几种:

  1. Hibernate基础类型之一(比如:integer, string, character,date, timestamp, float, binary, serializable, object, blob)。

  2. 一个Java类的名字,这个类属于一种默认基础类型 (比如: int, float,char, java.lang.String, java.util.Date, java.lang.Integer, java.sql.Clob)。

  3. 一个可以序列化的Java类的名字。

  4. 一个自定义类型的类的名字。(比如: com.illflow.type.MyCustomType)。

如果你没有指定类型,Hibernarte会使用反射来得到这个名字的属性,以此来猜测正确的Hibernate类型。 Hibernate会按照规则2,3,4的顺序对属性读取器(getter方法)的返回类进行解释。然而,这还不够。 在某些情况下你仍然需要type属性。(比如,为了区别Hibernate.DATEHibernate.TIMESTAMP,或者为了指定一个自定义类型。)

access属性用来让你控制Hibernate如何在运行时访问属性。在默认情况下, Hibernate会使用属性的get/set方法对(pair)。如果你指明access="field", Hibernate会忽略get/set方法对,直接使用反射来访问成员变量。你也可以指定你自己的策略, 这就需要你自己实现org.hibernate.property.PropertyAccessor接口, 再在access中设置你自定义策略类的名字。

衍生属性(derive propertie)是一个特别强大的特征。这些属性应该定义为只读,属性值在装载时计算生成。 你用一个SQL表达式生成计算的结果,它会在这个实例转载时翻译成一个SQL查询的SELECT 子查询语句。

<property name="totalPrice"    formula="( SELECT SUM (li.quantity*p.price) FROM LineItem li, Product p                WHERE li.productId = p.productId                AND li.customerId = customerId                AND li.orderNumber = orderNumber )"/>

注意,你可以使用实体自己的表,而不用为这个特别的列定义别名( 上面例子中的customerId)。同时注意,如果你不喜欢使用属性, 你可以使用嵌套的<formula>映射元素。

6.1.10. 多对一(many-to-one)

通过many-to-one元素,可以定义一种常见的与另一个持久化类的关联。 这种关系模型是多对一关联(实际上是一个对象引用-译注):这个表的一个外键引用目标表的 主键字段。

<many-to-one        name="propertyName"                                          (1)        column="column_name"                                         (2)        class="ClassName"                                            (3)        cascade="cascade_style"                                      (4)        fetch="join|select"                                          (5)        update="true|false"                                          (6)        insert="true|false"                                          (6)        property-ref="propertyNameFromAssociatedClass"               (7)        access="field|property|ClassName"                            (8)        unique="true|false"                                          (9)        not-null="true|false"                                        (10)        optimistic-lock="true|false"                                 (11)        lazy="true|proxy|false"                                      (12)        not-found="ignore|exception"                                 (13)        entity-name="EntityName"                                     (14)        node="element-name|@attribute-name|element/@attribute|."        embed-xml="true|false"        />
(1)

name: 属性名。

(2)

column (可选): 外间字段名。它也可以通过嵌套的 <column>元素指定。

(3)

class (可选 - 默认是通过反射得到属性类型): 关联的类的名字。

(4)

cascade(级联) (可选): 指明哪些操作会从父对象级联到关联的对象。

(5)

fetch (可选 - 默认为 select): 在外连接抓取(outer-join fetching)和序列选择抓取(sequential select fetching)两者中选择其一。

(6)

update, insert (可选 - defaults to true) 指定对应的字段是否包含在用于UPDATE 和/或 INSERT 的SQL语句中。如果二者都是false,则这是一个纯粹的 “外源性(derived)”关联,它的值是通过映射到同一个(或多个)字段的某些其他属性得到 或者通过trigger(触发器)、或其他程序。

(7)

property-ref: (可选) 指定关联类的一个属性,这个属性将会和本外键相对应。 如果没有指定,会使用对方关联类的主键。

(8)

access (可选 - 默认是 property): Hibernate用来访问属性的策略。

(9)

unique (可选): 使用DDL为外键字段生成一个唯一约束。此外, 这也可以用作property-ref的目标属性。这使关联同时具有 一对一的效果。

(10)

not-null (可选): 使用DDL为外键字段生成一个非空约束。

(11)

optimistic-lock (可选 - 默认为 true): 指定这个属性在做更新时是否需要获得乐观锁定(optimistic lock)。 换句话说,它决定这个属性发生脏数据时版本(version)的值是否增长。

(12)

lazy (可选 - 默认为 proxy): 默认情况下,单点关联是经过代理的。lazy="true"指定此属性应该在实例变量第一次被访问时应该延迟抓取(fetche lazily)(需要运行时字节码的增强)。 lazy="false"指定此关联总是被预先抓取。

(13)

not-found (可选 - 默认为 exception): 指定外键引用的数据不存在时如何处理: ignore会将数据不存在作为关联到一个空对象(null)处理。

(14)

entity-name (optional): 被关联的类的实体名。

cascade属性设置为除了none以外任何有意义的值, 它将把特定的操作传播到关联对象中。这个值就代表着Hibernate基本操作的名称, persist, merge, delete, save-update, evict, replicate, lock, refresh, 以及特别的值delete-orphanall,并且可以用逗号分隔符 来合并这些操作,例如,cascade="persist,merge,evict"cascade="all,delete-orphan"。更全面的解释请参考第 11.11 节 “传播性持久化(transitive persistence)”.

一个典型的简单many-to-one定义例子:

<many-to-one name="product" class="Product" column="PRODUCT_ID"/>

property-ref属性只应该用来对付老旧的数据库系统, 可能有外键指向对方关联表的是个非主键字段(但是应该是一个惟一关键字)的情况下。 这是一种十分丑陋的关系模型。比如说,假设Product类有一个惟一的序列号, 它并不是主键。(unique属性控制Hibernate通过SchemaExport工具生成DDL的过程。)

<property name="serialNumber" unique="true" type="string" column="SERIAL_NUMBER"/>

那么关于OrderItem 的映射可能是:

<many-to-one name="product" property-ref="serialNumber" column="PRODUCT_SERIAL_NUMBER"/>

当然,我们决不鼓励这种用法。

如果被引用的唯一主键由关联实体的多个属性组成,你应该在名称为<properties>的元素 里面映射所有关联的属性。

6.1.11. 一对一

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

<one-to-one        name="propertyName"                                          (1)        class="ClassName"                                            (2)        cascade="cascade_style"                                      (3)        constrained="true|false"                                     (4)        fetch="join|select"                                          (5)        property-ref="propertyNameFromAssociatedClass"               (6)        access="field|property|ClassName"                            (7)        formula="any SQL expression"                                 (8)        lazy="true|proxy|false"                                      (9)        entity-name="EntityName"                                     (10)        node="element-name|@attribute-name|element/@attribute|."        embed-xml="true|false"/>
(1)

name: 属性的名字。

(2)

class (可选 - 默认是通过反射得到的属性类型):被关联的类的名字。

(3)

cascade(级联) (可选) 表明操作是否从父对象级联到被关联的对象。

(4)

constrained(约束) (可选) 表明该类对应的表对应的数据库表,和被关联的对象所对应的数据库表之间,通过一个外键引用对主键进行约束。 这个选项影响save()delete()在级联执行时的先后顺序以及 决定该关联能否被委托(也在schema export tool中被使用).

(5)

fetch (可选 - 默认设置为选择): 在外连接抓取或者序列选择抓取选择其一.

(6)

property-ref: (可选) 指定关联类的属性名,这个属性将会和本类的主键相对应。如果没有指定,会使用对方关联类的主键。

(7)

access (可选 - 默认是 property): Hibernate用来访问属性的策略。

(8)

formula (可选):绝大多数一对一的关联都指向其实体的主键。在一些少见的情况中, 你可能会指向其他的一个或多个字段,或者是一个表达式,这些情况下,你可以用一个SQL公式来表示。 (可以在org.hibernate.test.onetooneformula找到例子)

(9)

lazy (可选 - 默认为 proxy): 默认情况下,单点关联是经过代理的。lazy="true"指定此属性应该在实例变量第一次被访问时应该延迟抓取(fetche lazily)(需要运行时字节码的增强)。 lazy="false"指定此关联总是被预先抓取。注意,如果constrained="false", 不可能使用代理,Hibernate会采取预先抓取!

(10)

entity-name (可选): 被关联的类的实体名。

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

  • 主键关联

  • 惟一外键关联

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

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

<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实例被赋予和该Personemployee属性所指向的Employee实例同样的关键字值。

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

<many-to-one name="person" class="Person" column="PERSON_ID" unique="true"/>

如果在Person的映射加入下面几句,这种关联就是双向的:

<one-to-one name"employee" class="Employee" property-ref="person"/>

6.1.12. 组件(component), 动态组件(dynamic-component)

<component>元素把子对象的一些元素与父类对应的表的一些字段映射起来。 然后组件可以定义它们自己的属性、组件或者集合。参见后面的“Components”一章。

<component         name="propertyName"                 (1)        class="className"                   (2)        insert="true|false"                 (3)        update="true|false"                 (4)        access="field|property|ClassName"   (5)        lazy="true|false"                   (6)        optimistic-lock="true|false"        (7)        unique="true|false"                 (8)        node="element-name|.">                <property ...../>        <many-to-one .... />        ........</component>
(1)

name: 属性名

(2)

class (可选 - 默认为通过反射得到的属性类型):组件(子)类的名字。

(3)

insert: 被映射的字段是否出现在SQL的INSERT语句中?

(4)

update: 被映射的字段是否出现在SQL的UPDATE语句中?

(5)

access (可选 - 默认是 property): Hibernate用来访问属性的策略。

(6)

lazy (可选 - 默认是 false): 表明此组件应在实例变量第一次被访问的时候延迟加载(需要编译时字节码装置器)

(7)

optimistic-lock (可选 - 默认是 true):表明更新此组件是否需要获取乐观锁。换句话说,当这个属性变脏时,是否增加版本号(Version)

(8)

unique (可选 - 默认是 false):表明组件映射的所有字段上都有唯一性约束

<property>子标签为子类的一些属性与表字段之间建立映射。

<component>元素允许加入一个<parent>子元素,在组件类内部就可以有一个指向其容器的实体的反向引用。

<dynamic-component>元素允许把一个Map映射为组件,其属性名对应map的键值。 参见第 9.5 节 “动态组件 (Dynamic components)”.

6.1.13. properties

<properties> 元素允许定义一个命名的逻辑分组(grouping)包含一个类中的多个属性。 这个元素最重要的用处是允许多个属性的组合作为property-ref的目标(target)。 这也是定义多字段唯一约束的一种方便途径。

<properties         name="logicalName"                  (1)        insert="true|false"                 (2)        update="true|false"                 (3)        optimistic-lock="true|false"        (4)        unique="true|false"                 (5)>                <property ...../>        <many-to-one .... />        ........</properties>
(1)

name: 分组的逻辑名称 - 不是 实际属性的名称.

(2)

insert: 被映射的字段是否出现在SQL的 INSERT语句中?

(3)

update: 被映射的字段是否出现在SQL的 UPDATE语句中?

(4)

optimistic-lock (可选 - 默认是 true):表明更新此组件是否需要获取乐观锁。换句话说,当这个属性变脏时,是否增加版本号(Version)

(5)

unique (可选 - 默认是 false):表明组件映射的所有字段上都有唯一性约束

例如,如果我们有如下的<properties>映射:

<class name="Person">    <id name="personNumber"/>    ...    <properties name="name"             unique="true" update="false">        <property name="firstName"/>        <property name="initial"/>        <property name="lastName"/>    </properties></class>

然后,我们可能有一些遗留的数据关联,引用 Person表的这个唯一键,而不是主键。

<many-to-one name="person"          class="Person" property-ref="name">    <column name="firstName"/>    <column name="initial"/>    <column name="lastName"/></many-to-one>

我们并不推荐这样使用,除非在映射遗留数据的情况下。

6.1.14. 子类(subclass)

最后,多态持久化需要为父类的每个子类都进行定义。对于“每一棵类继承树对应一个表”的策略来说,就需要使用<subclass>定义。

<subclass        name="ClassName"                              (1)        discriminator-value="discriminator_value"     (2)        proxy="ProxyInterface"                        (3)        lazy="true|false"                             (4)        dynamic-update="true|false"        dynamic-insert="true|false"        entity-name="EntityName"        node="element-name">        <property .... />        .....</subclass>
(1)

name: 子类的全限定名。

(2)

discriminator-value(辨别标志) (可选 - 默认为类名):一个用于区分每个独立的子类的值。

(3)

proxy(代理) (可选): 指定一个类或者接口,在延迟装载时作为代理使用。

(4)

lazy (可选, 默认是true): 设置为 lazy="false" 禁止使用延迟抓取

每个子类都应该定义它自己的持久化属性和子类。 <version><id> 属性可以从根父类继承下来。在一棵继承树上的每个子类都必须定义一个唯一的discriminator-value。如果没有指定,就会使用Java类的全限定名。

可以在单独的映射文件中,直接在hibernate-mapping下定义subclassunion-subclassjoined-subclass映射。这样你只要增加一个新的映射文件就可以继承一棵类继承树。你必须在子类的映射中指定extends 属性来指定已映射的超类。注意:以前,这个特性使得映射文件的顺序变得很重要。从Hibernate3开始,当使用extends关键字的时候,映射文件的次序便不重要了。而在单一映射文件中,依旧需要保持将超类定义在子类之前这样的次序。

<hibernate-mapping>    <subclass name="DomesticCat" extends="Cat" discriminator-value="D">         <property name="name" type="string"/>    </subclass></hibernate-mapping>

更多关于继承映射的信息, 参考 第 10 章 继承映射(Inheritance Mappings)章节.

6.1.15. 连接的子类(joined-subclass)

此外,每个子类可能被映射到他自己的表中(每个子类一个表的策略)。被继承的状态通过和超类的表关联得到。我们使用<joined-subclass>元素。

<joined-subclass        name="ClassName"                    (1)        table="tablename"                   (2)        proxy="ProxyInterface"              (3)        lazy="true|false"                   (4)        dynamic-update="true|false"        dynamic-insert="true|false"        schema="schema"        catalog="catalog"        extends="SuperclassName"        persister="ClassName"        subselect="SQL expression"        entity-name="EntityName"        node="element-name">        <key .... >        <property .... />        .....</joined-subclass>
(1)

name: 子类的全限定名。

(2)

table: 子类的表名.

(3)

proxy (可选): 指定一个类或者接口,在延迟装载时作为代理使用。

(4)

lazy (可选, 默认是 true): 设置为 lazy="false" 禁止使用延迟装载。

这种映射策略不需要指定辨别标志(discriminator)字段。但是,每一个子类都必须使用<key>元素指定一个表字段来持有对象的标识符。本章开始的映射可以被用如下方式重写:

<?xml version="1.0"?><!DOCTYPE hibernate-mapping PUBLIC        "-//Hibernate/Hibernate Mapping DTD//EN"        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"><hibernate-mapping package="eg">        <class name="Cat" table="CATS">                <id name="id" column="uid" type="long">                        <generator class="hilo"/>                </id>                <property name="birthdate" type="date"/>                <property name="color" not-null="true"/>                <property name="sex" not-null="true"/>                <property name="weight"/>                <many-to-one name="mate"/>                <set name="kittens">                        <key column="MOTHER"/>                        <one-to-many class="Cat"/>                </set>                <joined-subclass name="DomesticCat" table="DOMESTIC_CATS">                    <key column="CAT"/>                    <property name="name" type="string"/>                </joined-subclass>        </class>        <class name="eg.Dog">                <!-- mapping for Dog could go here -->        </class></hibernate-mapping>

更多关于继承映射的信息,参考第 10 章 继承映射(Inheritance Mappings)

6.1.16. 联合子类(union-subclass)

第三种选择是仅仅映射类继承树中具体类部分到表中(每个具体类一张表的策略)。其中,每张表定义了类的所有持久化状态,包括继承的状态。在 Hibernate 中,并不需要完全显式地映射这样的继承树。你可以简单地使用单独的<class>定义映射每个类。然而,如果你想使用多态关联(例如,一个对类继承树中超类的关联),你需要使用<union-subclass>映射。

<union-subclass        name="ClassName"                    (1)        table="tablename"                   (2)        proxy="ProxyInterface"              (3)        lazy="true|false"                   (4)        dynamic-update="true|false"        dynamic-insert="true|false"        schema="schema"        catalog="catalog"        extends="SuperclassName"        abstract="true|false"        persister="ClassName"        subselect="SQL expression"        entity-name="EntityName"        node="element-name">        <property .... />        .....</union-subclass>
(1)

name: 子类的全限定名。

(2)

table: 子类的表名

(3)

proxy (可选): 指定一个类或者接口,在延迟装载时作为代理使用。

(4)

lazy (可选, 默认是 true): 设置为 lazy="false" 禁止使用延迟装载。

这种映射策略不需要指定辨别标志(discriminator)字段。

更多关于继承映射的信息,参考第 10 章 继承映射(Inheritance Mappings)

6.1.17. 连接(join)

使用 <join> 元素,可以将一个类的属性映射到多张表中。

<join        table="tablename"                        (1)        schema="owner"                           (2)        catalog="catalog"                        (3)        fetch="join|select"                      (4)        inverse="true|false"                     (5)        optional="true|false">                   (6)                <key ... />                <property ... />        ...</join>
(1)

table: 被连接表的名称。

(2)

schema (可选):覆盖由根<hibernate-mapping>元素指定的模式名称。

(3)

catalog (可选): 覆盖由根 <hibernate-mapping>元素指定的目录名称。

(4)

fetch (可选 - 默认是 join): 如果设置为默认值join, Hibernate 将使用一个内连接来得到这个类或其超类定义的<join>,而使用一个外连接来得到其子类定义的<join>。如果设置为select,则 Hibernate 将为子类定义的 <join>使用顺序选择。这仅在一行数据表示一个子类的对象的时候才会发生。对这个类和其超类定义的<join>,依然会使用内连接得到。

(5)

inverse (可选 - 默认是 false): 如果打开,Hibernate 不会插入或者更新此连接定义的属性。

(6)

optional (可选 - 默认是 false): 如果打开,Hibernate 只会在此连接定义的属性非空时插入一行数据,并且总是使用一个外连接来得到这些属性。

例如,一个人(person)的地址(address)信息可以被映射到单独的表中(并保留所有属性的值类型语义):

<class name="Person"    table="PERSON">    <id name="id" column="PERSON_ID">...</id>    <join table="ADDRESS">        <key column="ADDRESS_ID"/>        <property name="address"/>        <property name="zip"/>        <property name="country"/>    </join>    ...

此特性常常对遗留数据模型有用,我们推荐表个数比类个数少,以及细粒度的领域模型。然而,在单独的继承树上切换继承映射策略是有用的,后面会解释这点。

6.1.18. 键(key)

我们目前已经见到过<key>元素多次了。 这个元素在父映射元素定义了对新表的连接,并且在被连接表中定义了一个外键引用原表的主键的情况下经常使用。

<key        column="columnname"                      (1)        on-delete="noaction|cascade"             (2)        property-ref="propertyName"              (3)        not-null="true|false"                    (4)        update="true|false"                      (5)        unique="true|false"                      (6)/>
(1)

column (可选): 外键字段的名称。也可以通过嵌套的 <column>指定。

(2)

on-delete (可选, 默认是 noaction): 表明外键关联是否打开数据库级别的级联删除。

(3)

property-ref (可选): 表明外键引用的字段不是原表的主键(提供给遗留数据)。

(4)

not-null (可选): 表明外键的字段不可为空(这意味着无论何时外键都是主键的一部分)。

(5)

update (可选): 表明外键决不应该被更新(这意味着无论何时外键都是主键的一部分)。

(6)

unique (可选): 表明外键应有唯一性约束 (这意味着无论何时外键都是主键的一部分)。

对那些看重删除性能的系统,我们推荐所有的键都应该定义为on-delete="cascade",这样 Hibernate 将使用数据库级的ON CASCADE DELETE约束,而不是多个DELETE语句。 注意,这个特性会绕过 Hibernate 通常对版本数据(versioned data)采用的乐观锁策略。

not-nullupdate 属性在映射单向一对多关联的时候有用。如果你映射一个单向一对多关联到非空的(non-nullable)外键,你必须<key not-null="true">定义此键字段。

6.1.19. 字段和规则元素(column and formula elements)

任何接受column属性的映射元素都可以选择接受<column> 子元素。同样的,formula也可以替换<formula>属性。

<column        name="column_name"        length="N"        precision="N"        scale="N"        not-null="true|false"        unique="true|false"        unique-key="multicolumn_unique_key_name"        index="index_name"        sql-type="sql_type_name"        check="SQL expression"/>
<formula>SQL expression</formula>

columnformula 属性甚至可以在同一个属性或关联映射中被合并来表达,例如,一些奇异的连接条件。

<many-to-one name="homeAddress" class="Address"        insert="false" update="false">    <column name="person_id" not-null="true" length="10"/>    <formula>'MAILING'</formula></many-to-one>

6.1.20. 引用(import)

假设你的应用程序有两个同样名字的持久化类,但是你不想在Hibernate查询中使用他们的全限定名。除了依赖auto-import="true"以外,类也可以被显式地“import(引用)”。你甚至可以引用没有明确被映射的类和接口。

<import class="java.lang.Object" rename="Universe"/>
<import        class="ClassName"              (1)        rename="ShortName"             (2)/>
(1)

class: 任何Java类的全限定名。

(2)

rename (可选 - 默认为类的全限定名): 在查询语句中可以使用的名字。

6.1.21. any

这是属性映射的又一种类型。<any> 映射元素定义了一种从多个表到类的多态关联。这种类型的映射常常需要多于一个字段。第一个字段持有被关联实体的类型,其他的字段持有标识符。对这种类型的关联来说,不可能指定一个外键约束,所以这当然不是映射(多态)关联的通常的方式。你只应该在非常特殊的情况下使用它(比如,审计log,用户会话数据等等)。

meta-type 属性使得应用程序能指定一个将数据库字段的值映射到持久化类的自定义类型。这个持久化类包含有用id-type指定的标识符属性。 你必须指定从meta-type的值到类名的映射。

<any name="being" id-type="long" meta-type="string">    <meta-value value="TBL_ANIMAL" class="Animal"/>    <meta-value value="TBL_HUMAN" class="Human"/>    <meta-value value="TBL_ALIEN" class="Alien"/>    <column name="table_name"/>    <column name="id"/></any>
<any        name="propertyName"                      (1)        id-type="idtypename"                     (2)        meta-type="metatypename"                 (3)        cascade="cascade_style"                  (4)        access="field|property|ClassName"        (5)        optimistic-lock="true|false"             (6)>        <meta-value ... />        <meta-value ... />        .....        <column .... />        <column .... />        .....</any>
(1)

name: 属性名

(2)

id-type: 标识符类型

(3)

meta-type (可选 -默认是 string): 允许辨别标志(discriminator)映射的任何类型

(4)

cascade (可选 -默认是none): 级联的类型

(5)

access (可选 -默认是 property): Hibernate 用来访问属性值的策略。

(6)

optimistic-lock (可选 -默认是 true): 表明更新此组件是否需要获取乐观锁。换句话说,当这个属性变脏时,是否增加版本号(Version)

6.2. Hibernate 的类型

6.2.1. 实体(Entities)和值(values)

为了理解很多与持久化服务相关的Java语言级对象的行为,我们需要把它们分为两类:

实体entity 独立于任何持有实体引用的对象。与通常的Java模型相比,不再被引用的对象会被当作垃圾收集掉。实体必须被显式的保存和删除(除非保存和删除是从父实体向子实体引发的级联)。这和ODMG模型中关于对象通过可触及保持持久性有一些不同——比较起来更加接近应用程序对象通常在一个大系统中的使用方法。实体支持循环引用和交叉引用,它们也可以加上版本信息。

一个实体的持久状态包含指向其他实体和类型实例的引用。值可以是原始类型,集合(不是集合中的对象),组件或者特定的不可变对象。与实体不同,值(特别是集合和组件)是通过可触及性来进行持久化和删除的。因为值对象(和原始类型数据)是随着包含他们的实体而被持久化和删除的,他们不能被独立的加上版本信息。值没有独立的标识,所以他们不能被两个实体或者集合共享。

直到现在,我们都一直使用术语“持久类”(persistent class)来代表实体。我们仍然会这么做。 然而严格说来,不是所有的用户自定义的,带有持久化状态的类都是实体。组件就是用户自定义类,却是值语义的。java.lang.String类型的java属性也是值语义的。给了这个定义以后,我们可以说所有JDK提供的类型(类)都是值类型的语义,而用于自定义类型可能被映射为实体类型或值类型语义。采用哪种类型的语义取决于开发人员。在领域模型中,寻找实体类的一个好线索是共享引用指向这个类的单一实例,而组合或聚合通常被转化为值类型。

我们会在本文档中重复碰到这两个概念。

挑战在于将java类型系统(和开发者定义的实体和值类型)映射到 SQL/数据库类型系统。Hibernate提供了连接两个系统之间的桥梁:对于实体类型,我们使用<class>, <subclass> 等等。对于值类型,我们使用 <property>, <component> 及其他,通常跟随着type属性。这个属性的值是Hibernate 的映射类型的名字。Hibernate提供了许多现成的映射(标准的JDK值类型)。你也可以编写自己的映射类型并实现自定义的变换策略,随后我们会看到这点。

所有的Hibernate内建类型,除了collections以外,都支持空(null)语义。

6.2.2. 基本值类型

The built-in basic mapping types may be roughly categorized into 内建的 基本映射类型可以大致分为

integer, long, short, float, double, character, byte, boolean, yes_no, true_false

这些类型都对应Java的原始类型或者其封装类,来符合(特定厂商的)SQL 字段类型。boolean, yes_notrue_false都是Java 中boolean 或者java.lang.Boolean的另外说法。

string

java.lang.StringVARCHAR (或者 Oracle的 VARCHAR2)的映射。

date, time, timestamp

java.util.Date和其子类到SQL类型DATE, TIMETIMESTAMP (或等价类型)的映射。

calendar, calendar_date

java.util.Calendar 到SQL 类型TIMESTAMPDATE(或等价类型)的映射。

big_decimal, big_integer

java.math.BigDecimaljava.math.BigIntegerNUMERIC (或者 Oracle 的NUMBER类型)的映射。

locale, timezone, currency

java.util.Locale, java.util.TimeZonejava.util.CurrencyVARCHAR (或者 Oracle 的VARCHAR2类型)的映射. LocaleCurrency 的实例被映射为它们的ISO代码。TimeZone的实例被影射为它的ID

class

java.lang.ClassVARCHAR (或者 Oracle 的VARCHAR2类型)的映射。Class被映射为它的全限定名。

binary

把字节数组(byte arrays)映射为对应的 SQL二进制类型。

text

把长Java字符串映射为SQL的CLOB或者TEXT类型。

serializable

把可序列化的Java类型映射到对应的SQL二进制类型。你也可以为一个并非默认为基本类型的可序列化Java类或者接口指定Hibernate类型serializable

clob, blob

JDBC 类 java.sql.Clobjava.sql.Blob的映射。某些程序可能不适合使用这个类型,因为blob和clob对象可能在一个事务之外是无法重用的。(而且, 驱动程序对这种类型的支持充满着补丁和前后矛盾。)

实体及其集合的唯一标识可以是除了binaryblobclob之外的任何基础类型。(联合标识也是允许的,后面会说到。)

org.hibernate.Hibernate中,定义了基础类型对应的Type常量。比如,Hibernate.STRING代表string 类型。

6.2.3. 自定义值类型

开发者创建属于他们自己的值类型也是很容易的。比如说,你可能希望持久化java.lang.BigInteger类型的属性,持久化成为VARCHAR字段。Hibernate没有内置这样一种类型。自定义类型能够映射一个属性(或集合元素)到不止一个数据库表字段。比如说,你可能有这样的Java属性:getName()/setName(),这是java.lang.String类型的,对应的持久化到三个字段:FIRST_NAME, INITIAL, SURNAME

要实现一个自定义类型,可以实现org.hibernate.UserTypeorg.hibernate.CompositeUserType中的任一个,并且使用类型的Java全限定类名来定义属性。请查看org.hibernate.test.DoubleStringType这个例子,看看它是怎么做的。

<property name="twoStrings" type="org.hibernate.test.DoubleStringType">    <column name="first_string"/>    <column name="second_string"/></property>

注意使用<column>标签来把一个属性映射到多个字段的做法。

CompositeUserType, EnhancedUserType, UserCollectionType, 和 UserVersionType 接口为更特殊的使用方式提供支持。

你甚至可以在一个映射文件中提供参数给一个UserType。 为了这样做,你的UserType必须实现org.hibernate.usertype.ParameterizedType接口。为了给自定义类型提供参数,你可以在映射文件中使用<type>元素。

<property name="priority">    <type name="com.mycompany.usertypes.DefaultValueIntegerType">        <param name="default">0</param>    </type></property>

现在,UserType 可以从传入的Properties对象中得到default 参数的值。

如果你非常频繁地使用某一UserType,可以为他定义一个简称。这可以通过使用 <typedef>元素来实现。Typedefs为一自定义类型赋予一个名称,并且如果此类型是参数化的,还可以包含一系列默认的参数值。

<typedef class="com.mycompany.usertypes.DefaultValueIntegerType" name="default_zero">    <param name="default">0</param></typedef>
<property name="priority" type="default_zero"/>

也可以根据具体案例通过属性映射中的类型参数覆盖在typedef中提供的参数。

尽管 Hibernate 内建的丰富的类型和对组件的支持意味着你可能很少 需要使用自定义类型。不过,为那些在你的应用中经常出现的(非实体)类使用自定义类型也是一个好方法。例如,一个MonetaryAmount类使用CompositeUserType来映射是不错的选择,虽然他可以很容易地被映射成组件。这样做的动机之一是抽象。使用自定义类型,以后假若你改变表示金额的方法时,它可以保证映射文件不需要修改。

6.3. SQL中引号包围的标识符

你可通过在映射文档中使用反向引号(`)把表名或者字段名包围起来,以强制Hibernate在生成的SQL中把标识符用引号包围起来。Hibernate会使用相应的SQLDialect(方言)来使用正确的引号风格(通常是双引号,但是在SQL Server中是括号,MySQL中是反向引号)。

<class name="LineItem" table="`Line Item`">    <id name="id" column="`Item Id`"/><generator class="assigned"/></id>    <property name="itemNumber" column="`Item #`"/>    ...</class>

6.4. 其他元数据(Metadata)

XML 并不适用于所有人, 因此有其他定义Hibernate O/R 映射元数据(metadata)的方法。

6.4.1. 使用 XDoclet 标记

很多Hibernate使用者更喜欢使用XDoclet@hibernate.tags将映射信息直接嵌入到源代码中。我们不会在本文档中涉及这个方法,因为严格说来,这属于XDoclet的一部分。然而,我们包含了如下使用XDoclet映射的Cat类的例子。

package eg;import java.util.Set;import java.util.Date;/** * @hibernate.class *  table="CATS" */public class Cat {    private Long id; // identifier    private Date birthdate;    private Cat mother;    private Set kittens    private Color color;    private char sex;    private float weight;    /*     * @hibernate.id     *  generator-class="native"     *  column="CAT_ID"     */    public Long getId() {        return id;    }    private void setId(Long id) {        this.id=id;    }    /**     * @hibernate.many-to-one     *  column="PARENT_ID"     */    public Cat getMother() {        return mother;    }    void setMother(Cat mother) {        this.mother = mother;    }    /**     * @hibernate.property     *  column="BIRTH_DATE"     */    public Date getBirthdate() {        return birthdate;    }    void setBirthdate(Date date) {        birthdate = date;    }    /**     * @hibernate.property     *  column="WEIGHT"     */    public float getWeight() {        return weight;    }    void setWeight(float weight) {        this.weight = weight;    }    /**     * @hibernate.property     *  column="COLOR"     *  not-null="true"     */    public Color getColor() {        return color;    }    void setColor(Color color) {        this.color = color;    }    /**     * @hibernate.set     *  inverse="true"     *  order-by="BIRTH_DATE"     * @hibernate.collection-key     *  column="PARENT_ID"     * @hibernate.collection-one-to-many     */    public Set getKittens() {        return kittens;    }    void setKittens(Set kittens) {        this.kittens = kittens;    }    // addKitten not needed by Hibernate    public void addKitten(Cat kitten) {        kittens.add(kitten);    }    /**     * @hibernate.property     *  column="SEX"     *  not-null="true"     *  update="false"     */    public char getSex() {        return sex;    }    void setSex(char sex) {        this.sex=sex;    }}

参考Hibernate网站更多的Xdoclet和Hibernate的例子

6.4.2. 使用 JDK 5.0 的注解(Annotation)

JDK 5.0 在语言级别引入了 XDoclet 风格的标注,并且是类型安全的,在编译期进行检查。这一机制比XDoclet的注解更为强大,有更好的工具和IDE支持。例如, IntelliJ IDEA,支持JDK 5.0注解的自动完成和语法高亮 。EJB规范的新修订版(JSR-220)使用 JDK 5.0的注解作为entity beans的主要元数据(metadata)机制。Hibernate 3 实现了JSR-220 (the persistence API)的EntityManager,支持通过Hibernate Annotations包定义映射元数据。这个包作为单独的部分下载,支持EJB3 (JSR-220)和Hibernate3的元数据。

这是一个被注解为EJB entity bean 的POJO类的例子

@Entity(access = AccessType.FIELD)public class Customer implements Serializable {    @Id;    Long id;    String firstName;    String lastName;    Date birthday;    @Transient    Integer age;    @Dependent    private Address homeAddress;    @OneToMany(cascade=CascadeType.ALL,               targetEntity="Order")    @JoinColumn(name="CUSTOMER_ID")    Set orders;    // Getter/setter and business methods}

注意:对 JDK 5.0 注解 (和 JSR-220)支持的工作仍然在进行中,并未完成。

第 7 章 集合类(Collections)映射

7.1. 持久化集合类(Persistent collections)

(译者注:在阅读本章的时候,以后整个手册的阅读过程中,我们都会面临一个名词方面的问题,那就是“集合”。"Collections"和"Set"在中文里对应都被翻译为“集合”,但是他们的含义很不一样。Collections是一个超集,Set是其中的一种。大部分情况下,本译稿中泛指的未加英文注明的“集合”,都应当理解为“Collections”。在有些二者同时出现,可能造成混淆的地方,我们用“集合类”来特指“Collecions”,“集合(Set)”来指"Set",一般都会在后面的括号中给出英文。希望大家在阅读时联系上下文理解,不要造成误解。 与此同时,“元素”一词对应的英文“element”,也有两个不同的含义。其一为集合的元素,是内存中的一个变量;另一含义则是XML文档中的一个标签所代表的元素。也请注意区别。 本章中,特别是后半部分是需要反复阅读才能理解清楚的。如果遇到任何疑问,请记住,英文版本的reference是惟一标准的参考资料。)

Hibernate要求持久化集合值字段必须声明为接口,比如:

public class Product {    private String serialNumber;    private Set parts = new HashSet();        public Set getParts() { return parts; }    void setParts(Set parts) { this.parts = parts; }    public String getSerialNumber() { return serialNumber; }    void setSerialNumber(String sn) { serialNumber = sn; }}

实际的接口可能是java.util.Set, java.util.Collection, java.util.List, java.util.Map, java.util.SortedSet, java.util.SortedMap 或者...任何你喜欢的类型!("任何你喜欢的类型" 代表你需要编写 org.hibernate.usertype.UserCollectionType的实现.)

注意我们是如何用一个HashSet实例来初始化实例变量的.这是用于初始化新创建(尚未持久化)的类实例中集合值属性的最佳方法。当你持久化这个实例时——比如通过调用persist()——Hibernate 会自动把HashSet替换为Hibernate自己的Set实现。观察下面的错误:

Cat cat = new DomesticCat();Cat kitten = new DomesticCat();....Set kittens = new HashSet();kittens.add(kitten);cat.setKittens(kittens);session.persist(cat);kittens = cat.getKittens(); //Okay, kittens collection is a Set(HashSet) cat.getKittens(); //Error!

根据不同的接口类型,被Hibernate注射的持久化集合类的表现类似HashMap, HashSet, TreeMap, TreeSet or ArrayList

集合类实例具有值类型的通常行为。当被持久化对象引用后,他们会自动被持久化,当不再被引用后,自动被删除。假若实例被从一个持久化对象传递到另一个,它的元素可能从一个表转移到另一个表。两个实体不能共享同一个集合类实例的引用。因为底层关系数据库模型的原因,集合值属性无法支持空值语义;Hibernate对空的集合引用和空集合不加区别。

你不需要过多的为此担心。就如同你平时使用普通的Java集合类一样来使用持久化集合类。只是要确认你理解了双向关联的语义(后文讨论)。

7.2. 集合映射( Collection mappings )

用于映射集合类的Hibernate映射元素取决于接口的类型。比如, <set> 元素用来映射Set类型的属性。

<class name="Product">    <id name="serialNumber" column="productSerialNumber"/>    <set name="parts">        <key column="productSerialNumber" not-null="true"/>        <one-to-many class="Part"/>    </set></class>

除了<set>,还有<list>, <map>, <bag>, <array><primitive-array> 映射元素。<map>具有代表性:

<map    name="propertyName"                                         (1)    table="table_name"                                          (2)    schema="schema_name"                                        (3)    lazy="true|false"                                           (4)    inverse="true|false"                                        (5)    cascade="all|none|save-update|delete|all-delete-orphan"     (6)    sort="unsorted|natural|comparatorClass"                     (7)    order-by="column_name asc|desc"                             (8)    where="arbitrary sql where condition"                       (9)    fetch="join|select|subselect"                               (10)    batch-size="N"                                              (11)    access="field|property|ClassName"                           (12)    optimistic-lock="true|false"                                (13)    node="element-name|."    embed-xml="true|false">    <key .... />    <map-key .... />    <element .... /></map>
(1)

name 集合属性的名称

(2)

table (可选——默认为属性的名称)这个集合表的名称(不能在一对多的关联关系中使用)

(3)

schema (可选) 表的schema的名称, 他将覆盖在根元素中定义的schema

(4)

lazy (可选--默认为true) 可以用来关闭延迟加载,指定一直使用预先抓取(对数组不适用)

(5)

inverse (可选——默认为false) 标记这个集合作为双向关联关系中的方向一端。

(6)

cascade (可选——默认为none) 让操作级联到子实体

(7)

sort(可选)指定集合的排序顺序, 其可以为自然的(natural)或者给定一个用来比较的类。

(8)

order-by (可选, 仅用于jdk1.4) 指定表的字段(一个或几个)再加上asc或者desc(可选), 定义Map,Set和Bag的迭代顺序

(9)

where (可选) 指定任意的SQL where条件, 该条件将在重新载入或者删除这个集合时使用(当集合中的数据仅仅是所有可用数据的一个子集时这个条件非常有用)

(10)

fetch (可选, 默认为select) 用于在外连接抓取、通过后续select抓取和通过后续subselect抓取之间选择。

(11)

batch-size (可选, 默认为1) 指定通过延迟加载取得集合实例的批处理块大小("batch size")。

(12)

access(可选-默认为属性property):Hibernate取得属性值时使用的策略

(12)

乐观锁 (可选 - 默认为 true): 对集合的状态的改变会是否导致其所属的实体的版本增长。 (对一对多关联来说,关闭这个属性常常是有理的)

7.2.1. 集合外键(Collection foreign keys)

集合实例在数据库中依靠持有集合的实体的外键加以辨别。此外键作为集合关键字段(collection key column)(或多个字段)加以引用。集合关键字段通过<key> 元素映射。

在外键字段上可能具有非空约束。对于大多数集合来说,这是隐含的。对单向一对多关联来说,外键字段默认是可以为空的,因此你可能需要指明 not-null="true"

<key column="productSerialNumber" not-null="true"/>

外键约束可以使用ON DELETE CASCADE

<key column="productSerialNumber" on-delete="cascade"/>

<key> 元素的完整定义,请参阅前面的章节。

7.2.2. 集合元素(Collection elements)

集合几乎可以包含任何其他的Hibernate类型,包括所有的基本类型、自定义类型、组件,当然还有对其他实体的引用。存在一个重要的区别:位于集合中的对象可能是根据“值”语义来操作(其声明周期完全依赖于集合持有者),或者它可能是指向另一个实体的引用,具有其自己的生命周期。在后者的情况下,被作为集合持有的状态考虑的,只有两个对象之间的“连接”。

被包容的类型被称为集合元素类型(collection element type)。集合元素通过<element><composite-element>映射,或在其是实体引用的时候,通过<one-to-many><many-to-many>映射。前两种用于使用值语义映射元素,后两种用于映射实体关联。

7.2.3. 索引集合类(Indexed collections)

所有的集合映射,除了set和bag语义的以外,都需要指定一个集合表的索引字段(index column)——用于对应到数组索引,或者List的索引,或者Map的关键字。通过<map-key>,Map 的索引可以是任何基础类型;若通过<map-key-many-to-many>,它也可以是一个实体引用;若通过<composite-map-key>,它还可以是一个组合类型。数组或列表的索引必须是integer类型,并且使用 <list-index>元素定义映射。被映射的字段包含有顺序排列的整数(默认从0开始)。

<map-key         column="column_name"                (1)        formula="any SQL expression"        (2)        type="type_name"                    (3)        node="@attribute-name"        length="N"/>
(1)

column(可选):保存集合索引值的字段名。

(2)

formula (可选): 用于计算map关键字的SQL公式

(3)

type (可选,默认为整型integer):集合索引的类型。

<map-key-many-to-many        column="column_name"                (1)        formula="any SQL expression"        (2)(3)        class="ClassName"/>
(1)

column(可选):集合索引值中外键字段的名称

(2)

formula (可选): 用于计算map关键字的外键的SQL公式

(3)

class (必需):集合的索引使用的实体类。

假若你的表没有一个索引字段,当你仍然希望使用List作为属性类型,你应该把此属性映射为Hibernate <bag>。从数据库中获取的时候,bag不维护其顺序,但也可选择性的进行排序。

从集合类可以产生很大一部分映射,覆盖了很多常见的关系模型。我们建议你试验schema生成工具,来体会一下不同的映射声明是如何被翻译为数据库表的。

7.2.4. 值集合于多对多关联(Collections of values and many-to-many associations)

任何值集合或者多对多关联需要专用的具有一个或多个外键字段的collection table、一个或多个collection element column,以及还可能有一个或多个索引字段。

对于一个值集合, 我们使用<element>标签。

<element        column="column_name"                     (1)        formula="any SQL expression"             (2)        type="typename"                          (3)        length="N"        precision="N"        scale="N"        not-null="true|false"        unique="true|false"        node="element-name"/>
(1)

column(可选):保存集合元素值的字段名。

(2)

formula (可选): 用于计算元素的SQL公式

(3)

type (必需):集合元素的类型

多对多关联(many-to-many association) 使用 <many-to-many>元素定义.

<many-to-many        column="column_name"                               (1)        formula="any SQL expression"                       (2)        class="ClassName"                                  (3)        fetch="select|join"                                (4)        unique="true|false"                                (5)        not-found="ignore|exception"                       (6)        entity-name="EntityName"                           (7)        node="element-name"        embed-xml="true|false"    />
(1)

column(可选): 这个元素的外键关键字段名

(2)

formula (可选): 用于计算元素外键值的SQL公式.

(3)

class (必需): 关联类的名称

(3)

outer-join (可选 - 默认为auto): 在Hibernate系统参数中hibernate.use_outer_join被打开的情况下,该参数用来允许使用outer join来载入此集合的数据。

(4)

为此关联打开外连接抓取或者后续select抓取。这是特殊情况;对于一个实体及其指向其他实体的多对多关联进全预先抓取(使用一条单独的SELECT),你不仅需要对集合自身打开join,也需要对<many-to-many>这个内嵌元素打开此属性。

(5)

对外键字段允许DDL生成的时候生成一个惟一约束。这使关联变成了一个高效的一对多关联。(此句存疑:原文为This makes the association multiplicity effectively one to many.)

(6)

not-found (可选 - 默认为 exception): 指明引用的外键中缺少某些行该如何处理: ignore 会把缺失的行作为一个空引用处理。

(7)

entity-name (可选): 被关联的类的实体名,作为class的替代。

例子:首先, 一组字符串:

<set name="names" table="NAMES">    <key column="GROUPID"/>    <element column="NAME" type="string"/></set>

包含一组整数的bag(还设置了order-by参数指定了迭代的顺序):

<bag name="sizes"         table="item_sizes"         order-by="size asc">    <key column="item_id"/>    <element column="size" type="integer"/></bag>

一个实体数组,在这个案例中是一个多对多的关联(注意这里的实体是自动管理生命周期的对象(lifecycle objects),cascade="all"):

<array name="addresses"         table="PersonAddress"         cascade="persist">    <key column="personId"/>    <list-index column="sortOrder"/>    <many-to-many column="addressId" class="Address"/></array>

一个map,通过字符串的索引来指明日期:

<map name="holidays"         table="holidays"         schema="dbo"         order-by="hol_name asc">    <key column="id"/>    <map-key column="hol_name" type="string"/>    <element column="hol_date" type="date"/></map>

一个组件的列表:(下一章讨论)

<list name="carComponents"         table="CarComponents">    <key column="carId"/>    <list-index column="sortOrder"/>    <composite-element class="CarComponent">        <property name="price"/>        <property name="type"/>        <property name="serialNumber" column="serialNum"/>    </composite-element></list>

7.2.5. 一对多关联(One-to-many Associations)

一对多关联 通过外键 连接两个类对应的表,而没有中间集合表。 这个关系模型失去了一些Java集合的语义:

  • 一个被包含的实体的实例只能被包含在一个集合的实例中

  • 一个被包含的实体的实例只能对应于集合索引的一个值中

一个从ProductPart的关联需要关键字字段,可能还有一个索引字段指向Part所对应的表。 <one-to-many>标记指明了一个一对多的关联。

<one-to-many         class="ClassName"                                  (1)        not-found="ignore|exception"                       (2)        entity-name="EntityName"                           (3)        node="element-name"        embed-xml="true|false"    />
(1)

class(必须):被关联类的名称。

(2)

not-found (可选 - 默认为exception): 指明若缓存的标示值关联的行缺失,该如何处理: ignore 会把缺失的行作为一个空关联处理。

(3)

entity-name (可选): 被关联的类的实体名,作为class的替代。

例子

<set name="bars">    <key column="foo_id"/>    <one-to-many class="org.hibernate.Bar"/></set>

注意:<one-to-many>元素不需要定义任何字段。 也不需要指定表名。

重要提示 :如果一对多关联中的外键字段定义成NOT NULL,你必须把<key>映射声明为not-null="true",或者使用双向关联,并且标明inverse="true"。参阅本章后面关于双向关联的讨论。

下面的例子展示一个Part实体的map,把name作为关键字。( partNamePart的持久化属性)。注意其中的基于公式的索引的用法。

<map name="parts"        cascade="all">    <key column="productId" not-null="true"/>    <map-key formula="partName"/>    <one-to-many class="Part"/></map>

7.3. 高级集合映射(Advanced collection mappings)

7.3.1. 有序集合(Sorted collections)

Hibernate支持实现java.util.SortedMapjava.util.SortedSet的集合。你必须在映射文件中指定一个比较器:

<set name="aliases"             table="person_aliases"             sort="natural">    <key column="person"/>    <element column="name" type="string"/></set><map name="holidays" sort="my.custom.HolidayComparator">    <key column="year_id"/>    <map-key column="hol_name" type="string"/>    <element column="hol_date" type="date"/></map>

sort属性中允许的值包括unsorted,natural和某个实现了java.util.Comparator的类的名称。

分类集合的行为事实上象java.util.TreeSet或者java.util.TreeMap

如果你希望数据库自己对集合元素排序,可以利用set,bag或者map映射中的order-by属性。这个解决方案只能在jdk1.4或者更高的jdk版本中才可以实现(通过LinkedHashSet或者 LinkedHashMap实现)。 它是在SQL查询中完成排序,而不是在内存中。

<set name="aliases" table="person_aliases" order-by="lower(name) asc">    <key column="person"/>    <element column="name" type="string"/></set><map name="holidays" order-by="hol_date, hol_name">    <key column="year_id"/>    <map-key column="hol_name" type="string"/>    <element column="hol_date" type="date"/></map>

注意: 这个order-by属性的值是一个SQL排序子句而不是HQL的!

关联还可以在运行时使用集合filter()根据任意的条件来排序。

sortedUsers = s.createFilter( group.getUsers(), "order by this.name" ).list();

7.3.2. 双向关联(Bidirectional associations)

双向关联 允许通过关联的任一端访问另外一端。在Hibernate中, 支持两种类型的双向关联:

一对多(one-to-many)

Set或者bag值在一端, 单独值(非集合)在另外一端

多对多(many-to-many)

两端都是set或bag值

要建立一个双向的多对多关联,只需要映射两个many-to-many关联到同一个数据库表中,并再定义其中的一端为inverse(使用哪一端要根据你的选择,但它不能是一个索引集合)。

这里有一个many-to-many的双向关联的例子;每一个category都可以有很多items,每一个items可以属于很多categories:

<class name="Category">    <id name="id" column="CATEGORY_ID"/>    ...    <bag name="items" table="CATEGORY_ITEM">        <key column="CATEGORY_ID"/>        <many-to-many class="Item" column="ITEM_ID"/>    </bag></class><class name="Item">    <id name="id" column="CATEGORY_ID"/>    ...    <!-- inverse end -->    <bag name="categories" table="CATEGORY_ITEM" inverse="true">        <key column="ITEM_ID"/>        <many-to-many class="Category" column="CATEGORY_ID"/>    </bag></class>

如果只对关联的反向端进行了改变,这个改变不会被持久化。 这表示Hibernate为每个双向关联在内存中存在两次表现,一个从A连接到B,另一个从B连接到A。如果你回想一下Java对象模型,我们是如何在Java中创建多对多关系的,这可以让你更容易理解:

category.getItems().add(item);          // The category now "knows" about the relationshipitem.getCategories().add(category);     // The item now "knows" about the relationshipsession.persist(item);                   // The relationship won''t be saved!session.persist(category);               // The relationship will be saved

非反向端用于把内存中的表示保存到数据库中。

要建立一个一对多的双向关联,你可以通过把一个一对多关联,作为一个多对一关联映射到到同一张表的字段上,并且在"多"的那一端定义inverse="true"

<class name="Parent">    <id name="id" column="parent_id"/>    ....    <set name="children" inverse="true">        <key column="parent_id"/>        <one-to-many class="Child"/>    </set></class><class name="eg.Child">    <id name="id" column="id"/>    ....    <many-to-one name="parent"         class="Parent"         column="parent_id"        not-null="true"/></class>

在“一”这一端定义inverse="true"不会影响级联操作,二者是正交的概念!

7.3.3. 三重关联(Ternary associations)

有三种可能的途径来映射一个三重关联。第一种是使用一个Map,把一个关联作为其索引:

<map name="contracts">    <key column="employer_id" not-null="true"/>    <map-key-many-to-many column="employee_id" class="Employee"/>    <one-to-many class="Contract"/></map>
<map name="connections">    <key column="incoming_node_id"/>    <map-key-many-to-many column="outgoing_node_id" class="Node"/>    <many-to-many column="connection_id" class="Connection"/></map>

第二种方法是简单的把关联重新建模为一个实体类。这使我们最经常使用的方法。

最后一种选择是使用复合元素,我们会在后面讨论

7.3.4. 使用<idbag>

如果你完全信奉我们对于“联合主键(composite keys)是个坏东西”,和“实体应该使用(无机的)自己生成的代用标识符(surrogate keys)”的观点,也许你会感到有一些奇怪,我们目前为止展示的多对多关联和值集合都是映射成为带有联合主键的表的!现在,这一点非常值得争辩;看上去一个单纯的关联表并不能从代用标识符中获得什么好处(虽然使用组合值的集合可能会获得一点好处)。不过,Hibernate提供了一个(一点点试验性质的)功能,让你把多对多关联和值集合应得到一个使用代用标识符的表去。

<idbag> 属性让你使用bag语义来映射一个List (或Collection)。

<idbag name="lovers" table="LOVERS">    <collection-id column="ID" type="long">        <generator class="sequence"/>    </collection-id>    <key column="PERSON1"/>    <many-to-many column="PERSON2" class="eg.Person" outer-join="true"/></idbag>

你可以理解,<idbag>人工的id生成器,就好像是实体类一样!集合的每一行都有一个不同的人造关键字。但是,Hibernate没有提供任何机制来让你取得某个特定行的人造关键字。

注意<idbag>的更新性能要比普通的<bag>高得多!Hibernate可以有效的定位到不同的行,分别进行更新或删除工作,就如同处理一个list, map或者set一样。

在目前的实现中,还不支持使用identity标识符生成器策略来生成<idbag>集合的标识符。

7.4. 集合例子(Collection example)

在前面的几个章节的确非常令人迷惑。 因此让我们来看一个例子。这个类:

package eg;import java.util.Set;public class Parent {    private long id;    private Set children;    public long getId() { return id; }    private void setId(long id) { this.id=id; }    private Set getChildren() { return children; }    private void setChildren(Set children) { this.children=children; }    ....    ....}

这个类有一个Child的实例集合。如果每一个子实例至多有一个父实例, 那么最自然的映射是一个one-to-many的关联关系:

<hibernate-mapping>    <class name="Parent">        <id name="id">            <generator class="sequence"/>        </id>        <set name="children">            <key column="parent_id"/>            <one-to-many class="Child"/>        </set>    </class>    <class name="Child">        <id name="id">            <generator class="sequence"/>        </id>        <property name="name"/>    </class></hibernate-mapping>

在以下的表定义中反应了这个映射关系:

create table parent ( id bigint not null primary key )create table child ( id bigint not null primary key, name varchar(255), parent_id bigint )alter table child add constraint childfk0 (parent_id) references parent

如果父亲是必须的, 那么就可以使用双向one-to-many的关联了:

<hibernate-mapping>    <class name="Parent">        <id name="id">            <generator class="sequence"/>        </id>        <set name="children" inverse="true">            <key column="parent_id"/>            <one-to-many class="Child"/>        </set>    </class>    <class name="Child">        <id name="id">            <generator class="sequence"/>        </id>        <property name="name"/>        <many-to-one name="parent" class="Parent" column="parent_id" not-null="true"/>    </class></hibernate-mapping>

请注意NOT NULL的约束:

create table parent ( id bigint not null primary key )create table child ( id bigint not null                     primary key,                     name varchar(255),                     parent_id bigint not null )alter table child add constraint childfk0 (parent_id) references parent

另外,如果你绝对坚持这个关联应该是单向的,你可以对<key>映射声明NOT NULL约束:

<hibernate-mapping>    <class name="Parent">        <id name="id">            <generator class="sequence"/>        </id>        <set name="children">            <key column="parent_id" not-null="true"/>            <one-to-many class="Child"/>        </set>    </class>    <class name="Child">        <id name="id">            <generator class="sequence"/>        </id>        <property name="name"/>    </class></hibernate-mapping>

另外一方面,如果一个子实例可能有多个父实例, 那么就应该使用many-to-many关联:

<hibernate-mapping>    <class name="Parent">        <id name="id">            <generator class="sequence"/>        </id>        <set name="children" table="childset">            <key column="parent_id"/>            <many-to-many class="Child" column="child_id"/>        </set>    </class>    <class name="Child">        <id name="id">            <generator class="sequence"/>        </id>        <property name="name"/>    </class></hibernate-mapping>

表定义:

create table parent ( id bigint not null primary key )create table child ( id bigint not null primary key, name varchar(255) )create table childset ( parent_id bigint not null,                        child_id bigint not null,                        primary key ( parent_id, child_id ) )alter table childset add constraint childsetfk0 (parent_id) references parentalter table childset add constraint childsetfk1 (child_id) references child

更多的例子,以及一个完整的父/子关系映射的排练,请参阅第 22 章 示例:父子关系(Parent Child Relationships).

甚至可能出现更加复杂的关联映射,我们会在下一章中列出所有可能性。

第 8 章 关联关系映射

8.1. 介绍

关联关系映射通常情况是最难配置正确的。在这个部分中,我们从单向关系映射开始,然后考虑双向关系映射,由浅至深讲述一遍典型的案例。在所有的例子中,我们都使用 PersonAddress

我们根据映射关系是否涉及连接表以及多样性来划分关联类型。

在传统的数据建模中,允许为Null值的外键被认为是一种不好的实践,因此我们所有的例子中都使用不允许为Null的外键。这并不是Hibernate的要求,即使你删除掉不允许为Null的约束,Hibernate映射一样可以工作的很好。

8.2. 单向关联(Unidirectional associations)

8.2.1. 多对一(many to one)

单向many-to-one关联 是最常见的单向关联关系。

<class name="Person">    <id name="id" column="personId">        <generator class="native"/>    </id>    <many-to-one name="address"         column="addressId"        not-null="true"/></class><class name="Address">    <id name="id" column="addressId">        <generator class="native"/>    </id></class>
create table Person ( personId bigint not null primary key, addressId bigint not null )create table Address ( addressId bigint not null primary key )        

8.2.2. 一对一(one to one)

基于外键关联的单向一对一关联 单向多对一关联几乎是一样的。唯一的不同就是单向一对一关联中的外键字段具有唯一性约束。

<class name="Person">    <id name="id" column="personId">        <generator class="native"/>    </id>    <many-to-one name="address"         column="addressId"         unique="true"        not-null="true"/></class><class name="Address">    <id name="id" column="addressId">        <generator class="native"/>    </id></class>
create table Person ( personId bigint not null primary key, addressId bigint not null unique )create table Address ( addressId bigint not null primary key )        

基于主键关联的单向一对一关联 通常使用一个特定的id生成器。(请注意,在这个例子中我们掉换了关联的方向。)

<class name="Person">    <id name="id" column="personId">        <generator class="native"/>    </id></class><class name="Address">    <id name="id" column="personId">        <generator class="foreign">            <param name="property">person</param>        </generator>    </id>    <one-to-one name="person" constrained="true"/></class>
create table Person ( personId bigint not null primary key )create table Address ( personId bigint not null primary key )        

8.2.3. 一对多(one to many)

基于外键关联的单向一对多关联 是一种很少见的情况,并不推荐使用。

<class name="Person">    <id name="id" column="personId">        <generator class="native"/>    </id>    <set name="addresses">        <key column="personId"             not-null="true"/>        <one-to-many class="Address"/>    </set></class><class name="Address">    <id name="id" column="addressId">        <generator class="native"/>    </id></class>
create table Person ( personId bigint not null primary key )create table Address ( addressId bigint not null primary key, personId bigint not null )        

我们认为对于这种关联关系最好使用连接表。

8.3. 使用连接表的单向关联(Unidirectional associations with join tables)

8.3.1. 一对多(one to many)

基于连接表的单向一对多关联 应该优先被采用。请注意,通过指定unique="true",我们可以把多样性从多对多改变为一对多。

<class name="Person">    <id name="id" column="personId">        <generator class="native"/>    </id>    <set name="addresses" table="PersonAddress">        <key column="personId"/>        <many-to-many column="addressId"            unique="true"            class="Address"/>    </set></class><class name="Address">    <id name="id" column="addressId">        <generator class="native"/>    </id></class>
create table Person ( personId bigint not null primary key )create table PersonAddress ( personId not null, addressId bigint not null primary key )create table Address ( addressId bigint not null primary key )        

8.3.2. 多对一(many to one)

基于连接表的单向多对一关联 在关联关系可选的情况下应用也很普遍。

<class name="Person">    <id name="id" column="personId">        <generator class="native"/>    </id>    <join table="PersonAddress"         optional="true">        <key column="personId" unique="true"/>        <many-to-one name="address"            column="addressId"             not-null="true"/>    </join></class><class name="Address">    <id name="id" column="addressId">        <generator class="native"/>    </id></class>
create table Person ( personId bigint not null primary key )create table PersonAddress ( personId bigint not null primary key, addressId bigint not null )create table Address ( addressId bigint not null primary key )        

8.3.3. 一对一(one to one)

基于连接表的单向一对一关联 非常少见,但也是可行的。

<class name="Person">    <id name="id" column="personId">        <generator class="native"/>    </id>    <join table="PersonAddress"         optional="true">        <key column="personId"             unique="true"/>        <many-to-one name="address"            column="addressId"             not-null="true"            unique="true"/>    </join></class><class name="Address">    <id name="id" column="addressId">        <generator class="native"/>    </id></class>
create table Person ( personId bigint not null primary key )create table PersonAddress ( personId bigint not null primary key, addressId bigint not null unique )create table Address ( addressId bigint not null primary key )        

8.3.4. 多对多(many to many)

最后,还有 单向多对多关联.

<class name="Person">    <id name="id" column="personId">        <generator class="native"/>    </id>    <set name="addresses" table="PersonAddress">        <key column="personId"/>        <many-to-many column="addressId"            class="Address"/>    </set></class><class name="Address">    <id name="id" column="addressId">        <generator class="native"/>    </id></class>
create table Person ( personId bigint not null primary key )create table PersonAddress ( personId bigint not null, addressId bigint not null, primary key (personId, addressId) )create table Address ( addressId bigint not null primary key )        

8.4. 双向关联(Bidirectional associations)

8.4.1. 一对多(one to many) / 多对一(many to one)

双向多对一关联 是最常见的关联关系。(这也是标准的父/子关联关系。)

<class name="Person">    <id name="id" column="personId">        <generator class="native"/>    </id>    <many-to-one name="address"         column="addressId"        not-null="true"/></class><class name="Address">    <id name="id" column="addressId">        <generator class="native"/>    </id>    <set name="people" inverse="true">        <key column="addressId"/>        <one-to-many class="Person"/>    </set></class>
create table Person ( personId bigint not null primary key, addressId bigint not null )create table Address ( addressId bigint not null primary key )        

8.4.2. 一对一(one to one)

基于外键关联的双向一对一关联 也很常见。

<class name="Person">    <id name="id" column="personId">        <generator class="native"/>    </id>    <many-to-one name="address"         column="addressId"         unique="true"        not-null="true"/></class><class name="Address">    <id name="id" column="addressId">        <generator class="native"/>    </id>   <one-to-one name="person"         property-ref="address"/></class>
create table Person ( personId bigint not null primary key, addressId bigint not null unique )create table Address ( addressId bigint not null primary key )        

基于主键关联的一对一关联 需要使用特定的id生成器。

<class name="Person">    <id name="id" column="personId">        <generator class="native"/>    </id>    <one-to-one name="address"/></class><class name="Address">    <id name="id" column="personId">        <generator class="foreign">            <param name="property">person</param>        </generator>    </id>    <one-to-one name="person"         constrained="true"/></class>
create table Person ( personId bigint not null primary key )create table Address ( personId bigint not null primary key )        

8.5. 使用连接表的双向关联(Bidirectional associations with join tables)

8.5.1. 一对多(one to many) /多对一( many to one)

基于连接表的双向一对多关联 。注意inverse="true"可以出现在关联的任意一端,即collection端或者join端。

<class name="Person">    <id name="id" column="personId">        <generator class="native"/>    </id>    <set name="addresses"         table="PersonAddress">        <key column="personId"/>        <many-to-many column="addressId"            unique="true"            class="Address"/>    </set></class><class name="Address">    <id name="id" column="addressId">        <generator class="native"/>    </id>    <join table="PersonAddress"         inverse="true"         optional="true">        <key column="addressId"/>        <many-to-one name="person"            column="personId"            not-null="true"/>    </join></class>
create table Person ( personId bigint not null primary key )create table PersonAddress ( personId bigint not null, addressId bigint not null primary key )create table Address ( addressId bigint not null primary key )        

8.5.2. 一对一(one to one)

基于连接表的双向一对一关联 极为罕见,但也是可行的。

<class name="Person">    <id name="id" column="personId">        <generator class="native"/>    </id>    <join table="PersonAddress"         optional="true">        <key column="personId"             unique="true"/>        <many-to-one name="address"            column="addressId"             not-null="true"            unique="true"/>    </join></class><class name="Address">    <id name="id" column="addressId">        <generator class="native"/>    </id>    <join table="PersonAddress"         optional="true"        inverse="true">        <key column="addressId"             unique="true"/>        <many-to-one name="address"            column="personId"             not-null="true"            unique="true"/>    </join></class>
create table Person ( personId bigint not null primary key )create table PersonAddress ( personId bigint not null primary key, addressId bigint not null unique )create table Address ( addressId bigint not null primary key )        

8.5.3. 多对多(many to many)

最后,还有 双向多对多关联.

<class name="Person">    <id name="id" column="personId">        <generator class="native"/>    </id>    <set name="addresses">        <key column="personId"/>        <many-to-many column="addressId"            class="Address"/>    </set></class><class name="Address">    <id name="id" column="addressId">        <generator class="native"/>    </id>    <set name="people" inverse="true">        <key column="addressId"/>        <many-to-many column="personId"            class="Person"/>    </set></class>
create table Person ( personId bigint not null primary key )create table PersonAddress ( personId bigint not null, addressId bigint not null, primary key (personId, addressId) )create table Address ( addressId bigint not null primary key )        

第 9 章 组件(Component)映射

Component 这个概念在Hibernate中几处不同的地方为了不同的目的被重复使用.

9.1. 依赖对象(Dependent objects)

Component是一个被包含的对象,它作为值类型被持久化,而非一个被引用的实体。“component(组件)”这一术语指的是面向对象的合成概念(而并不是系统构架层次上的组件的概念)举个例子, 你可以对人(Person)如以下这样来建模:

public class Person {    private java.util.Date birthday;    private Name name;    private String key;    public String getKey() {        return key;    }    private void setKey(String key) {        this.key=key;    }    public java.util.Date getBirthday() {        return birthday;    }    public void setBirthday(java.util.Date birthday) {        this.birthday = birthday;    }    public Name getName() {        return name;    }    public void setName(Name name) {        this.name = name;    }    ......    ......}
public class Name {    char initial;    String first;    String last;    public String getFirst() {        return first;    }    void setFirst(String first) {        this.first = first;    }    public String getLast() {        return last;    }    void setLast(String last) {        this.last = last;    }    public char getInitial() {        return initial;    }    void setInitial(char initial) {        this.initial = initial;    }}

现在,姓名(Name)是作为人(Person)的一个组成部分。需要注意的是:需要对姓名 的持久化属性定义getter和setter方法,但是不需要实现任何的接口或申明标识符字段。

以下是这个例子的Hibernate映射文件:

<class name="eg.Person" table="person">    <id name="Key" column="pid" type="string">        <generator class="uuid.hex"/>    </id>    <property name="birthday" type="date"/>    <component name="Name" class="eg.Name"> <!-- class attribute optional -->        <property name="initial"/>        <property name="first"/>        <property name="last"/>    </component></class>

人员(Person)表中将包括pid, birthday, initial, firstlast等字段。

就像所有的值类型一样, Component不支持共享引用。 换句话说,两个人可能重名,但是两个person对象应该包含两个独立的name对象,只不过是具有“同样”的值。 Component的值为空从语义学上来讲是专有的(ad hoc)。 每当 重新加载一个包含组件的对象,如果component的所有字段为空,那么将Hibernate将假定整个component为 空。对于绝大多数目的,这样假定是没有问题的。

Component的属性可以是Hibernate类型(包括Collections, many-to-one 关联, 以及其它Component 等等)。嵌套Component不应该作为特殊的应用被考虑(Nested components should not be considered an exotic usage)。 Hibernate趋向于支持设计细致(fine-grained)的对象模型。

<component> 元素还允许有 <parent>子元素 ,用来表明component类中的一个属性返回包含它的实体的引用。

<class name="eg.Person" table="person">    <id name="Key" column="pid" type="string">        <generator class="uuid.hex"/>    </id>    <property name="birthday" type="date"/>    <component name="Name" class="eg.Name" unique="true">>        <parent name="namedPerson"/> <!-- reference back to the Person -->        <property name="initial"/>        <property name="first"/>        <property name="last"/>    </component></class>

9.2. 在集合中出现的依赖对象

Hibernate支持component的集合(例如: 一个元素是“姓名”这种类型的数组)。 你可以使用<composite-element>标签替代<element>标签来定义你的component集合。

<set name="someNames" table="some_names" lazy="true">    <key column="id"/>    <composite-element class="eg.Name"> <!-- class attribute required -->        <property name="initial"/>        <property name="first"/>        <property name="last"/>    </composite-element></set>

注意,如果你决定定义一个元素是联合元素的Set,正确地实现equals()hashCode()是非常重要的。

组合元素可以包含component但是不能包含集合。如果你的组合元素自身包含component, 必须使用<nested-composite-element>标签。这是一个相当特殊的案例 - 组合元素的集合自身可以包含component。 这个时候你就应该考虑一下使用one-to-many关联是否会更恰当。 尝试对这个组合元素重新建模为一个实体-但是需要注意的是,虽然Java模型和重新建模前 是一样的,关系模型和持久性语义上仍然存在轻微的区别。

请注意如果你使用<set>标签,一个组合元素的映射不支持可能为空的属性. 当删除对象时, Hibernate必须使用每一个字段的来确定一条记录(在组合元素表中,没有单个的关键字段), 如果有为null的字段,这样做就不可能了。你必须作出一个选择,要么在组合元素中使用不能为空的属性, 要么选择使用<list>, <map>,<bag> 或者 <idbag>而不是 <set>

组合元素有个特别的案例,是组合元素可以包含一个<many-to-one> 元素。类似这样的映射允许你映射一个many-to-mang关联表作为组合元素额外的字段。(A mapping like this allows you to map extra columns of a many-to-many association table to the composite element class.) 接下来的的例子是从OrderItem的一个多对多的关联关系,而 purchaseDate, pricequantityItem的关联属性。

<class name="eg.Order" .... >    ....    <set name="purchasedItems" table="purchase_items" lazy="true">        <key column="order_id">        <composite-element class="eg.Purchase">            <property name="purchaseDate"/>            <property name="price"/>            <property name="quantity"/>            <many-to-one name="item" class="eg.Item"/> <!-- class attribute is optional -->        </composite-element>    </set></class>

当然,在另一方面,无法存在指向purchase的关联,因此不能实现双向关联查询。记住组建是值类型,并且不允许共享关联。单个Purchase 可以放在包含Order的集合中,但它不能同时被Item所关联。

即使三重或多重管理都是可能的:

<class name="eg.Order" .... >    ....    <set name="purchasedItems" table="purchase_items" lazy="true">        <key column="order_id">        <composite-element class="eg.OrderLine">            <many-to-one name="purchaseDetails" class="eg.Purchase"/>            <many-to-one name="item" class="eg.Item"/>        </composite-element>    </set></class>

在查询中,组合元素使用的语法是和关联到其他实体的语法一样的。

9.3. 组件作为Map的索引(Components as Map indices )

<composite-map-key>元素允许你映射一个Component类作为Map的key, 但是你必须确定你正确的在这个类中重写了hashCode()equals()方法。

9.4. 组件作为联合标识符(Components as composite identifiers)

你可以使用一个component作为一个实体类的标识符。 你的component类必须满足以下要求:

  • 它必须实现java.io.Serializable接口

  • 它必须重新实现equals()hashCode()方法, 始终和组合关键字在数据库中的概念保持一致

注意:在Hibernate3中,第二种要求并非是Hibernate强制必须的。但最好这样做。

你不能使用一个IdentifierGenerator产生组合关键字。作为替代应用程序必须分配它自己的标识符。

使用<composite-id> 标签(并且内嵌<key-property>元素)代替通常的<id>标签。 比如,OrderLine类具有一个依赖Order的(联合)主键的主键。

<class name="OrderLine">        <composite-id name="id" class="OrderLineId">        <key-property name="lineId"/>        <key-property name="orderId"/>        <key-property name="customerId"/>    </composite-id>        <property name="name"/>        <many-to-one name="order" class="Order"            insert="false" update="false">        <column name="orderId"/>        <column name="customerId"/>    </many-to-one>    ....    </class>

现在,任何关联到OrderLine 的外键都是复合的。在你的映射文件中,必须为其他类也这样声明。指向OrderLine的关联可能被这样映射:

<many-to-one name="orderLine" class="OrderLine"><!-- the "class" attribute is optional, as usual -->    <column name="lineId"/>    <column name="orderId"/>    <column name="customerId"/></many-to-one>

(注意在各个地方<column>标签都是column属性的替代写法。)

指向OrderLine多对多关联也使用联合外键:

<set name="undeliveredOrderLines">    <key column name="warehouseId"/>    <many-to-many class="OrderLine">        <column name="lineId"/>        <column name="orderId"/>        <column name="customerId"/>    </many-to-many></set>

Order中, OrderLine的集合则是这样:

<set name="orderLines" inverse="true">    <key>        <column name="orderId"/>        <column name="customerId"/>    </key>    <one-to-many class="OrderLine"/></set>

(与通常一样,<one-to-many>元素不声明任何列.)

假若OrderLine本身拥有一个集合,它也具有组合外键。

<class name="OrderLine">    ....    ....    <list name="deliveryAttempts">        <key>   <!-- a collection inherits the composite key type -->            <column name="lineId"/>            <column name="orderId"/>            <column name="customerId"/>        </key>        <list-index column="attemptId" base="1"/>        <composite-element class="DeliveryAttempt">            ...        </composite-element>    </set></class>

9.5. 动态组件 (Dynamic components)

你甚至可以映射Map类型的属性:

<dynamic-component name="userAttributes">    <property name="foo" column="FOO"/>    <property name="bar" column="BAR"/>    <many-to-one name="baz" class="Baz" column="BAZ_ID"/></dynamic-component>

<dynamic-component>映射的语义上来讲,它和<component>是相同的。 这种映射类型的优点在于通过修改映射文件,就可以具有在部署时检测真实属性的能力.利用一个DOM解析器,是有可能在运行时刻操作映射文件的。 更好的是,你可以通过Configuration对象来访问(或者修改)Hibernate的运行时元模型。

第 10 章 继承映射(Inheritance Mappings)

10.1.  三种策略

Hibernate支持三种基本的继承映射策略:

  • 每个类分层结构一张表(table per class hierarchy)

  • 每个子类一张表(table per subclass)

  • 每个具体类一张表(table per concrete class)

此外,Hibernate还支持第四种稍有不同的多态映射策略:

  • 隐式多态(implicit polymorphism)

对于同一个继承层次内的不同分支,可以采用不同的映射策略,然后用隐式多 态来完成跨越整个层次的多态。但是在同一个<class>根元素 下,Hibernate不支持混合了元素<subclass><joined-subclass><union-subclass> 的映射。在同一个<class>元素下,可以混合使用 “每个类分层结构一张表”(table per hierarchy) 和“每个子类一张表”(table per subclass) 这两种映射策略,这是通过结合元素<subclass><join>来实现的(见后)。

10.1.1. 每个类分层结构一张表(Table per class hierarchy)

假设我们有接口Payment和它的几个实现类: CreditCardPayment, CashPayment, 和ChequePayment。则“每个类分层结构一张表”(Table per class hierarchy)的映射代码如下所示:

<class name="Payment" table="PAYMENT">    <id name="id" type="long" column="PAYMENT_ID">        <generator class="native"/>    </id>    <discriminator column="PAYMENT_TYPE" type="string"/>    <property name="amount" column="AMOUNT"/>    ...    <subclass name="CreditCardPayment" discriminator-value="CREDIT">        <property name="creditCardType" column="CCTYPE"/>        ...    </subclass>    <subclass name="CashPayment" discriminator-value="CASH">        ...    </subclass>    <subclass name="ChequePayment" discriminator-value="CHEQUE">        ...    </subclass></class>

采用这种策略只需要一张表即可。它有一个很大的限制:要求那些由子类定义的字段, 如CCTYPE,不能有非空(NOT NULL)约束。

10.1.2. 每个子类一张表(Table per subclass)

对于上例中的几个类而言,采用“每个子类一张表”的映射策略,代码如下所示:

<class name="Payment" table="PAYMENT">    <id name="id" type="long" column="PAYMENT_ID">        <generator class="native"/>    </id>    <property name="amount" column="AMOUNT"/>    ...    <joined-subclass name="CreditCardPayment" table="CREDIT_PAYMENT">        <key column="PAYMENT_ID"/>        ...    </joined-subclass>    <joined-subclass name="CashPayment" table="CASH_PAYMENT">        <key column="PAYMENT_ID"/>        <property name="creditCardType" column="CCTYPE"/>        ...    </joined-subclass>    <joined-subclass name="ChequePayment" table="CHEQUE_PAYMENT">        <key column="PAYMENT_ID"/>        ...    </joined-subclass></class>

需要四张表。三个子类表通过主键关联到超类表(因而关系模型实际上是一对一关联)。

10.1.3. 每个子类一张表(Table per subclass),使用辨别标志(Discriminator)

注意,对“每个子类一张表”的映射策略,Hibernate的实现不需要辨别字段,而其他 的对象/关系映射工具使用了一种不同于Hibernate的实现方法,该方法要求在超类 表中有一个类型辨别字段(type discriminator column)。Hibernate采用的方法更 难实现,但从关系(数据库)这点上来看,按理说它更正确。若你愿意使用带有辨别字 段的“每个子类一张表”的策略,你可以结合使用<subclass><join>,如下所示:

<class name="Payment" table="PAYMENT">    <id name="id" type="long" column="PAYMENT_ID">        <generator class="native"/>    </id>    <discriminator column="PAYMENT_TYPE" type="string"/>    <property name="amount" column="AMOUNT"/>    ...    <subclass name="CreditCardPayment" discriminator-value="CREDIT">        <join table="CREDIT_PAYMENT">            <property name="creditCardType" column="CCTYPE"/>            ...        </join>    </subclass>    <subclass name="CashPayment" discriminator-value="CASH">        <join table="CASH_PAYMENT">            ...        </join>    </subclass>    <subclass name="ChequePayment" discriminator-value="CHEQUE">        <join table="CHEQUE_PAYMENT" fetch="select">            ...        </join>    </subclass></class>

可选的声明fetch="select",是用来告诉Hibernate,在查询超类时, 不要使用外部连接(outer join)来抓取子类ChequePayment的数据。

10.1.4. 混合使用“每个类分层结构一张表”和“每个子类一张表”

你甚至可以采取如下方法混和使用“每个类分层结构一张表”和“每个子类一张表”这两种策略:

<class name="Payment" table="PAYMENT">    <id name="id" type="long" column="PAYMENT_ID">        <generator class="native"/>    </id>    <discriminator column="PAYMENT_TYPE" type="string"/>    <property name="amount" column="AMOUNT"/>    ...    <subclass name="CreditCardPayment" discriminator-value="CREDIT">        <join table="CREDIT_PAYMENT">            <property name="creditCardType" column="CCTYPE"/>            ...        </join>    </subclass>    <subclass name="CashPayment" discriminator-value="CASH">        ...    </subclass>    <subclass name="ChequePayment" discriminator-value="CHEQUE">        ...    </subclass></class>

对上述任何一种映射策略而言,指向根类Payment的 关联是使用<many-to-one>进行映射的。

<many-to-one name="payment" column="PAYMENT_ID" class="Payment"/>

10.1.5. 每个具体类一张表(Table per concrete class)

对于“每个具体类一张表”的映射策略,可以采用两种方法。第一种方法是使用 <union-subclass>

<class name="Payment">    <id name="id" type="long" column="PAYMENT_ID">        <generator class="sequence"/>    </id>    <property name="amount" column="AMOUNT"/>    ...    <union-subclass name="CreditCardPayment" table="CREDIT_PAYMENT">        <property name="creditCardType" column="CCTYPE"/>        ...    </union-subclass>    <union-subclass name="CashPayment" table="CASH_PAYMENT">        ...    </union-subclass>    <union-subclass name="ChequePayment" table="CHEQUE_PAYMENT">        ...    </union-subclass></class>

这里涉及三张表。每张表为对应类的所有属性(包括从超类继承的属性)定义相应字段。

这种方式的局限在于,如果一个属性在超类中做了映射,其字段名必须与所有子类 表中定义的相同。(我们可能会在Hibernate的后续发布版本中放宽此限制。) 不允许在联合子类(union subclass)的继承层次中使用标识生成器策略(identity generator strategy), 实际上, 主键的种子(primary key seed)不得不为同一继承层次中的全部被联合子类所共用.

10.1.6. Table per concrete class, using implicit polymorphism

10.1.6. Table per concrete class, using implicit polymorphism

另一种可供选择的方法是采用隐式多态:

<class name="CreditCardPayment" table="CREDIT_PAYMENT">    <id name="id" type="long" column="CREDIT_PAYMENT_ID">        <generator class="native"/>    </id>    <property name="amount" column="CREDIT_AMOUNT"/>    ...</class><class name="CashPayment" table="CASH_PAYMENT">    <id name="id" type="long" column="CASH_PAYMENT_ID">        <generator class="native"/>    </id>    <property name="amount" column="CASH_AMOUNT"/>    ...</class><class name="ChequePayment" table="CHEQUE_PAYMENT">    <id name="id" type="long" column="CHEQUE_PAYMENT_ID">        <generator class="native"/>    </id>    <property name="amount" column="CHEQUE_AMOUNT"/>    ...</class>

注意,我们没有在任何地方明确的提及接口Payment。同时注意 Payment的属性在每个子类中都进行了映射。如果你想避免重复, 可以考虑使用XML实体(例如:位于DOCTYPE声明内的 [ <!ENTITY allproperties SYSTEM "allproperties.xml"> ] 和映射中的&allproperties;)。

这种方法的缺陷在于,在Hibernate执行多态查询时(polymorphic queries)无法生成带 UNION的SQL语句。

对于这种映射策略而言,通常用<any>来实现到 Payment的多态关联映射。

<any name="payment" meta-type="string" id-type="long">    <meta-value value="CREDIT" class="CreditCardPayment"/>    <meta-value value="CASH" class="CashPayment"/>    <meta-value value="CHEQUE" class="ChequePayment"/>    <column name="PAYMENT_CLASS"/>    <column name="PAYMENT_ID"/></any>

10.1.7. 隐式多态和其他继承映射混合使用

对这一映射还有一点需要注意。因为每个子类都在各自独立的元素<class> 中映射(并且Payment只是一个接口),每个子类可以很容易的成为另一 个继承体系中的一部分!(你仍然可以对接口Payment使用多态查询。)

<class name="CreditCardPayment" table="CREDIT_PAYMENT">    <id name="id" type="long" column="CREDIT_PAYMENT_ID">        <generator class="native"/>    </id>    <discriminator column="CREDIT_CARD" type="string"/>    <property name="amount" column="CREDIT_AMOUNT"/>    ...    <subclass name="MasterCardPayment" discriminator-value="MDC"/>    <subclass name="VisaPayment" discriminator-value="VISA"/></class><class name="NonelectronicTransaction" table="NONELECTRONIC_TXN">    <id name="id" type="long" column="TXN_ID">        <generator class="native"/>    </id>    ...    <joined-subclass name="CashPayment" table="CASH_PAYMENT">        <key column="PAYMENT_ID"/>        <property name="amount" column="CASH_AMOUNT"/>        ...    </joined-subclass>    <joined-subclass name="ChequePayment" table="CHEQUE_PAYMENT">        <key column="PAYMENT_ID"/>        <property name="amount" column="CHEQUE_AMOUNT"/>        ...    </joined-subclass></class>

我们还是没有明确的提到Payment。 如果我们针对接口Payment执行查询 ——如from Payment—— Hibernate 自动返回CreditCardPayment(和它的子类,因为 它们也实现了接口Payment)、 CashPaymentChequepayment的实例, 但不返回NonelectronicTransaction的实例。

10.2. 限制

对“每个具体类映射一张表”(table per concrete-class)的映射策略而言,隐式多态的 方式有一定的限制。而<union-subclass>映射的限制则没有那 么严格。

下面表格中列出了在Hibernte中“每个具体类一张表”的策略和隐式多态的限制。

表 10.1. 继承映射特性(Features of inheritance mappings)

继承策略(Inheritance strategy)多态多对一多态一对一多态一对多多态多对多多态 load()/get()多态查询多态连接(join)外连接(Outer join)抓取
每个类分层结构一张表<many-to-one> <one-to-one> <one-to-many> <many-to-many> s.get(Payment.class, id) from Payment p from Order o join o.payment p 支持
每个子类一张表<many-to-one> <one-to-one> <one-to-many> <many-to-many> s.get(Payment.class, id) from Payment p from Order o join o.payment p 支持
每个具体类一张表(union-subclass)<many-to-one> <one-to-one> <one-to-many> (仅对于inverse="true"的情况)<many-to-many> s.get(Payment.class, id) from Payment p from Order o join o.payment p 支持
每个具体类一张表(隐式多态)<any> 不支持 不支持 <many-to-any> s.createCriteria(Payment.class).add( Restrictions.idEq(id) ).uniqueResult() from Payment p 不支持 不支持