欧美高清一区二区三区,亚洲一区欧洲一区,欧美freex

本文實例講述了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 來做，這個方法性能上是比較好的，也是最快的。(實例為更新操作)

				?

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