最近一直常常看到別人javaeye網(wǎng)站上看到別人在問在hibernate怎么樣處理海量數(shù)據(jù)，怎么樣提高性能，本人在CSDN博客上看到這篇好的文章，并結(jié)合本人一一驗證 確實如作者所說 故拿出來和大家分享。希望對初學HIBERNATE框架的朋友有所幫助。
Hibernate批量處理海量其實從性能上考慮，它是很不可取的，浪費了很大的內(nèi)存。從它的機制上講，Hibernate它是先把符合條件的數(shù)據(jù)查出來，放到內(nèi)存當中，然后再進行操作。實際使用下來性能非常不理想，在筆者的實際使用中采用下面的第三種優(yōu)化方案的數(shù)據(jù)是：100000條數(shù)據(jù)插入數(shù)據(jù)庫， 需要約30分鐘，呵呵，暈倒。（本人10分鐘插入1000000條數(shù)據(jù)（字段比較小）我的愛機是宏基Aspire 4920）
總結(jié)下來有三種來處理以解決性能問題：
1：繞過Hibernate API ，直接通過 JDBC API 來做，這個方法性能上是比較好的。也是最快的。
2：運用存儲過程。
3：還是用Hibernate API 來進行常規(guī)的批量處理，可以也有變，變就變在，我們可以在查找出一定的量的時候，及時的將這些數(shù)據(jù)做完操作就
刪掉，session.flush（）；session.evict（XX對象集）； 這樣也可以挽救一點性能損失。這個“一定的量”要就要根據(jù)實際情況做定量參考了。一般為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事務處理邊界
這小程序中，采用的是直接調(diào)用JDBC 的API 來訪問數(shù)據(jù)庫，效率很高。避免了Hibernate 先查詢出來加載到內(nèi)存，再進行操作引發(fā)的性能問題
。
2：運用存儲過程。但這種方式考慮到易植和程序部署的方便性，不建議使用。（實例為 更新操作）
如果底層數(shù)據(jù)庫（如Oracle）支持存儲過程，也可以通過存儲過程來執(zhí)行批量更新。存儲過程直接在數(shù)據(jù)庫中運行，速度更加快。在Oracle數(shù)
據(jù)庫中可以定義一個名為batchUpdateCustomer（）的存儲過程，代碼如下：
代碼內(nèi)容create or replace procedure batchUpdateCustomer（p_age in number） as begin update CUSTOMERS set AGE=AGE+1 where AGE>p_age；end；
以上存儲過程有一個參數(shù)p_age，代表客戶的年齡，應用程序可按照以下方式調(diào)用存儲過程：
代碼內(nèi)容
tx = session.beginTransaction（）；
Connection con=session.connection（）；
String procedure = "{call batchUpdateCustomer（？） }"；
CallableStatement cstmt = con.prepareCall（procedure）；
cstmt.setInt（1，0）； //把年齡參數(shù)設(shè)為0
cstmt.executeUpdate（）；
tx.commit（）；
從上面程序看出，應用程序也必須繞過Hibernate API，直接通過JDBC API來調(diào)用存儲過程。
3：還是用Hibernate API 來進行常規(guī)的批量處理，可以也有變，變就變在，我們可以在查找出一定的量的時候，及時的將這些數(shù)據(jù)做完操作就
刪掉，session.flush（）；session.evict（XX對象集）； 這樣也可以挽救一點性能損失。這個“一定的量”要就要根據(jù)實際情況做定量參考了……
（實例為 保存操作）
業(yè)務邏輯為：我們要想數(shù)據(jù)庫插入10 0000 條數(shù)據(jù)
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個數(shù)據(jù)作為一個處理單元，也就是我上面說的“一定的量”，這個量是要酌情考慮的
{
session.flush（）；
session.clear（）；
}
}
這樣可以把系統(tǒng)維持在一個穩(wěn)定的范圍……
在項目的開發(fā)過程之中，由于項目需求，我們常常需要把大批量的數(shù)據(jù)插入到數(shù)據(jù)庫。數(shù)量級有萬級、十萬級、百萬級、甚至千萬級別的。如此數(shù)量級別的數(shù)據(jù)用Hibernate做插入操作，就可能會發(fā)生異常，常見的異常是OutOfMemoryError（內(nèi)存溢出異常）。
首先，我們簡單來回顧一下Hibernate插入操作的機制。Hibernate要對它內(nèi)部緩存進行維護，當我們執(zhí)行插入操作時，就會把要操作的對象全部放到自身的內(nèi)部緩存來進行管理。
談到Hibernate的緩存，Hibernate有內(nèi)部緩存與二級緩存之說。由于Hibernate對這兩種緩存有著不同的管理機制，對于二級緩存，我們可以對它的大小進行相關(guān)配置，而對于內(nèi)部緩存，Hibernate就采取了“放任自流”的態(tài)度了，對它的容量并沒有限制。現(xiàn)在癥結(jié)找到了，我們做海量數(shù)據(jù)插入的時候，生成這么多的對象就會被納入內(nèi)部緩存（內(nèi)部緩存是在內(nèi)存中做緩存的），這樣你的系統(tǒng)內(nèi)存就會一點一點的被蠶食，如果最后系統(tǒng)被擠“炸”了，也就在情理之中了。
我們想想如何較好的處理這個問題呢？有的開發(fā)條件又必須使用Hibernate來處理，當然有的項目比較靈活，可以去尋求其他的方法。
筆者在這里推薦兩種方法：（1）：優(yōu)化Hibernate，程序上采用分段插入及時清除緩存的方法。
（2）：繞過Hibernate API ，直接通過 JDBC API 來做批量插入，這個方法性能上是最 好的，也是最快的。
對于上述中的方法1，其基本是思路為：優(yōu)化Hibernate，在配置文件中設(shè)置hibernate.jdbc.batch_size參數(shù)，來指定每次提交SQL的數(shù)量；程序上采用分段插入及時清除緩存的方法（Session實現(xiàn)了異步write-behind，它允許Hibernate顯式地寫操作的批處理），也就是每插入一定量的數(shù)據(jù)后及時的把它們從內(nèi)部緩存中清除掉，釋放占用的內(nèi)存。
設(shè)置hibernate.jdbc.batch_size參數(shù)，可參考如下配置。
<hibernate-configuration> <session-factory>……
<property name=“ hibernate.jdbc.batch_size”>50</property>……
<session-factory> <hibernate-configuration>
配置hibernate.jdbc.batch_size參數(shù)的原因就是盡量少讀數(shù)據(jù)庫，hibernate.jdbc.batch_size參數(shù)值越大，讀數(shù)據(jù)庫的次數(shù)越少，速度越快。從上面的配置可以看出，Hibernate是等到程序積累到了50個SQL之后再批量提交。
筆者也在想，hibernate.jdbc.batch_size參數(shù)值也可能不是設(shè)置得越大越好，從性能角度上講還有待商榷。這要考慮實際情況，酌情設(shè)置，一般情形設(shè)置30、50就可以滿足需求了。
程序?qū)崿F(xiàn)方面，筆者以插入10000條數(shù)據(jù)為例子，如
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個數(shù)據(jù)作為一個處理單元
{
session.flush（）； //保持與數(shù)據(jù)庫數(shù)據(jù)的同步
session.clear（）； //清除內(nèi)部緩存的全部數(shù)據(jù)，及時釋放出占用的內(nèi)存
}
}
tx.commit（）；
……
在一定的數(shù)據(jù)規(guī)模下，這種做法可以把系統(tǒng)內(nèi)存資源維持在一個相對穩(wěn)定的范圍。
注意：前面提到二級緩存，筆者在這里有必要再提一下。如果啟用了二級緩存，從機制上講Hibernate為了維護二級緩存，我們在做插入、更新、刪除操作時，Hibernate都會往二級緩存充入相應的數(shù)據(jù)。性能上就會有很大損失，所以筆者建議在批處理情況下禁用二級緩存。
對于方法2，采用傳統(tǒng)的JDBC的批處理，使用JDBC API來處理。
些方法請參照java 批處理自執(zhí)行SQL
看看上面的代碼，是不是總覺得有不妥的地方？對，沒發(fā)現(xiàn)么！這還是JDBC的傳統(tǒng)編程，沒有一點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的味道了。筆者經(jīng)過測試，采用JDBC API來做批量處理，性能上比使用Hibernate API要高將近10倍，性能上JDBC 占優(yōu)這是無疑的。
批量更新與刪除
Hibernate2中，對于批量更新操作，Hibernate是將符合要求的數(shù)據(jù)查出來，然后再做更新操作。批量刪除也是這樣，先把符合條件的數(shù)據(jù)查出來，然后再做刪除操作。
這樣有兩個大缺點：（1）：占用大量的內(nèi)存。
（2）：處理海量數(shù)據(jù)的時候，執(zhí)行update/delete語句就是海量了，而且一條update/delete語句只能操作一個對象，這樣頻繁的操作數(shù)據(jù)庫，性能低下應該是可想而知的了。
Hibernate3 發(fā)布后，對批量更新/刪除操作引入了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，語句執(zhí)行少了，性能上也與使用JDBC相差無幾，是一個提升性能很好的方法。當然為了有更好的性能，筆者建議批量更新與刪除操作還是使用JDBC，方法以及基本的知識點與上面的批量插入方法2基本相同，這里就不在冗述。
筆者這里再提供一個方法，就是從數(shù)據(jù)庫端來考慮提升性能，在Hibernate程序端調(diào)用存儲過程。存儲過程在數(shù)據(jù)庫端運行，速度更快。以批量更新為例，給出參考代碼。
首先在數(shù)據(jù)庫端建立名為batchUpdateStudent存儲過程：
create or replace produre batchUpdateStudent（a in number） as
begin
update STUDENT set AGE=AGE+1 where AGE>a；
end；
調(diào)用代碼如下：
Transaction tx=session.beginSession（）；
Connection conn=session.connection（）；
String pd=“……{call batchUpdateStudent（？）}”；
CallableStatement cstmt=conn.PrepareCall（pd）；
cstmt.setInt（1，20）； //把年齡這個參數(shù)設(shè)為20
tx.commit（）；
觀察上面的代碼，也是繞過Hibernate API，使用 JDBC API來調(diào)用存儲過程，使用的還是Hibernate的事務邊界。存儲過程無疑是提高批量處理性能的一個好方法，直接運行與數(shù)據(jù)庫端，某種程度上講把批處理的壓力轉(zhuǎn)接給了數(shù)據(jù)庫。
三：編后語
本文探討了Hibernate的批處理操作，出發(fā)點都是在提高性能上考慮了，也只是提供了提升性能的一個小方面。
不管采取什么樣的方法，來提升性能都要根據(jù)實際的情況來考慮，為用戶提供一個滿足需求的而且高效穩(wěn)定的系統(tǒng)才是重中之中。