<!--標(biāo)準(zhǔn)的XML文件的起始行，version='1.0'表明XML的版本，encoding='gb2312'表明XML文件的編碼方式--> 
                 <?xml version='1.0' encoding='gb2312'?> 
<!--表明解析本XML文件的DTD文檔位置，DTD是Document Type Definition 的縮寫,即文檔類型的定義,XML解析器使用DTD文檔來檢查XML文件的合法性。hibernate.sourceforge.net/hibernate-configuration-3.0dtd可以在Hibernate3.1.3軟件包中的src/org/hibernate目錄中找到此文件--> 
<!DOCTYPE hibernate-configuration PUBLIC  
          "-//Hibernate/Hibernate Configuration DTD 3.0//EN"  
          "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd"> 
    <!--聲明Hibernate配置文件的開始-->        
    <hibernate-configuration> 
    <!--表明以下的配置是針對session-factory配置的，SessionFactory是Hibernate中的一個類，這個類主要負(fù)責(zé)保存HIbernate的配置信息，以及對Session的操作--> 
       <session-factory>      
      <!--配置數(shù)據(jù)庫的驅(qū)動程序，Hibernate在連接數(shù)據(jù)庫時，需要用到數(shù)據(jù)庫的驅(qū)動程序--> 
           <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>   
       <!--設(shè)置數(shù)據(jù)庫的連接url:jdbc:mysql://localhost/hibernate,其中l(wèi)ocalhost表示mysql服務(wù)器名稱，此處為本機，     hibernate是數(shù)據(jù)庫名-->    
            <property name="hibernate.connection.url">jdbc:mysql://localhost/hibernate</hibernate> 
    <!--連接數(shù)據(jù)庫是用戶名--> 
           <property name="hibernate.connection.username">root</property>   
          <!--連接數(shù)據(jù)庫是密碼--> 
           <property name="hibernate.connection.password">123456</property>           
          <!--數(shù)據(jù)庫連接池的大小--> 
           <property name="hibernate.connection.pool.size">20</property>          
         <!--是否在后臺顯示Hibernate用到的SQL語句，開發(fā)時設(shè)置為true，便于差錯，程序運行時可以在Eclipse的控制臺顯示Hibernate的執(zhí)行Sql語句。項目部署后可以設(shè)置為false，提高運行效率--> 
         <property name="hibernate.show_sql">true</property> 
         <!--jdbc.fetch_size是指Hibernate每次從數(shù)據(jù)庫中取出并放到JDBC的Statement中的記錄條數(shù)。Fetch Size設(shè)的越大，讀數(shù)據(jù)庫的次數(shù)越少，速度越快，F(xiàn)etch Size越小，讀數(shù)據(jù)庫的次數(shù)越多，速度越慢--> 
         <property name="jdbc.fetch_size">50</property> 
         <!--jdbc.batch_size是指Hibernate批量插入,刪除和更新時每次操作的記錄數(shù)。Batch Size越大，批量操作的向數(shù)據(jù)庫發(fā)送Sql的次數(shù)越少，速度就越快，同樣耗用內(nèi)存就越大--> 
         <property name="jdbc.batch_size">23</property> 
         <!--jdbc.use_scrollable_resultset是否允許Hibernate用JDBC的可滾動的結(jié)果集。對分頁的結(jié)果集。對分頁時的設(shè)置非常有幫助--> 
         <property name="jdbc.use_scrollable_resultset">false</property> 
         <!--connection.useUnicode連接數(shù)據(jù)庫時是否使用Unicode編碼--> 
         <property name="Connection.useUnicode">true</property> 
         <!--connection.characterEncoding連接數(shù)據(jù)庫時數(shù)據(jù)的傳輸字符集編碼方式，最好設(shè)置為gbk，用gb2312有的字符不全--> 
    <property name="connection.characterEncoding">gbk</property>        
           
         <!--hibernate.dialect 只是Hibernate使用的數(shù)據(jù)庫方言,就是要用Hibernate連接那種類型的數(shù)據(jù)庫服務(wù)器。--> 
           <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property> 
         <!--指定映射文件為“hibernate/ch1/UserInfo.hbm.xml”-->           
           <mapping resource="org/mxg/UserInfo.hbm.xml"> 
  </session-factory> 
  </hibernate-configuration> 

 配置文件中映射元素詳解

對象關(guān)系的映射是用一個XML文檔來說明的。映射文檔可以使用工具來生成，如XDoclet，Middlegen和AndroMDA等。下面從一個映射的例子開始講解映射元素，映射文件的代碼如下。

＜?xml version="1.0"?＞  
＜!--  
所有的XML映射文件都需要定義如下所示的DOCTYPE。  
Hibernate會先在它的類路徑（classptah）中搜索DTD文件。  
--＞  
＜!DOCTYPE hibernate-mapping PUBLIC  
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
"http：//hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"＞  
＜!--  
hibernate-mapping有幾個可選的屬性：  
schema屬性指明了這個映射的表所在的schema名稱。  
default-cascade屬性指定了默認(rèn)的級聯(lián)風(fēng)格 可取值有 none、save、update。  
auto-import屬性默認(rèn)讓我們在查詢語言中可以使用非全限定名的類名 可取值有 true、false。  
package屬性指定一個包前綴。  
--＞  
＜hibernate-mapping schema="schemaName" default-cascade="none" 
auto-import="true" package="test"＞  
＜!--用class元素來定義一個持久化類 --＞  
＜class name="People" table="person"＞  
＜!-- id元素定義了屬性到數(shù)據(jù)庫表主鍵字段的映射。--＞  
＜id name="id"＞  
＜!-- 用來為該持久化類的實例生成唯一的標(biāo)識 --＞  
＜generator class="native"/＞  
＜/id＞  
＜!-- discriminator識別器 是一種定義繼承關(guān)系的映射方法--＞  
＜discriminator column="subclass" type="character"/＞  
＜!-- property元素為類聲明了一個持久化的，JavaBean風(fēng)格的屬性--＞  
＜property name="name" type="string"＞  
＜column name="name" length="64" not-null="true" /＞  
＜/property＞  
＜property name="sex" 
not-null="true" 
update="false"/＞  
＜!--多對一映射關(guān)系--＞  
＜many-to-one name="friend" 
column="friend_id" 
update="false"/＞  
＜!--設(shè)置關(guān)聯(lián)關(guān)系--＞  
＜set name="friends" inverse="true" order-by="id"＞  
＜key column="friend_id"/＞  
＜!—一對多映射--＞  
＜o(jì)ne-to-many class="Cat"/＞  
＜/set＞  
＜/class＞  
＜/hibernate-mapping＞ 

組件應(yīng)用的方法

組件有兩種類型，即組件（component）和動態(tài)組件（dynamic-component）。在配置文件中，component元素為子對象的元素與父類對應(yīng)表的字段建立起映射關(guān)系。然后組件可以聲明它們自己的屬性、組件或者集合。component元素的定義如下所示：

＜component name="propertyName" class="className" insert="true|false" 
upate="true|false" access="field|property|ClassName"＞  
＜property ...../＞  
＜many-to-one .... /＞  
........  
＜/component＞  

在這段代碼中，name是指屬性名，class是類的名字，insert指的是被映射的字段是否出現(xiàn)在SQL的INSERT語句中，upate指出被映射的字段是否出現(xiàn)在SQL的UPDATE語句中，access指出訪問屬性的策略。

Hiebernate的基本配置

Hibernate的數(shù)據(jù)庫連接信息是從配置文件中加載的。Hibernate的配置文件有兩種形式：一種是XML格式的文件，一種是properties屬性文件。properties形式的配置文件默認(rèn)文件名是hibernate.properties，一個properties形式的配置文件內(nèi)容如下所示：

#指定數(shù)據(jù)庫使用的驅(qū)動類  
hibernate.connection.driver_class = com.mysql.jdbc.Driver r  
#指定數(shù)據(jù)庫連接串  
hibernate.connection.url = jdbc:mysql://localhost:3306/db  
#指定數(shù)據(jù)庫連接的用戶名  
hibernate.connection.username = user 
#指定數(shù)據(jù)庫連接的密碼  
hibernate.connection.password = password 
#指定數(shù)據(jù)庫使用的方言  
hibernate.dialect = net.sf.hibernate.dialect.MySQLDialect  
#指定是否打印SQL語句  
hibernate.show_sql=true 

在配置文件中包含了一系列屬性的配置，Hibernate將根據(jù)這些屬性來連接數(shù)據(jù)庫。

在XML格式的配置文件中，除了基本的Hibernate配置信息，還可以指定具體的持久化類的映射文件，這可以避免將持久化類的配置文件硬編碼在程序中。XML格式的配置文件的默認(rèn)文件名為hibernate.cfg.xml，一個XML配置文件的示例如下所示：

＜?xml version=''1.0'' encoding=''UTF-8''?＞  
＜!DOCTYPE hibernate-configuration PUBLIC  
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"  
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd"＞  
＜hibernate-configuration＞  
＜session-factory＞  
＜!--顯示執(zhí)行的SQL語句--＞  
＜property name="show_sql"＞true＜/property＞  
＜!--連接字符串--＞  
＜property name="connection.url"＞jdbc:mysql://localhost:3306/STU＜/property＞  
＜!--連接數(shù)據(jù)庫的用戶名--＞  
＜property name="connection.username"＞root＜/property＞  
＜!--數(shù)據(jù)庫用戶密碼--＞  
＜property name="connection.password"＞root＜/property＞  
＜!--數(shù)據(jù)庫驅(qū)動--＞  
＜property name="connection.driver_class"＞com.mysql.jdbc.Driver＜/property＞  
＜!--選擇使用的方言--＞  
＜property name="dialect"＞org.hibernate.dialect.MySQLDialect＜/property＞  
＜!--映射文件 --＞  
＜mapping resource="com/stuman/domain/Admin.hbm.xml" /＞  
＜!--映射文件--＞  
＜mapping resource="com/stuman/domain/Student.hbm.xml" /＞  
＜/session-factory＞  
＜/hibernate-configuration＞  

properties形式的配置文件和XML格式的配置文件可以同時使用。當(dāng)同時使用兩種類型的配置文件時，XML配置文件中的設(shè)置會覆蓋properties配置文件的相同的屬性。

對象標(biāo)識符號

在關(guān)系數(shù)據(jù)庫表中，主鍵（Primary Key）用來識別記錄，并保證每條記錄的唯一性。在Java語言中，通過比較兩個變量所引用對象的內(nèi)存地址是否相同，或者比較兩個變量引用的對象值是否相同來判斷兩對象是否相等。Hibernate為了解決兩者之間的不同，使用對象標(biāo)識符（OID）來標(biāo)識對象的唯一性。OID是關(guān)系數(shù)據(jù)庫中主鍵在Java對象模型中的等價物。在運行時，Hibernate根據(jù)OID來維持Java對象和數(shù)據(jù)庫表中記錄的對應(yīng)關(guān)系。如下代碼所示，三次調(diào)用了Session的load()方法，分別加載OID為1或3的User對象。

Transaction tx = session.beginTransaction();  
User user1 = (User)session.load(User.class,new Long(1));  
User user2 = (User)session.load(User.class,new Long(1));  
User user3 = (User)session.load(User.class,new Long(3));  
System.out.println( user1 == user2 );  
System.out.println( user1 == user3 );  

應(yīng)用程序在執(zhí)行上述代碼時，第一次加載OID為1的User對象，從數(shù)據(jù)庫中查找ID為1的記錄，然后創(chuàng)建相應(yīng)的User實例，并把它保存在Session緩存中，最后將該實例的引用賦值給變量user1。第二次加載OID為1的對象時，直接把Session緩存中OID為1的實例的引用賦值給變量user2。因此，表達式user1==user2的結(jié)果為true。

標(biāo)識的生成可以使用不同的策略，表1為Hibernate內(nèi)置的標(biāo)識生成策略。

表1：Hibernate標(biāo)識生成策略

Hibernate映射類型

在對象/關(guān)系映射文件中，Hibernate采用映射類型作為Java類型和SQL類型的橋梁。Hibernate映射類型分為2種：內(nèi)置映射類型和自定義映射類型。

1、內(nèi)置映射類型

Hibernate對所有的Java原生類型、常用的Java類型如String、Date等都定義了內(nèi)置的映射類型。表2列出了Hibernate映射類型、對應(yīng)的Java類型以及對應(yīng)的標(biāo)準(zhǔn)SQL類型。

表2：Hibernate內(nèi)置映射類型

hibernate-mapping

這個元素包括三個可選的屬性。schema屬性，指明了這個映射所引用的表所在的schema名稱。假若指定了這個屬性，表名會加上所指定的schema的名字?jǐn)U展為全限定名。假若沒有指定，表名就不會使用全限定名。default-cascade指定了未明確注明cascade屬性的Java屬性和集合類Java會采取什么樣的默認(rèn)級聯(lián)風(fēng)格。auto-import屬性默認(rèn)讓我們在查詢語言中可以使用非全限定名的類名。

<hibernate-mapping  
         schema="schemaName"                           
         default-cascade="none|save-update"            
         auto-import="true|false"                      
         package="package.name"                        
 /> 

schema (可選): 數(shù)據(jù)庫schema名稱。

default-cascade (可選 - 默認(rèn)為 none): 默認(rèn)的級聯(lián)風(fēng)格。

auto-import (可選 - 默認(rèn)為 true): 指定是否我們可以在查詢語言中使用非全限定的類名（僅限于本映射文件中的類）。

package (可選): 指定一個包前綴，如果在映射文檔中沒有指定全限定名，就使用這個包名。

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

5.1.3. class

你可以使用class元素來定義一個持久化類：

<class 
        name="ClassName"                               
        table="tableName"                              
        discriminator-value="discriminator_value"      
        mutable="true|false"                           
        schema="owner"                                 
        proxy="ProxyInterface"                         
        dynamic-update="true|false"                    
        dynamic-insert="true|false"                    
        select-before-update="true|false"              
        polymorphism="implicit|explicit"               
        where="arbitrary sql where condition"         (11)  
        persister="PersisterClass"                    (12)  
        batch-size="N"                                (13)  
        optimistic-lock="none|version|dirty|all"      (14)  
        lazy="true|false"                             (15)  
/> 

name: 持久化類（或者接口）的Java全限定名。

table: 對應(yīng)的數(shù)據(jù)庫表名。

discriminator-value（辨別值） （可選 - 默認(rèn)和類名一樣）：一個用于區(qū)分不同的子類的值，在多態(tài)行為時使用。

mutable（可變） (可選, 默認(rèn)值為 true): 表明該類的實例可變（不可變）。

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

proxy (可選): 指定一個接口，在延遲裝載時作為代理使用。你可以在這里使用該類自己的名字。

dynamic-update（動態(tài)更新） (可選，默認(rèn)為false): 指定用于UPDATE 的SQL將會在運行時動態(tài)生成，并且只更新那些改變過的字段。

dynamic-insert（動態(tài)插入） (可選, 默認(rèn)為false): 指定用于INSERT的 SQL 將會在運行時動態(tài)生成，并且只包含那些非空值字段。

select-before-update (可選，默認(rèn)值為false): 指定Hibernate除非確定對象的確被修改了，不會執(zhí)行SQL UPDATE操作。在特定場合（實際上，只會發(fā)生在一個臨時對象關(guān)聯(lián)到一個新的session中去，執(zhí)行update()的時候），這說明Hibernate會在UPDATE之前執(zhí)行一次額外的SQL SELECT操作，來決定是否應(yīng)該進行UPDATE。

polymorphism（多形，多態(tài)） (可選, 默認(rèn)值為 implicit (隱式)): 界定是隱式還是顯式的使用查詢多態(tài)。

(11) where (可選) 指定一個附加的SQLWHERE 條件，在抓取這個類的對象時會一直增加這個條件。

(12) persister (可選): 指定一個定制的ClassPersister。

(13) batch-size (可選,默認(rèn)是1) 指定一個用于根據(jù)標(biāo)識符抓取實例時使用的"batch size"（批次抓取數(shù)量）。

(14) optimistic-lock（樂觀鎖定） (可選，默認(rèn)是version): 決定樂觀鎖定的策略。

(15) lazy（延遲） (可選): 假若設(shè)置 lazy="true"，就是設(shè)置這個類自己的名字作為proxy接口的一種等價快捷形式。

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

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

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

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

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

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

使用select-before-update通常會降低性能.當(dāng)是在防止數(shù)據(jù)庫不必要的觸發(fā)update觸發(fā)器，這就很有用了。

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

version（版本檢查）檢查version/timestamp字段

all（全部） 檢查全部字段

dirty（臟檢查）只檢察修改過的字段

none（不檢查）不使用樂觀鎖定

我們非常強烈建議你在Hibernate中使用version/timestamp字段來進行樂觀鎖定。對性能來說，這是最好的選擇，并且這也是唯一能夠處理在session外進行操作的策略（就是說，當(dāng)使用Session.update()的時候）。

5.1.4. id

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

<id  
name="propertyName"   
type="typename"   
column="column_name"   
unsaved-value="any|none|null|id_value"   
access="field|property|ClassName">   
 
<generator class="generatorClass"/>  
</id> 

name (可選): 標(biāo)識屬性的名字。

type (可選): 標(biāo)識Hibernate類型的名字。

column (可選 - 默認(rèn)為屬性名): 主鍵字段的名字。

unsaved-value (可選 - 默認(rèn)為null): 一個特定的標(biāo)識屬性值，用來標(biāo)志該實例是剛剛創(chuàng)建的，尚未保存。這可以把這種實例和從以前的session中裝載過（可能又做過修改--譯者注）但未再次持久化的實例區(qū)分開來。

access (可選 - 默認(rèn)為property): Hibernate用來訪問屬性值的策略。

如果 name屬性不存在，會認(rèn)為這個類沒有標(biāo)識屬性。

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

還有一個另外的<composite-id>聲明可以訪問舊式的多主鍵數(shù)據(jù)。我們強烈不鼓勵使用這種方式。

5.1.4.1. generator

必須聲明的<generator>子元素是一個Java類的名字，用來為該持久化類的實例生成唯一的標(biāo)識。如果這個生成器實例需要某些配置值或者初始化參數(shù)，用<param>元素來傳遞。

<id name="id" type="long" column="uid" unsaved-value="0"> 
<generator class="net.sf.hibernate.id.TableHiLoGenerator"> 
<param name="table">uid_table</param> 
<param name="column">next_hi_value_column</param> 
</generator> 
</id> 

所有的生成器都實現(xiàn)net.sf.hibernate.id.IdentifierGenerator接口。這是一個非常簡單的接口；某些應(yīng)用程序可以選擇提供他們自己特定的實現(xiàn)。當(dāng)然，Hibernate提供了很多內(nèi)置的實現(xiàn)。下面是一些內(nèi)置生成器的快捷名字：

increment（遞增）

用于為long, short或者int類型生成唯一標(biāo)識。只有在沒有其他進程往同一張表中插入數(shù)據(jù)時才能使用。在集群下不要使用。

identity

對DB2,MySQL, MS SQL Server, Sybase和HypersonicSQL的內(nèi)置標(biāo)識字段提供支持。返回的標(biāo)識符是long, short 或者int類型的。

sequence （序列）

在DB2,PostgreSQL, Oracle, SAP DB, McKoi中使用序列（sequence)，而在Interbase中使用生成器(generator)。返回的標(biāo)識符是long, short或者 int類型的。

hilo （高低位）

使用一個高/低位算法來高效的生成long, short或者 int類型的標(biāo)識符。給定一個表和字段（默認(rèn)分別是是hibernate_unique_key 和next）作為高位值得來源。高/低位算法生成的標(biāo)識符只在一個特定的數(shù)據(jù)庫中是唯一的。在使用JTA獲得的連接或者用戶自行提供的連接中，不要使用這種生成器。

seqhilo（使用序列的高低位）

使用一個高/低位算法來高效的生成long, short或者 int類型的標(biāo)識符，給定一個數(shù)據(jù)庫序列（sequence)的名字。

uuid.hex

用一個128-bit的UUID算法生成字符串類型的標(biāo)識符。在一個網(wǎng)絡(luò)中唯一（使用了IP地址）。UUID被編碼為一個32位16進制數(shù)字的字符串。

uuid.string

使用同樣的UUID算法。UUID被編碼為一個16個字符長的任意ASCII字符組成的字符串。不能使用在PostgreSQL數(shù)據(jù)庫中

native（本地）

根據(jù)底層數(shù)據(jù)庫的能力選擇identity, sequence 或者h(yuǎn)ilo中的一個。

assigned（程序設(shè)置）

讓應(yīng)用程序在save()之前為對象分配一個標(biāo)示符。

foreign（外部引用）

使用另外一個相關(guān)聯(lián)的對象的標(biāo)識符。和<one-to-one>聯(lián)合一起使用。

原文鏈接：http://blog.csdn.net/ysynlm/article/details/2766281

【編輯推薦】

1. 詳解Hibernate攔截器與事件監(jiān)聽器
2. Hibernate的緩存解讀
3. Hibernate的集合映射
4. Hibernate關(guān)聯(lián)關(guān)系配置
5. Hibernate中inverse屬性與cascade屬性