`
liuliu140
  • 浏览: 6299 次
  • 性别: Icon_minigender_1
  • 来自: 广州
社区版块
存档分类
最新评论

hibernate3 批量操作

阅读更多

通常,在一个Session对象的缓存中只存放数量有限的持久化对象,等到Session对象处理事务完毕,还要关闭Session对象,从而及时释放Session的缓存占用的内存。
批量处理数据是指在一个事务中处理大量数据。以下程序在一个事务中批量更新CUSTOMERS表中年龄大于零的所有记录的AGE字段:
Transaction tx = session.beginTransaction();
Iterator customers=
session.createQuery("from Customer c where c.age>0").list().iterator();
while(customers.hasNext()){
Customer customer=(Customer)customers.next();
customer.setAge(customer.getAge()+1);
}

tx.commit();
session.close();

如果CUSTOMERS表中有1万条年龄大于零的记录,那么hibernate会一下子加载1万个Customer对象到内存。当执行tx.commit()方法时,会清理缓存,Hibernate执行1万条更新CUSTOMERS表的update语句:
update CUSTOMERS set AGE=? …. where ID=i;
update CUSTOMERS set AGE=? …. where ID=j;
……
update CUSTOMERS set AGE=? …. where ID=k;

以上批量更新方式有两个缺点:
占用大量内存,必须把1万个Customer对象先加载到内存,然后一一更新它们。
执行的update语句的数目太多,每个update语句只能更新一个Customer对象,必须通过1万条update语句才能更新1万个Customer对象,频繁地访问数据库,会大大降低应用的性能。

一般说来,应该尽可能避免在应用层进行批量操作,而应该在数据库层直接进行批量操作,例如直接在数据库中执行用于批量更新或删除的SQL语句,如果批量操作的逻辑比较复杂,则可以通过直接在数据库中运行的存储过程来完成批量操作。
并不是所有的数据库系统都支持存储过程。例如目前的MySQL就不支持存储过程,因此不能通过存储过程来进行批量更新或批量删除。
当然,在应用层也可以进行批量操作,主要有以下方式:
(1)通过Session来进行批量操作。
(2)通过StatelessSession来进行批量操作。
(3)通过HQL来进行批量操作。
(4)直接通过JDBC API来进行批量操作。

一、通过Session来进行批量操作

Session的save()以及update()方法都会把处理的对象存放在自己的缓存中。如果通过一个Session对象来处理大量持久化对象,应该及时从缓存中清空已经处理完毕并且不会再访问的对象。具体的做法是在处理完一个对象或小批量对象后,立刻调用flush()方法清理缓存,然后再调用clear()方法清空缓存。

通过Session来进行批量操作会受到以下约束:
(1)需要在Hibernate的配置文件中设置JDBC单次批量处理的数目,合理的取值通常为10到50之间,例如:
hibernate.jdbc.batch_size=20
在按照本节介绍的方法进行批量操作时,应该保证每次向数据库发送的批量SQL语句数目与这个batch_size属性一致。
(2)如果对象采用"identity"标识符生成器,则Hibernate无法在JDBC层进行批量插入操作。
(3)进行批量操作时,建议关闭Hibernate的第二级缓存。本书的姊妹篇《精通Hibernate:高级篇》对第二级缓存做了详细介绍。Session的缓存为Hibernate的第一级缓存,通常它是事务范围内的缓存,也就是说,每个事务都有单独的第一级缓存。SessionFactory的外置缓存为Hibernate的第二级缓存,它是应用范围内的缓存,也就是说,所有事务都共享同一个第二级缓存。在任何情况下,Hibernate的第一级缓存总是可用的。而默认情况下,Hibernate的第二级缓存是关闭的,此外也可以在Hibernate的配置文件中通过如下方式显式关闭第二级缓存:
hibernate.cache.use_second_level_cache=false

1.批量插入数据
以下代码一共向数据库中插入十万条CUSTOMERS记录,单次批量插入20条CUSTOMERS记录:
Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();

for ( int i=0; i<100000; i++ ) {
Customer customer = new Customer(.....);
session.save(customer);
if ( i % 20 == 0 ) { //单次批量操作的数目为20
session.flush(); //清理缓存,执行批量插入20条记录的SQL insert语句
session.clear(); //清空缓存中的Customer对象
}
}

tx.commit();
session.close();

在以上程序中,每次执行session.flush()方法,就会向数据库中批量插入20条记录。接下来session.clear()方法把20个刚保存的Customer对象从缓存中清空。
为了保证以上程序顺利运行,需要遵守以下约束。
在Hibernate的配置文件中,应该把hibernate.jdbc.batch_size属性也设为20。
关闭第二级缓存。因为假如使用了第二级缓存,那么所有在第一级缓存(即Session的缓存)中创建的Customer对象还要先复制到第二级缓存中,然后再保存到数据库中,这会导致大量不必要的开销。
Customer对象的标识符生成器不能为"identity"。

2.批量更新数据

进行批量更新时,如果一下子把所有对象到加载到Session的缓存中,然后再在缓存中一一更新它们,显然是不可取的。为了解决这一问题,可以使用可滚动的结果集org.hibernate.ScrollableResults,Query的scroll()方法返回一个ScrollableResults对象。以下代码演示批量更新Customer对象,该代码一开始利用ScrollableResults对象来加载所有的Customer对象:
Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();

ScrollableResults customers= session.createQuery("from Customer")
.scroll(ScrollMode.FORWARD_ONLY);
int count=0;
while ( customers.next() ) {
Customer customer = (Customer) customers.get(0);
customer.setAge(customer.getAge()+1); //更新Customer对象的age属性
if ( ++count % 20 == 0 ) { //单次批量操作的数目为20

session.flush();//清理缓存,执行批量更新20条记录的SQL update语句
session.clear();//清空缓存中的Customer对象
}
}

tx.commit();
session.close();

在以上代码中,Query的scroll()方法返回的ScrollableResults对象中实际上并不包含任何Customer对象,它仅仅包含了用于在线定位数据库中CUSTOMERS记录的游标。只有当程序遍历访问ScrollableResults对象中的特定元素时,它才会到数据库中加载相应的Customer对象。
为了保证以上程序顺利运行,需要遵守以下约束:
在Hibernate的配置文件中,应该把hibernate.jdbc.batch_size属性也设为20。
关闭第二级缓存。假如已经在配置文件中启用了第二级缓存,也可以通过以下方式在程序中忽略第二级缓存:
ScrollableResults customers= session.createQuery("from Customer")
//忽略第二级缓存
.setCacheMode(CacheMode.IGNORE)
.scroll(ScrollMode.FORWARD_ONLY);

二、通过StatelessSession来进行批量操作

Session具有一个用于保持内存中对象与数据库中相应数据保持同步的缓存,位于Session缓存中的对象为持久化对象。但在进行批量操作时,把大量对象存放在Session缓存中会消耗大量内存空间。作为一种替代方案,可以采用无状态的StatelessSession来进行批量操作。
以下代码利用 StatelessSession来进行批量更新操作:
StatelessSession session = sessionFactory.openStatelessSession();
Transaction tx = session.beginTransaction();

ScrollableResults customers = session.getNamedQuery("GetCustomers")
.scroll(ScrollMode.FORWARD_ONLY);
while ( customers.next() ) {
Customer customer = (Customer) customers.get(0);
customer.setAge(customer.getAge()+1); //在内存中更新Customer对象的age属性;
session.update(customer);//立即执行update语句,更新数据库中相应CUSTOMERS记录
}

tx.commit();
session.close();

从形式上看,StatelessSession与Session的用法有点相似。StatelessSession与Session相比,有以下区别:
(1)StatelessSession没有缓存,通过StatelessSession来加载、保存或更新后的对象都处于游离状态。
(2)StatelessSession不会与Hibernate的第二级缓存交互。
(3)当调用StatelessSession的save()、update()或delete()方法时,这些方法会立即执行相应的SQL语句,而不会仅仅计划执行一条SQL语句。
(4)StatelessSession不会对所加载的对象自动进行脏检查。所以在以上程序中,修改了内存中Customer对象的属性后,还需要通过StatelessSession的update()方法来更新数据库中的相应数据。
(5)StatelessSession不会对关联的对象进行任何级联操作。举例来说,通过StatelessSession来保存一个Customer对象时,不会级联保存与之关联的Order对象。
(6)StatelessSession所做的操作可以被Interceptor拦截器捕获到,但会被Hibernate的事件处理系统忽略。
(7)通过同一个StatelessSession对象两次加载OID为1的Customer对象时,会得到两个具有不同内存地址的Customer对象,例如:
StatelessSession session = sessionFactory.openStatelessSession();
Customer c1=(Customer)session.get(Customer.class,new Long(1));
Customer c2=(Customer)session.get(Customer.class,new Long(1));
System.out.println(c1==c2); //打印false

三、通过HQL来进行批量操作

Hibernate3中的HQL(Hibernate Query Language,Hibernate查询语言)不仅可以检索数据,还可以用于进行批量更新、删除和插入数据。批量操作实际上直接在数据库中完成,所处理的数据不会被保存在Session的缓存中,因此不会占用内存空间。
Query.executeUpdate()方法和JDBC API中的PreparedStatement.executeUpdate()很相似,前者执行用于更新、删除和插入的HQL语句,而后者执行用于更新、删除和插入的SQL语句。

1.批量更新数据
以下程序代码演示通过HQL来批量更新Customer对象:
Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();

String hqlUpdate =
"update Customer c set c.name = :newName where c.name = :oldName";
int updatedEntities = session.createQuery( hqlUpdate )
.setString( "newName", "Mike" )
.setString( "oldName", "Tom" )
.executeUpdate();

tx.commit();
session.close();
以上程序代码向数据库发送的SQL语句为:
update CUSTOMERS set NAME="Mike" where NAME="Tom"

2.批量删除数据
Session的delete()方法一次只能删除一个对象,不适合进行批量删除操作。以下程序代码演示通过HQL来批量删除Customer对象:
Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();

String hqlDelete = "delete Customer c where c.name = :oldName";
int deletedEntities = session.createQuery( hqlDelete )
.setString( "oldName", "Tom" )
.executeUpdate();
tx.commit();
session.close();
以上程序代码向数据库提交的SQL语句为:
delete from CUSTOMERS where NAME="Tom"

3.批量插入数据
插入数据的HQL语法为:
insert into EntityName properties_list select_statement
以上EntityName表示持久化类的名字,properties_list表示持久化类的属性列表,select_statement表示子查询语句。
HQL只支持insert into ... select ... 形式的插入语句,而不支持"insert into ... values ... "形式的插入语句。
下面举例说明如何通过HQL来批量插入数据。假定有DelinquentAccount和Customer类,它们都有id和name属性,与这两个类对应的表分别为DELINQUENT_ACCOUNTS和CUSTOMERS表。DelinquentAccount.hbm.xml和Customer.hbm.xml文件分别为这两个类的映射文件。以下代码能够把CUSTOMERS表中的数据复制到DELINQUENT_ACCOUNTS表中:
Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();

String hqlInsert = "insert into DelinquentAccount (id, name) select c.id, c.name from Customer c where c.id>1";
int createdEntities = s.createQuery( hqlInsert )
.executeUpdate();
tx.commit();
session.close();

以上程序代码向数据库提交的SQL语句为:
insert into DELINQUENT_ACCOUNTS(ID,NAME) select ID,NAME from CUSTOMERS where ID>1

四、直接通过JDBC API来进行批量操作

当通过JDBC API来执行SQL insert、update和delete语句时,SQL语句中涉及到的数据不会被加载到内存中,因此不会占用内存空间。
以下程序直接通过JDBC API来执行用于批量更新的SQL语句:
Transaction tx = session.beginTransaction();
//获得该Session使用的数据库连接
Java.sql.Connection con=session.connection();
//通过JDBC API执行用于批量更新的SQL语句
PreparedStatement stmt=con.prepareStatement("update CUSTOMERS set AGE=AGE+1 "
+"where AGE>0 ");
stmt.executeUpdate();

tx.commit();

以上程序通过Session的connection()方法获得该Session使用的数据库连接,然后通过它创建PreparedStatement对象并执行SQL语句。值得注意的是,应用程序仍然通过Hibernate的Transaction接口来声明事务边界。
值得注意的是,在Hibernate3中,尽管Session的connection()方法还存在,但是已经被废弃,不提倡使用了,不过Hibernate3提供了替代方案:org.hibernate.jdbc.Work接口表示直接通过JDBC API来访问数据库的操作,Work接口的execute()方法用于执行直接通过JDBC API来访问数据库的操作:
public interface Work {
//直接通过JDBC API来访问数据库的操作
public void execute(Connection connection) throws SQLException;
}
Session的doWork(Work work)方法用于执行Work对象指定的操作,即调用Work对象的execute()方法。Session会把当前使用的数据库连接传给execute()方法。

以下程序演示了通过Work接口以及Session的doWork()方法来执行批量操作的过程:
Transaction tx=session.beginTransaction();
//定义一个匿名类,实现了Work接口
Work work=new Work(){
public void execute(Connection connection)throws SQLException{
//通过JDBC API执行用于批量更新的SQL语句
PreparedStatement stmt=connection
.prepareStatement("update CUSTOMERS set AGE=AGE+1 "
+"where AGE>0 ");
stmt.executeUpdate();
}
};

//执行work
session.doWork(work);
tx.commit();

当通过JDBC API中的PreparedStatement接口来执行SQL语句时,SQL语句中涉及到的数据不会被加载到Session的缓存中,因此不会占用内存空间。

 

转自http://blog.csdn.net/weiling_shen/article/details/44960303

分享到:
评论

相关推荐

    Hibernate下数据批量处理解决方案

    需要注意的是,如果启用二级缓存,批量操作可能导致额外的内存问题,因为Hibernate需要在事务结束时同步二级缓存。在这种情况下,可能需要临时禁用二级缓存以避免不必要的内存消耗。 总的来说,虽然ORM框架在处理...

    JSF+hibernate实现批量删除

    本篇文章将详细探讨如何利用JSF与Hibernate相结合来实现批量删除功能,以及在CRUD(创建、读取、更新和删除)操作中的应用。 首先,我们需要理解JSF的工作原理。JSF是一个基于组件的MVC(Model-View-Controller)...

    hibernate批量删除

    ### Hibernate批量删除详解 #### 背景与概念 在Java开发中,处理大量数据时,经常需要执行批量操作,如批量更新或批量删除。这些操作对于提高应用程序性能至关重要,尤其是在涉及成千上万条记录的情况下。...

    在Hibernate中处理批量更新和批量删除

    本文将深入探讨在Hibernate中处理批量更新和批量删除的策略,以及如何优化这些操作,以提高数据库操作的效率。 ### 批量更新的常规方法 在Hibernate中,最直观的批量更新方式是通过循环遍历查询结果集,并对每个...

    在Hibernate应用中处理批量更新和批量删除

    2. **使用原生SQL或存储过程**:直接使用JDBC API执行原生SQL或调用存储过程,绕过Hibernate的ORM层,可以实现更高性能的批量操作。例如,可以创建一个存储过程用于批量更新操作: ```sql CREATE OR REPLACE ...

    struts2 hibernate spring 整合批量删除源码

    在批量删除操作中,Struts2会接收用户的批量删除请求,通过Action类来处理这些请求,并将结果转发到相应的视图页面。Action类通常会注入Spring管理的业务服务层,以便调用删除方法。 其次,Hibernate是一个对象关系...

    Hibernate批量处理

    ### Hibernate批量处理详解 #### 一、批量处理概述 Hibernate作为一种强大的对象关系映射(ORM)框架,提供了多种批量处理的方式以提高数据处理效率。批量处理对于需要在短时间内处理大量数据的应用尤其重要,如...

    jsp Hibernate批量更新和批量删除处理代码

    通过合理利用Hibernate的会话缓存机制、手动提交与清理策略、直接使用JDBC API或通过存储过程调用数据库原生批量操作,可以有效提升批量操作的性能和效率。开发者应当根据具体的应用场景和数据库特性,选择合适的...

    Java中Hibernate的批量插入

    然而,在处理大量数据的批量操作时,如批量插入、更新或删除,如果不采取适当的策略,可能会导致性能问题甚至出现内存溢出异常。针对这种情况,Hibernate提供了一些批量处理的解决方案。 批量插入是处理大量数据...

    hibernate数据库相关操作步骤

    - 使用批处理:批量处理多个保存、更新或删除操作,以减少数据库交互次数。 - 适当使用懒加载和立即加载:避免加载不必要的关联对象,减小内存开销。 - 优化HQL和SQL:避免全表扫描,利用索引,减少子查询。 ...

    hibernate批量操作实例详解

    【hibernate批量操作实例详解】 批量操作是提高数据库处理效率的重要手段,特别是在处理大量数据时,能够显著提升性能并减少资源消耗。在Hibernate中,批量操作主要包括批量插入、批量更新和批量删除。以下是对这些...

    hibernate批量删除.txt

    通过上述介绍,我们可以了解到使用Hibernate进行批量删除操作不仅可以简化代码,还能有效提升系统的整体性能。合理利用Hibernate提供的API和数据库特性,能够帮助开发者更好地应对大数据量场景下的挑战。

    Hibernate批量处理数据

    ### Hibernate批量处理数据 #### 一、概述 Hibernate作为一款流行的Java持久层框架,它能够以面向对象的方式处理数据库操作,极大地简化了开发过程。然而,在处理大量数据时,如果仍然采用逐条处理的方式,将会...

    Pro Hibernate 3 DAVE MINTER AND JEFF LINWOOD.pdf

    通过Hibernate,开发者可以使用面向对象的方式进行数据操作,而不是直接处理复杂的SQL语句,这大大提高了开发效率和代码可维护性。 #### 2. Hibernate 3新特性 Hibernate 3相对于前一版本,引入了许多新的特性和...

    Hibernate管理Session和批量操作分析

    在Java的持久化框架Hibernate中,管理Session和执行批量操作是优化数据库交互的关键技术。本文主要探讨了如何高效地管理Hibernate的Session以及如何实施批量处理数据,这些技巧对于提升应用程序性能至关重要。 首先...

    Java Hibernate3 添加和删除数据

    Java Hibernate3 是一个强大的...总的来说,Java Hibernate3简化了数据库操作,使得开发者可以专注于业务逻辑,而不是底层的SQL。通过理解和掌握这些基本操作,能够帮助开发者更高效地构建数据库驱动的Java应用程序。

    hibernate 3,25

    10. **批处理**:通过设置批处理大小,可以批量执行SQL语句,提高数据库操作效率。 在实际项目中,使用Hibernate 3.2.5可以极大地提升开发效率,减少数据库相关的代码量,并且提供了一套完整的对象模型,使开发者更...

    jsp Hibernate批量更新和批量删除处理代码.docx

    本文件主要探讨了如何使用Hibernate进行批量更新和批量删除处理,这些操作在处理大量数据时尤其重要,因为它们可以显著提高应用的性能。下面我们将深入解析这两个主题。 批量更新在Hibernate中通常涉及在一个事务中...

    Hibernate3的配置参数汇总

    - `hibernate.default_batch_fetch_size`:设置默认的批量抓取大小,提高查询性能。 - `hibernate.default_entity_mode`:定义Session的默认实体模式,例如POJO或DTO。 这些配置参数可以帮助开发者根据具体项目...

Global site tag (gtag.js) - Google Analytics