MyBatis批量操作_MySql

最新推荐文章于 2023-12-23 15:59:54 发布
最新推荐文章于 2023-12-23 15:59:54 发布
阅读量2.2w 收藏 11
点赞数 3
分类专栏： MyBatis/Ibatis 文章标签： MyBatis批量操作
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hardworking0323/article/details/51105218
版权

1.配置文件

   jdbc.properties,需要注意，需要加allowMultiQueries=true配置

#MySql
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc\:mysql\://127.0.0.1\:3306/mybatis?useUnicode\=true&characterEncoding\=UTF-8&allowMultiQueries\=true
jdbc.username=root
jdbc.password=root
 mybatis-config.xml 

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
	<properties resource="jdbc.properties"/>
	<typeAliases>
		<package name="com.mybatis.model"/>
	</typeAliases>
	<environments default="development">
		<environment id="development">
			<transactionManager type="JDBC" />
			<dataSource type="POOLED">
				<property name="driver" value="${jdbc.driverClassName}" />
				<property name="url" value="${jdbc.url}" />
				<property name="username" value="${jdbc.username}" />
				<property name="password" value="${jdbc.password}" />
			</dataSource>
		</environment>
		<environment id="test">
			<transactionManager type="JDBC" />
			<dataSource type="POOLED">
				<property name="driver" value="${jdbc.driverClassName}" />
				<property name="url" value="${jdbc.url}" />
				<property name="username" value="${jdbc.username}" />
				<property name="password" value="${jdbc.password}" />
			</dataSource>
		</environment>
	</environments>
	<mappers>
		<package name="com.mybatis.mappers"/>
	</mappers>
</configuration>
2.接口Mapper:StudentMapper 

import java.util.List;
import java.util.Map;

import com.mybatis.model.Student;

public interface StudentMapper {
	/**
	 * 通过List集合批量插入
	 * @param list
	 * @return
	 */
	public int batchInsertStudentWithList(List<Student> list);
	/**
	 * 通过IdList进行Update特定字段为特定值
	 * @param list
	 * @return
	 */
	public int batchUpdateByIdList(List<Integer> list);
	/**
	 * 通过Map批量更新
	 * @param map
	 * @return
	 */
	public int batchUpdateStudentWithMap(Map<String, Object> map);
	/**
	 * 通过List集合批量更新
	 * @param list
	 * @return
	 */
	public int batchUpdateStudentWithList(List<Student> list);
	
	/**
	 * 通过数组进行批量删除
	 * @param array
	 * @return
	 */
	public int batchDeleteStudentWithArray(int array[]);
	/**
	 * 能过IdList进行批量删除
	 * @param list
	 * @return
	 */
	public int batchDeleteStudentWithIdList(List<Integer> list);
	/**
	 * 通过list删除
	 * @param list
	 * @return
	 */
	public int batchDeleteStudentWithList(List<Student> list);
	/**
	 * 通过list中对象进行删除
	 * @param list
	 * @return
	 */
	public int batchDeleteStudentWithListOnlyId(List<Student> list);
}
3.Mapper配置StudentMapper 

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.mybatis.mappers.StudentMapper">

	<!-- 1，size:表示缓存cache中能容纳的最大元素数。默认是1024； 
		 2，flushInterval:定义缓存刷新周期，以毫秒计； 
		 3，eviction:定义缓存的移除机制；默认是LRU(least recently userd，最近最少使用),还有FIFO(first in 
			first out，先进先出) 
		 4，readOnly:默认值是false，假如是true的话，缓存只能读。 -->
	<cache size="1024" flushInterval="60000" eviction="LRU" readOnly="false" />

	<resultMap type="Student" id="StudentResult">
		<id property="id" column="id" />
		<result property="name" column="name" />
	</resultMap>

	<delete id="batchDeleteStudentWithArray" parameterType="java.lang.String">
		DELETE FROM t_student where id in
		<foreach item="idItem" collection="array" open="(" separator=","
			close=")">
			#{idItem}
		</foreach>
	</delete>
	
	<delete id="batchDeleteStudentWithIdList" parameterType="java.util.List">
		DELETE FROM t_student where id in
		<foreach collection="list" item="idItem" index="index" open="("
			separator="," close=")">
			#{idItem}
		</foreach>
	</delete>
	
	
	<delete id="batchDeleteStudentWithListOnlyId" parameterType="java.util.List">
		DELETE FROM t_student where id in
		<foreach collection="list" index="index" item="item" open="("  
            separator="," close=")">  
            #{item.id}  
        </foreach>  
	</delete>
	
	
	<!-- 效率低，不推荐 -->
	<delete id="batchDeleteStudentWithList" parameterType="java.util.List">
		<foreach collection="list" item="item" index="index" open="" close="" separator=";">
		DELETE  FROM t_student
			where id=#{item.id}
		</foreach>
	</delete>
	
	<update id="batchUpdateByIdList" parameterType="java.util.List">
		UPDATE t_student set name='test' where id in
		<foreach collection="list" item="idItem" index="index" open="("
			separator="," close=")">
			#{idItem}
		</foreach>
	</update>

	<update id="batchUpdateStudentWithList" parameterType="java.util.List">
		<foreach collection="list" item="item" index="index" open="" close="" separator=";">
		UPDATE t_student
			<set>
				name=#{item.name}
			</set>
			where id=#{item.id}
		</foreach>
	</update>

	<update id="batchUpdateStudentWithMap" parameterType="java.util.Map">
		UPDATE t_student SET name = #{name} WHERE id IN
		<foreach collection="idList" index="index" item="idItem" open="("
			separator="," close=")">
			#{idItem}
		</foreach>
	</update>
	
	<insert id="batchInsertStudentWithList" parameterType="java.util.List">
		INSERT INTO /*+append_values */ t_student (name)
		VALUES
		<foreach collection="list" item="item" index="index" separator=",">
			(#{item.name})
		</foreach>
	</insert>
</mapper>
 4.SqlSessionFactoryUtil 
package com.mybatis.util;

import java.io.InputStream;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

public class SqlSessionFactoryUtil {

	private static SqlSessionFactory sqlSessionFactory;
	
	public static SqlSessionFactory getSqlSessionFactory(){
		if(sqlSessionFactory==null){
			InputStream inputStream=null;
			try{
				inputStream=Resources.getResourceAsStream("mybatis-config.xml");
				sqlSessionFactory=new SqlSessionFactoryBuilder().build(inputStream);
			}catch(Exception e){
				e.printStackTrace();
			}
		}
		return sqlSessionFactory;
	}
	
	public static SqlSession openSession(){
		return getSqlSessionFactory().openSession();
	}
}
5.Model:Student 
package com.mybatis.model;

import java.io.Serializable;

public class Student implements Serializable {

	private Integer id;
	private String name;
	private byte[] pic;// blob
	private String remark;// clob
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}

	public Student(Integer id, String name) {
		super();
		this.id = id;
		this.name = name;
	}

	public Student(String namee) {
		super();
		this.name = name;
	}

	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public byte[] getPic() {
		return pic;
	}

	public void setPic(byte[] pic) {
		this.pic = pic;
	}

	public String getRemark() {
		return remark;
	}

	public void setRemark(String remark) {
		this.remark = remark;
	}

	@Override
	public String toString() {
		return "Student [id=" + id + ", name=" + name + ", remark=" + remark + "]";
	}

}
6.测试类 

package com.mybatis.service;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.ibatis.session.SqlSession;
import org.apache.log4j.Logger;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.mybatis.mappers.StudentMapper;
import com.mybatis.model.Student;
import com.mybatis.util.SqlSessionFactoryUtil;

public class StudentBatchTest {

	private static Logger logger=Logger.getLogger(Student.class);
	private SqlSession sqlSession=null;
	private StudentMapper studentMapper=null;
	
	/**
	 * 测试方法前调用
	 * @throws Exception
	 */
	@Before
	public void setUp() throws Exception {
		sqlSession=SqlSessionFactoryUtil.openSession();
		studentMapper=sqlSession.getMapper(StudentMapper.class);
	}

	/**
	 * 测试方法后调用
	 * @throws Exception
	 */
	@After
	public void tearDown() throws Exception {
		sqlSession.close();
	}
	
	//通过list进行批量插入
	@Test
	public void batchInsertStudentWithList(){
		  List<Student> list= new ArrayList<Student>();
		    for(int i = 2;i < 10;i++){
		        Student student = new Student();
		        student.setName("test" + i);
		        list.add(student);
		    }
		    int n=studentMapper.batchInsertStudentWithList(list);
		    System.out.println("成功插入"+n+"条记录");
		    sqlSession.commit();
	}
	//分页批量插入
	@Test
	public void batchInsertStudentPage(){
	    List<Student> list= new ArrayList<Student>();
	    for(int i = 0;i < 2000;i++){
	        Student student = new Student();
	        student.setName("test" + i);
	        list.add(student);
	    }
	    try {
			save(list);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	private void save(List<Student> uidCodeList) throws Exception {
		SqlSession batchSqlSession = null;
		try {
			batchSqlSession =SqlSessionFactoryUtil.openSession();//获取批量方式的sqlsession		
			int batchCount = 1000;//每批commit的个数
			int batchLastIndex = batchCount - 1;//每批最后一个的下标
			for(int index = 0; index < uidCodeList.size()-1;){
				if(batchLastIndex > uidCodeList.size()-1){
					batchLastIndex = uidCodeList.size() - 1;
					batchSqlSession.insert("com.mybatis.mappers.StudentMapper.batchInsertStudentWithList", uidCodeList.subList(index, batchLastIndex+1));
					batchSqlSession.commit();
					System.out.println("index:"+index+"     batchLastIndex:"+batchLastIndex);
					break;//数据插入完毕,退出循环
					
				}else{
					batchSqlSession.insert("com.mybatis.mappers.StudentMapper.batchInsertStudentWithList", uidCodeList.subList(index, batchLastIndex+1));					                batchSqlSession.commit();
					System.out.println("index:"+index+"     batchLastIndex:"+batchLastIndex);
					index = batchLastIndex + 1;//设置下一批下标
					batchLastIndex = index + (batchCount - 1);						
				}				
			}						
		}finally{
			batchSqlSession.close();
		}		
	}
	//通过IdList批量更新
	@Test
	public void batchUpdateByIdList() {
		logger.info("通过IdList批量更新");
		List<Integer> list = new ArrayList<Integer>();
		list.add(5);
		list.add(6);
		int n = studentMapper.batchUpdateByIdList(list);
		System.out.println("成功更新" + n + "条记录");
		sqlSession.commit();
	}

	//通过map进行批量更新
	@Test
	public void batchUpdateStudentWithMap() {
		List<Integer> ls = new ArrayList<Integer>();
		for (int i = 5; i < 7; i++) {
			ls.add(i);
		}
		Map<String, Object> map = new HashMap<String, Object>();
		map.put("idList", ls);
		map.put("name", "小群11");
		int n = studentMapper.batchUpdateStudentWithMap(map);
		System.out.println("成功更新" + n + "条记录");
		sqlSession.commit();
	}
	//通过list批量更新
	@Test
	public void batchUpdateStudentWithList() {
		logger.info("更新学生(带条件)");
		List<Student> list = new ArrayList<Student>();
		list.add(new Student(6, "张三aa"));
		list.add(new Student(6, "李四aa"));
		int n = studentMapper.batchUpdateStudentWithList(list);
		System.out.println("成功更新" + n + "条记录");
		sqlSession.commit();
	}
	
	//通过Array进行批量删除
	@Test
	public void batchDeleteStudentWithArray() {
		logger.info("删除学生，通过Array");
		int array[] = new int[] { 3, 4 };
		studentMapper.batchDeleteStudentWithArray(array);
		sqlSession.commit();
	}
	@Test
	public void batchDeleteStudentWithIdList() {
		logger.info("通过IdList批量更新");
		List<Integer> list = new ArrayList<Integer>();
		list.add(9);
		list.add(10);
		int n = studentMapper.batchDeleteStudentWithIdList(list);
		System.out.println("成功删除" + n + "条记录");
		sqlSession.commit();
	}
	@Test
	public void batchDeleteStudentWithList() {
		logger.info("通过IdList批量更新");
		List<Student> list = new ArrayList<Student>();
		list.add(new Student(12, null));
		list.add(new Student(13, null));
		int n = studentMapper.batchDeleteStudentWithList(list);
		System.out.println("成功删除" + n + "条记录");
		sqlSession.commit();
	}
	
	@Test
	public void batchDeleteStudentWithListOnlyId() {
		logger.info("通过IdList批量更新");
		List<Student> list = new ArrayList<Student>();
		list.add(new Student(14, null));
		list.add(new Student(15, null));
		int n = studentMapper.batchDeleteStudentWithListOnlyId(list);
		System.out.println("成功删除" + n + "条记录");
		sqlSession.commit();
	}
	
}
说明:本人于ITEYE创建于2014年,现转移到CSDN



有恒则成
关注
  • 3
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
101个MySQL的配置和优化的提示
12-15
MySQL是一个功能强大的开源数据库。随着越来越多的数据库驱动的应用程序，人们一直在推动MySQL发展到它的极限。这里是101条调节和优化 MySQL安装的技巧。一些技巧是针对特定的安装环境的，但这些思路是通用的。我已经把他们分成几类，来帮助你掌握更多MySQL的调节和优化技巧。 MySQL 服务器硬件和操作系统调节: 1. 拥有足够的物理内存来把整个InnoDB文件加载到内存中——在内存中访问文件时的速度要比在硬盘中访问时快的多。2. 不惜一切代价避免使用Swap交换分区 – 交换时是从硬盘读取的，它的速度很慢。3. 使用电池供电的RAM（注：RAM即随机存储器）。4. 使用高级的RAID（
Mybatis-Plus批量插入
qq_43842093的博客
06-10 9896
使用mybatis-plus做数据批量插入时候，发现通常我们自定义mapper接口继承BaseMapper。然而BaseMapper中不提供批量插入方法,只有单条插入方式。那如何批量插入呢？
Mybatis-plus---的批量插入
second_place_zyj的博客
04-20 1万+
丝滑的批量操作，我选它insertBatchSomeColumn
Mybatis-plus实现【真·批量插入】
~o( =∩ω∩= )o~
08-08 1万+
新建一个名为的类，继承。（当然，类名可以根据自己的喜好来）//添加InsertBatchSomeColumn方法 return methodList;} }
MyBatis执行批量操作
奔跑的小豪吖的博客
06-21 6042
Mybatis常会出现批量操作，如批量查询，批量插入，批量修改(replace into)。批量操作要比循环执行效率提升很多，这里对mybatis的批量操作做一个总结讲解。 foreach的主要用在构建in条件中，它可以在SQL语句中进行迭代一个集合。foreach标签的属性主要有item，index，collection，open，separator，close。在使用foreach的时候最关键的也是最容易出错的就是collection属性，该属性是必须指定的，但是在不同情况下，该属性的值是不一样的，主要
mybatis_insertbatch_db.rar
09-30
源代码，springboot+mybatis 分析对比批量数据插入数据的性能对比
Mybatis批量删除数据操作方法
09-01
MyBatis的作用我想不用多说,今天说说MyBatis中的批量删除操作。 非常不错，感兴趣的朋友一起看看吧
mybatis学习之路mysql批量新增数据的方法
08-26
主要介绍了mybatis学习之路mysql批量新增数据的方法，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
mybatis 批量插入返回主键
04-26
只提供代码,自己去下载相关jar包谢谢只提供代码,自己去下载相关jar包谢谢只提供代码,自己去下载相关jar包谢谢只提供代码,自己去下载相关jar包谢谢只提供代码,自己去下载相关jar包谢谢
mybatis中批量插入的两种方式(高效插入)
09-01
MyBatis是一个支持普通SQL查询，存储过程和高级映射的优秀持久层框架。这篇文章主要介绍了mybatis中批量插入的两种方式(高效插入)的相关资料，非常不错，具有参考借鉴价值，感兴趣的朋友一起看看吧
面试官：MyBatis批量插入的五种方式，哪种最强？
GitHub质检员
08-28 8429
Override// 注意：此SQL注入器继承了DefaultSqlInjector(默认注入器)，调用了DefaultSqlInjector的getMethodList方法，保留了mybatis-plus的自带方法2、定义核心配置类注入此Bean@Bean3、编写UserService服务类@ResourceUser user;i < 10000;i++) {
mybatis-plus实现真正的批量插入
A_asdfv的博客
06-12 2185
前言：用过mybatis或者mybatis-plus的小伙伴们都知道，工具虽好，偏就是没有实现真正的批量插入，每次都需要手写SQL。今天就基于mybatis-plus实现一个不用写SQL的真正的批量插入。还没有使用上正版激活码激活的朋友们，或者想获取更多资料的同学们，可以通过。5.继承我们自己的RootMapper之后就可以使用了。Mybatis-plus实现真正的批量插入。2.添加自定义方法SQL注入器。手懒的兄弟们快在代码中用起来吧。4.添加通用mapper。3.向MP中注入此配置。
MyBatis最佳实践之——批量操作
yuiezt的专栏
02-05 2543
我们在项目中会有一些的场景，比如从导入文件中解析数据进行批量新增入库，需要做批处理操作。
MyBatisPlus 批量添加
weixin_42555971的博客
03-03 7442
mybatisplus 批量插入
mybatis-plus（insertBatchSomeColumn批量添加）
热门推荐
爪哇人的博客
08-04 2万+
大家平时在做业务时肯定会遇到会向表中批量添加数据的方法，那么这种方法mybatis-plus给我们提供了吗？首先baseMapper中肯定没有提供，如下：只是添加单个实体的但是IService貌似给我们提供了一个批量添加的方法：saveBatch(Collection entityList)那我们就拿这个方法来测试一下@Test//批量添加,?,?)i .........
使用Mybatis，实现批量操作
哈哈
10-17 2294
查询不存在批量，一般是增删改的概念如何让批量插入运行效率提高？数据库处理层。
Mybatis-plus实现真正的批量插入
最新发布
qq_53010925的博客
12-23 633
最近在做一个文件存储服务的项目，项目中需要对超过指定大小的数据进行分包存储到mongoDB中并将文件详情存入数据库中，最初，我只是循环遍历将数据存入数据库中，并没有想着批量插入，但是直到看到了日志中的一对sql日志，我感到十分头疼，话不多少直接上代码。
mybatis-plus下如何使用批量插入以及问题解决
qq_41824830的博客
11-28 1920
1.背景mybatis-plus自带的方法中没有批量插入,需要通过配置文件使其生效.2.配置文件2.1 创建一个批量插入器2.2 在mybatis-plus配置类中注入bean3.使用3.1 在bean的mapper中生成此方法3.2 在service中直接调用即可。
mybatis批量插入数据mysql
06-28
Mybatis可以通过使用批量插入的方式来提高数据插入的效率。具体步骤如下： 1. 在Mapper.xml文件中编写批量插入的SQL语句，例如： ``` insert into user (name, ...以上就是使用Mybatis批量插入数据到MySQL的方法。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

有恒则成

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值