javahibernate批量更新_Hibernate批量处理海量数据的⽅法本⽂实例讲述了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 tion();
3 PreparedStatement stmt=conn.preparedStatement("update CUSTOMER as C set C.sarlary=c.sarlary+1 where
c.sarlary>1000");uteUpdate();5 txmit(); //注意⽤的是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 tion();
3 String procedure ="{call
batchUpdateCustomer(？) }";4 CallableStatement cstmt = con.prepareCall(procedure);5 cstmt.setInt(1，0); //把年龄参数设为uteUpdate();7 txmit();
从上⾯程序看出，应⽤程序也必须绕过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 {批量更新sql语句
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 ......2 50 (3)
配置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 txmit();14 ……
在⼀定的数据规模下，这种做法可以把系统内存资源维持在⼀个相对稳定的范围。
注意：前⾯提到⼆级缓存，笔者在这⾥有必要再提⼀下。如果启⽤了⼆级缓存，从机制上讲Hibernate为了维护⼆级缓存，我们在做插⼊、更新、删除操作时，Hibernate都会往⼆级缓存充⼊相应的数据。性能上就会有很⼤损失，所以笔者建议在批处理情况下禁⽤⼆级缓存。
对于⽅法2，采⽤传统的JDBC的批处理，使⽤JDBC API来处理。
些⽅法请参照java 批处理⾃执⾏SQL
看看上⾯的代码，是不是总觉得有不妥的地⽅？对，没发现么！这还是JDBC的传统编程，没有⼀点Hibernate味道。
可以对以上的代码修改成下⾯这样：
1 Transaction tx=session.beginTransaction(); //使⽤Hibernate事务处理
2 Connection tion();
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 }uteUpdate();11 txmit(); //使⽤ 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="deleteSTUDENT";
3 Query ateQuery(HQL);
4 int uteUpdate();
5 txmit();
6 ……
控制台输出了也就⼀条删除语句Hibernate：delete from T_STUDENT，语句执⾏少了，性能上也与使⽤JDBC相差⽆⼏，是⼀个提升性能很好的⽅法。当然为了有更好的性能，笔者建议批量更新与删除操作还是使⽤JDBC，⽅法以及基本的知识点与上⾯的批量插⼊⽅法2基本相同，这⾥就不在冗述。
笔者这⾥再提供⼀个⽅法，就是从数据库端来考虑提升性能，在Hibernate程序端调⽤存储过程。存储过程在数据库端运⾏，速度更快。以批量更新为例，给出参考代码。
⾸先在数据库端建⽴名为batchUpdateStudent存储过程：
1 create or replace produre batchUpdateStudent(a in number) as
2 begin
3 update STUDENT set AGE=AGE+1 where AGE>a;
4 end;
1 Transaction tx=session.beginSession();
2 Connection tion();
3 String pd="……{call batchUpdateStudent(？)}";
4 CallableStatement cstmt=conn.PrepareCall(pd);
5 cstmt.setInt(1，20); //把年龄这个参数设为20
6 txmit();
观察上⾯的代码，也是绕过Hibernate API，使⽤ JDBC API来调⽤存储过程，使⽤的还是Hibernate的事务边界。存储过程⽆疑是提⾼批量处理性能的⼀个好⽅法，直接运⾏与数据库端，某种程度上讲把批处理的压⼒转接给了数据库。

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。