所有的XML映射都需要定義如上所示的doctype。DTD可以從上述URL中獲取， 從hibernate-x.x.x/src/net/sf/hibernate目錄中、 或hibernate.jar文件中找到。Hibernate總是會(huì)首先在它的classptah中搜索DTD文件。 如果你發(fā)現(xiàn)它是通過連接Internet查找DTD文件，就對(duì)照你的classpath目錄檢查XML文件里的DTD聲明。

這個(gè)元素包括一些可選的屬性。schema和catalog屬性， 指明了這個(gè)映射所連接（refer）的表所在的schema和/或catalog名稱。 假若指定了這個(gè)屬性，表名會(huì)加上所指定的schema和catalog的名字?jǐn)U展為全限定名。假若沒有指定，表名就不會(huì)使用全限定名。 default-cascade指定了未明確注明cascade屬性的Java屬性和 集合類Hibernate會(huì)采取什么樣的默認(rèn)級(jí)聯(lián)風(fēng)格。auto-import屬性默認(rèn)讓我們?cè)诓樵冋Z(yǔ)言中可以使用 非全限定名的類名。

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

假若你有兩個(gè)持久化類，它們的非全限定名是一樣的（就是兩個(gè)類的名字一樣，所在的包不一樣--譯者注）， 你應(yīng)該設(shè)置auto-import="false"。假若說你把一個(gè)“import過”的名字同時(shí)對(duì)應(yīng)兩個(gè)類， Hibernate會(huì)拋出一個(gè)異常。

注意hibernate-mapping 元素允許你嵌套多個(gè)如上所示的 <class>映射。但是最好的做法（也許一些工具需要的）是一個(gè) 持久化類（或一個(gè)類的繼承層次）對(duì)應(yīng)一個(gè)映射文件，并以持久化的超類名稱命名，例如： Cat.hbm.xml， Dog.hbm.xml，或者如果使用繼承，Animal.hbm.xml。

你可以使用class元素來(lái)定義一個(gè)持久化類：

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

若指明的持久化類實(shí)際上是一個(gè)接口，這也是完全可以接受的。 之后你可以用<subclass>來(lái)指定該接口的實(shí)際實(shí)現(xiàn)類。 你可以持久化任何static（靜態(tài)的）內(nèi)部類。 你應(yīng)該使用標(biāo)準(zhǔn)的類名格式來(lái)指定類名，比如：Foo$Bar。

不可變類，mutable="false"不可以被應(yīng)用程序更新或者刪除。 這可以讓Hibernate做一些小小的性能優(yōu)化。

可選的proxy屬性允許延遲加載類的持久化實(shí)例。 Hibernate開始會(huì)返回實(shí)現(xiàn)了這個(gè)命名接口的CGLIB代理。當(dāng)代理的某個(gè)方法被實(shí)際調(diào)用的時(shí)候， 真實(shí)的持久化對(duì)象才會(huì)被裝載。參見下面的“用于延遲裝載的代理”。

Implicit (隱式)的多態(tài)是指，如果查詢時(shí)給出的是任何超類、該類實(shí)現(xiàn)的接口或者該類的 名字，都會(huì)返回這個(gè)類的實(shí)例；如果查詢中給出的是子類的名字，則會(huì)返回子類的實(shí)例。 Explicit （顯式）的多態(tài)是指，只有在查詢時(shí)給出明確的該類名字時(shí)才會(huì)返回這個(gè)類的實(shí)例； 同時(shí)只有在這個(gè)<class>的定義中作為<subclass> 或者<joined-subclass>出現(xiàn)的子類，才會(huì)可能返回。 在大多數(shù)情況下，默認(rèn)的polymorphism="implicit"都是合適的。 顯式的多態(tài)在有兩個(gè)不同的類映射到同一個(gè)表的時(shí)候很有用。（允許一個(gè)“輕型”的類，只包含部分表字段）。

persister屬性可以讓你定制這個(gè)類使用的持久化策略。 你可以指定你自己實(shí)現(xiàn) org.hibernate.persister.EntityPersister的子類，你甚至可以完全從頭開始編寫一個(gè) org.hibernate.persister.ClassPersister接口的實(shí)現(xiàn)， 比如是用儲(chǔ)存過程調(diào)用、序列化到文件或者LDAP數(shù)據(jù)庫(kù)來(lái)實(shí)現(xiàn)。 參閱org.hibernate.test.CustomPersister，這是一個(gè)簡(jiǎn)單的例子 （“持久化”到一個(gè)Hashtable）。

請(qǐng)注意dynamic-update和dynamic-insert的設(shè)置并不會(huì)繼承到子類， 所以在<subclass>或者<joined-subclass>元素中可能 需要再次設(shè)置。這些設(shè)置是否能夠提高效率要視情形而定。請(qǐng)用你的智慧決定是否使用。

使用select-before-update通常會(huì)降低性能。如果你重新連接一個(gè)脫管（detache）對(duì)象實(shí)例 到一個(gè)Session中時(shí)，它可以防止數(shù)據(jù)庫(kù)不必要的觸發(fā)update。 這就很有用了。

如果你打開了dynamic-update，你可以選擇幾種樂觀鎖定的策略：

我們非常強(qiáng)烈建議你在Hibernate中使用version/timestamp字段來(lái)進(jìn)行樂觀鎖定。 對(duì)性能來(lái)說，這是最好的選擇，并且這也是唯一能夠處理在session外進(jìn)行操作的策略（例如： 在使用Session.merge()的時(shí)候）。

對(duì)Hibernate映射來(lái)說視圖和表是沒有區(qū)別的，這是因?yàn)樗鼈冊(cè)跀?shù)據(jù)層都是透明的（ 注意：一些數(shù)據(jù)庫(kù)不支持視圖屬性，特別是更新的時(shí)候）。有時(shí)你想使用視圖，但卻不能在數(shù)據(jù)庫(kù) 中創(chuàng)建它（例如：在遺留的schema中）。這樣的話，你可以映射一個(gè)不可變的（immutable）并且是 只讀的實(shí)體到一個(gè)給定的SQL子查詢表達(dá)式：

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

定義這個(gè)實(shí)體用到的表為同步（synchronize），確保自動(dòng)刷新（auto-flush）正確執(zhí)行， 并且依賴原實(shí)體的查詢不會(huì)返回過期數(shù)據(jù)。<subselect>在屬性元素 和一個(gè)嵌套映射元素中都可見。

被映射的類必須定義對(duì)應(yīng)數(shù)據(jù)庫(kù)表主鍵字段。大多數(shù)類有一個(gè)JavaBeans風(fēng)格的屬性， 為每一個(gè)實(shí)例包含唯一的標(biāo)識(shí)。<id> 元素定義了該屬性到數(shù)據(jù)庫(kù)表主鍵字段的映射。

<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屬性不存在，會(huì)認(rèn)為這個(gè)類沒有標(biāo)識(shí)屬性。

unsaved-value 屬性很重要！如果你的類的標(biāo)識(shí)屬性不是默認(rèn)為 正常的Java默認(rèn)值（null或零），你應(yīng)該指定正確的默認(rèn)值。

還有一個(gè)另外的<composite-id>定義可以訪問舊式的多主鍵數(shù)據(jù)。 我們強(qiáng)烈不建議使用這種方式。

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

如果表使用聯(lián)合主鍵，你可以映射類的多個(gè)屬性為標(biāo)識(shí)符屬性。 <composite-id>元素接受<key-property> 屬性映射和<key-many-to-one>屬性映射作為子元素。

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

你的持久化類必須重載equals()和 hashCode()方法，來(lái)實(shí)現(xiàn)組合的標(biāo)識(shí)符的相等判斷。 實(shí)現(xiàn)Serializable接口也是必須的。

不幸的是，這種組合關(guān)鍵字的方法意味著一個(gè)持久化類是它自己的標(biāo)識(shí)。除了對(duì)象自己之外， 沒有什么方便的“把手”可用。你必須自己初始化持久化類的實(shí)例，在使用組合關(guān)鍵字load() 持久化狀態(tài)之前，必須填充他的聯(lián)合屬性。我們會(huì)在第 9.4 節(jié) “組件作為聯(lián)合標(biāo)識(shí)符(Components as composite identifiers)”章中說明一種 更加便捷的方法，把聯(lián)合標(biāo)識(shí)實(shí)現(xiàn)為一個(gè)獨(dú)立的類，下面描述的屬性只對(duì)這種備用方法有效:

在"一棵對(duì)象繼承樹對(duì)應(yīng)一個(gè)表"的策略中,<discriminator>元素是必需的, 它定義了表的鑒別器字段。鑒別器字段包含標(biāo)志值，用于告知持久化層應(yīng)該為某個(gè)特定的行創(chuàng)建哪一個(gè)子類的實(shí)例。 如下這些受到限制的類型可以使用： 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)
/>

鑒別器字段的實(shí)際值是根據(jù)<class>和<subclass>元素中 的discriminator-value屬性得來(lái)的。

force屬性僅僅是在表包含一些未指定應(yīng)該映射到哪個(gè)持久化類的時(shí)候才是有用的。 這種情況不會(huì)經(jīng)常遇到。

使用formula屬性你可以定義一個(gè)SQL表達(dá)式，用來(lái)判斷一個(gè)行數(shù)據(jù)的類型。

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

<version>元素是可選的，表明表中包含附帶版本信息的數(shù)據(jù)。 這在你準(zhǔn)備使用 長(zhǎng)事務(wù)（long transactions）的時(shí)候特別有用。（見后）

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

版本號(hào)必須是以下類型：long, integer, short, timestamp或者calendar。

一個(gè)脫管（detached）實(shí)例的version或timestamp不能為空（null），因?yàn)镠ibernate不管 unsaved-value指定為何種策略，它將分離任何屬性為空的version或timestamp 實(shí)例為瞬時(shí)（transient）實(shí)例。 避免Hibernate中的傳遞重附（transitive reattachment）問題的一個(gè)簡(jiǎn)單方法是 定義一個(gè)不能為空的version或timestamp屬性，特別是在人們使用程序分配的標(biāo)識(shí)符（assigned identifiers） 或復(fù)合主鍵時(shí)非常有用！

可選的<timestamp>元素指明了表中包含時(shí)間戳數(shù)據(jù)。 這用來(lái)作為版本的替代。時(shí)間戳本質(zhì)上是一種對(duì)樂觀鎖定的一種不是特別安全的實(shí)現(xiàn)。當(dāng)然， 有時(shí)候應(yīng)用程序可能在其他方面使用時(shí)間戳。

<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">是等價(jià)的。

<property>元素為類定義了一個(gè)持久化的,JavaBean風(fēng)格的屬性。

<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會(huì)使用反射來(lái)得到這個(gè)名字的屬性，以此來(lái)猜測(cè)正確的Hibernate類型。 Hibernate會(huì)按照規(guī)則2,3,4的順序?qū)傩宰x取器(getter方法）的返回類進(jìn)行解釋。然而，這還不夠。 在某些情況下你仍然需要type屬性。（比如，為了區(qū)別Hibernate.DATE 和Hibernate.TIMESTAMP,或者為了指定一個(gè)自定義類型。）

access屬性用來(lái)讓你控制Hibernate如何在運(yùn)行時(shí)訪問屬性。在默認(rèn)情況下， Hibernate會(huì)使用屬性的get/set方法對(duì)（pair）。如果你指明access="field", Hibernate會(huì)忽略get/set方法對(duì)，直接使用反射來(lái)訪問成員變量。你也可以指定你自己的策略， 這就需要你自己實(shí)現(xiàn)org.hibernate.property.PropertyAccessor接口， 再在access中設(shè)置你自定義策略類的名字。

衍生屬性（derive propertie）是一個(gè)特別強(qiáng)大的特征。這些屬性應(yīng)該定義為只讀，屬性值在裝載時(shí)計(jì)算生成。 你用一個(gè)SQL表達(dá)式生成計(jì)算的結(jié)果，它會(huì)在這個(gè)實(shí)例轉(zhuǎn)載時(shí)翻譯成一個(gè)SQL查詢的SELECT 子查詢語(yǔ)句。

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

注意，你可以使用實(shí)體自己的表，而不用為這個(gè)特別的列定義別名（ 上面例子中的customerId）。同時(shí)注意，如果你不喜歡使用屬性， 你可以使用嵌套的<formula>映射元素。

通過many-to-one元素,可以定義一種常見的與另一個(gè)持久化類的關(guān)聯(lián)。 這種關(guān)系模型是多對(duì)一關(guān)聯(lián)（實(shí)際上是一個(gè)對(duì)象引用－譯注）：這個(gè)表的一個(gè)外鍵引用目標(biāo)表的 主鍵字段。

<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屬性設(shè)置為除了none以外任何有意義的值， 它將把特定的操作傳播到關(guān)聯(lián)對(duì)象中。這個(gè)值就代表著Hibernate基本操作的名稱， persist, merge, delete, save-update, evict, replicate, lock, refresh， 以及特別的值delete-orphan和all，并且可以用逗號(hào)分隔符 來(lái)合并這些操作，例如，cascade="persist,merge,evict"或 cascade="all,delete-orphan"。更全面的解釋請(qǐng)參考第 11.11 節(jié) “傳播性持久化(transitive persistence)”.

一個(gè)典型的簡(jiǎn)單many-to-one定義例子：

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

property-ref屬性只應(yīng)該用來(lái)對(duì)付老舊的數(shù)據(jù)庫(kù)系統(tǒng)， 可能有外鍵指向?qū)Ψ疥P(guān)聯(lián)表的是個(gè)非主鍵字段（但是應(yīng)該是一個(gè)惟一關(guān)鍵字）的情況下。 這是一種十分丑陋的關(guān)系模型。比如說，假設(shè)Product類有一個(gè)惟一的序列號(hào)， 它并不是主鍵。（unique屬性控制Hibernate通過SchemaExport工具生成DDL的過程。）

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

那么關(guān)于OrderItem 的映射可能是：

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

當(dāng)然，我們決不鼓勵(lì)這種用法。

如果被引用的唯一主鍵由關(guān)聯(lián)實(shí)體的多個(gè)屬性組成，你應(yīng)該在名稱為<properties>的元素 里面映射所有關(guān)聯(lián)的屬性。

持久化對(duì)象之間一對(duì)一的關(guān)聯(lián)關(guān)系是通過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"
/>

有兩種不同的一對(duì)一關(guān)聯(lián)：

主鍵關(guān)聯(lián)不需要額外的表字段；如果兩行是通過這種一對(duì)一關(guān)系相關(guān)聯(lián)的，那么這兩行就共享同樣的主關(guān)鍵字值。所以如果你希望兩個(gè)對(duì)象通過主鍵一對(duì)一關(guān)聯(lián)，你必須確認(rèn)它們被賦予同樣的標(biāo)識(shí)值！

比如說，對(duì)下面的Employee和Person進(jìn)行主鍵一對(duì)一關(guān)聯(lián):

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

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

現(xiàn)在我們必須確保PERSON和EMPLOYEE中相關(guān)的字段是相等的。我們使用一個(gè)被成為foreign的特殊的hibernate標(biāo)識(shí)符生成策略：

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

一個(gè)剛剛保存的Person實(shí)例被賦予和該Person的employee屬性所指向的Employee實(shí)例同樣的關(guān)鍵字值。

另一種方式是一個(gè)外鍵和一個(gè)惟一關(guān)鍵字對(duì)應(yīng)，上面的Employee和Person的例子，如果使用這種關(guān)聯(lián)方式，可以表達(dá)成：

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

如果在Person的映射加入下面幾句，這種關(guān)聯(lián)就是雙向的：

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

<component>元素把子對(duì)象的一些元素與父類對(duì)應(yīng)的表的一些字段映射起來(lái)。 然后組件可以定義它們自己的屬性、組件或者集合。參見后面的“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>子標(biāo)簽為子類的一些屬性與表字段之間建立映射。

<component>元素允許加入一個(gè)<parent>子元素，在組件類內(nèi)部就可以有一個(gè)指向其容器的實(shí)體的反向引用。

<dynamic-component>元素允許把一個(gè)Map映射為組件，其屬性名對(duì)應(yīng)map的鍵值。 參見第 9.5 節(jié) “動(dòng)態(tài)組件 （Dynamic components）”.

<properties> 元素允許定義一個(gè)命名的邏輯分組(grouping)包含一個(gè)類中的多個(gè)屬性。 這個(gè)元素最重要的用處是允許多個(gè)屬性的組合作為property-ref的目標(biāo)(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>

然后，我們可能有一些遺留的數(shù)據(jù)關(guān)聯(lián)，引用 Person表的這個(gè)唯一鍵，而不是主鍵。

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

我們并不推薦這樣使用，除非在映射遺留數(shù)據(jù)的情況下。

最后，多態(tài)持久化需要為父類的每個(gè)子類都進(jìn)行定義。對(duì)于“每一棵類繼承樹對(duì)應(yīng)一個(gè)表”的策略來(lái)說，就需要使用<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>

每個(gè)子類都應(yīng)該定義它自己的持久化屬性和子類。 <version> 和<id> 屬性可以從根父類繼承下來(lái)。在一棵繼承樹上的每個(gè)子類都必須定義一個(gè)唯一的discriminator-value。如果沒有指定，就會(huì)使用Java類的全限定名。

可以在單獨(dú)的映射文件中，直接在hibernate-mapping下定義subclass，union-subclass和joined-subclass映射。這樣你只要增加一個(gè)新的映射文件就可以繼承一棵類繼承樹。你必須在子類的映射中指定extends 屬性來(lái)指定已映射的超類。注意：以前，這個(gè)特性使得映射文件的順序變得很重要。從Hibernate3開始，當(dāng)使用extends關(guān)鍵字的時(shí)候，映射文件的次序便不重要了。而在單一映射文件中，依舊需要保持將超類定義在子類之前這樣的次序。

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

更多關(guān)于繼承映射的信息, 參考 第 10 章 繼承映射(Inheritance Mappings)章節(jié).

此外，每個(gè)子類可能被映射到他自己的表中(每個(gè)子類一個(gè)表的策略)。被繼承的狀態(tài)通過和超類的表關(guān)聯(lián)得到。我們使用<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>

這種映射策略不需要指定辨別標(biāo)志(discriminator)字段。但是，每一個(gè)子類都必須使用<key>元素指定一個(gè)表字段來(lái)持有對(duì)象的標(biāo)識(shí)符。本章開始的映射可以被用如下方式重寫：

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

更多關(guān)于繼承映射的信息，參考第 10 章 繼承映射(Inheritance Mappings)。

第三種選擇是僅僅映射類繼承樹中具體類部分到表中(每個(gè)具體類一張表的策略)。其中，每張表定義了類的所有持久化狀態(tài)，包括繼承的狀態(tài)。在 Hibernate 中，并不需要完全顯式地映射這樣的繼承樹。你可以簡(jiǎn)單地使用單獨(dú)的<class>定義映射每個(gè)類。然而，如果你想使用多態(tài)關(guān)聯(lián)(例如，一個(gè)對(duì)類繼承樹中超類的關(guān)聯(lián))，你需要使用<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>

這種映射策略不需要指定辨別標(biāo)志(discriminator)字段。

更多關(guān)于繼承映射的信息，參考第 10 章 繼承映射(Inheritance Mappings)。

使用 <join> 元素，可以將一個(gè)類的屬性映射到多張表中。

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

例如，一個(gè)人(person)的地址(address)信息可以被映射到單獨(dú)的表中(并保留所有屬性的值類型語(yǔ)義)：

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

此特性常常對(duì)遺留數(shù)據(jù)模型有用，我們推薦表個(gè)數(shù)比類個(gè)數(shù)少，以及細(xì)粒度的領(lǐng)域模型。然而，在單獨(dú)的繼承樹上切換繼承映射策略是有用的，后面會(huì)解釋這點(diǎn)。

我們目前已經(jīng)見到過<key>元素多次了。 這個(gè)元素在父映射元素定義了對(duì)新表的連接，并且在被連接表中定義了一個(gè)外鍵引用原表的主鍵的情況下經(jīng)常使用。

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

對(duì)那些看重刪除性能的系統(tǒng)，我們推薦所有的鍵都應(yīng)該定義為on-delete="cascade"，這樣 Hibernate 將使用數(shù)據(jù)庫(kù)級(jí)的ON CASCADE DELETE約束，而不是多個(gè)DELETE語(yǔ)句。 注意，這個(gè)特性會(huì)繞過 Hibernate 通常對(duì)版本數(shù)據(jù)(versioned data)采用的樂觀鎖策略。

not-null 和 update 屬性在映射單向一對(duì)多關(guān)聯(lián)的時(shí)候有用。如果你映射一個(gè)單向一對(duì)多關(guān)聯(lián)到非空的(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 屬性甚至可以在同一個(gè)屬性或關(guān)聯(lián)映射中被合并來(lái)表達(dá)，例如，一些奇異的連接條件。

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

假設(shè)你的應(yīng)用程序有兩個(gè)同樣名字的持久化類，但是你不想在Hibernate查詢中使用他們的全限定名。除了依賴auto-import="true"以外，類也可以被顯式地“import(引用)”。你甚至可以引用沒有明確被映射的類和接口。

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

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

這是屬性映射的又一種類型。<any> 映射元素定義了一種從多個(gè)表到類的多態(tài)關(guān)聯(lián)。這種類型的映射常常需要多于一個(gè)字段。第一個(gè)字段持有被關(guān)聯(lián)實(shí)體的類型，其他的字段持有標(biāo)識(shí)符。對(duì)這種類型的關(guān)聯(lián)來(lái)說，不可能指定一個(gè)外鍵約束，所以這當(dāng)然不是映射(多態(tài))關(guān)聯(lián)的通常的方式。你只應(yīng)該在非常特殊的情況下使用它(比如，審計(jì)log，用戶會(huì)話數(shù)據(jù)等等)。

meta-type 屬性使得應(yīng)用程序能指定一個(gè)將數(shù)據(jù)庫(kù)字段的值映射到持久化類的自定義類型。這個(gè)持久化類包含有用id-type指定的標(biāo)識(shí)符屬性。 你必須指定從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>

為了理解很多與持久化服務(wù)相關(guān)的Java語(yǔ)言級(jí)對(duì)象的行為，我們需要把它們分為兩類：

實(shí)體entity 獨(dú)立于任何持有實(shí)體引用的對(duì)象。與通常的Java模型相比，不再被引用的對(duì)象會(huì)被當(dāng)作垃圾收集掉。實(shí)體必須被顯式的保存和刪除(除非保存和刪除是從父實(shí)體向子實(shí)體引發(fā)的級(jí)聯(lián))。這和ODMG模型中關(guān)于對(duì)象通過可觸及保持持久性有一些不同——比較起來(lái)更加接近應(yīng)用程序?qū)ο笸ǔＴ谝粋€(gè)大系統(tǒng)中的使用方法。實(shí)體支持循環(huán)引用和交叉引用，它們也可以加上版本信息。

一個(gè)實(shí)體的持久狀態(tài)包含指向其他實(shí)體和值類型實(shí)例的引用。值可以是原始類型，集合(不是集合中的對(duì)象)，組件或者特定的不可變對(duì)象。與實(shí)體不同，值(特別是集合和組件)是通過可觸及性來(lái)進(jìn)行持久化和刪除的。因?yàn)橹祵?duì)象(和原始類型數(shù)據(jù))是隨著包含他們的實(shí)體而被持久化和刪除的，他們不能被獨(dú)立的加上版本信息。值沒有獨(dú)立的標(biāo)識(shí)，所以他們不能被兩個(gè)實(shí)體或者集合共享。

直到現(xiàn)在，我們都一直使用術(shù)語(yǔ)“持久類”(persistent class)來(lái)代表實(shí)體。我們?nèi)匀粫?huì)這么做。 然而嚴(yán)格說來(lái)，不是所有的用戶自定義的，帶有持久化狀態(tài)的類都是實(shí)體。組件就是用戶自定義類，卻是值語(yǔ)義的。java.lang.String類型的java屬性也是值語(yǔ)義的。給了這個(gè)定義以后，我們可以說所有JDK提供的類型(類)都是值類型的語(yǔ)義，而用于自定義類型可能被映射為實(shí)體類型或值類型語(yǔ)義。采用哪種類型的語(yǔ)義取決于開發(fā)人員。在領(lǐng)域模型中，尋找實(shí)體類的一個(gè)好線索是共享引用指向這個(gè)類的單一實(shí)例，而組合或聚合通常被轉(zhuǎn)化為值類型。

我們會(huì)在本文檔中重復(fù)碰到這兩個(gè)概念。

挑戰(zhàn)在于將java類型系統(tǒng)(和開發(fā)者定義的實(shí)體和值類型)映射到 SQL/數(shù)據(jù)庫(kù)類型系統(tǒng)。Hibernate提供了連接兩個(gè)系統(tǒng)之間的橋梁：對(duì)于實(shí)體類型，我們使用<class>, <subclass> 等等。對(duì)于值類型，我們使用 <property>, <component> 及其他，通常跟隨著type屬性。這個(gè)屬性的值是Hibernate 的映射類型的名字。Hibernate提供了許多現(xiàn)成的映射(標(biāo)準(zhǔn)的JDK值類型)。你也可以編寫自己的映射類型并實(shí)現(xiàn)自定義的變換策略，隨后我們會(huì)看到這點(diǎn)。

所有的Hibernate內(nèi)建類型，除了collections以外，都支持空(null)語(yǔ)義。

The built-in basic mapping types may be roughly categorized into 內(nèi)建的 基本映射類型可以大致分為

實(shí)體及其集合的唯一標(biāo)識(shí)可以是除了binary、 blob 和 clob之外的任何基礎(chǔ)類型。(聯(lián)合標(biāo)識(shí)也是允許的，后面會(huì)說到。)

在org.hibernate.Hibernate中，定義了基礎(chǔ)類型對(duì)應(yīng)的Type常量。比如，Hibernate.STRING代表string 類型。

開發(fā)者創(chuàng)建屬于他們自己的值類型也是很容易的。比如說，你可能希望持久化java.lang.BigInteger類型的屬性，持久化成為VARCHAR字段。Hibernate沒有內(nèi)置這樣一種類型。自定義類型能夠映射一個(gè)屬性(或集合元素)到不止一個(gè)數(shù)據(jù)庫(kù)表字段。比如說，你可能有這樣的Java屬性：getName()/setName()，這是java.lang.String類型的，對(duì)應(yīng)的持久化到三個(gè)字段：FIRST_NAME, INITIAL, SURNAME。

要實(shí)現(xiàn)一個(gè)自定義類型，可以實(shí)現(xiàn)org.hibernate.UserType或org.hibernate.CompositeUserType中的任一個(gè)，并且使用類型的Java全限定類名來(lái)定義屬性。請(qǐng)查看org.hibernate.test.DoubleStringType這個(gè)例子，看看它是怎么做的。

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

注意使用<column>標(biāo)簽來(lái)把一個(gè)屬性映射到多個(gè)字段的做法。

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

你甚至可以在一個(gè)映射文件中提供參數(shù)給一個(gè)UserType。 為了這樣做，你的UserType必須實(shí)現(xiàn)org.hibernate.usertype.ParameterizedType接口。為了給自定義類型提供參數(shù)，你可以在映射文件中使用<type>元素。

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

現(xiàn)在，UserType 可以從傳入的Properties對(duì)象中得到default 參數(shù)的值。

如果你非常頻繁地使用某一UserType，可以為他定義一個(gè)簡(jiǎn)稱。這可以通過使用 <typedef>元素來(lái)實(shí)現(xiàn)。Typedefs為一自定義類型賦予一個(gè)名稱，并且如果此類型是參數(shù)化的，還可以包含一系列默認(rèn)的參數(shù)值。

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

<property name="priority" type="default_zero"/>

也可以根據(jù)具體案例通過屬性映射中的類型參數(shù)覆蓋在typedef中提供的參數(shù)。

盡管 Hibernate 內(nèi)建的豐富的類型和對(duì)組件的支持意味著你可能很少 需要使用自定義類型。不過，為那些在你的應(yīng)用中經(jīng)常出現(xiàn)的(非實(shí)體)類使用自定義類型也是一個(gè)好方法。例如，一個(gè)MonetaryAmount類使用CompositeUserType來(lái)映射是不錯(cuò)的選擇，雖然他可以很容易地被映射成組件。這樣做的動(dòng)機(jī)之一是抽象。使用自定義類型，以后假若你改變表示金額的方法時(shí)，它可以保證映射文件不需要修改。

很多Hibernate使用者更喜歡使用XDoclet@hibernate.tags將映射信息直接嵌入到源代碼中。我們不會(huì)在本文檔中涉及這個(gè)方法，因?yàn)閲?yán)格說來(lái)，這屬于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網(wǎng)站更多的Xdoclet和Hibernate的例子

JDK 5.0 在語(yǔ)言級(jí)別引入了 XDoclet 風(fēng)格的標(biāo)注，并且是類型安全的，在編譯期進(jìn)行檢查。這一機(jī)制比XDoclet的注解更為強(qiáng)大，有更好的工具和IDE支持。例如， IntelliJ IDEA，支持JDK 5.0注解的自動(dòng)完成和語(yǔ)法高亮 。EJB規(guī)范的新修訂版(JSR-220)使用 JDK 5.0的注解作為entity beans的主要元數(shù)據(jù)(metadata)機(jī)制。Hibernate 3 實(shí)現(xiàn)了JSR-220 (the persistence API)的EntityManager，支持通過Hibernate Annotations包定義映射元數(shù)據(jù)。這個(gè)包作為單獨(dú)的部分下載，支持EJB3 (JSR-220)和Hibernate3的元數(shù)據(jù)。

這是一個(gè)被注解為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
}

注意：對(duì) JDK 5.0 注解 (和 JSR-220)支持的工作仍然在進(jìn)行中,并未完成。