Mybatis教程 | 第六篇：批量新增、批量修改、批量删除

已于 2024-07-10 07:43:38 修改
阅读量1.6k 收藏 6
点赞数 1
分类专栏： mybatis 文章标签： Mybatis 批量操作
于 2019-02-27 22:44:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41381863/article/details/87987115
版权
本文介绍了如何使用Mybatis进行批量新增、删除和修改操作，通过对比动态SQL与传统方式，展示了动态SQL在性能上的优势。同时探讨了Mybatis内置的批处理设置，指出在大量数据操作时，批处理能提供更好的性能，但在获取影响行数上有局限，需要额外设计计数器。
摘要由CSDN通过智能技术生成

前言

在上一篇中提到了这么一个问题:

for(Integer id : ids) {
	userDao.deleteUserById(id);
}

但我们需要批量删除的时候，这样会不停的获取数据库连接，资源消耗是很大的。

接下来就利用Mybatis的动态SQL功能，去验证一下这个问题（传送门:动态SQL）。

首先搭建Mybatis环境和日志环境搭建mybatis环境和日志环境(参考第一篇和第二篇)，并创建如下一张表tb_user（id、姓名）和相应的持久层对象:

2019022719500580.png

批量新增

A.利用想当然的方式测试

mapper文件和dao层接口

<insert id="saveUser" parameterType="com.zepal.mybatis.domain.User" useGeneratedKeys="true">
  	INSERT INTO tb_user (user_name, user_age) VALUEs (#{userName}, #{userAge});
  </insert>
int saveUser(User user);

测试程序和结果

public class Test {

	public static void main(String[] args) {
		InputStream is = Test.class.getResourceAsStream("/mybatis/mybatis-config.xml");
		SqlSessionFactory sqlSessionFactory = new
		SqlSessionFactoryBuilder().build(is); 
		SqlSession sqlSession = sqlSessionFactory.openSession(); 
		UserDao userDao = sqlSession.getMapper(UserDao.class);
		long start_time = System.currentTimeMillis();
		for(int i=0;i<10000;i++) {
			User user = new User();
			user.setUserName("name"+i);
			user.setUserAge(i);
			userDao.saveUser(user);
			System.out.println("===循环执行中===");
		}
		sqlSession.commit();
		sqlSession.close();
		System.out.println("耗时 : " + (System.currentTimeMillis()-start_time));
	}
}
耗时 : 9414

增加1000条数据用了近10S钟。

B.利用动态SQL批量执行

mapper文件和dao层接口

<insert id="saveUserWithBatch" parameterType="list" useGeneratedKeys="true">
  	INSERT INTO tb_user (user_name, user_age) VALUES 
  	<foreach collection="list" item="item" separator="," close=";">
		(#{item.userName},#{item.userAge})  	
  	</foreach>
  </insert>
int saveUserWithBatch(List<User> users);

测试代码和结果

public class Test {

	public static void main(String[] args) {
		InputStream is = Test.class.getResourceAsStream("/mybatis/mybatis-config.xml");
		SqlSessionFactory sqlSessionFactory = new
		SqlSessionFactoryBuilder().build(is); 
		SqlSession sqlSession = sqlSessionFactory.openSession(); 
		UserDao userDao = sqlSession.getMapper(UserDao.class);
		long start_time = System.currentTimeMillis();
		List<User> users = new LinkedList<>();
		for(int i=0;i<10000;i++) {
			User user = new User();
			user.setUserName("name"+i);
			user.setUserAge(i);
			users.add(user);
		}
		int result = userDao.saveUserWithBatch(users);
		System.out.println("受影响的行 : " + result);
		System.out.println("耗时:" + (System.currentTimeMillis()-start_time));
		sqlSession.commit();
		sqlSession.close();
	}
}
受影响的行 : 10000
耗时:1882

可以明显的看到,用动态SQL构建批量操作,快了5倍以上。

核心就是构建如下SQL语句:

INSERT INTO tb_user (user_name, user_age) VALUES
(?,?),(?,?),(?,?),(?,?),(?,?),(?,?)....;

这里有个主意的地方:就是mysql允许的最大通讯数据

用sql语句查看:

show VARIABLES LIKE 'max_allowed_packet%';

如果想查看mysql所有配置属性，去掉like条件即可。

得到的结果是以B为单位的数值就是mysql最大允许的传输数据。如果往mysql发送的数据过大，会报错，可以通过修改my.ini再重启Mysql服务。

max_allowed_packet=20M

或者直接执行

set global max_allowed_packet = 2*1024*1024*10

上面修改为了20M，然后再执行show VARIABLES LIKE 'max_allowed_packet%'查看是否修改成功。

批量删除

利用上面的结果

1、利用错误的方式测试

mapper文件和dao层接口

<delete id="deleteUser" parameterType="int">
  	delete from tb_user where user_id = #{userId};
  </delete>
int deleteUser(@Param("userId")Integer userId);

测试代码和结果

public class Test {

	public static void main(String[] args) {
		InputStream is = Test.class.getResourceAsStream("/mybatis/mybatis-config.xml");
		SqlSessionFactory sqlSessionFactory = new
		SqlSessionFactoryBuilder().build(is); 
		SqlSession sqlSession = sqlSessionFactory.openSession(); 
		UserDao userDao = sqlSession.getMapper(UserDao.class);
		long start_time = System.currentTimeMillis();
		for(int i=1;i<=10000;i++) {
			userDao.deleteUser(i);
		}
		System.out.println("耗时 ： " + (System.currentTimeMillis() - start_time));
		sqlSession.commit();
		sqlSession.close();
	}
}
耗时 ： 7911

可以看到删除1000条数据也差不多用了8s钟。

B.利用动态SQL构建批量删除

mapper文件和dao层接口

<delete id="deleteUserWithBatch" parameterType="list">
  	delete from tb_user where user_id in
  	<foreach collection="list" item="item" open="(" separator="," close=");">
  		#{item}
  	</foreach>
  </delete>
int deleteUserWithBatch(List<Integer> userIds);

测试代码和结果

public class Test {

	public static void main(String[] args) {
		InputStream is = Test.class.getResourceAsStream("/mybatis/mybatis-config.xml");
		SqlSessionFactory sqlSessionFactory = new
		SqlSessionFactoryBuilder().build(is); 
		SqlSession sqlSession = sqlSessionFactory.openSession(); 
		UserDao userDao = sqlSession.getMapper(UserDao.class);
		long start_time = System.currentTimeMillis();
		List<Integer> ids = new LinkedList<>();
		for(int i=1;i<=10000;i++) {
			ids.add(i);
		}
		int result = userDao.deleteUserWithBatch(ids);
		System.out.println("受影响的行 : " + result);
		System.out.println("耗时 ： " + (System.currentTimeMillis()-start_time));
		sqlSession.commit();
		sqlSession.close();
	}
}
受影响的行 : 10000
耗时 ： 1043

很明显，快了近8倍。

核心就是构建如下SQL语句:

DELETE FROM tb_user WHERE user_id in (?,?,?,?.....);

批量修改

A、利用错误的方式测试

mapper文件和dao层接口

<update id="updateUser" parameterType="com.zepal.mybatis.domain.User">
  	UPDATE tb_user SET user_name = #{userName},
  	user_age = #{userAge}
  	WHERE user_id = #{userId};
  </update>
int updateUser(User user);

测试代码和结果

public class Test {

	public static void main(String[] args) {
		InputStream is = Test.class.getResourceAsStream("/mybatis/mybatis-config.xml");
		SqlSessionFactory sqlSessionFactory = new
		SqlSessionFactoryBuilder().build(is); 
		SqlSession sqlSession = sqlSessionFactory.openSession(); 
		UserDao userDao = sqlSession.getMapper(UserDao.class);
		long start_time = System.currentTimeMillis();
		for(int i=1;i<=10000;i++) {
			User user = new User();
			user.setUserName("name"+i);
			user.setUserAge(i);
			user.setUserId(i);
			userDao.updateUser(user);
		}
		System.out.println("耗时 ：" + (System.currentTimeMillis()-start_time));
		sqlSession.commit();
		sqlSession.close();
	}
}
耗时 ：8295

可以看到循环修改了10000条数据用了8s钟

B.利用动态SQL执行批量修改

mapper文件和dao层接口

 <update id="updateUserWithBatch" parameterType="list">
  	UPDATE tb_user
	SET user_name =
	CASE
		<foreach collection="list" item="item">
			WHEN user_id = #{item.userId} THEN  #{item.userName}
		</foreach>
	END
	WHERE user_id in 
		<foreach collection="list" item="item" open="(" separator="," close=");">
			#{item.userId}
		</foreach>
  </update>
int updateUserWithBatch(List<User> users);
public class Test {

	public static void main(String[] args) {
		InputStream is = Test.class.getResourceAsStream("/mybatis/mybatis-config.xml");
		SqlSessionFactory sqlSessionFactory = new
		SqlSessionFactoryBuilder().build(is); 
		SqlSession sqlSession = sqlSessionFactory.openSession(); 
		UserDao userDao = sqlSession.getMapper(UserDao.class);
		long start_time = System.currentTimeMillis();
		List<User> users = new LinkedList<>();
		for(int i=1;i<=10000;i++) {
			User user = new User();
			user.setUserName("name"+i);
			user.setUserId(i);
			users.add(user);
		}
		int result = userDao.updateUserWithBatch(users);
		System.out.println("受影响的行 :" + result);
		System.out.println("耗时 ：" + (System.currentTimeMillis()-start_time));
		sqlSession.commit();
		sqlSession.close();
	}
}
受影响的行 :10000
耗时 ：1761

核心就是要构造如下的SQL语句

UPDATE tb_user
SET user_name=  
CASE
	WHEN user_id=? THEN ?（这里是要修改的值）
	WHEN user_id=? THEN ?
	......
END
WHERE user_id in (?,?...);

快是快了不少，但是这种方式有短板，就是修改多个字段的时候，mapper文件中会充斥着大量的<foreach>标签，反而会更慢，因为在遍历一遍后又遍历了一次。

尝试一下Mybatis自身的批处理

在mybatis配置文件中开启批处理(settings标签下)

<setting name="defaultExecutorType" value="BATCH"/>

获取SqlSession对象的时候打开批处理,如果整合Spring，则在配置IOC的时候加入ExecutorType.BATCH

SqlSession sqlSession = sqlSessionFactory.openSession(ExecutorType.BATCH);

mapper文件和dao层接口沿用了上面批量修改中的第一种方法

完整测试代码和结果

public class Test {

	public static void main(String[] args) {
		InputStream is = Test.class.getResourceAsStream("/mybatis/mybatis-config.xml");
		SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is); 
		//注意这里--
		SqlSession sqlSession = sqlSessionFactory.openSession(ExecutorType.BATCH);
		UserDao userDao = sqlSession.getMapper(UserDao.class);
		long start_time = System.currentTimeMillis();
		for(int i=1;i<=10000;i++) {
			User user = new User();
			user.setUserId(i);
			user.setUserName("name"+i);
			user.setUserAge(i);
			userDao.updateUser(user);
		}
		System.out.println(System.currentTimeMillis()-start_time);
		sqlSession.commit();
		sqlSession.close();
	}
}
DEBUG [main] - ==> Parameters: name10000(String), 10000(Integer), 10000(Integer)
耗时 : 1206

根据结果看，好像比动态SQL还快了，所以，在修改数据量大或者多字段修改的时候，用Mybatis提供的批量处理比较好，新增和删除，经过测试动态SQL要快(自己动手哦)。

但是这中间肯定是有个临界值的，因为发送数据到数据库也是要耗时的，数据量大肯定慢，况且，在mapper文件中，同样存在遍历操作。

所以，具体还得看自身的需求及对事务的要求。然后综合测试对比一下，再决定采用的方式。这里有个注意的地方就是，开启了Mybatis的批处理后，不能正确的返回受影响的行，如果执行成功，永远都是返回-2147482646，官方文档也给出了说明:“If the BATCH executor is in use, the update counts are being lost. ”。那么要正确捕获受影响的行数，只能自己设计计数器去实现了。

总之，批量处理的核心就是，所有的操作要保持在一个数据库连接之下，不要不停地获取数据库连接，再释放连接(Mybatis自身的批处理也是保持在当前连接下进行的，要区别对待循环调用)。

此篇完结

 

hi,你礼貌吗
关注
专栏目录
MyBatis批量添加、修改和删除
09-02
本文给大家分享mybatis批量添加，修改，删除的实例代码，本文代码简单易懂，对mybatis 批量添加、修改及删除相关知识感兴趣的朋友一起学习吧
MyBatis实现批量修改的三种办法
热门推荐
lili的点点滴滴
11-23 3万+
MyBatis实现批量修改
基于Springboot+mybatis批量查询，修改，删除；@RequestParam、@RequestBody、@PathVariable、@RequestHeader的适用和区别
最新发布
f552126506的博客
07-24 1066
基于Springboot+mybatis批量查询，修改，删除；@RequestParam、@RequestBody、@PathVariable、@RequestHeader的适用和区别
mybatis批量新增和修改
慢积跬步的博客
03-22 4515
使用mybatis批量新增和批量修改： ON DUPLICATE KEY UPDATE on duplicate key update ：判断主键是否存在，主键存在则更新，不存在就新增 insert…on duplicate key update语法的作用，可以分析到，当发生主键冲突的时候，可以直接进行update操作，这个update操作里面可以更新任意想要更新的列；而没有主键冲突的时候，相当于对这个表进行了一次插入操作 int i = sysUserMapper.batchInsertOrUpdate
mybatis批量修改
weixin_44357719的博客
07-15 354
<!-- 批量修改镇区分配信息 --> <update id="editCmsDataTownAssignmentBatch" parameterType="java.util.List" > update cms_data_town_assignment set assignment = <foreach collection="list" item="item" index="index" open="case id" close="end" separator=""&gt
mybatis批量修改、添加数据
Valeng Liu的专栏
10-18 1245
public interface SchoolClassStorageDao extends BaseMapper{ public int saveList(@Param("list")List list) throws Exception; public int updateList(@Param("list")List list) throws Exception; }
Mybatis批量添加、批量修改
虽千万人,吾往矣
07-15 5817
Mybatias中批量修改功能实现，批量添加功能实现
Mybatis批量插入、修改
weixin_59354251的博客
03-24 1783
Mybatis批量插入、修改。 在 MyBatis 中， 标签用于遍历集合类型的条件，并且可以将多个参数值拼接成为 SQL 语句的一个部分，通常被用于批量插入或更新等操作。
mybatis做批量修改
weixin_44991320的博客
10-21 410
批量修改 <update id="batchUpdateDipDiseOprnCrsp"> UPDATE dip_dise_oprn_crsp_d <trim prefix="set" suffixOverrides=","> <trim prefix="DISE_SCO = case" suffix="end,"> <!--修改对照病种分值--> <foreach
MyBatis批量修改
weixin_44117045的博客
01-23 669
mybatis批量查询，批量新增就不聊了，今天看看批量修改。
MyBatis的批量修改
w15103473851的博客
12-27 564
之前做项目时踩过的坑，批量修改隔离符号是分号“；”,批量添加隔离符号时逗号“，”
mybatis批量增删改.txt
05-15
mybatis 框架批量增删改代码 示例 含java与xml
java进阶|MyBatis系列文章(六)XML版批量操作sql
qq_35006660的博客
04-17 1151
一,MyBatis框架介绍MyBatis是支持定制化SQL,存储过程以及高级映射的优秀的持久层框架。MyBatis避免了几乎所有的JDBC代码和手动设置参数以及获取结果集。 MyBati...
MyBatis Plus详细教程
m0_67403240的博客
07-30 1369
为什么要学MybatisPlus？MybatisPlus可以节省大量时间，所有的CRUD代码都可以自动化完成MyBatis-Plus是一个MyBatis的增强工具，在MyBatis的基础上只做增强不做改变，为简化开发、提高效率而生。特性无侵入只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑损耗小启动即会自动注入基本CURD，性能基本无损耗，直接面向对象操作强大的CRUD操作支持Lambda形式调用通过Lambda表达式，方便的编写各类查询条件，无需再担心字段写错。...
DDD系列 - 第6讲 仓库Repository - Mybatis篇
罗小爬的技术宝书
12-10 1134
书接上回，之前通过一个关于拆解、微服务、面向对象的故事，向大家介绍了如何从微服务、面向对象一步步演进到DDD的，整个演进过程如下图：其中在领域层，我们定义了富血模型的领域模型，包括聚合、聚合根、实体、值对象等。聚合在代码层面中的表现形式即是一个包Package，起到了边界的作用，聚合内的对象间高内聚，而聚合间低耦合。聚合中放着实体、值对象、仓库等，实体相较于值对象的一个典型区别就是实体存在唯一标识，并且可通过该唯一标识查询到该实体并对其进行相关操作，值对象不存在唯一标识且通常作为实体。
15篇MyBatis-Plus系列集合篇「值得收藏学习」
悟纤学院
11-20 221
这里汇集了MyBatis-Plus基本的使用以及日常会碰到的一些业务场景的文章，有需要的可以收藏学习。
Mybatis（六）：源码分析-获取Mapper接口动态代理对象
weixin_40074110的博客
06-28 977
从官网Demo代码来入手：https://mybatis.org/mybatis-3/zh/getting-started.html 根据Mapper.Class对象获取接口的代理对象(映射器) // 从 SqlSessionFactory 中获取 SqlSession try (SqlSession session = sqlSessionFactory.openSession()) { // 映射代理器，根据Mapper.Class对象获取接口的代理对象 BlogMapper mapp
mybatis实现批量更新修改(性能极佳)
weixin_45465881的博客
04-25 1154
经常分享一些好用的代码示例，希望与大家共同学习，共同交流！
mybatis 批量修改sql语句
06-06
MyBatis批量修改SQL语句是一种优化数据库操作的方式，可以减轻数据库服务器的负担和减少交互次数。在MyBatis中，批量修改SQL语句的实现方式有两种：一种是使用foreach标签，另一种是使用批处理执行器。 使用foreach标签，可以将集合中的数据逐一遍历，根据需要进行修改操作。首先需要在Mapper文件中编写SQL语句，并使用foreach标签将集合中的数据逐个传递到SQL语句中。在执行SQL语句前，还需要使用openSession()方法打开一个会话，然后调用update()方法执行修改操作。 使用批处理执行器，可以在一次数据库连接中执行多条SQL语句，从而减少了连接数据库的次数，提高了操作效率。使用批处理执行器需要在配置文件中进行配置，得到SqlSession后，将其转换为BatchExecutor类型，然后使用update()方法批量执行修改SQL语句。 总的来说，使用MyBatis批量修改SQL语句具有以下几个优点：可以有效减少数据库交互次数，提高操作效率；可以降低服务器的负载；可以减少编写SQL语句的工作量，提高代码的可读性和可维护性。因此，在MyBatis中批量修改SQL语句是一种非常常见和实用的技术。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值