在项目的开发过程之中，我们常会遇到数据的批量处理问题。在持久层采用Hibernate框架时，在进行批量操作时，需要考虑Hibernate实现机制带来的一些问题。
我们知道在每个Hibernate Session中都维持了一个必选的数据缓存，所有保存的实例都将保存在Session缓存中，这个缓存随着Session的创建而存在，随着Session的销毁而消亡。这个内部缓存正常情况下是由Hibernate自动维护的，并且没有容量限制。在批量插入与更新时，由于每次保存的实体都会保存在Session缓存中，当数据量大的时候，就可能出现OutOfMemoryException（内存溢出异常）。所以批量增加或更新操作中, 应该考虑到控制内部缓存的过度增长而出现OutOfMemeoryError错误。
这里有两个方面进行控制：一是在数据保存过程中周期性的对Session调用flush和clear方法，确保Session的容量不至于太大。二是设置hibernate.jdbc.batch_size参数来指定每次提交SQL的数量。
周期性调用session的flush和clear方法，最简单的一个方式是：设置一个计数器，每保存一个实例时，计数器加1。根据计数器的值决定是否需要将Session缓存中的数据刷入数据库。
配置hibernate.jdbc.batch_size参数的原因就是尽量少读数据库，hibernate.jdbc.batch_size参数值越大，读数据库的次数越少，速度越快。
另外一个需要考虑的问题是在批量更新或批量删除时，最简单的思路是都是先将符合要求的数据查出来，然后再做更新/删除操作。而且更新/删除操作通常是逐行更新/删除，即每更新/删除一行记录，都需要执行一条update/delete语句。这样做的目的在于缓存同步，所以往往是一次批量更新/删除往往执行的是1+N次操作. 第一次是查询, 第二次是逐条更除/删除。由于带来的问题是内存消耗。特别是过大数据量时还可能在查询时导致OutOfMemeoryError错误。
这里可以考虑使用session.iterator或者Query.iterate方法逐条获取数据，或者采用基于游标的数据遍历操作(JDBC驱动需支持游标), 通过游标来逐条获取数据，从而控制内存的使用。（注：iterate方法首先从本地缓存中根据id查找对应的实体对象——类似Session.load方法，如果实体在缓存中已经存在，则直接以此数据对象作为查询结果，如果没找到，再执行相应的Select语句获得对应的库表记录）
另外也可以采用Hibernate 3.0后提供的批量更新/删除接口。Hibernate3.0 采用新的基于ANTLR的HQL/SQL查询翻译器，在Hibernate的配置文件中hibernate.query.factory_class属性用来选择查询翻译器。
1）选择Hibernate3.0的查询翻译器：hibernate.query.factory_class= org.hibernate.hql.ast.ASTQueryTranslatorFactory
2）选择Hibernate2.1的查询翻译器：hibernate.query.factory_class= org.hibernate.hql.classic.ClassicQueryTranslatorFactory
为了使用3.0的批量更新和删除功能，只能选择ASTQueryTranslatorFactory，否则不能解释批量更新的语句。
注：ANTLR是用纯Java语言编写出来的一个编译工具，它可生成Java语言或者是C++的词法和语法分析器，并可产生语法分析树并对该树进行遍历。ANTLR由于是纯Java的，因此可以安装在任意平台上，但是需要JDK的支持。
下面就分别从批量插入、批量更新和批量删除3个方面总结一下Hibernate批量处理的情开。
批量增加
由于批量增加会带来session级缓存的增长，所以我们一般在数据保存过程中周期性地调用Session的flush和clear方法。如下：
public <T> int batchSave(final T[] array) {
Transaction tx = session.beginTransaction();
for(int i = 0; i < array.length; i++) {
session.save(array[i]);
if (i % BATCH_MAX_ROW == 0) {
session.flush();
session.clear();
}
}
session.flush();
session.clear();
tx.commit();
return array.length;
}
上面代码中，当i % BATCH_MAX_ROW == 0时，就手动Session处的缓存数据写入数据库。
其中，Session.flush()方法会完成两个主要任务(见DefaultFlushEventListener类)：1．刷新所有数据；2．执行数据库SQL完成持久化动作；flush方法必须在操作结束且在提交事务和关闭连接之前被调用。Session.clear()则是清除session中的缓存数据。这样就达到控制session的一级缓存的大小。
如果在Spring+Hibernate环境下，利用Spring提供的Hibernate模板，我们可以如下定义：
public <T> int batchSave(final T[] array) {
int affectedRow = (Integer) getHibernateTemplate().execute(
new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException, SQLException {
for (int i = 0; i < array.length; ++i) {
session.save(array[i]);
if (i % BATCH_MAX_ROW == 0) {
session.flush();
session.clear();
}
}
session.flush();
session.clear();
return array.length;
}
});
return affectedRow;
}
我们也可以通过SQL的方式来批量增加数据，那么在JDBC中使用批量增加的情况如下：
Statement stmt = connection.createStatement();
connection.setAutoCommit(false);//将Auto commit设置为false,不允许自动提交
stmt.addBatch("insert into employee values(23,'wang','man',20)");
stmt.addBatch("insert into employee values(24,'xiaowu','woman',24)");
stmt.executeBatch(); //将一批命令提交给数据库来执行，如果全部命令执行成功，则返回更新计数组成的数组
connection.setAutoCommit(true);
以上代码显示的是利用JDBC Statement接口来处理批量增加的情况，其中,statement接口中的两个方法：
addBatch(String sql)——在批处理缓存中加入一条sql语句；
executeBatch()——执行批处理缓存中的所有sql语句
另外一种方式是利用PrepareStatement来处理批量增加，如下：
PreparedStatement pstm = connection.prepareStatement("insert into employee values(?,?,?,?)");
connection.setAutoCommit(false);//将Auto commit设置为false,不允许自动提交
//设置第一条语句
pstm.setInt(1, 33);
pstm.setString(2,"wang");
pstm.setString(3, "man");
pstm.setDouble(4, 20);
pstm.addBatch(); //将一组参数添加到此 PreparedStatement 对象的批处理命令中。
//设置第二条语句
pstm.setInt(1, 34);
pstm.setString(2,"xiaowu");
pstm.setString(3, "woman");
pstm.setDouble(4, 24);
pstm.addBatch();
pstm.executeBatch();//将一批参数提交给数据库来执行，如果全部命令执行成功，则返回更新计数组成的数组
connection.commit();
connection.setAutoCommit(true);//将Auto commit还原为true
其中, PreparedStatement接口中的两个方法：
addBatch()——将一组参数添加到PreparedStatement对象中。
executeBatch()——将一批参数提交给数据库来执行，如果命令执行成功，则返回更新计数组成的数组。
在以上的代码中，只需使用Hibernate连接来改造上述代码就可实现Hibernate利用JDBC来批量增加。
批量修改
批量增加的思路同样适用于批量更新数据，如果需要返回多行数据，可以使用scroll()方法，从而可充分利用服务器端游标所带来的性能优势。如下代码：为
String hqlString = ...;
Transaction tx = session.beginTransaction();
Iterator iter = session.find(hqlString).iterator();
//ScrollableResults users = session.createQuery(hqlString)
// .setCacheMode(CacheMode.IGNORE)
// .scroll(ScrollMode.FORWARD_ONLY);
int count=0;
while(iter.hasNext()){
Oject obj = iter.next();
// do something here….
if (++count % BATCH_MAX_ROW == 0 ) {
session.flush();
session.clear();
}
}
tx.commit();
session.close();
如前所述，我们应该力求避免出现先执行数据查询进行数据逐行更新(即每更新一行记录，都需要执行一条update语句)的情况。实际上，我们可考虑利用Hibernate提供的类似于SQL的批量更新/删除的HQL语法来进行批量操作。
我们先看一下在SQL中进行批量更新的操作：
采用Statement接口进行更新：
Statement stmt = connection.createStatement();
String sqlString = "update s set age=20 where id=s1";
stmt.executeUpdate(sql);
采用PreparedStatement接口进行更新：
PreparedStatement stmt = connection.prepareStatement("update s set age=? where id=?");
stmt.setObject(1, "20");
stmt.setObject(2, "s1");
int i = statement.executeUpdate();
我们在Hibernate中绕过Hibernate API，通过JDBC API来执行SQL语句，示例：
String sqlString = ...; //定义批量更新的SQL语句
tx = session.beginTransaction();
Connection con = session.connection();
PreparedStatement stmt = con.prepareStatement(sqlString);
//set the parameter
stmt.executeUpdate();
tx.commit();
利用Spring模板示例：
public Integer executeBySql(final String sqlString, final Object[] values)
throws HibernateException, SQLException {
return (Integer) getHibernateTemplate().execute(
new HibernateCallback() {
public Object doInHibernate(Session session) throws HibernateException, SQLException {
Transaction tx = session.beginTransaction();
Integer result = -1;
try {
tx.begin();
SQLQuery query = session.createSQLQuery(sqlString);
for (int k = 0; k < values.length; k++) {
query.setParameter(k, values[k]); //按位置进行绑定。。
}
result = query.executeUpdate();
tx.commit();
} catch (HibernateException e) {
e.printStackTrace();
if (tx != null) {
tx.rollback();
}
} finally {
session.clear();
}
return result;
}
}
);
}
利用Hiberante3提供的批量操作接口处理如下：
Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();
String hqlUpdate = "update Customer set name = :newName where name = :oldName";
int updatedEntities = s.createQuery( hqlUpdate )
.setString( "newName", newName )
.setString( "oldName", oldName )
.executeUpdate();
tx.commit();
session.close();
由Query.executeUpdate()方法返回一个整型值，该值是受此操作影响的记录数量。实际上，Hibernate的底层操作是通过JDBC完成的。因此，如果有批量的UPDATE或DELETE操作被转换成多条UPDATE或DELETE语句，该方法返回的是最后一条SQL语句影响的记录行数。
利用Spring模板示例：
public Integer exeByHQL(final String hqlString, final Object[] params) {
return (Integer) getHibernateTemplate().execute(
new HibernateCallback() {
public Object doInHibernate(Session session) throws HibernateException, SQLException {
Integer result = -1;
Transaction tx = session.beginTransaction();
Query query = session.createQuery(hqlString);
for (int i = 0; i < params.length; i++)
query.setParameter(i, params[i]);
result = Integer.valueOf(query.executeUpdate());
tx.commit();
return result;
}
});
}
如果底层数据库支持存储过程，也可以通过存储过程来执行批量更新。以下是利用Spring模板的一个例子：
public String executeByProcedure(final String sqlString, final Object[] values)
throws HibernateException, SQLException {
return (String) getHibernateTemplate().execute(
new HibernateCallback() {
public Object doInHibernate(Session session) throws HibernateException, SQLException {
try {
Connection connection = session.connection();
CallableStatement cstm = connection.prepareCall(sqlString);
String as[] = values;
int j = as.length;
for (int k = 0; k < j; k++) {
String s1 = as[k];
cstm.setString(k, s1);
}
cstm.executeUpdate();
String s = cstm.getString(1);
if (cstm != null)
cstm.close();
return s;
}
catch (RuntimeException runtimeException) {
runtimeException.printStackTrace();
throw runtimeException;
}
}
}
);
}
在Hiberante中的示例如下；
Transaction tx = session.beginTransaction();
Connection con=session.connection();
String procedure = "{call batchUpdateXXX(?) }";
CallableStatement cstmt = con.prepareCall(procedure);
cstmt.setInt(1,0);
cstmt.executeUpdate();
tx.commit();
批量删除
批量删除与批量修改类似，以下是通过Hibernate3.0执行批量删除的程序代码：
代码
Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();
String hqlDelete = "delete from Customer where name = :oldName";
int deletedEntities = s.createQuery( hqlDelete )
.setString( "oldName", oldName )
.executeUpdate();
tx.commit();
session.close();
通过JDBC API执行相关的SQL语句或调用相关的存储过程是批量更新和批量删除的理想方式，它具有以下优点：
(1) 不会消耗大量内存。因为它不再将数据库中的大批量数据先加载到内存中，然后再逐个更新或修改。
(2) 可以在一条SQL语句中更新或删除大批量的数据。
无论是直接引用SQL方式还是使用Hibernate 3的bulk接口, 通过一条的SQL完成对数据的批量删除/更新都在一个问题：无法解决缓存同步问题(包括一级缓存和二级缓存)。为了保持缓存数据的一致性，简单的办法就是清空缓存数据。