`
廖世勇
  • 浏览: 90274 次
  • 性别: Icon_minigender_1
  • 来自: 湖南郴州
社区版块
存档分类
最新评论

hibernate

 
阅读更多

第6章对象/关系数据库映射基础(BasicO/R Mapping)

6.1.映射定义（Mapping declaration）

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

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

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

<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping PUBLIC

"-//Hibernate/HibernateMapping DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="eg">

<classname="Cat"

table="cats"

discriminator-value="C">

<idname="id">

<generator class="native"/>

</id>

<discriminatorcolumn="subclass"

type="character"/>

<propertyname="weight"/>

<propertyname="birthdate"

type="date"

not-null="true"

update="false"/>

<propertyname="color"

type="eg.types.ColorUserType"

not-null="true"

update="false"/>

<propertyname="sex"

not-null="true"

update="false"/>

<propertyname="litterId"

column="litterId"

update="false"/>

<many-to-onename="mother"

column="mother_id"

update="false"/>

<setname="kittens"

inverse="true"

order-by="litter_id">

<keycolumn="mother_id"/>

<one-to-many class="Cat"/>

</set>

<subclassname="DomesticCat"

discriminator-value="D">

<propertyname="name"

type="string"/>

</subclass>

</class>

<classname="Dog">

<!-- mapping forDog 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

这个元素包括一些可选的属性。schema和catalog属性， 指明了这个映射所连接（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.xml， Dog.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 sqlwhere 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 sqlcheck 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 (可选 - 默认和类名一样): 一个用于区分不同的子类的值，在多态行为时使用。它可以接受的值包括 null 和 not 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-update和dynamic-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>

<synchronizetable="item"/>

<synchronizetable="bid"/>

<idname="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|.">

<generatorclass="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">

<generatorclass="org.hibernate.id.TableHiLoGenerator">

<paramname="table">uid_table</param>

<paramname="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_key 和next_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）

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

<id name="id" type="long"column="cat_id">

<generatorclass="hilo">

<paramname="table">hi_value</param>

<paramname="column">next_value</param>

<paramname="max_lo">100</param>

</generator>

</id>

<id name="id" type="long"column="cat_id">

<generator class="seqhilo">

<paramname="sequence">hi_value</param>

<paramname="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">

<generatorclass="sequence">

<paramname="sequence">person_id_sequence</param>

</generator>

</id>

<id name="id" type="long" column="person_id"unsaved-value="0">

<generatorclass="identity"/>

</id>

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

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">

<generatorclass="select">

<paramname="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-propertyname="propertyName" type="typename"column="column_name"/>

<key-many-to-onename="propertyName class="ClassName"column="column_name"/>

......

</composite-id>

For a table with a composite key, you may map multipleproperties 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-propertyname="medicareNumber"/>

<key-propertyname="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 sqlexpression" (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 whenCLASS_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属性，特别是在人们使用程序分配的标识符（assignedidentifiers） 或复合主键时非常有用！

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 SQLexpression"(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可以是如下几种：

  • Hibernate基础类型之一（比如：integer, string, character,date, timestamp, float, binary, serializable, object, blob）。
  • 一个Java类的名字，这个类属于一种默认基础类型 (比如： int, float,char, java.lang.String, java.util.Date, java.lang.Integer, java.sql.Clob)。
  • 一个可以序列化的Java类的名字。
  • 一个自定义类型的类的名字。（比如： com.illflow.type.MyCustomType)。

如果你没有指定类型，Hibernarte会使用反射来得到这个名字的属性，以此来猜测正确的Hibernate类型。 Hibernate会按照规则2,3,4的顺序对属性读取器(getter方法）的返回类进行解释。然而，这还不够。 在某些情况下你仍然需要type属性。（比如，为了区别Hibernate.DATE 和Hibernate.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-orphan和all，并且可以用逗号分隔符 来合并这些操作，例如，cascade="persist,merge,evict"或 cascade="all,delete-orphan"。更全面的解释请参考第11.11节 “传播性持久化(transitivepersistence)”.

一个典型的简单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 SQLexpression"(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 (可选): 被关联的类的实体名。

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

·主键关联

·惟一外键关联

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

比如说，对下面的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">

<generatorclass="foreign">

<paramname="property">employee</param>

</generator>

</id>

...

<one-to-onename="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"/>

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">

<idname="personNumber"/>

...

<propertiesname="name"

unique="true"update="false">

<propertyname="firstName"/>

<propertyname="initial"/>

<propertyname="lastName"/>

</properties>

</class>

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

<many-to-one name="person"

class="Person"property-ref="name">

<columnname="firstName"/>

<columnname="initial"/>

<columnname="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下定义subclass，union-subclass和joined-subclass映射。这样你只要增加一个新的映射文件就可以继承一棵类继承树。你必须在子类的映射中指定extends 属性来指定已映射的超类。注意：以前，这个特性使得映射文件的顺序变得很重要。从Hibernate3开始，当使用extends关键字的时候，映射文件的次序便不重要了。而在单一映射文件中，依旧需要保持将超类定义在子类之前这样的次序。

<hibernate-mapping>

<subclassname="DomesticCat" extends="Cat"discriminator-value="D">

<propertyname="name" type="string"/>

</subclass>

</hibernate-mapping>

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

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="SQLexpression"

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/HibernateMapping DTD//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="eg">

<classname="Cat" table="CATS">

<idname="id" column="uid" type="long">

<generator class="hilo"/>

</id>

<propertyname="birthdate" type="date"/>

<propertyname="color" not-null="true"/>

<property name="sex"not-null="true"/>

<propertyname="weight"/>

<many-to-onename="mate"/>

<setname="kittens">

<keycolumn="MOTHER"/>

<one-to-many class="Cat"/>

</set>

<joined-subclassname="DomesticCat" table="DOMESTIC_CATS">

<keycolumn="CAT"/>

<propertyname="name" type="string"/>

</joined-subclass>

</class>

<classname="eg.Dog">

<!-- mapping forDog could go here -->

</class>

</hibernate-mapping>

更多关于继承映射的信息，参考第10章 继承映射(InheritanceMappings)。

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="SQLexpression"

entity-name="EntityName"

node="element-name">

<property .... />

.....

</union-subclass>

(1)

name: 子类的全限定名。

(2)

table: 子类的表名

(3)

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

(4)

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

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

更多关于继承映射的信息，参考第10章 继承映射(InheritanceMappings)。

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>

<jointable="ADDRESS">

<keycolumn="ADDRESS_ID"/>

<propertyname="address"/>

<propertyname="zip"/>

<propertyname="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-null 和 update 属性在映射单向一对多关联的时候有用。如果你映射一个单向一对多关联到非空的(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="SQLexpression"/>

<formula>SQL expression</formula>

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

<many-to-one name="homeAddress" class="Address"

insert="false"update="false">

<columnname="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-valuevalue="TBL_ANIMAL" class="Animal"/>

<meta-valuevalue="TBL_HUMAN" class="Human"/>

<meta-valuevalue="TBL_ALIEN" class="Alien"/>

<columnname="table_name"/>

<columnname="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 roughlycategorized into 内建的 基本映射类型可以大致分为

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

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

string

从java.lang.String 到 VARCHAR (或者 Oracle的 VARCHAR2)的映射。

date, time, timestamp

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

calendar, calendar_date

从java.util.Calendar 到SQL 类型TIMESTAMP和 DATE(或等价类型)的映射。

big_decimal, big_integer

从java.math.BigDecimal和java.math.BigInteger到NUMERIC (或者 Oracle 的NUMBER类型)的映射。

locale, timezone, currency

从java.util.Locale, java.util.TimeZone 和java.util.Currency 到VARCHAR (或者 Oracle 的VARCHAR2类型)的映射. Locale和 Currency 的实例被映射为它们的ISO代码。TimeZone的实例被影射为它的ID。

class

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

binary

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

text

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

serializable

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

clob, blob

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

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

在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.UserType或org.hibernate.CompositeUserType中的任一个，并且使用类型的Java全限定类名来定义属性。请查看org.hibernate.test.DoubleStringType这个例子，看看它是怎么做的。

<property name="twoStrings"type="org.hibernate.test.DoubleStringType">

<columnname="first_string"/>

<columnname="second_string"/>

</property>

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

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

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

<property name="priority">

<typename="com.mycompany.usertypes.DefaultValueIntegerType">

<paramname="default">0</param>

</type>

</property>

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

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

<typedefclass="com.mycompany.usertypes.DefaultValueIntegerType"name="default_zero">

<paramname="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>

<propertyname="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 byHibernate

public void addKitten(Catkitten) {

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 businessmethods

}

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

http://docs.huihoo.com/hibernate/reference-v3_zh-cn/quickstart.html

分享到：
| 嵌入式开发工具介绍与下载
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

Magicbox
Global site tag (gtag.js) - Google Analytics