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