Hibernate批量處理海量資料的方法

標籤：常見   cst   mit   壓力   ssi   customers   插入資料   custom   blog   

本文執行個體講述了Hibernate批量處理海量資料的方法。分享給大家供大家參考，具體如下：

Hibernate批量處理海量其實從效能上考慮，它是很不可取的，浪費了很大的記憶體。從它的機制上講，Hibernate它是先把合格資料查出來，放到記憶體當中，然後再進行操作。實際使用下來效能非常不理想，在筆者的實際使用中採用下面的第三種最佳化方案的資料是：100000條資料插入資料庫， 需要約30分鐘，呵呵，暈倒。(本人10分鐘插入1000000條資料(欄位比較小))

總結下來有三種來處理以解決效能問題：

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

　　2：運用預存程序。

　　3：還是用Hibernate API 來進行常規的批量處理，可以也有變，變就變在，我們可以在尋找出一定的量的時候，及時的將這些資料做完操作就 刪掉，session.flush();session.evict(XX對象集); 這樣也可以挽救一點效能損失。這個"一定的量"要就要根據實際情況做定量參考了。一般為30-60左右，但效果仍然不理想。

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

1 Transaction tx=session.beginTransaction(); //注意用的是hibernate交易處理邊界2 Connection conn=session.connection();3 PreparedStatement stmt=conn.preparedStatement("update CUSTOMER as C set C.sarlary=c.sarlary+1 where c.sarlary>1000");4 stmt.excuteUpdate();5 tx.commit(); //注意用的是hibernate交易處理邊界

　　這小程式中，採用的是直接調用JDBC 的API 來訪問資料庫，效率很高。避免了Hibernate 先查詢出來載入到記憶體，再進行操作引發的效能問題
。
　　2：運用預存程序。但這種方式考慮到易植和程式部署的方便性，不建議使用。(執行個體為 更新操作)

如果底層資料庫(如Oracle)支援預存程序，也可以通過預存程序來執行批次更新。預存程序直接在資料庫中運行，速度更加快。在Oracle資料庫中可以定義一個名為batchUpdateCustomer()的預存程序，代碼如下：

1 create or replace procedure batchUpdateCustomer(p_age in number) as begin update CUSTOMERS set AGE=AGE+1 where AGE>p_age;end;

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

1 tx = session.beginTransaction();2 Connection con=session.connection();3 String procedure = "{call batchUpdateCustomer(？) }";4 CallableStatement cstmt = con.prepareCall(procedure);5 cstmt.setInt(1，0); //把年齡參數設為06 cstmt.executeUpdate();7 tx.commit();

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

　　3：還是用Hibernate API 來進行常規的批量處理，可以也有變，變就變在，我們可以在尋找出一定的量的時候，及時的將這些資料做完操作就刪掉，session.flush();session.evict(XX對象集); 這樣也可以挽救一點效能損失。這個"一定的量"要就要根據實際情況做定量參考了……
　　(執行個體為 儲存操作)

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

 1 tx=session.beginTransaction(); 2 for(int i=0;i<100000;i++) 3 { 4 Customer custom=new Customer(); 5 custom.setName("user"+i); 6 session.save(custom); 7 if(i%50==0) // 以每50個資料作為一個處理單元，也就是我上面說的"一定的量"，這個量是要酌情考慮的 8 { 9 session.flush();10 session.clear();11 }12 }

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

　　在項目的開發過程之中，由於項目需求，我們常常需要把大批量的資料插入到資料庫。數量級有萬級、十萬級、百萬級、甚至千萬層級的。如此數量層級的資料用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參數，可參考如下配置。

1 <hibernate-configuration> <session-factory>……2 <property name=" hibernate.jdbc.batch_size">50</property>……3 <session-factory> <hibernate-configuration>

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

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

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

 1 Transatcion tx=session.beginTransaction(); 2 for(int i=0;i<10000;i++) 3 { 4 Student st=new Student(); 5 st.setName("feifei"); 6 session.save(st); 7 if(i%50==0) //以每50個資料作為一個處理單元 8 { 9 session.flush(); //保持與資料庫資料的同步10 session.clear(); //清除內部緩衝的全部資料，及時釋放出佔用的記憶體11 }12 }13 tx.commit();14 ……

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

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

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

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

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

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

 1 Transaction tx=session.beginTransaction(); //使用Hibernate交易處理 2 Connection conn=session.connection(); 3 PrepareStatement stmt=conn.prepareStatement("insert into T_STUDENT(name) values(？)"); 4 for(int j=0;j++;j<200){ 5 for(int i=0;i++;j<50) 6 { 7 stmt.setString(1，"feifei"); 8 } 9 }10 stmt.executeUpdate();11 tx.commit(); //使用 Hibernate交易處理邊界12 ……

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

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

　　這樣有兩個大缺點：

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

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

1 Transaction tx=session.beginSession();2 String HQL="delete STUDENT";3 Query query=session.createQuery(HQL);4 int size=query.executeUpdate();5 tx.commit();6 ……

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

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

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

1 create or replace produre batchUpdateStudent(a in number) as2 begin3 update STUDENT set AGE=AGE+1 where AGE>a;4 end;

1 Transaction tx=session.beginSession();2 Connection conn=session.connection();3 String pd="……{call batchUpdateStudent(？)}";4 CallableStatement cstmt=conn.PrepareCall(pd);5 cstmt.setInt(1，20); //把年齡這個參數設為206 tx.commit();

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

　　參考部落格：http://www.jb51.net/article/81436.htm

Hibernate批量處理海量資料的方法