Hibernate的批量处理

Hibernate批量处理其实从性能上考虑 它是很不可取的 浪费了很大的内存 从它的机制上讲 Hibernate它是先把符合条件的数据查出来 放到内存当中 然后再进行 *** 作 实际使用下来性能非常不理想 在笔者的实际使用中采用下面的第三种优化方案的数据是 条数据插入数据库 主流台式机的配置 需要约 分钟 呵呵 晕倒

总结下来有三种来处理以解决性能问题

绕过Hibernate API 直接通过 JDBC API 来做 这个方法性能上是比较好的 也是最快的

运用存储过程

还是用Hibernate API 来进行常规的批顷告备量处理 可以也有变 变就变在 我们可以在查找出一定的量的时候 及时的将这些数据做完 *** 作就

删掉 session flush（） session evict（XX对象集） 这样也可以挽救一点性能损失 这个 一定的量 要就要根据实际情况做定量参考了 一般为 左右 但效果仍然不理想

绕过Hibernate API 直接通过 JDBC API 来做 这个方法性能上是比较好的 也是最快的 （实例为 更新 *** 作）

Transaction tx=session beginTransaction（） //注意用的是hibernate事务处理边界

Connection conn=nnection（）

PreparedStatement stmt=conn preparedStatement（ update CUSTOMER as C set C sarlary=c sarlary+ where c sarlary>）

stmt excuteUpdate（）

mit（） //注意用的是hibernate事务处理边界

这小程序中 采用的是直接调用JDBC 的API 来访问数据库 效率很高 避免了Hibernate 先查询出来加载到内存 再进行 *** 作引发的性能问题

运用存储过程 但这种方式考虑到易植和程序部署的方便性 不建议使用 （实例为 更新 *** 作）

如果底层数据库（如Oracle）支持存储过程 也可以通过存储过程来执行批量更新 存储过程直接在数据库中运行 速度更加快 在Oracle数

据库中可以定义一个名为batchUpdateCustomer（）的存储过程 代码如下

代码内容create or replace procedure batchUpdateCustomer（p_age in number） as begin update CUSTOMERS set AGE=AGE+ where AGE>p_age end

以上存储过程有一个参数p_age 代表客户的年龄 应用程序可按照以下方式调用存储过程

代码内容

tx = session beginTransaction（）

Connection con=nnection（）

String procedure = {call batchUpdateCustomer（？） }

CallableStatement cstmt = con prepareCall（procedure）

cstmt setInt（ ） //把年龄参数设为

cstmt executeUpdate（）

mit（）

从上面程序看出 应用程序也必须绕过Hibernate API 直接通过JDBC API来调用存储过程

还是用Hibernate API 来进行常规的批量处理 可以也有变 变就变在 我们可以在查找出一定的量的时候 及时的将这些数据做完 *** 作就

删掉 session flush（） session evict（XX对象集友培） 这样也可以挽救一点性能损失 这个 一定的量 要就要根据实际情况做定量参考了……

（实例为 保存 *** 作）

业务逻雀毁辑为 我们要想数据库插入 条数据

tx=session beginTransaction（）

for（int i= i<i++）

{

Customer custom=new Customer（）

custom setName（ user +i）

session save（custom）

if（i% == ） // 以每 个数据作为一个处理单元 也就是我上面说的 一定的量 这个量是要酌情考虑的

{

session flush（）

session clear（）

}

}

这样可以把系统维持在一个稳定的范围……

在项目的开发过程之中 由于项目需求 我们常常需要把大批量的数据插入到数据库 数量级有万级 十万级 百万级 甚至千万级别的 如此数量级别的数据用Hibernate做插入 *** 作 就可能会发生异常 常见的异常是OutOfMemoryError（内存溢出异常）

首先 我们简单来回顾一下Hibernate插入 *** 作的机制 Hibernate要对它内部缓存进行维护 当我们执行插入 *** 作时 就会把要 *** 作的对象全部放到自身的内部缓存来进行管理

谈到Hibernate的缓存 Hibernate有内部缓存与二级缓存之说 由于Hibernate对这两种缓存有着不同的管理机制 对于二级缓存 我们可以对它的大小进行相关配置 而对于内部缓存 Hibernate就采取了 放任自流 的态度了 对它的容量并没有限制 现在症结找到了 我们做海量数据插入的时候 生成这么多的对象就会被纳入内部缓存（内部缓存是在内存中做缓存的） 这样你的系统内存就会一点一点的被蚕食 如果最后系统被挤 炸 了 也就在情理之中了

我们想想如何较好的处理这个问题呢？有的开发条件又必须使用Hibernate来处理 当然有的项目比较灵活 可以去寻求其他的方法

笔者在这里推荐两种方法 （ ） 优化Hibernate 程序上采用分段插入及时清除缓存的方法

（ ） 绕过Hibernate API 直接通过 JDBC API 来做批量插入 这个方法性能上是最 好的 也是最快的

对于上述中的方法 其基本是思路为 优化Hibernate 在配置文件中设置hibernate jdbc batch_size参数 来指定每次提交SQL的数量 程序上采用分段插入及时清除缓存的方法（Session实现了异步write behind 它允许Hibernate显式地写 *** 作的批处理） 也就是每插入一定量的数据后及时的把它们从内部缓存中清除掉 释放占用的内存

设置hibernate jdbc batch_size参数 可参考如下配置

<hibernate configuration><session factory>……

<property name= hibernate jdbc batch_size ></property>……

<session factory><hibernate configuration>

配置hibernate jdbc batch_size参数的原因就是尽量少读数据库 hibernate jdbc batch_size参数值越大 读数据库的次数越少 速度越快 从上面的配置可以看出 Hibernate是等到程序积累到了 个SQL之后再批量提交

笔者也在想 hibernate jdbc batch_size参数值也可能不是设置得越大越好 从性能角度上讲还有待商榷 这要考虑实际情况 酌情设置 一般情形设置 就可以满足需求了

程序实现方面 笔者以插入 条数据为例子 如

Session session=HibernateUtil currentSession（）

Transatcion tx=session beginTransaction（）

for（int i= i<i++）

{

Student st=new Student（）

st setName（ feifei ）

session save（st）

if（i% == ） //以每 个数据作为一个处理单元

{

session flush（） //保持与数据库数据的同步

session clear（） //清除内部缓存的全部数据 及时释放出占用的内存

}

}

mit（）

……

在一定的数据规模下 这种做法可以把系统内存资源维持在一个相对稳定的范围

注意 前面提到二级缓存 笔者在这里有必要再提一下 如果启用了二级缓存 从机制上讲Hibernate为了维护二级缓存 我们在做插入 更新 删除 *** 作时 Hibernate都会往二级缓存充入相应的数据 性能上就会有很大损失 所以笔者建议在批处理情况下禁用二级缓存

对于方法 采用传统的JDBC的批处理 使用JDBC API来处理

些方法请参照java 批处理自执行SQL

看看上面的代码 是不是总觉得有不妥的地方？对 没发现么！这还是JDBC的传统编程 没有一点Hibernate味道

可以对以上的代码修改成下面这样

Transaction tx=session beginTransaction（） //使用Hibernate事务处理

边界Connection conn=nnection（）

PrepareStatement stmt=conn prepareStatement（ insert into T_STUDENT（name） values（？） ）

for（int j= j++ j<）{

for（int i= i++ j<）

{

stmt setString（ feifei ）

}

}

stmt executeUpdate（）

mit（） //使用 Hibernate事务处理边界

……

这样改动就很有Hibernate的味道了 笔者经过测试 采用JDBC API来做批量处理 性能上比使用Hibernate API要高将近 倍 性能上JDBC 占优这是无疑的

批量更新与删除

Hibernate 中 对于批量更新 *** 作 Hibernate是将符合要求的数据查出来 然后再做更新 *** 作 批量删除也是这样 先把符合条件的数据查出来 然后再做删除 *** 作

这样有两个大缺点 （ ） 占用大量的内存

（ ） 处理海量数据的时候 执行update/delete语句就是海量了 而且一条update/delete语句只能 *** 作一个对象 这样频繁的 *** 作数据库 性能低下应该是可想而知的了

Hibernate 发布后 对批量更新/删除 *** 作引入了bulk update/delete 其原理就是通过一条HQL语句完成批量更新/删除 *** 作 很类似JDBC的批量更新/删除 *** 作 在性能上 比Hibernate 的批量更新/删除有很大的提升

Transaction tx=session beginSession（）

String HQL= delete STUDENT

Query query=session createQuery（HQL）

int size=query executeUpdate（）

mit（）

……

控制台输出了也就一条删除语句Hibernate delete from T_STUDENT 语句执行少了 性能上也与使用JDBC相差无几 是一个提升性能很好的方法 当然为了有更好的性能 笔者建议批量更新与删除 *** 作还是使用JDBC 方法以及基本的知识点与上面的批量插入方法 基本相同 这里就不在冗述

笔者这里再提供一个方法 就是从数据库端来考虑提升性能 在Hibernate程序端调用存储过程 存储过程在数据库端运行 速度更快 以批量更新为例 给出参考代码

首先在数据库端建立名为batchUpdateStudent存储过程

create or replace produre batchUpdateStudent（a in number） as

begin

update STUDENT set AGE=AGE+ where AGE>a

end

调用代码如下

Transaction tx=session beginSession（）

Connection conn=nnection（）

String pd= ……{call batchUpdateStudent（？）}

CallableStatement cstmt=conn PrepareCall（pd）

cstmt setInt（ ） //把年龄这个参数设为

mit（）

观察上面的代码 也是绕过Hibernate API 使用 JDBC API来调用存储过程 使用的还是Hibernate的事务边界 存储过程无疑是提高批量处理性能的一个好方法 直接运行与数据库端 某种程度上讲把批处理的压力转接给了数据库

三 编后语

本文探讨了Hibernate的批处理 *** 作 出发点都是在提高性能上考虑了 也只是提供了提升性能的一个小方面

lishixinzhi/Article/program/Java/ky/201311/28885

写个适配器器吧，传入数据库类型，输出拼接的sql。

其实个人更建议你使用hibernate的Hql来作sql相关 *** 作，首先它语法和通用Sql是近似的，不一样的地方在于 语句里写的是类名 不是表名，最后hibernate会根据Hql翻译成当前数据库可执行的sql来执行，这样你就不需要去判断究竟是什么数据库，写法支桥指持不支持。

当然，如果你的语句特复杂一定得用Sql server或者Oracle的特殊语法，那没办法，写个适配器吧

以下是HQL相关资料

HQL查询：

Criteria查询对查询条件进行了面向对象封装，符合编程人员的思维方式，不过HQL(Hibernate Query Lanaguage)查询提供了更加丰富的和灵活的查询特性，因此

Hibernate将HQL查询方式立为官方推荐的标准查询方式，HQL查询在涵盖Criteria查询的所有功能的前提下，提供了类似标准SQL语句的查询方式，同时也提供了更

加面向对象的封装。完整的HQL语句形势如下：

Select/update/delete…… from …… where …… group by …… having …… order by …… asc/desc

其中的update/delete为Hibernate3中所新添加的功能，可见HQL查询非常类似于标准SQL查询。由于HQL查询在整个Hibernate实体 *** 作体系中的核心地位，这一节我

将专门围绕HQL *** 作的具体技术细节进行讲解。

1、 实体查询：

有关实体查询技术，其实我们在先前已经有多次涉及，比如下面的例子：

String hql=”from User user ”

List list=session.CreateQuery(hql).list()

上面的代码执行结果是，查询出User实体对象所对应的所有数据，而且将数据封装成User实体对象，并且放入List中返回。这里需要注意的是，Hibernate的实体查

询存在着对继承关系的判定，比如我们前面讨论映射实体继承关系中的Employee实体对象，它有两个子类分别是HourlyEmployee，SalariedEmployee,如果有这样的

HQL语句：“from Employee”,当执行检索时Hibernate会检索出所有Employee类型实体对象所对应的数据（包括它的子类HourlyEmployee，SalariedEmployee对应

的数据）。

因为HQL语句与标准SQL语句相似，所以我们也可以在HQL语句中使用where字句，并且可以在where字句中使用各种表达式，比较 *** 作符以及使用“and”,”or”连接

不同的查询条件的组合。看下面的一些简单的例子：

from User user where user.age=20

from User user where user.age between 20 and 30

from User user where user.age in(20,30)

from User user where user.name is null

from User user where user.name like ‘%zx%’

from User user where (user.age%2)=1

from User user where user.age=20 and user.name like ‘%zx%’

2、 实体的更新和删除：

在继续讲解HQL其他更睁轿为强大的查询功能前，我们先来讲解以下利用HQL进行实体更新和删除的技术。这项技术功能是Hibernate3的新加入的功能，在Hibernate2

中是不具备的。比如在Hibernate2中，如果我们想将数据库中所有18岁的用户的年龄全部改为20岁，那敏早配么我们要首先将年龄在18岁的用户检索出来，然后将他们的

年龄修改为20岁，最后调用Session.update()语句进行更新。在Hibernate3中对这个问题提供了更加灵活和更具效率的解决办法，如下面的代码：

Transaction trans=session.beginTransaction()

String hql=”update User user set user.age=20 where user.age=18”

Query queryupdate=session.createQuery(hql)

int ret=queryupdate.executeUpdate()

trans.commit()

通过这种方式我们可以在Hibernate3中，一次性完成批量数据的更新，对性能的提高是相当的可观。同样也可以通过类似的方式来完成delete *** 作，如下面的代码

：

Transaction trans=session.beginTransaction()

String hql=”delete from User user where user.age=18”

Query queryupdate=session.createQuery(hql)

int ret=queryupdate.executeUpdate()

trans.commit()

如果你是逐个章节阅读的化，那么你一定会记起我在第二部分中有关批量数据 *** 作的相关论述中，讨论过这种 *** 作方式，这种 *** 作方式在Hibernate3中称为bulk

delete/update，这种方式能够在很大程度上提高 *** 作的灵活性和运行效率，但是采用这种方式极有可能引起缓存同步上的问题(请参考相关论述)。

3、 属性查询：

很多时候我们在检索数据时，并不需要获得实体对象所对应的全部数据，而只需要检索实体对象的部分属性所对应的数据。这时候就可以利用HQL属性查询技术

，如下面程序示例：

List list=session.createQuery(“select user.name from User user ”).list()

for(int i=0i<list.size()i++){

System.out.println(list.get(i))

}

我们只检索了User实体的name属性对应的数据，此时返回的包含结果集的list中每个条目都是String类型的name属性对应的数据。我们也可以一次检索多个属性，

如下面程序：

List list=session.createQuery(“select user.name,user.age from User user ”).list()

for(int i=0i<list.size()i++){

Object[] obj=(Object[])list.get(i)

System.out.println(obj[0])

System.out.println(obj[1])

}

此时返回的结果集list中，所包含的每个条目都是一个Object[]类型，其中包含对应的属性数据值。作为当今我们这一代深受面向对象思想影响的开发人员，可能

会觉得上面返回Object[]不够符合面向对象风格，这时我们可以利用HQL提供的动态构造实例的功能对这些平面数据进行封装，如下面的程序代码：

List list=session.createQuery(“select new User(user.name,user.age) from User user ”).list()

for(int i=0i<list.size()i++){

User user=(User)list.get(i)

System.out.println(user.getName())

System.out.println(user.getAge())

}

这里我们通过动态构造实例对象，对返回结果进行了封装，使我们的程序更加符合面向对象风格，但是这里有一个问题必须注意，那就是这时所返回的User对象，

仅仅只是一个普通的Java对象而以，除了查询结果值之外，其它的属性值都为null（包括主键值id），也就是说不能通过Session对象对此对象执行持久化的更新 ***

作。如下面的代码：

List list=session.createQuery(“select new User(user.name,user.age) from User user ”).list()

for(int i=0i<list.size()i++){

User user=(User)list.get(i)

user.setName(“gam”)

session.saveOrUpdate(user)//这里将会实际执行一个save *** 作，而不会执行update *** 作，因为这个User对象的id属性为null，Hibernate会把它作为一个自由对

象（请参考持久化对象状态部分的论述），因此会对它执行save *** 作。

}

4、 分组与排序

A、Order by子句：

与SQL语句相似，HQL查询也可以通过order by子句对查询结果集进行排序，并且可以通过asc或者desc关键字指定排序方式，如下面的代码：

from User user order by user.name asc,user.age desc

上面HQL查询语句，会以name属性进行升序排序，以age属性进行降序排序，而且与SQL语句一样，默认的排序方式为asc,即升序排序。

B、Group by子句与统计查询：

在HQL语句中同样支持使用group by子句分组查询，还支持group by子句结合聚集函数的分组统计查询，大部分标准的SQL聚集函数都可以在HQL语句中使用，比如：

count(),sum(),max(),min(),avg()等。如下面的程序代码：

String hql=”select count(user),user.age from User user group by user.age having count(user)>10 ”

List list=session.createQuery(hql).list()

C、优化统计查询：

假设我们现在有两张数据库表，分别是customer表和order表，它们的结构如下：

customer

ID varchar2(14)

age number(10)

name varchar2(20)

order

ID varchar2(14)

order_number number(10)

customer_ID varchar2(14)

现在有两条HQL查询语句，分别如下：

from Customer c inner join c.orders o group by c.age(1)

select c.ID,c.name,c.age,o.ID,o.order_number,o.customer_ID

from Customer c inner join c.orders c group by c.age(2)

这两条语句使用了HQL语句的内连接查询（我们将在HQL语句的连接查询部分专门讨论），现在我们可以看出这两条查询语句最后所返回的结果是一样的，但是它们

其实是有明显区别的，语句（1）检索的结果会返回Customer与Order持久化对象，而且它们会被置于Hibernate的Session缓存之中，并且Session会负责它们在缓存

中的唯一性以及与后台数据库数据的同步，只有事务提交后它们才会从缓存中被清除；而语句（2）返回的是关系数据而并非是持久化对象，因此它们不会占用

Hibernate的Session缓存，只要在检索之后应用程序不在访问它们，它们所占用的内存就有可能被JVM的垃圾回收器回收，而且Hibernate不会同步对它们的修改。

在我们的系统开发中，尤其是Mis系统，不可避免的要进行统计查询的开发，这类功能有两个特点：第一数据量大；第二一般情况下都是只读 *** 作而不会涉及到对统

计数据进行修改，那么如果采用第一种查询方式，必然会导致大量持久化对象位于Hibernate的Session缓存中，而且Hibernate的Session缓存还要负责它们与数据

库数据的同步。而如果采用第二种查询方式，显然就会提高查询性能，因为不需要Hibernate的Session缓存的管理开销，而且只要应用程序不在使用这些数据，它

们所占用的内存空间就会被回收释放。

因此在开发统计查询系统时，尽量使用通过select语句写出需要查询的属性的方式来返回关系数据，而避免使用第一种查询方式返回持久化对象（这种方式是在有

修改需求时使用比较适合），这样可以提高运行效率并且减少内存消耗。㊣真正的高手并不是精通一切，而是精通在合适的场合使用合适的手段。

5、 参数绑定：

Hibernate中对动态查询参数绑定提供了丰富的支持，那么什么是查询参数动态绑定呢？其实如果我们熟悉传统JDBC编程的话，我们就不难理解查询参数动态绑定，

如下代码传统JDBC的参数绑定：

PrepareStatement pre=connection.prepare(“select * from User where user.name=?”)

pre.setString(1,”zhaoxin”)

ResultSet rs=pre.executeQuery()

在Hibernate中也提供了类似这种的查询参数绑定功能，而且在Hibernate中对这个功能还提供了比传统JDBC *** 作丰富的多的特性，在Hibernate中共存在4种参数绑

定的方式，下面我们将分别介绍：

A、 按参数名称绑定：

在HQL语句中定义命名参数要用”:”开头，形式如下：

Query query=session.createQuery(“from User user where user.name=:customername and user.customerage=:age ”)

query.setString(“customername”,name)

query.setInteger(“customerage”,age)

上面代码中用:customername和:customerage分别定义了命名参数customername和customerage，然后用Query接口的setXXX()方法设定名参数值，setXXX()方法包

含两个参数，分别是命名参数名称和命名参数实际值。

B、 按参数位置邦定：

在HQL查询语句中用”?”来定义参数位置，形式如下：

Query query=session.createQuery(“from User user where user.name=? and user.age =? ”)

query.setString(0,name)

query.setInteger(1,age)

同样使用setXXX()方法设定绑定参数，只不过这时setXXX()方法的第一个参数代表邦定参数在HQL语句中出现的位置编号（由0开始编号），第二个参数仍然代表参

数实际值。

注：在实际开发中，提倡使用按名称邦定命名参数，因为这不但可以提供非常好的程序可读性，而且也提高了程序的易维护性，因为当查询参数的位置发生改变时

，按名称邦定名参数的方式中是不需要调整程序代码的。

C、 setParameter()方法：

在Hibernate的HQL查询中可以通过setParameter()方法邦定任意类型的参数，如下代码：

String hql=”from User user where user.name=:customername ”

Query query=session.createQuery(hql)

query.setParameter(“customername”,name,Hibernate.STRING)

如上面代码所示，setParameter()方法包含三个参数，分别是命名参数名称，命名参数实际值，以及命名参数映射类型。对于某些参数类型setParameter()方法可

以更具参数值的Java类型，猜测出对应的映射类型，因此这时不需要显示写出映射类型，像上面的例子，可以直接这样写：

query.setParameter(“customername”,name)但是对于一些类型就必须写明映射类型，比如java.util.Date类型，因为它会对应Hibernate的多种映射类型，比如

Hibernate.DATA或者Hibernate.TIMESTAMP。

D、 setProperties()方法：

在Hibernate中可以使用setProperties()方法，将命名参数与一个对象的属性值绑定在一起，如下程序代码：

Customer customer=new Customer()

customer.setName(“pansl”)

customer.setAge(80)

Query query=session.createQuery(“from Customer c where c.name=:name and c.age=:age ”)

query.setProperties(customer)

setProperties()方法会自动将customer对象实例的属性值匹配到命名参数上，但是要求命名参数名称必须要与实体对象相应的属性同名。

这里还有一个特殊的setEntity()方法，它会把命名参数与一个持久化对象相关联，如下面代码所示：

Customer customer=(Customer)session.load(Customer.class,”1”)

Query query=session.createQuery(“from Order order where order.customer=:customer ”)

query. setProperties(“customer”,customer)

List list=query.list()

上面的代码会生成类似如下的SQL语句：

Select * from order where customer_ID=’1’

E、 使用绑定参数的优势：

我们为什么要使用绑定命名参数？任何一个事物的存在都是有其价值的，具体到绑定参数对于HQL查询来说，主要有以下两个主要优势：

①、 可以利用数据库实施性能优化，因为对Hibernate来说在底层使用的是PrepareStatement来完成查询，因此对于语法相同参数不同的SQL语句，可

以充分利用预编译SQL语句缓存，从而提升查询效率。

②、 可以防止SQL Injection安全漏洞的产生：

SQL Injection是一种专门针对SQL语句拼装的攻击方式，比如对于我们常见的用户登录，在登录界面上，用户输入用户名和口令，这时登录验证程序可能会生成如

下的HQL语句：

“from User user where user.name=’”+name+”’ and user.password=’”+password+”’ ”

这个HQL语句从逻辑上来说是没有任何问题的，这个登录验证功能在一般情况下也是会正确完成的，但是如果在登录时在用户名中输入”zhaoxin or ‘x’=’x”,

这时如果使用简单的HQL语句的字符串拼装，就会生成如下的HQL语句：

“from User user where user.name=’zhaoxin’ or ‘x’=’x’ and user.password=’admin’ ”

显然这条HQL语句的where字句将会永远为真，而使用户口令的作用失去意义，这就是SQL Injection攻击的基本原理。

而使用绑定参数方式，就可以妥善处理这问题,当使用绑定参数时，会得到下面的HQL语句：

from User user where user.name=’’zhaoxin’’ or ‘’x=’’x’’ ‘ and user.password=’admin’由此可见使用绑定参数会将用户名中输入的单引号解

析成字符串（如果想在字符串中包含单引号，应使用重复单引号形式），所以参数绑定能够有效防止SQL Injection安全漏洞。

---