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

这个元素包括一些可选的属性。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)
/>

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

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

你可以使用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)
/>

若指明的持久化类实际上是一个接口，这也是完全可以接受的。 之后你可以用<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，你可以选择几种乐观锁定的策略：

我们非常强烈建议你在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>在属性元素 和一个嵌套映射元素中都可见。

被映射的类必须定义对应数据库表主键字段。大多数类有一个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>

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

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

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

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

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

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

<id name="id" type="long" column="person_id">
<generator class="select">
<param name="key">socialSecurityNumber</param>
</generator>
</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)”章中说明一种 更加便捷的方法，把联合标识实现为一个独立的类，下面描述的属性只对这种备用方法有效:

在"一棵对象继承树对应一个表"的策略中,<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)
/>

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

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

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

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

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

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

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

可选的<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|."
/>

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

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

typename可以是如下几种：

如果你没有指定类型，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>映射元素。

通过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"
/>

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 节 “传播性持久化(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>的元素 里面映射所有关联的属性。

持久化对象之间一对一的关联关系是通过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"
/>

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

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

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

<one-to-one name="person" class="Person"/>

<one-to-one name="employee" class="Employee" constrained="true"/>

现在我们必须确保PERSON和EMPLOYEE中相关的字段是相等的。我们使用一个被成为foreign的特殊的hibernate标识符生成策略：

<class name="person" table="PERSON">
<id name="id" column="PERSON_ID">
<generator class="foreign">
<param name="property">employee</param>
</generator>
</id>
...
<one-to-one name="employee"
class="Employee"
constrained="true"/>
</class>

一个刚刚保存的Person实例被赋予和该Person的employee属性所指向的Employee实例同样的关键字值。

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

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

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

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

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

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

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

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

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

例如，如果我们有如下的<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>

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

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

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

可以在单独的映射文件中，直接在hibernate-mapping下定义subclass，union-subclass和joined-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)章节.

此外，每个子类可能被映射到他自己的表中(每个子类一个表的策略)。被继承的状态通过和超类的表关联得到。我们使用<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>

这种映射策略不需要指定辨别标志(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)。

第三种选择是仅仅映射类继承树中具体类部分到表中(每个具体类一张表的策略)。其中，每张表定义了类的所有持久化状态，包括继承的状态。在 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>

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

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

使用 <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>

例如，一个人(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>
...

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

我们目前已经见到过<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)
/>

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

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

任何接受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>

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

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

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

<import class="java.lang.Object" rename="Universe"/>

<import
class="ClassName"              (1)
rename="ShortName"             (2)
/>

这是属性映射的又一种类型。<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>

为了理解很多与持久化服务相关的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)语义。

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

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

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

开发者创建属于他们自己的值类型也是很容易的。比如说，你可能希望持久化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">
<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来映射是不错的选择，虽然他可以很容易地被映射成组件。这样做的动机之一是抽象。使用自定义类型，以后假若你改变表示金额的方法时，它可以保证映射文件不需要修改。

很多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的例子

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)支持的工作仍然在进行中,并未完成。