使用Hibernate處理數據 (轉)

開始之前

　　在開始之前，您需要Hibernate的發行版，可以在Hibernate web站點（http://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文件。

Java代碼

　　儘管這些業務需求簡單且易於理解，但是編寫一堆準備好的語句的傳統方法將很快令人厭煩。而Hibernate將會把我們解放出來。我們所需的只是一組簡單的映射文件。但首先我們需要編寫Java類。

　　 注意：我們將把所有將要持久化的類放到test.hibernate包中，把所有輔助類放到test包中。

Product

　　這個簡單的類只定義了必要的字段：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約定。

<script src="http://pagead2.googlesyndication.com/pagead/show_ads.js" type="text/javascript"> </script> <iframe name="google_ads_frame" marginwidth="0" marginheight="0" src="http://pagead2.googlesyndication.com/pagead/ads?client=ca-pub-9416189179052893&dt=1139990058125&lmt=1139990058&prev_fmts=160x600_as&format=468x60_as&output=html&channel=0040068371&pv_ch=0040068371%2B&url=http%3A%2F%2Fblog.csdn.net%2Fbaggio785%2Farchive%2F2006%2F02%2F09%2F595170.aspx&color_bg=FFFFFF&color_text=000000&color_link=FF0000&color_url=008000&color_border=FFFFFF&ad_type=text_image&ref=http%3A%2F%2Fsearch.csdn.net%2Fsearch.asp%3Fkey%3Dhibernate%26class%3D%26pre%3Dhibernate%26or%3D%26not%3D%26whole%3D%26date%3D%26field%3D%26class%3D%26option%3Dadvres%26result%3Dpage%26page%3D2%26size%3D10%26orderby%3D&cc=22&u_h=768&u_w=1024&u_ah=738&u_aw=1024&u_cd=32&u_tz=480&u_java=true" frameborder="0" width="468" scrolling="no" height="60" allowtransparency="allowtransparency"></iframe>

Order

　　我們需要創建的下一個類是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執行循環！下載完整的源代碼來查看這個示例。

OrderItem

　　這個類稍微複雜一些，但仍然很易懂。我們的業務需求決定我們需要一定量的產品，我們將會把它們放到一個訂單中。那些產品將自動變成訂單項。這時就需要自定義構造函數了。

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);
}

啓動Hibernate

　　在我們假想的應用程序中，基本的使用模式非常簡單：我們將創建一個Product，然後將其持久化（或者換句話說，保存它）；我們將搜索並加載一個已經持久化的Product，並確保其可以使用；我們將會更新和刪除Product。

創建和持久化Product

　　現在我們終於用到Hibernate了。使用的場景非常簡單：

1. 創建一個有效的Product。
2. 在應用程序啓動時使用net.sf.hibernate.cfg.Configuration獲取net.sf.hibernate.SessionFactory。
3. 通過調用SessionFactory#openSession()，打開net.sf.hibernate.Session。
4. 保存Product，關閉Session。

　　正如我們所看到的，這裏沒有提到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 price
public 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.3
Nov 23, 2003 9:05:50 AM net.sf.hibernate.cfg.Environment <clinit>
INFO: hibernate.properties not found
Nov 23, 2003 9:05:50 AM net.sf.hibernate.cfg.Environment <clinit>
INFO: using CGLIB reflection optimizer
Nov 23, 2003 9:05:50 AM net.sf.hibernate.cfg.Environment <clinit>
INFO: JVM proxy support: true
Nov 23, 2003 9:05:50 AM net.sf.hibernate.cfg.Configuration addClass
INFO: Mapping resource: test/hibernate/Product.hbm.xml
Exception 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 and
Resource: test/hibernate/Product.hbm.xml not found.

　　 當然，INFO行指出我們需要一個hibernate.properties配置文件。在這個文件中，我們配置要使用的數據庫、用戶名和密碼以及其他選項。使用下面提供的這個示例來連接前面提到的Hypersonic數據庫：

hibernate.connection.username=sa
hibernate.connection.password=
hibernate.connection.url=jdbc:hsqldb:/home/davor/hibernate/orders
hibernate.connection.driver_class=org.hsqldb.jdbcDriver
hibernate.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>

　　它非常簡單且易於理解。幾個細節特別令人感興趣：

• <class name="test.hibernate.Product" table="products">，指出正在映射一個名爲test.hibernate.Product的類到表products。
• <id>元素及其子元素，定義Java類與數據庫之間的連接。
• <property>元素，定義每個字段存儲到哪個列及其類型、名稱等。

　　<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 |
40288081f907f42900f907f448460001|Milk  |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 name
public 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中有幾點值得注意：

• 有一個具有where子句的query字符串，這與標準SQL語句很相似。
• 初始化Hibernate的方法與第一個示例中一樣。這一次，我們有配置文件和映射文件。
• sess.find()執行查詢，並將提供的產品名稱設置爲類型Hibernate.STRING的搜索參數。
• 作爲結果，我們得到一個包含所找到的Product的java.util.List。
• 使用Product p = (Product) list.get(0); 我們用通常的類型轉換方法獲取找到的對象。

　　執行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語句。所有的魔法都通過映射文件實現。

Orders，OrderItems

　　有時一個一個地操縱對象確實可行，但是我們希望能夠級聯加載和更新。現在我們來看如何做到這一點。

　　 我們需要同時檢查Order和OrderItem。就如前面所提到的，我們添加一項Product到一個Order中，它將變成一個OrderItem。Order在內部保存一個OrderItem集。我們希望保存Order，讓Hibernate來做其他工作：保存OrderItem和更新所添加的Product的可用庫存（數量）。聽起來很複雜，但實際上非常簡單。Hibernate知道如何處理一對一、一對多、多對一和多對多方式中的相關對象。我們將從映射文件開始。

Order.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.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），我們將在下面的示例中看一下如何使用它們。

OrderItem.hbm.xml

　　這個對象比較有意思。它的實例自動在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。