Hibernate中如何高效處理海量資料

最近一直常常看到別人javaeye網站上看到別人在問在hibernate怎麼樣處理海量資料，怎麼樣提高效能，本人在CSDN部落格上看到這篇好的文章，並結合本人一一驗證 確實如作者所說 故拿出來和大家分享。希望對初學HIBERNATE架構的朋友有所協助。
Hibernate批量處理海量其實從效能上考慮，它是很不可取的，浪費了很大的記憶體。從它的機制上講，Hibernate它是先把合格資料查出來，放到記憶體當中，然後再進行操作。實際使用下來效能非常不理想，在筆者的實際使用中採用下面的第三種最佳化方案的資料是：100000條資料插入資料庫， 需要約30分鐘，呵呵，暈倒。（本人10分鐘插入1000000條資料（欄位比較小）我的愛機是宏基Aspire 4920）
    總結下來有三種來處理以解決效能問題：

    1：繞過Hibernate API ，直接通過 JDBC API 來做，這個方法效能上是比較好的。也是最快的。

    2：運用預存程序。

    3：還是用Hibernate API 來進行常規的批量處理，可以也有變，變就變在，我們可以在尋找出一定的量的時候，及時的將這些資料做完操作就

    刪掉，session.flush（）；session.evict（XX對象集）； 這樣也可以挽救一點效能損失。這個“一定的量”要就要根據實際情況做定量參考了。一般為30-60左右，但效果仍然不理想。

    1：繞過Hibernate API ，直接通過 JDBC API 來做，這個方法效能上是比較好的，也是最快的。（執行個體為 更新操作）

 

    Transaction tx=session.beginTransaction（）； //注意用的是hibernate交易處理邊界

    Connection conn=session.connection（）；

    PreparedStatement stmt=conn.preparedStatement（"update CUSTOMER as C set C.sarlary=c.sarlary+1 where c.sarlary>1000"）；

 

    stmt.excuteUpdate（）；

    tx.commit（）； //注意用的是hibernate交易處理邊界

    這小程式中，採用的是直接調用JDBC 的API 來訪問資料庫，效率很高。避免了Hibernate 先查詢出來載入到記憶體，再進行操作引發的效能問題

 

    。

    2：運用預存程序。但這種方式考慮到易植和程式部署的方便性，不建議使用。（執行個體為 更新操作）

 

    如果底層資料庫（如Oracle）支援預存程序，也可以通過預存程序來執行批次更新。預存程序直接在資料庫中運行，速度更加快。在Oracle數

    據庫中可以定義一個名為batchUpdateCustomer（）的預存程序，代碼如下：

 

    代碼內容create or replace procedure batchUpdateCustomer（p_age in number） as begin update CUSTOMERS set AGE=AGE+1 where AGE>p_age；end；

    以上預存程序有一個參數p_age，代表客戶的年齡，應用程式可按照以下方式調用預存程序：

    代碼內容

    tx = session.beginTransaction（）；

    Connection con=session.connection（）；

    String procedure = "{call batchUpdateCustomer（？） }"；

    CallableStatement cstmt = con.prepareCall（procedure）；

    cstmt.setInt（1，0）； //把年齡參數設為0

    cstmt.executeUpdate（）；

    tx.commit（）；

    從上面程式看出，應用程式也必須繞過Hibernate API，直接通過JDBC API來調用預存程序。

 

3：還是用Hibernate API 來進行常規的批量處理，可以也有變，變就變在，我們可以在尋找出一定的量的時候，及時的將這些資料做完操作就

    刪掉，session.flush（）；session.evict（XX對象集）； 這樣也可以挽救一點效能損失。這個“一定的量”要就要根據實際情況做定量參考了……

 

    （執行個體為 儲存操作）

    商務邏輯為：我們要想資料庫插入10 0000 條資料

 

    tx=session.beginTransaction（）；

    for（int i=0；i<100000；i++）

    {

    Customer custom=new Customer（）；

 

    custom.setName（"user"+i）；

    session.save（custom）；

 

    if（i%50==0） // 以每50個資料作為一個處理單元，也就是我上面說的“一定的量”，這個量是要酌情考慮的

 

    {

    session.flush（）；

    session.clear（）；

 

    }

    }

 

    這樣可以把系統維持在一個穩定的範圍……

    在項目的開發過程之中，由於項目需求，我們常常需要把大批量的資料插入到資料庫。數量級有萬級、十萬級、百萬級、甚至千萬層級的。如此數量層級的資料用Hibernate做插入操作，就可能會發生異常，常見的異常是OutOfMemoryError（記憶體溢出異常）。

    首先，我們簡單來回顧一下Hibernate插入操作的機制。Hibernate要對它內部緩衝進行維護，當我們執行插入操作時，就會把要操作的對象全部放到自身的內部緩衝來進行管理。

    談到Hibernate的緩衝，Hibernate有內部緩衝與二級緩衝之說。由於Hibernate對這兩種緩衝有著不同的管理機制，對於二級緩衝，我們可以對它的大小進行相關配置，而對於內部緩衝，Hibernate就採取了“放任自流”的態度了，對它的容量並沒有限制。現在癥結找到了，我們做海量資料插入的時候，產生這麼多的對象就會被納入內部緩衝（內部緩衝是在記憶體中做緩衝的），這樣你的系統記憶體就會一點一點的被蠶食，如果最後系統被擠“炸”了，也就在情理之中了。

    我們想想如何較好的處理這個問題呢？有的開發條件又必須使用Hibernate來處理，當然有的項目比較靈活，可以去尋求其他的方法。

    筆者在這裡推薦兩種方法：（1）：最佳化Hibernate，程式上採用分段插入及時清除緩衝的方法。

    （2）：繞過Hibernate API ，直接通過 JDBC API 來做批量插入，這個方法效能上是最 好的，也是最快的。

    對於上述中的方法1，其基本是思路為：最佳化Hibernate，在設定檔中設定hibernate.jdbc.batch_size參數，來指定每次提交SQL的數量；程式上採用分段插入及時清除緩衝的方法（Session實現了非同步write-behind，它允許Hibernate顯式地寫操作的批處理），也就是每插入一定量的資料後及時的把它們從內部緩衝中清除掉，釋放佔用的記憶體。

    設定hibernate.jdbc.batch_size參數，可參考如下配置。

    <hibernate-configuration> <session-factory>……

 

    <property name=“ hibernate.jdbc.batch_size”>50</property>……

    <session-factory> <hibernate-configuration>

    配置hibernate.jdbc.batch_size參數的原因就是盡量少讀資料庫，hibernate.jdbc.batch_size參數值越大，讀資料庫的次數越少，速度越快。從上面的配置可以看出，Hibernate是等到程式積累到了50個SQL之後再批量提交。

    筆者也在想，hibernate.jdbc.batch_size參數值也可能不是設定得越大越好，從效能角度上講還有待商榷。這要考慮實際情況，酌情設定，一般情形設定30、50就可以滿足需求了。

    程式實現方面，筆者以插入10000條資料為例子，如

 

    Session session=HibernateUtil.currentSession（）；

    Transatcion tx=session.beginTransaction（）；

    for（int i=0；i<10000；i++）

 

    {

    Student st=new Student（）；

 

    st.setName（“feifei”）；

 

    session.save（st）；

    if（i%50==0） //以每50個資料作為一個處理單元

    {

    session.flush（）； //保持與資料庫資料的同步

    session.clear（）； //清除內部緩衝的全部資料，及時釋放出佔用的記憶體

    }

    }

 

    tx.commit（）；

    ……

 

    在一定的資料規模下，這種做法可以把系統記憶體資源維持在一個相對穩定的範圍。

 

    注意：前面提到二級緩衝，筆者在這裡有必要再提一下。如果啟用了二級緩衝，從機制上講Hibernate為了維護二級緩衝，我們在做插入、更新、刪除操作時，Hibernate都會往二級緩衝充入相應的資料。效能上就會有很大損失，所以筆者建議在批處理情況下禁用二級緩衝。

    對於方法2，採用傳統的JDBC的批處理，使用JDBC API來處理。

    些方法請參照java 批處理自執行SQL

    看看上面的代碼，是不是總覺得有不妥的地方？對，沒發現麼！這還是JDBC的傳統編程，沒有一點Hibernate味道。

 

    可以對以上的代碼修改成下面這樣：

 

    Transaction tx=session.beginTransaction（）； //使用Hibernate交易處理

    邊界Connection conn=session.connection（）；

    PrepareStatement stmt=conn.prepareStatement（“insert into T_STUDENT（name） values（？）”）；

    for（int j=0；j++；j<200）{

    for（int i=0；i++；j<50）

 

    {

    stmt.setString（1，“feifei”）；

    }

    }

    stmt.executeUpdate（）；

 

    tx.commit（）； //使用 Hibernate交易處理邊界

    ……

    這樣改動就很有Hibernate的味道了。筆者經過測試，採用JDBC API來做批量處理，效能上比使用Hibernate API要高將近10倍，效能上JDBC 佔優這是無疑的。

    批次更新與刪除

    Hibernate2中，對於批次更新操作，Hibernate是將符合要求的資料查出來，然後再做更新操作。大量刪除也是這樣，先把合格資料查出來，然後再做刪除操作。

    這樣有兩個大缺點：（1）：佔用大量的記憶體。

    （2）：處理海量資料的時候，執行update/delete語句就是海量了，而且一條update/delete語句只能操作一個對象，這樣頻繁的操作資料庫，效能低下應該是可想而知的了。

    Hibernate3 發布後，對批次更新/刪除操作引入了bulk update/delete，其原理就是通過一條HQL陳述式完成批次更新/刪除操作，很類似JDBC的批次更新/刪除操作。在效能上，比Hibernate2的批次更新/刪除有很大的提升。

    Transaction tx=session.beginSession（）；

    String HQL=“delete STUDENT”；

    Query query=session.createQuery（HQL）；

    int size=query.executeUpdate（）；

 

    tx.commit（）；

 

    ……

    控制台輸出了也就一條刪除語句Hibernate：delete from T_STUDENT，語句執行少了，效能上也與使用JDBC相差無幾，是一個提升效能很好的方法。當然為了有更好的效能，筆者建議批次更新與刪除操作還是使用JDBC，方法以及基本的知識點與上面的批量插入方法2基本相同，這裡就不在冗述。

    筆者這裡再提供一個方法，就是從資料庫端來考慮提升效能，在Hibernate程式端調用預存程序。預存程序在資料庫端運行，速度更快。以批次更新為例，給出參考代碼。

    首先在資料庫端建立名為batchUpdateStudent預存程序：

    create or replace produre batchUpdateStudent（a in number） as

 

    begin

    update STUDENT set AGE=AGE+1 where AGE>a；

    end；

    調用代碼如下：

 

    Transaction tx=session.beginSession（）；

    Connection conn=session.connection（）；

    String pd=“……{call batchUpdateStudent（？）}”；

    CallableStatement cstmt=conn.PrepareCall（pd）；

    cstmt.setInt（1，20）； //把年齡這個參數設為20

    tx.commit（）；

    觀察上面的代碼，也是繞過Hibernate API，使用 JDBC API來調用預存程序，使用的還是Hibernate的事務邊界。預存程序無疑是提高批量處理效能的一個好方法，直接運行與資料庫端，某種程度上講把批處理的壓力轉接給了資料庫。

    三：編後語

    本文探討了Hibernate的批處理操作，出發點都是在提高效能上考慮了，也只是提供了提升效能的一個小方面。

    不管採取什麼樣的方法，來提升效能都要根據實際的情況來考慮，為使用者提供一個滿足需求的而且高效穩定的系統才是重中之中。