Hibernate的批量更新与删除（&&JDBC）

最新推荐文章于 2024-05-11 15:30:00 发布
最新推荐文章于 2024-05-11 15:30:00 发布
阅读量1.3w 收藏 8
点赞数 2
分类专栏： Hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/an_2016/article/details/51762170
版权

更新&&删除

语法格式：（HQL）

update  |     delete from? <ClassName> [where where_conditions]

1>在from子句中，from关键字是可选的，即完全可以不写from关键字

2>在from子句中，只能有一个类名，可以在该类名后指定别名

3>不能在批量HQL语句中使用连接，显示或者隐式的都不行，但可以在where子句中使用子查询

4>整个where子句是可选的，where子句的语法sql语句中where子句的语法完全相同

5>Query.executeUpdate()方法返回一个整型值，该值是受此操作影响的记录数量，由于hibernate的底层操作实际上是由JDBC完成的，因此，如果有批量update或delete操作被转换成多条update或delete语句，(关联或者继承映射)，该方法只能返回最后一条sql语句影响的记录行数，不是所有的记录行数，需要注意；


一，批量更新(两种方式)

1，使用Hibernate直接进行批量更新

(1)方式1：(Hibernate的HQL直接支持update/delete的批量更新语法)

<span style="font-size:18px;">package com.anlw.util;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;

public class SessionUtil {
	Configuration conf = null;
	ServiceRegistry st = null;
	SessionFactory sf = null;
	Session sess = null;
	Transaction tx = null;

	public void HIbernateTest() {
		conf = new Configuration().configure();
		st = new StandardServiceRegistryBuilder().applySettings(conf.getProperties()).build();
		sf = conf.buildSessionFactory(st);
		try {
			sess = sf.openSession();
			tx = sess.beginTransaction();
			//在HQL查询中使用update进行批量更新，下面的的语句是HQL语句，不是sql语句
			Query query = sess.createQuery("update Student set name = 'www'");
			query.executeUpdate();
			tx.commit();
		} catch (Exception e) {
			if (tx != null) {
				tx.rollback();
			}
		} finally {
			sess.close();
			sf.close();
		}
	}

	public static void main(String[] args) {
		new SessionUtil().HIbernateTest();
	}
}
</span>
(2)方式2：(强烈不推荐) 

<span style="font-size:18px;">package com.anlw.util;

import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;

import org.hibernate.CacheMode;
import org.hibernate.Query;
import org.hibernate.ScrollMode;
import org.hibernate.ScrollableResults;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.jdbc.Work;
import org.hibernate.service.ServiceRegistry;

import com.anlw.entity.Student;

public class SessionUtil {
	Configuration conf = null;
	ServiceRegistry st = null;
	SessionFactory sf = null;
	Session sess = null;
	Transaction tx = null;

	public void HIbernateTest() {
		conf = new Configuration().configure();
		st = new StandardServiceRegistryBuilder().applySettings(conf.getProperties()).build();
		sf = conf.buildSessionFactory(st);
		try {
			sess = sf.openSession();
			tx = sess.beginTransaction();
			//查询表中的所有数据
			ScrollableResults student = sess.createQuery("from Student")
					.setCacheMode(CacheMode.IGNORE)
					.scroll(ScrollMode.FORWARD_ONLY);
			int count = 0;
			while(student.next()){
				Student s = (Student)student.get(0);
				s.setName("haha");
				if(++count%3 == 0){
					sess.flush();
					sess.clear();
				}
			}
			tx.commit();
		} catch (Exception e) {
			if (tx != null) {
				tx.rollback();
			}
		} finally {
			sess.close();
			sf.close();
		}
	}

	public static void main(String[] args) {
		new SessionUtil().HIbernateTest();
	}
}
</span>
通过这种方式，虽然可以执行批量更新，但效果非常不好，执行效率不高，需要先执行数据查询，然后再执行数据更新，而且这种更新将是逐行更新，即每更新一行记录，都要执行一条update语句，性能非常低；

2，绕过Hibernate，调用JDBC API

(1)方式1：

<span style="font-size:18px;">package com.anlw.util;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Statement;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.jdbc.Work;
import org.hibernate.service.ServiceRegistry;

public class SessionUtil {
	Configuration conf = null;
	ServiceRegistry st = null;
	SessionFactory sf = null;
	Session sess = null;
	Transaction tx = null;

	public void HIbernateTest() {
		conf = new Configuration().configure();
		st = new StandardServiceRegistryBuilder().applySettings(conf.getProperties()).build();
		sf = conf.buildSessionFactory(st);
		try {
			sess = sf.openSession();
			tx = sess.beginTransaction();
			//执行Work对象指定的操作，即调用Work对象的execute()方法
			//Session会把当前使用的数据库连接传给execute()方法
			sess.doWork(new Work() {
				
				@Override
				public void execute(Connection arg0) throws SQLException {//需要注意的是，不需要调用close()方法关闭这个连接
					String sql = "update student set name = 'oracle'";
					//创建一个Satement对象
					Statement st  = arg0.createStatement();
					//调用JDBC的update进行批量更新
					st.executeUpdate(sql);
				}
			});
			tx.commit();
		} catch (Exception e) {
			if (tx != null) {
				tx.rollback();
			}
		} finally {
			sess.close();
			sf.close();
		}
	}

	public static void main(String[] args) {
		new SessionUtil().HIbernateTest();
	}
}
</span>
(2)方式2： 

<span style="font-size:18px;">package com.anlw.util;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Statement;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.jdbc.Work;
import org.hibernate.service.ServiceRegistry;

public class SessionUtil {
	Configuration conf = null;
	ServiceRegistry st = null;
	SessionFactory sf = null;
	Session sess = null;
	Transaction tx = null;

	public void HIbernateTest() {
		conf = new Configuration().configure();
		st = new StandardServiceRegistryBuilder().applySettings(conf.getProperties()).build();
		sf = conf.buildSessionFactory(st);
		try {
			sess = sf.openSession();
			tx = sess.beginTransaction();
			//执行Work对象指定的操作，即调用Work对象的execute()方法
			//Session会把当前使用的数据库连接传给execute()方法
			sess.doWork(new Work() {
				
				@Override
				public void execute(Connection arg0) throws SQLException {//需要注意的是，不需要调用close()方法关闭这个连接
					String sql = "update student set name = ? where name=?";
					PreparedStatement ps = arg0.prepareStatement(sql);
					for(int i=0;i<10;i++){
						ps.setString(1,"tom");
						ps.setString(2, "oracle");
						ps.addBatch();
					}
					ps.executeBatch();
					
				}
			});
			tx.commit();
		} catch (Exception e) {
			if (tx != null) {
				tx.rollback();
			}
		} finally {
			sess.close();
			sf.close();
		}
	}

	public static void main(String[] args) {
		new SessionUtil().HIbernateTest();
	}
}
</span>

二，批量删除(两种方式)

1，使用Hibernate直接进行批量删除

(1)方式1：(Hibernate的HQL直接支持update/delete的批量更新语法)

<span style="font-size:18px;">package com.anlw.util;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;

public class SessionUtil {
	Configuration conf = null;
	ServiceRegistry st = null;
	SessionFactory sf = null;
	Session sess = null;
	Transaction tx = null;

	public void HIbernateTest() {
		conf = new Configuration().configure();
		st = new StandardServiceRegistryBuilder().applySettings(conf.getProperties()).build();
		sf = conf.buildSessionFactory(st);
		try {
			sess = sf.openSession();
			tx = sess.beginTransaction();
			//在HQL查询中使用delete进行批量删除，下面的的语句是HQL语句，不是sql
			Query query = sess.createQuery("delete Student");//也可以是delete from，from关键字是可选的，可以不要，加条件的时候可以指定类的别名
			query.executeUpdate();
			tx.commit();
		} catch (Exception e) {
			if (tx != null) {
				tx.rollback();
			}
		} finally {
			sess.close();
			sf.close();
		}
	}

	public static void main(String[] args) {
		new SessionUtil().HIbernateTest();
	}
}
</span>

(2)方式2：(强烈不推荐)

<span style="font-size:18px;">package com.anlw.util;

import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;

import org.hibernate.CacheMode;
import org.hibernate.Query;
import org.hibernate.ScrollMode;
import org.hibernate.ScrollableResults;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.jdbc.Work;
import org.hibernate.service.ServiceRegistry;

import com.anlw.entity.Student;

public class SessionUtil {
	Configuration conf = null;
	ServiceRegistry st = null;
	SessionFactory sf = null;
	Session sess = null;
	Transaction tx = null;

	public void HIbernateTest() {
		conf = new Configuration().configure();
		st = new StandardServiceRegistryBuilder().applySettings(conf.getProperties()).build();
		sf = conf.buildSessionFactory(st);
		try {
			sess = sf.openSession();
			tx = sess.beginTransaction();
			//查询表中的所有数据
			ScrollableResults student = sess.createQuery("from Student")
					.setCacheMode(CacheMode.IGNORE)
					.scroll(ScrollMode.FORWARD_ONLY);
			int count = 0;
			while(student.next()){
				Student s = (Student)student.get(0);
				sess.delete(s);
			}
			tx.commit();
		} catch (Exception e) {
			if (tx != null) {
				tx.rollback();
			}
		} finally {
			sess.close();
			sf.close();
		}
	}

	public static void main(String[] args) {
		new SessionUtil().HIbernateTest();
	}
}
</span>
通过这种方式，虽然可以执行批量删除，但效果非常不好，执行效率不高，需要先执行数据查询，然后再执行数据删除，而且这种删除将是逐行删除，即每删除一行记录，都要执行一条delete语句，性能非常低；

2，绕过Hibernate，调用JDBC API

(1)方式1：

<span style="font-size:18px;">package com.anlw.util;

import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.jdbc.Work;
import org.hibernate.service.ServiceRegistry;

import com.anlw.entity.Student;

public class SessionUtil {
	Configuration conf = null;
	ServiceRegistry st = null;
	SessionFactory sf = null;
	Session sess = null;
	Transaction tx = null;

	public void HIbernateTest() {
		conf = new Configuration().configure();
		st = new StandardServiceRegistryBuilder().applySettings(conf.getProperties()).build();
		sf = conf.buildSessionFactory(st);
		try {
			sess = sf.openSession();
			tx = sess.beginTransaction();
			sess.doWork(new Work() {
				
				@Override
				public void execute(Connection arg0) throws SQLException {
					String sql = "delete from student where age > 5"; //mysql中删除语句不能省略from
					Statement st = arg0.createStatement();
					st.executeUpdate(sql);
				}
			});
			tx.commit();
		} catch (Exception e) {
			if (tx != null) {
				tx.rollback();
			}
		} finally {
			sess.close();
			sf.close();
		}
	}

	public static void main(String[] args) {
		new SessionUtil().HIbernateTest();
	}
}
</span>
2)方式2： 

<span style="font-size:18px;">package com.anlw.util;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Statement;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.jdbc.Work;
import org.hibernate.service.ServiceRegistry;

import com.anlw.entity.Student;

public class SessionUtil {
	Configuration conf = null;
	ServiceRegistry st = null;
	SessionFactory sf = null;
	Session sess = null;
	Transaction tx = null;

	public void HIbernateTest() {
		conf = new Configuration().configure();
		st = new StandardServiceRegistryBuilder().applySettings(conf.getProperties()).build();
		sf = conf.buildSessionFactory(st);
		try {
			sess = sf.openSession();
			tx = sess.beginTransaction();
			sess.doWork(new Work() {
				
				@Override
				public void execute(Connection arg0) throws SQLException {
					String sql = "delete from student where age = ?"; //mysql中删除语句不能省略from
					PreparedStatement ps = arg0.prepareStatement(sql);
					for(int i=0;i<10;i++){
						if(i%2 == 0){
							ps.setInt(1, i);
							ps.addBatch();
						}
						ps.executeBatch();
					}
				}
			});
			tx.commit();
		} catch (Exception e) {
			if (tx != null) {
				tx.rollback();
			}
		} finally {
			sess.close();
			sf.close();
		}
	}

	public static void main(String[] args) {
		new SessionUtil().HIbernateTest();
	}
}
</span>



科比请留步
关注
  • 2
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
java hibernate批量更新_Hibernate批量处理海量数据的方法
weixin_42116585的博客
02-13 1425
本文实例讲述了Hibernate批量处理海量数据的方法。分享给大家供大家参考，具体如下：Hibernate批量处理海量其实从性能上考虑，它是很不可取的，浪费了很大的内存。从它的机制上讲，Hibernate它是先把符合条件的数据查出来，放到内存当中，然后再进行操作。实际使用下来性能非常不理想，在笔者的实际使用中采用下面的第三种优化方案的数据是：100000条数据插入数据库， 需要约30分钟，呵呵，晕...
hibernate的批量删除
热门推荐
然月 枕流君
12-14 2万+
呵呵,来说说hibernate的批量删除;一般而言,hibernate的批量删除的写法有两种,一种是hibernate内置的批量删除,不过他的批量删除是将每条记录逐一生成删除语句,其效率极低,当然我们可以使用抓取策略给其进行优化,不过这只是亡羊补牢的方法,效率的提升依然不能让我们满意,很不推荐使用;另一种是由"拼串"形成的HQL语句,其能够形成一条语句,从而是效率得到最大的提升;我们先说"拼串"形
hibernate里批量删除
赵达宇的博客
08-23 409
假设上一步结果是personList,然后传进去就可以了。调用这两个方法，就可以实现优雅的批量删除。可以用 hibernate自带的方法。1、先根据id集合查。
使用JDBC进行批量更新操作的例子
最新发布
fishlovejavaa的博客
05-11 381
5. **建立数据库连接和PreparedStatement**：使用`DriverManager.getConnection`获取数据库连接，并使用`Connection.prepareStatement`创建一个`PreparedStatement`对象。6. **设置批量模式**：通过`conn.setAutoCommit(false)`关闭自动提交，这样所有的更新操作都会被缓存起来，直到显式调用`executeBatch`或`commit`。// 更新订单号101的金额为150.00。
Hibernate的批量处理-批量更新
weixin_34290096的博客
06-28 480
上面介绍的方法同样适用于批量更新数据，如果需要返回多行数据，应该使用scroll()方法，从而可以充分利用服务器端游标所带来的性能优势。下面是进行批量更新的代码片段。 程序清单：codes\06\6.3\batchUpdate\src\lee\UserManager.java private void updateUsers()throws Exception  {      //打开Sess...
java hibernate批量更新_Hibernate批量更新和批量删除批量添加(转)
weixin_30299099的博客
02-13 853
通常，在一个Session对象的缓存中只存放数量有限的持久化对象，等到Session对象处理事务完毕，还要关闭Session对象，从而及时释放Session的缓存占用的内存。批量处理数据是指在一个事务中处理大量数据。以下程序在一个事务中批量更新CUSTOMERS表中年龄大于零的所有记录的AGE字段：Transaction tx = session.beginTransaction();Iterat...
Springboot+jpa+druid+hibernate实现批量新增
风间净琉璃的博客
02-21 2534
Springboot+jpa+druid+hibernate实现批量新增，并验证批量功能
Hibernate批量更新与删除实例浅析
08-10
对于大量数据的删除，建议使用JDBC的`DELETE`语句或者使用数据库级别的批量删除功能。需要注意的是，直接执行`DELETE`语句可能会导致缓存和级联关系的问题，因此在执行前需谨慎考虑。 总结起来，Hibernate虽然提供...
Hibernate+JDBC实现批量插入、更新及删除的方法详解
08-28
* 使用Hibernate+JDBC可以实现批量删除，通过使用Hibernate的批量删除方法，例如使用Hibernate的delete()方法来实现批量删除。 本文通过实例形式详细分析了Hibernate+JDBC实现批量插入、更新及删除的方法，提供了...
hibernate批量删除
02-25
在我们的Java项目中，批量更新是指在一个事务中更新大批量数据，批量删除是指在一个事务中删除大批量数据。批量删除虽然在Hibernate里也可以实现，但因Hibernate的实现机制是一个一个删除，在数量大的情况下很影响...
Hibernate管理Session和批量操作分析
09-04
2. **通过HQL（Hibernate Query Language）**：利用HQL语句实现批量操作，比如更新或删除，可以避免加载整个对象到内存。 3. **通过StatelessSession**：StatelessSession不维护任何持久化状态，没有一级缓存，适合...
jsp Hibernate批量更新和批量删除处理代码
10-30
批量更新是指在一个事务中更新大批量数据，批量删除是指在一个事务中删除大批量数据。
SpringJDBC.rar_SpringJDBC_spring jdbc
09-24
- Spring JDBC可以与Spring的其他模块无缝集成，比如MyBatis、Hibernate等ORM框架，以及Spring Data JPA，提供了更高级别的数据访问抽象。 现在，让我们看一个简单的Spring JDBC实例： ```java @Autowired ...
Hibernate 批量更新数据
RonaldoZH的专栏
11-18 2038
进行批量更新时，如果一下子把所有对象加载到session的缓存中，然后再进缓存中一一更新它们，显然是不可取的，为了解决这一问题，可以使用滚动的结果集 org.hibernate.ScrollableResults,Query的 scroll()方法返回一个ScrollableResults对象。以下是示例，该代码一开始利用ScrollableResults对象来家在所有的Customer
hibernate 批量删除
fgsgsgfgsg的专栏
01-09 326
在BaseDao中批量删除的方法，传入需要删除数据的id，类名通过反射获取泛型参数的Class对象 public int delete(String[] ids) {             // classPo 通过反射获取到泛型的Class对象         String hql="delete  "+classPo.getName()+" where id in (:ids)
hibernate 批量插入
u010676959的专栏
02-28 794
一般如果要插入100万条数据，则会写如下代码： [java] view plaincopy package org.xiazdong.test;    import junit.framework.TestCase;    import org.hibernate.Session;  import org.hibernate.SessionFactory;  import 
java hibernate批量更新_《Hibernate快速开始 – 批量处理》
weixin_35679132的博客
02-16 438
JDBC 批量处理JDBC提供了对批量查询语句集合到单条查询语句的支持。在应用方面，这意味着数据驱动在批量处理的时候只需要发送一条查询请求，减少了对数据库的请求次数。hibernate合理使用了JDBC批量处理的特点，可以通过以下配置控制这一行为。hibernate.jdbc.batch_size设定hibernate单条批量处理请求中查询语句数量的上限。可用零或负数来禁用此功能。hibernat...
hibernate update 操作
qq_47959958的博客
02-28 1076
涉及到三层结构 Controller（控制逻辑）层：它是负责在页面和程序之间传输数据的，还有作用是做页面跳转。 页面由用户填写表单数据，点击提交按钮，页面的表单数据由传入Service层。 DAO层（数据库操作层）：负责对数据向数据库增删改查的操作。 Service层（业务逻辑层）：负责的是对数据的处理。如果没有数据处理任务的话，此层只做单纯的数据传递作用，而后又到了DAO层。 参考了https://blog.csdn.net/qq_38881474/article/details/96447
java hibernate批量更新_在Hibernate应用中如何处理批量更新和批量删除
weixin_33873956的博客
02-16 180
批量更新是指在一个事务中更新大批量数据，批量删除是指在一个事务中删除大批量数据。以下程序直接通过HibernateAPI批量更新CUSTOMERS表中年龄大于零的所有记录的AGE字段：tx = session.beginTransaction();Iterator customers=session.find("from Customerc where c.age>0").itera...
hibernate批量插入
05-09
Hibernate提供了多种方式来实现批量插入，以下是其中一种方法： 1. 利用Session的doWork方法执行JDBC操作，可以使用JDBC的批量操作API实现批量插入。 ```java Session session = sessionFactory.getCurrentSession(); session.doWork(connection -> { try (PreparedStatement statement = connection.prepareStatement("INSERT INTO table_name(column1, column2) VALUES(?,?)")) { for (int i = 0; i < dataList.size(); i++) { statement.setString(1, dataList.get(i).getColumn1()); statement.setString(2, dataList.get(i).getColumn2()); statement.addBatch(); if (i % batchSize == 0 || i == dataList.size() - 1) { statement.executeBatch(); } } } }); ``` 2. 使用Hibernate的批量插入API来实现批量插入，需要设置`hibernate.jdbc.batch_size`参数，以及在事务中执行插入操作。 ```java Session session = sessionFactory.getCurrentSession(); Transaction tx = session.beginTransaction(); for (int i = 0; i < dataList.size(); i++) { session.save(dataList.get(i)); if (i % batchSize == 0 || i == dataList.size() - 1) { session.flush(); session.clear(); } } tx.commit(); ``` 需要注意的是，这种方法适用于插入大量数据，但是需要在事务中执行，因此可能会对性能产生影响。同时，也需要根据具体情况调整批量大小和事务大小。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值