對象-關系映射（O/R映射）是許多軟件開發項目的常見需求。數據持久化過程中所涉及到的活動是非常乏味且易于出錯的。如果考慮到不可避免的需求變化，我們就面臨很大的麻煩：數據存儲結構必須與源代碼保持同步。再加上移植性問題，事情就變得非常復雜。
而Hibernate可以幫助我們輕松地在永久性存儲介質中保存數據，而不需要在選擇存儲、安裝或配置類型方面浪費太多精力。Hibernate允許我們存儲任何類型的對象，因此，應用程序不需要知道其數據將使用Hibernate進行持久化。當然，這里提到的任何事情都可以逆向應用：現在從存儲器獲取已經準備好的對象是很平常的事情。更新和刪除數據也是如此。
在開始之前，您需要Hibernate的發行版，可以在Hibernate web站點（www.hibernate.org）上找到它。我們將使用2.0.3版本。對于數據庫，我們將使用Hypersonic SQL 1.7.1版本,它可以在hsqldb.sourceforge.net上找到。 Hibernate還支持許多開源或商業數據庫，例如MySQL、PostgreSQL、Oracle、DB2等。對于受支持的任何數據庫，安裝這個教程都很簡單。完整列表參見官方文檔。
注意：如果您不希望類被持久化在數據庫中（比如說，您只希望進行串行化），那么Hibernate API為您提供了net.sf.hibernate.persister.EntityPersister類和net.sf.hibernate.persister.ClassPersister接口。通過編寫子類或實現它們，您可以編寫自己的持久化類，并根據需要使用它們。
下載了所有必需的安裝包后，我們必須設置測試環境?；旧?，我們所需做的就是把下載的.jar文件放到CLASSPATH中。這包括Hibernate發行版中的hibernate2.jar和Hypersonic的lib/ 目錄下的hsqldb.jar。Hibernate還需要其他的幾個庫，這些庫都可以在<hibernate-dist>/lib目錄中找到。并不是該目錄下的所有.jars文件都需要，但是如果您使用所有文件，也沒有什么壞處。在我們開始研究Hibernate之前，我們將首先定義我們的問題域。
注意：Hibernate使用Apache的commons-logging。它是一個智能工具，如果找到log4j，它就會默認地使用它。Log4j是一個出色的日志記錄庫，我們將在這個教程中使用它。如果您還沒有這個軟件（您真的應該安裝這個軟件！），可以從Log4j homepage下載，并將它添加到CLASSPATH中。使用Hibernate團隊所提供的示例log4j.PRoperties，它可以在<hibernate-dist>/src目錄下找到。
每個開發人員都至少執行過一次類似的任務：創建一個訂單，把一些產品放在其中，它就變成訂單項，然后保存該訂單。
我們使用這些簡單的SQL命令來設置數據庫：
CREATE TABLE ORDERS( ID VARCHAR NOT NULL PRIMARY KEY, ORDER_DATE TIMESTAMP NOT NULL, PRICE_TOTAL DOUBLE NOT NULL)CREATE TABLE PRODUCTS( ID VARCHAR NOT NULL PRIMARY KEY, NAME VARCHAR NOT NULL, PRICE DOUBLE NOT NULL, AMOUNT INTEGER NOT NULL)CREATE TABLE ORDER_ITEMS( ID VARCHAR NOT NULL PRIMARY KEY, ORDER_ID VARCHAR NOT NULL, PRODUCT_ID VARCHAR NOT NULL, AMOUNT INTEGER NOT NULL, PRICE DOUBLE NOT NULL)
這個數據模型非常簡單。對于一個實際的“生產質量”數據模型，我們會需要外鍵、索引、額外的字段等等。對于本教程，上面的數據模型就可以了。
注意：如果您決定為這個教程使用HypersonicSQL，那么可以使用本文附件源軟件包中提供的orders.script和orders.properties文件。
盡管這些業務需求簡單且易于理解，但是編寫一堆準備好的語句的傳統方法將很快令人厭煩。而Hibernate將會把我們解放出來。我們所需的只是一組簡單的映射文件。但首先我們需要編寫Java類。
注意：我們將把所有將要持久化的類放到test.hibernate包中，把所有輔助類放到test包中。
這個簡單的類只定義了必要的字段：ID、產品名稱、產品價格和這種產品的當前庫存量。由于Hibernate使用無格式的簡單JavaBeans，我們需要做的只是為每個重要字段（在我們的示例中，所有字段都是重要字段）創建getter和setter方法，以及默認的構造函數。
package test.hibernate;public class Product { private String id; private String name; private double price; private int amount; public String getId() { return id; } public void setId(String string) { id = string; } // 默認的構造函數及其他 // 為了簡潔起見，getter/setter方法沒有顯示 // ...}
我們還需要重寫toString()方法。這將幫助我們使用簡單的System.out.println(obj)調用來跟蹤應用程序流：
public String toString() { return "[Product] " + name + "(" + id + ") price=" + price + " amount=" + amount;}這就是全部的product類代碼。但Product沒有實現任何接口，也沒有繼承任何類，Hibernate又如何知道持久化該類型的對象呢？答案很簡單：Hibernate可以處理任何類型的Java對象，只要它能夠遵循JavaBeans約定。
我們需要創建的下一個類是Order，它甚至比Product更簡單：它只包含ID、創建日期、總價格和該Order所包括的OrderItems的Set。當然，還需要創建getter和setter方法以及默認的構造函數。
package test.hibernate;import java.util.Date;import java.util.HashSet;import java.util.Set;public class Order { private String id; private Date date; private double priceTotal; private Set orderItems = new HashSet(); // 自動設置該Order的創建時間 public Order() { this.date = new Date(); } public String getId() { return id; } public void setId(String string) { id = string; } // 為了簡潔起見，其他getter/setter方法沒有顯示 // ...}同樣也要重寫toString()方法。不要忘記對orderItems執行循環！下載完整的源代碼來查看這個示例。
這個類稍微復雜一些，但仍然很易懂。我們的業務需求決定我們需要一定量的產品，我們將會把它們放到一個訂單中。那些產品將自動變成訂單項。這時就需要自定義構造函數了。
package test.hibernate;public class OrderItem { /** * 創建有效的訂單項。自動設置訂單項的價格，并更正產品的庫存可用量 * * @param order 該訂單項屬于的訂單 * @param product 該訂單項為哪種產品而創建 * @param amount */ public OrderItem(Order order, Product product, int amount) { this.order = order; this.product = product; this.amount = amount; product.setAmount(product.getAmount() - amount); this.price = product.getPrice() * amount; } // 還需要默認的構造函數來保證Hibernate工作 /** * 空構造函數遵循JavaBeans約定 * */ public OrderItem() { // 空的默認構造函數 } // 字段 private String id; private Product product; private Order order; private String productId; private String orderId; private double price; private int amount; public String getId() { return id; } public String getProductId() { return product.getId(); } public String getOrderId() { return order.getId(); } // 其他getter/setter方法沒有顯示 // ... //顯示該訂單項的方便方式 public String toString() { return "[OrderItem] id=" + id + " amount=" + amount + " price=" + price + "(" + product + ")"; }}現在我們有了反映數據庫結構的所有類。余下的唯一一件沒有解釋的事情就是如何把產品放到一個訂單中。只需把下面的方法添加到Order類中：
/*** 添加一項產品到訂單中。產品自動成為一個訂單項。 * priceTotal被自動更新。* * @param p 添加到該訂單的產品* @param amount 添加的產品量*/public void addProduct(Product p, int amount) { OrderItem orderItem = new OrderItem(this, p, amount); this.priceTotal = this.priceTotal + p.getPrice() * amount; this.orderItems.add(orderItem);}
在我們假想的應用程序中，基本的使用模式非常簡單：我們將創建一個Product，然后將其持久化（或者換句話說，保存它）；我們將搜索并加載一個已經持久化的Product，并確保其可以使用；我們將會更新和刪除Product。
現在我們終于用到Hibernate了。使用的場景非常簡單：
正如我們所看到的，這里沒有提到JDBC、SQL或任何類似的東西。非常令人振奮！下面的示例遵循了上面提到的步驟：
package test;import net.sf.hibernate.Session;import net.sf.hibernate.SessionFactory;import net.sf.hibernate.Transaction;import net.sf.hibernate.cfg.Configuration;import test.hibernate.Product;// 用法：// java test.InsertProduct name amount pricepublic class InsertProduct { public static void main(String[] args) throws Exception { // 1. 創建Product對象 Product p = new Product(); p.setName(args[0]); p.setAmount(Integer.parseInt(args[1])); p.setPrice(Double.parseDouble(args[2])); // 2. 啟動Hibernate Configuration cfg = new Configuration() .addClass(Product.class); SessionFactory sf = cfg.buildSessionFactory(); // 3. 打開Session Session sess = sf.openSession(); // 4. 保存Product，關閉Session Transaction t = sess.beginTransaction(); sess.save(p); t.commit(); sess.close(); }}讓我們來運行它！通過運行java test.InsertProduct Milk 100 1.99命令，插入價格為1.99的100瓶牛奶。我們會得到如下的輸出日志：
Nov 23, 2003 9:05:50 AM net.sf.hibernate.cfg.Environment <clinit>INFO: Hibernate 2.0.3Nov 23, 2003 9:05:50 AM net.sf.hibernate.cfg.Environment <clinit>INFO: hibernate.properties not foundNov 23, 2003 9:05:50 AM net.sf.hibernate.cfg.Environment <clinit>INFO: using CGLIB reflection optimizerNov 23, 2003 9:05:50 AM net.sf.hibernate.cfg.Environment <clinit>INFO: JVM proxy support: trueNov 23, 2003 9:05:50 AM net.sf.hibernate.cfg.Configuration addClassINFO: Mapping resource: test/hibernate/Product.hbm.xmlException in thread "main" net.sf.hibernate.MappingException: Resource: test/hibernate/Product.hbm.xml not found at net.sf.hibernate.cfg.Configuration.addClass(Configuration.java:285) at test.FindProductByName.main(FindProductByName.java:24)
它無法工作。其中有兩行尤其讓人感興趣：
INFO: hibernate.properties not found andResource: test/hibernate/Product.hbm.xml not found.
當然，INFO行指出我們需要一個hibernate.properties配置文件。在這個文件中，我們配置要使用的數據庫、用戶名和密碼以及其他選項。使用下面提供的這個示例來連接前面提到的Hypersonic數據庫：
hibernate.connection.username=sahibernate.connection.passWord=hibernate.connection.url=jdbc:hsqldb:/home/davor/hibernate/ordershibernate.connection.driver_class=org.hsqldb.jdbcDriverhibernate.dialect=net.sf.hibernate.dialect.HSQLDialect
適當地進行修改（例如，可能需要修改hibernate.connection.url），并保存到classpath中。
這很容易，但那個test/hibernate/Product.hbm.xml資源是什么呢？它是一個XML文件，定義了Java對象如何被持久化（映射）到一個數據庫。在該文件中，我們定義數據存儲到哪個數據庫表中，哪個字段映射到數據庫表的哪個列，不同的對象如何互相關聯，等等。讓我們來看一下Product.hbm.xml。
<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD//EN" "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd"> <hibernate-mapping> <class name="test.hibernate.Product" table="products"> <id name="id" type="string" unsaved-value="null"> <column name="id" sql-type="char(32)" not-null="true"/> <generator class="uuid.hex"/> </id> <property name="name"> <column name="name" sql-type="char(255)" not-null="true"/> </property> <property name="price"> <column name="price" sql-type="double" not-null="true"/> </property> <property name="amount"> <column name="amount" sql-type="integer" not-null="true"/> </property> </class></hibernate-mapping>
它非常簡單且易于理解。幾個細節特別令人感興趣：
<generator class="uuid.hex"/>元素乍一看不太好理解。但是知道了它是<id>的一個子元素后，它的作用就很明顯了：由于應用程序不知道它的數據如何被持久化（我們一直這么說），我們需要一個沒有任何業務含義的代理鍵幫助Hibernate操縱對象。新創建的Products沒有那個id，Hibernate將為我們創建它們。我們選擇使用UUID字符串，但它提供了許多ID生成器（順序的、限定范圍的，甚至是用戶指派的，等等），而且還可以編寫自己的ID生成器。詳細內容參見文檔。
現在，創建（復制、粘貼）Product.hbm.xml的內容，并把文件和test.hibernate.Product類放到同一個包內（例如，放置Product.java文件的目錄），重新運行java test.InsertProduct Milk 100 1.99命令。現在我們看到更多的日志以及...沒有其他東西了！它運行正常嗎？在Session sess = sf.openSession(); 前和sess.close()后添加System.out.println(p)，看一看Produc出了什么問題。重新運行程序。您將看到類似于如下內容的日志輸出（ID數字肯定會不同的）：
[Product] Milk(null) price=1.99 amount=100[Product] Milk(40288081f907f42900f907f448460001) price=1.99 amount=100
Hibernate為我們創建了Product的id！讓我們看一下Product是否存儲到了數據庫中。執行select * from products，數據庫返回類似于以下內容的輸出：
ID NAME PRICE AMOUNT 40288081f907f42900f907f448460001Milk 1.99 100
Product信息被成功地插入到了數據庫中，我們甚至都還沒有編寫一行SQL語句！
插入一些其他產品，例如面包、咖啡、啤酒等，這樣就可以繼續學習下面的教程。
查找和加載已經持久化的對象在Hibernate中非常簡單。使用它的查詢語言，我們可以很容易地通過ID、名稱或其他屬性獲取一個對象（或對象集）。我們能夠獲取完整的對象或它的一部分屬性。Hibernate將處理余下的工作，最后，我們將擁有相當有用的對象層次體系。我們來看一下test.FindProductByName類。
package test;import java.util.List;import net.sf.hibernate.Hibernate;import net.sf.hibernate.Session;import net.sf.hibernate.SessionFactory;import net.sf.hibernate.cfg.Configuration;import test.hibernate.Product;// 用法：// java test.FindProductByName namepublic class FindProductByName { public static void main(String[] args) throws Exception { // 執行的查詢 String query = "select product from product " + "in class test.hibernate.Product " + "where product.name=:name"; // 搜索的內容 String name = args[0]; // 初始化 Configuration cfg = new Configuration() .addClass(Product.class); SessionFactory sf = cfg.buildSessionFactory(); // 打開會話 Session sess = sf.openSession(); // 搜索并返回 List list = sess.find(query, name, Hibernate.STRING); if (list.size() == 0) { System.out.println("No products named " + name); System.exit(0); } Product p = (Product) list.get(0); sess.close(); System.out.println("Found product: " + p); }}
在FindProductByName中有幾點值得注意：
執行java test.FindProductByName Milk，查看顯示在控制臺中的內容。
注意：查詢是區分大小寫的，所以搜索小寫的milk將不會返回任何結果。使用lower()或upper()SQL函數來啟用不區分大小寫的搜索。在這種情況下，我們會在查詢字符串中使用where lower(product.name)=lower(:name)。關于查詢的詳細內容，請參見文檔。此外，如果不希望顯示所有的INFO日志信息，可以修改log4j.properties文件，將日志等級設置為warn。
到現在為止，您應該對Hibernate的工作方式有了一個基本的了解，因此我們將縮短冗長的示例，只顯示重要的部分。
為了在單個事務中將所有產品的價格提高10%，我們可以編寫如下的內容：
double percentage = Double.parseDouble(args[0])/100;sess = sf.openSession();Transaction t = sess.beginTransaction();// 列表包含產品Iterator iter = list.iterator();while (iter.hasNext()) { Product p = (Product) iter.next(); p.setPrice(p.getPrice() * (1 + percentage)); sess.saveOrUpdate(p); }t.commit();sess.close();最后，要刪除Product，當然要調用sess.delete(product)。如果數據庫關閉了autocommit，不要忘記調用commit()提交Transaction。
現在，我們已經完成了針對單個對象的所有基本操作——創建、讀取、更新和刪除。看上去相當有趣，但我們可以做得更好。現在我們來學習如何操縱對象集而不需要編寫SQL語句。所有的魔法都通過映射文件實現。
有時一個一個地操縱對象確實可行，但是我們希望能夠級聯加載和更新。現在我們來看如何做到這一點。
我們需要同時檢查Order和OrderItem。就如前面所提到的，我們添加一項Product到一個Order中，它將變成一個OrderItem。Order在內部保存一個OrderItem集。我們希望保存Order，讓Hibernate來做其他工作：保存OrderItem和更新所添加的Product的可用庫存（數量）。聽起來很復雜，但實際上非常簡單。Hibernate知道如何處理一對一、一對多、多對一和多對多方式中的相關對象。我們將從映射文件開始。
<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD//EN" "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd"><hibernate-mapping> <class name="test.hibernate.Order" table="orders"> <id name="id" type="string" unsaved-value="null" > <column name="id" sql-type="char(32)" not-null="true"/> <generator class="uuid.hex"/> </id> <property name="date"> <column name="order_date" sql-type="datetime" not-null="true"/> </property> <property name="priceTotal"> <column name="price_total" sql-type="double" not-null="true"/> </property> <set name="orderItems" table="order_items" inverse="true" cascade="all"> <key column="order_id" /> <one-to-many class="test.hibernate.OrderItem" /> </set> </class></hibernate-mapping>
這個映射文件非常易于理解，除了最后一個元素<set>。它表示了不同類之間的連接，在我們的例子中，這些類是Order和OrderItem。屬性和子元素很容易理解：一個Set類型的字段，名為orderItems（參見上面的Order源代碼），它包含類型為test.hibernate.OrderItem的對象，正如<one-to-many>子元素所解釋的那樣。這些對象被持久化在表order_items中，order_id列包含OrderItem類型的對象的鍵。
cascade="all"是一個非常重要的屬性。它解釋了在操縱連接到的對象時，Hibernate如何動作。在我們的例子中，當創建一個Order時，我們無疑希望它所有的OrderItem也被創建；當然，當一個Order被刪除時，我們也希望它所有的OrderItem也被刪除。Cascade屬性還有另外三個選項（none、save-update和delete），我們將在下面的示例中看一下如何使用它們。
這個對象比較有意思。它的實例自動在Order中創建，基本上不會存在于其外。然而，由于它們在創建Order時代表Product，所以我們需要它們。如果一項產品的價格改變了，我們無疑不希望所有相關的OrderItem以及Order的價格被改變。我們需要的只是在OrderItem創建時更新Product的可用庫存。最后，當一項Order被刪除時，其OrderItem也被刪除，但我們不能改變Product！聽上去很復雜，特別是要編寫所有這些SQL語句的話。但Hibernate把它們壓縮成了映射文件中的兩行！
<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD//EN" "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd"><hibernate-mapping> <class name="test.hibernate.OrderItem" table="order_items"> <id name="id" type="string" unsaved-value="null" > <column name="id" sql-type="char(32)" not-null="true"/> <generator class="uuid.hex"/> </id> <property name="orderId" insert="false" update="false"> <column name="order_id" sql-type="char(32)" not-null="true"/> </property> <property name="productId" insert="false" update="false"> <column name="product_id" sql-type="char(32)" not-null="true"/> </property> <property name="amount"> <column name="amount" sql-type="int" not-null="true"/> </property> <property name="price"> <column name="price" sql-type="double" not-null="true"/> </property> <many-to-one name="order" class="test.hibernate.Order" column="order_id" /> <many-to-one name="product" class="test.hibernate.Product" cascade="save-update" column="product_id"/> </class></hibernate-mapping>
到目前為止，我們了解了關于<id>和<property>元素的一切，但<many-to-one>是一個新元素。這個元素非常簡單。第一個<many-to-one>元素指出OrderItem的名為order的字段是test.hibernate.Order類型，并且通過表order_items的order_id列來引用（參見class元素的table屬性）。第二個many-to-one元素類似于第一個，除了它具有cascade="save-update"屬性。它在定義的內容之前進行解釋。在這個例子中，我們假設Hibernate只在保存（創建）或更新（更改）OrderItem時傳遞Product的更改，而在刪除時不傳遞更改。因此，上述的復雜SQL語句就被壓縮為單個屬性！現在這個問題解決了！
創建一個訂單。在該示例中，我們創建并持久化一個訂單。反復運行這個示例，查看產品數量在每次成功創建訂單后如何變化。
// ...Configuration cfg = new Configuration() .addClass(Product.class) .addClass(Order.class) .addClass(OrderItem.class);// ...Order order = new Order();order.addProduct(milk, 3);order.addProduct(coffee, 5);// ...sess = sf.openSession();Transaction t = sess.beginTransaction();sess.save(order);t.commit();sess.close();System.out.println(order);// ...
按照價格范圍查找訂單。在該示例中，我們將展示如何使用一個帶有兩個參數的查詢。Hibernate正確地加載具有適當訂單項和產品的訂單。
// ...String query = "select o from o " + "in class test.hibernate.Order " + "where o.priceTotal > :priceTotalLower " + "and o.priceTotal < :priceTotalUpper";// ... Query q = sess.createQuery(query);q.setDouble("priceTotalLower", Double.parseDouble(args[0]));q.setDouble("priceTotalUpper", Double.parseDouble(args[1]));List list = q.list();// ...sess.close();// ...刪除一定價格范圍內的訂單。這是一個重要的示例。這里我們會看到Hibernate是一個多么智能的工具。正如前面所提到的，當刪除一個訂單時，其訂單項也需要被刪除，但不能改變產品。在運行該示例后，檢查數據庫，確認產品沒有變化。
// ...String query = "select o from o " + "in class test.hibernate.Order " + "where o.priceTotal > :priceTotalLower " + "and o.priceTotal < :priceTotalUpper";Transaction tx = sess.beginTransaction();sess.delete(query, new Object[]{new Double(args[0]), new Double(args[1])}, new Type[]{Hibernate.DOUBLE, Hibernate.DOUBLE} ); tx.commit();sess.close();本文展示了Hibernate有多么強大。您已經了解到可以多么輕松地持久化任何類型的Java對象、操縱對象層次結構、處理集合、使用事務。但Hibernate的功能不止于此。它可以處理使用提交和回滾的完整事務、繼承、幾種類型的集合，并提供非常強大的面向對象查詢語言HQL，HQL支持關聯和聯結、多態、子查詢等。接下來您可以閱讀Hibernate參考文檔，并著手在日常工作中使用Hibernate。
原文出處: Hibernate Your Data http://www.onjava.com/pub/a/onjava/2004/01/14/hibernate.Html
（出處：http://www.49028c.com）
新聞熱點
疑難解答
