首页 > 代码库 > Hibernate批量操作(一)

Hibernate批量操作(一)

在项目的开发过程之中,我们常会遇到数据的批量处理问题。在持久层采用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完成对数据的批量删除/更新都在一个问题:无法解决缓存同步问题(包括一级缓存和二级缓存)。为了保持缓存数据的一致性,简单的办法就是清空缓存数据。

Hibernate批量操作(一)