下载文档原格式
动态 SQLMyBatis 的一个强大的特性之一通常是它的动态 SQL 能力。
如果你有使用 JDBC 或其他相似框架的经验,你就明白条件地串联 SQL 字符串在一起是多么的痛苦,确保不能忘了空格或在列表的最后省略逗号。
动态 SQL 可以彻底处理这种痛苦。
通常使用动态 SQL 不可能是独立的一部分,MyBatis 当然使用一种强大的动态 SQL 语言来改进这种情形,这种语言可以被用在任意映射的 SQL 语句中。
动态 SQL 元素和使用 JSTL 或其他相似的基于 XML 的文本处理器相似。
在 MyBatis 之前的版本中,有很多的元素需要来了解。
MyBatis 3 大大提升了它们,现在用不到原先一半的元素就能工作了。
MyBatis 采用功能强大的基于 OGNL 的表达式来消除其他元素。
ifchoose (when, otherwise)trim (where, set)foreachif在动态 SQL 中所做的最通用的事情是包含部分 where 字句的条件。
比如:[html] view plaincopy<select id="findActiveBlogWithTitleLike"parameterType="Blog" resultType="Blog">SELECT * FROM BLOGWHERE state = ‘ACTIVE’<if test="title != null">AND title like #{title}</if></select>这条语句会提供一个可选的文本查找功能。
如果你没有传递 title,那么所有激活的博客都会被返回。
但是如果你传递了 title,那么就会查找相近的 title(对于敏锐的检索,这中情况下你的参数值需要包含任意的遮掩或通配符)的博客。
oracle数据库⼀条sql语句批量插⼊数据最近有个功能是需要重置不同⾝份的密码根据不同的规则，其中⼀个规则就是⼿机号码后六位，有多个⾝份，并且底层数据封装的⽐较死，只能通过公⽤⽅法去更新密码，但是这好⼏个⾝份都有共同的数据特性，⽤户编码，⽤户名称，⼿机号码，将这些字段存⼊⼀张临时表，在开始时根据需要选中某个单位的某个⾝份进⾏密码重置，这就涉及多个表插⼊临时表，当数据多的时候每次插⼊⼀条记录，⼀万条数据执⾏⼀万次记录很不现实，所以需要执⾏⼀次sql插⼊多条记录到数据库当中ORACLE 数据库插⼊多条记录的sql结构为：INSERT ALLINTO TABLENAME(FIELDS1, FIELD2) VALUES(VALUE1, VALUE2)INTO TABLENAME(FIELDS1, FIELD2) VALUES(VALUE1, VALUE2)SELECT 1 FROM DUAL;与mysql稍有不同，⽐如在前台根据需要选择要初始化密码的⾝份StringBuilder strSQL = new StringBuilder ();if(选中⾝份1){strSQL.Append ("INTO TABLENAME(FIELD1, FIELD2) VALUES (VALUE1, VALUE2 ")}if(选中⾝份2){strSQL.Append ("INTO TABLENAME(FIELD1, FIELD2) VALUES (VALUE1, VALUEE2 ")}if(选中⾝份3){strSQL.Append ("INTO TABLENAME(FIELD1, FIELD2) VALUES (VALUE1, VALUE2 ")}if (strSQL.Length == 0){“未查询到数据”return;}strSQL.Insert (0, "INSERT ALL ");strSQL.Append (" SELECT 1 FROM DUAL ");bool = 执⾏sql在后续截取密码中，先判断⼿机号码是否合法，strTelphone = "156********";strTelphone.substring(strTelphone.length -6); //后六位。
mybatis oracle批量更新的语句在使用MyBatis和Oracle数据库进行批量更新时，我们可以通过批量操作来提高性能和效率。
本文将介绍如何使用MyBatis和Oracle数据库来执行批量更新操作。
对于批量更新操作，我们可以使用MyBatis的动态SQL和Oracle数据库的批处理功能来实现。
下面是一个示例，用于批量更新指定表中的多行数据。
首先，我们需要创建一个Mapper接口，定义批量更新的方法。
在这个方法中，我们使用@Param注解来传递需要更新的数据列表。
```javapublic interface MyMapper {void batchUpdate(@Param("list") List<Bean> list);}```接下来，我们需要在Mapper.xml文件中编写批量更新的SQL语句。
使用foreach标签来循环遍历需要更新的数据列表，并生成相应的更新语句。
在这个示例中，我们假设需要更新的表名为"table_name"，需要更新的字段为"column1"和"column2"。
```xml<update id="batchUpdate" parameterType="java.util.List"><foreach collection="list" item="item" index="index" separator=";">UPDATE table_name SET column1 = #{item.column1}, column2 =#{item.column2} WHERE id = #{item.id}</foreach></update>```在这个SQL语句中，我们使用了动态变量#{item.xxx}来引用列表中的每个对象的字段值。
MyBatis批量插⼊数据的三种⽅法实例⽬录前⾔准备⼯作1.循环单次插⼊2.MP批量插⼊①控制器实现②业务逻辑层实现③数据持久层实现MP性能测试MP源码分析3.原⽣批量插⼊①业务逻辑层扩展②数据持久层扩展③添加UserMapper.xml原⽣批量插⼊性能测试缺点分析解决⽅案总结前⾔批量插⼊功能是我们⽇常⼯作中⽐较常见的业务功能之⼀，之前我也写过⼀篇关于《》的⽂章，但评论区的反馈不是很好，主要有两个问题：第⼀，对 MyBatis Plus（下⽂简称 MP）的批量插⼊功能很多⼈都有误解，认为 MP 也是使⽤循环单次插⼊数据的，所以性能并没有提升；第⼆，对于原⽣批量插⼊的⽅法其实也是有坑的，但鲜有⼈知。
所以综合以上情况，磊哥决定再来⼀个 MyBatis 批量插⼊的汇总篇，同时对 3 种实现⽅法做⼀个性能测试，以及相应的原理分析。
先来简单说⼀下 3 种批量插⼊功能分别是：1. 循环单次插⼊；2. MP 批量插⼊功能；3. 原⽣批量插⼊功能。
准备⼯作开始之前我们先来创建数据库和测试数据，执⾏的 SQL 脚本如下：-- ------------------------------ 创建数据库-- ----------------------------SET NAMES utf8mb4;SET FOREIGN_KEY_CHECKS = 0;DROP DATABASE IF EXISTS `testdb`;CREATE DATABASE `testdb`;USE `testdb`;-- ------------------------------ 创建 user 表-- ----------------------------DROP TABLE IF EXISTS `user`;CREATE TABLE `user` (`id` int(11) NOT NULL AUTO_INCREMENT,`name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL,`password` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL,`createtime` datetime NULL DEFAULT CURRENT_TIMESTAMP,PRIMARY KEY (`id`) USING BTREE) ENGINE = InnoDB AUTO_INCREMENT = 6 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_bin ROW_FORMAT = Dynamic;-- ------------------------------ 添加测试数据-- ----------------------------INSERT INTO `user` VALUES (1, '赵云', '123456', '2021-09-10 18:11:16');INSERT INTO `user` VALUES (2, '张飞', '123456', '2021-09-10 18:11:28');INSERT INTO `user` VALUES (3, '关⽻', '123456', '2021-09-10 18:11:34');INSERT INTO `user` VALUES (4, '刘备', '123456', '2021-09-10 18:11:41');INSERT INTO `user` VALUES (5, '曹操', '123456', '2021-09-10 18:12:02');SET FOREIGN_KEY_CHECKS = 1;数据库的最终效果如下：1.循环单次插⼊接下来我们将使⽤ Spring Boot 项⽬，批量插⼊ 10W 条数据来分别测试各个⽅法的执⾏时间。
mysql注解批量添加mybatis_Mybatis注解方式实现批量插入数据库MyBatis是一个开源的持久化框架，它提供了一种简单而灵活的方式来访问关系数据库。
在MyBatis中，可以使用注解方式来实现批量插入数据库的操作。
本文将介绍如何使用MyBatis注解来实现批量插入数据。
首先，需要在Maven或Gradle中添加MyBatis依赖。
以下是使用Maven的示例配置：```xml<dependencies><dependency><groupId>org.mybatis</groupId><artifactId>mybatis</artifactId><version>3.5.7</version></dependency></dependencies>```接下来，需要创建一个数据模型类，用于表示数据库中的表结构。
假设我们有一个名为User的表，包含id、name和age字段，那么对应的数据模型类可以如下所示：```javapublic class Userprivate Long id;private String name;private Integer age;// 省略getter和setter方法```然后，需要创建一个Mapper接口，用于定义数据库操作的方法。
在该接口中，我们将使用注解方式来实现批量插入数据的方法。
假设我们的Mapper接口为UserMapper，那么可以如下所示：```javapublic interface UserMapper"<script>","INSERT INTO user (name, age) VALUES ","<foreach collection='list' item='user' separator=','>","(#{}, #{user.age})","</foreach>","</script>"})```接下来，需要在MyBatis的配置文件中配置Mapper接口的扫描路径，并且使用注解配置的方式来启用Mapper接口。
MyBatis动态SQL————MyBatis动态SQL标签的⽤法1.MyBatis动态SQLMyBatis 的强⼤特性之⼀便是它的动态 SQL，即拼接SQL字符串。
如果你有使⽤ JDBC 或其他类似框架的经验，你就能体会到根据不同条件拼接 SQL 语句有多么痛苦。
拼接的时候要确保不能忘了必要的空格，还要注意省掉列名列表最后的逗号。
利⽤动态 SQL 这⼀特性可以彻底摆脱这种痛苦。
通常使⽤动态 SQL 不可能是独⽴的⼀部分,MyBatis 当然使⽤⼀种强⼤的动态 SQL 语⾔来改进这种情形,这种语⾔可以被⽤在任意的 SQL 映射语句中。
动态 SQL 元素和使⽤ JSTL 或其他类似基于 XML 的⽂本处理器相似。
在 MyBatis 之前的版本中,有很多的元素需要来了解。
MyBatis 3 ⼤⼤提升了它们,现在⽤不到原先⼀半的元素就可以了。
MyBatis 采⽤功能强⼤的基于 OGNL 的表达式来消除其他元素。
2.动态SQL标签：if，choose (when, otherwise)，trim (where, set)，foreach2.1 if标签：直接上代码<select id="queryByIdAndTitle"resultType="Blog">SELECT * FROM BLOGWHERE 1=1<if test="id!= null and title!=null">AND id=#{id} and title=#{title}</if></select>注：if标签⼀般⽤于⾮空验证，如上例，若id为空，if标签⾥的代码，将不会执⾏，反之，则会执⾏。
2.2 choose(when,otherwise)标签：直接上代码<select id="queryBy"resultType="Blog">SELECT * FROM BLOG WHERE 1=1<choose><when test="title != null">AND title like #{title}</when><otherwise>AND id= 1</otherwise></choose></select>注：choose(when,otherwise)标签相当于switch(case,default) ，如上例，若title 为空，when标签⾥的代码，将不会执⾏，默认执⾏otherwise 标签⾥⾯的代码。
mybatis 批量插入原理MyBatis是一种流行的Java持久化框架，它提供了一种简单、高效的方式来处理数据库操作。
其中，批量插入是MyBatis的一个重要特性，它可以大大提高数据库的插入性能。
本文将介绍MyBatis批量插入的原理及其实现方式。
一、MyBatis批量插入的原理在传统的数据库操作中，每次向数据库插入一条记录都需要进行一次网络传输，这样会导致插入大量数据时性能较低。
而MyBatis批量插入通过一次网络传输插入多条记录，从而减少了网络开销，提高了插入性能。
MyBatis批量插入的原理主要是通过JDBC的批量操作实现的。
JDBC提供了addBatch()和executeBatch()方法，分别用于添加批量操作的SQL语句和执行批量操作。
MyBatis在底层封装了这些方法，提供了更加简便的接口供开发者使用。
二、MyBatis批量插入的实现方式MyBatis提供了两种方式来实现批量插入：使用foreach标签和使用batch插件。
1. 使用foreach标签foreach标签是MyBatis中的一个循环标签，可以用于遍历集合或数组，并将元素传递给SQL语句中的参数。
在批量插入中，可以使用foreach标签来遍历插入的数据集合，并将每条记录作为参数传递给SQL语句。
具体实现步骤如下：（1）在SQL语句中使用foreach标签定义一个循环，指定要遍历的集合和循环变量名。
（2）在循环体中编写插入语句，使用循环变量作为参数。
（3）在Java代码中调用MyBatis的insert方法，传入数据集合。
2. 使用batch插件batch插件是MyBatis官方提供的一个插件，它可以将多个相同类型的SQL语句合并为一个批量操作。
在批量插入中，可以使用batch插件来将多条插入语句合并为一个批量插入操作。
具体实现步骤如下：（1）在MyBatis的配置文件中配置batch插件。
（2）在Java代码中调用MyBatis的insert方法，传入数据集合。
MyBatis 动态批量插入sql语句方法MyBatis实现动态批量插入的SQL语句可以采用foreach标签,具体方法如下:XML映射文件:xml<insert id="batchInsert">insert into USER (NAME, AGE)<foreach collection="list" item="item" separator="union all">(#{},#{item.age})</foreach></insert>Java代码:javaList<User> list = new ArrayList<>();list.add(new User("John", 20));list.add(new User("Tom", 25));list.add(new User("Jack", 30));SqlSession session = sqlSessionFactory.openSession();UserMapper mapper = session.getMapper(UserMapper.class);mapper.batchInsert(list);mit();最后生成的SQL语句为:sqlinsert into USER (NAME, AGE)values('John', 20)union allvalues('Tom', 25)union allvalues('Jack', 30)通过foreach标签,动态拼接了多条insert语句,并使用union all连接,最终实现了批量插入。
主要特点:1. 将需要批量插入的数据封装在List集合中2. 在foreach标签内,使用#{item.属性}的方式访问集合中的每条记录3. 使用separator属性,指定union all连接多条insert语句4. 将封装好的List集合,作为参数传入mapper方法,执行批量插入批量插入能有效减少数据库交互次数,提高插入效率。
mybatis generator 批量插入方法MyBatis Generator是一款优秀的Java代码生成工具，它可以帮助我们快速生成MyBatis的CRUD（创建、读取、更新、删除）代码。
在处理大量数据时，批量插入方法可以提高数据插入的效率，下面我们就来介绍如何使用MyBatis Generator生成批量插入方法。
**一、设置生成器配置**首先，你需要在MyBatis Generator的配置文件中，指定需要生成代码的表和对应的字段。
你需要提供表的结构信息，包括每个字段的数据类型、长度、是否主键等。
在生成的配置文件中，需要设置好数据库连接信息。
**二、编写Mapper接口**在Mapper接口中，你需要定义对应的批量插入方法。
这个方法会接收一个包含所有要插入数据的List对象，然后通过MyBatis Generator自动生成的CRUD方法将数据逐条插入数据库。
**三、生成代码**运行MyBatis Generator，根据你的配置文件生成对应的代码。
生成的代码中，应该包含Mapper接口中的批量插入方法以及对应的SQL语句。
你还可以在数据库表对应的实体类中看到自动生成的批量插入方法的调用方式。
**四、使用代码**在主程序中，你可以使用生成的代码进行批量插入操作。
注意，由于是批量插入，插入的数据量较大时，需要考虑到数据库的性能和内存使用情况，适当调整数据库连接数和JVM内存大小。
**示例代码**假设我们有一个User实体类，其中有id、name、age三个字段：1. 配置文件mybatis-generator-config.xml:```xml<configuration><environments default="development"><environment id="development"><database driver="com.mysql.jdbc.Driver"url="jdbc:mysql://localhost:3306/test" user="root"password="123456"><table name="user" schema="test"><propertyname="idColumn">id</property><propertyname="insertColumn">name,age</property><propertyname="mapperPrefix">UserMapper</property></table></database></environment></environments></configuration>```2. Mapper接口UserMapper：```javapublic interface UserMapper {void insertBatch(@Param("users") List<User> users);}```3. User实体类：```javapublic class User {private Integer id;private String name;private Integer age;// getter and setter methods...}```4. 使用生成的代码进行批量插入：在主程序中：```javaList<User> users = new ArrayList<>(); // 假设有多个User 对象需要插入数据库...UserMapper userMapper =MyBatisUtil.getMapper(UserMapper.class); // 获取Mapper接口实例...userMapper.insertBatch(users); // 调用批量插入方法...```以上就是使用MyBatis Generator生成批量插入方法的完整流程。
在MyBatis 中，你可以使用以下两种方式来进行批量插入：方法一：使用<foreach>标签MyBatis 提供了<foreach>标签，你可以使用它来遍历集合，并对集合中的每个元素执行SQL 语句。
以下是使用<foreach>标签进行批量插入的示例：xml复制代码<insert id="batchInsert" parameterType="java.util.List">INSERT INTO your_table (column1, column2, ...)VALUES<foreach collection="list" item="item" separator=",">(#{item.column1}, #{item.column2}, ...)</foreach></insert>在上面的示例中，你需要将your_table替换为你要插入数据的表名，column1, column2, ...替换为表中的列名。
list是传递给SQL 语句的参数名称，item是每次遍历的元素名称。
方法二：使用ExecutorType.BATCH执行器MyBatis 还提供了ExecutorType.BATCH执行器，它专门用于批量操作。
以下是使用ExecutorType.BATCH执行器进行批量插入的示例：java复制代码try (SqlSession sqlSession = sqlSessionFactory.openSession(ExecutorType.BATCH)) { YourMapper mapper = sqlSession.getMapper(YourMapper.class);for (YourObject obj : yourList) {mapper.insert(obj);}mit();} catch (Exception e) {// 处理异常}在上面的示例中，你需要将YourMapper替换为你的Mapper 接口，YourObject替换为你要插入的对象类型，yourList替换为包含要插入对象的列表。
mybatis 批量插入的写法MyBatis 是一个优秀的持久层框架，它支持了大量的数据库操作，其中包括批量插入。
批量插入是将多条SQL 语句合并成一条，从而提高数据库操作的效率。
下面将详细介绍MyBatis 批量插入的写法。
一、MyBatis 批量插入的概念在MyBatis 中，批量插入可以通过ExecuteBatch 方法实现。
该方法将多条SQL 语句一次性提交给数据库，从而减少数据库的交互次数，提高操作性能。
二、批量插入的实现方法1.配置MyBatis 参数在MyBatis 配置文件中，添加如下配置：```xml<configuration>...<settings><setting name="defaultExecutorType" value="BATCH"/> </settings>...</configuration>```2.创建Mapper 接口和映射文件创建一个Mapper 接口，例如：```javapublic interface UserMapper {int insertBatch(List<User> userList);}```在对应的映射文件中，添加批量插入的SQL 语句：```xml<mapper namespace="erMapper"> <insert id="insertBatch" parameterType="java.util.List"> INSERT INTO user (username, password, email)VALUES<foreach collection="list" item="item" index="index" separator=",">(#{ername}, #{item.password}, #{item.email}) </foreach></insert></mapper>```三、具体示例代码假设我们有一个User 类，包含username、password 和email 属性。
mybatis+mysql批量插⼊和批量更新、存在及更新mybatis+mysql批量插⼊和批量更新⼀、批量插⼊批量插⼊数据使⽤的sql语句是：insert into table (字段⼀,字段⼆,字段三) values(xx,xx,xx),(oo,oo,oo)mybatis中mapper.xml的代码如下： <!-- 批量插⼊数据 --><insert id="insertBatch" parameterType="java.util.List"useGeneratedKeys="true"><selectKey resultType="long" keyProperty="id" order="AFTER">SELECTLAST_INSERT_ID()</selectKey>insert into wd_solr(fayu_id, tablename,name,logo,description,section_no,look_count,favorite_count,create_uid,create_time,update_time,timestamp) values<foreach collection="list" item="wdSolr" index="index"separator=",">(#{wdSolr.fayuId},#{wdSolr.tablename},#{},#{wdSolr.logo},#{wdSolr.description},#{wdSolr.sectionNo},#{wdSolr.lookCount},#{wdSolr.favoriteCount},#{wdSolr.createUid},#{wdSolr.createTime},#{wdSolr.updateTime},#{wdSolr.timestamp})</foreach></insert>⼆、批量更新批量更新数据使⽤的sql语句是：UPDATE tableSET aa = CASE idWHEN 1 THEN 'oo'WHEN 2 THEN 'pp'WHEN 3 THEN 'qq'END ,SET bb = CASE idWHEN 1 THEN 'xx'WHEN 2 THEN 'yy'WHEN 3 THEN 'zz'ENDWHERE id IN (1,2,3)上⾯这⼀条mysql语句可以更新多条记录，mybatis中mapper.xml的代码如下： <!-- 批量更新数据 --><update id="updateBatch">update wd_solr setname =<foreach collection="list" item="wdSolr" index="index"separator=" " open="case id" close="end">when #{wdSolr.id} then#{}</foreach>,logo =<foreach collection="list" item="wdSolr" index="index"separator=" " open="case id" close="end">when #{wdSolr.id} then#{wdSolr.logo}</foreach>,timestamp =<foreach collection="list" item="wdSolr" index="index"separator=" " open="case id" close="end">when #{wdSolr.id} then #{wdSolr.timestamp}</foreach>where id in<foreach collection="list" item="wdSolr" index="index"separator="," open="(" close=")">#{wdSolr.id}</foreach></update>三、SELECT LAST_INSERT_ID() 的使⽤和注意事项 总体解释：将插⼊数据的主键返回到 user 对象中。
解决Oracle+Mybatis批量插⼊报错：SQL命令未正确结束Mybatis批量插⼊需要foreach元素。
foreach元素有以下主要属性：（1）item：集合中每⼀个元素进⾏迭代时的别名。
（2）index：指定⼀个名字，⽤于表⽰在迭代过程中，每次迭代到的位置。
（3）collection：根据传⼊的参数值确定。
（4）open：表⽰该语句以什么开始。
（5）separator：表⽰在每次进⾏迭代之间以什么符号作为分隔符。
（6）close：表⽰以什么结束。
⾸先，错误的xml配置⽂件如下：<insert id="save" databaseId="oracle">insert into "sys_user_role"("user_id","role_id")values<foreach collection="roleIdList" item="item" index="index" separator="," >(#{userId},#{item})</foreach></insert>如果如上这样写就会报错：SQL 命令未正确结束。
经过修改后正确的xml配置⽂件如下：<insert id="save" databaseId="oracle">insert into "sys_user_role"("user_id","role_id")<foreach collection="roleIdList" item="item" index="index" separator="UNION ALL" >SELECT#{userId},#{item}FROM dual</foreach></insert>根据上下配置⽂件，需要注意三个地⽅：（1）需要取掉values（2）separator属性值改为UNION ALL。
mybatis的oracle的sql语句写法MyBatis是一种优秀的ORM框架，它支持多种数据库，包括Oracle。
在使用MyBatis操作Oracle数据库时，我们需要掌握一些基本的SQL语句写法。
1. 查询语句查询语句是我们使用最频繁的一种SQL语句。
在MyBatis中，我们可以使用select标签来编写查询语句。
下面是一个简单的查询语句示例：```<select id="getUserById" resultType="User">select * from user where id=#{id}</select>```在这个示例中，我们使用了select标签来编写查询语句。
其中id属性指定了这个查询语句的唯一标识符，resultType属性指定了查询结果的类型。
在查询语句中，我们使用了#{id}来表示查询条件，这个值会在执行查询语句时被动态替换。
2. 插入语句插入语句用于向数据库中插入新的数据。
在MyBatis中，我们可以使用insert标签来编写插入语句。
下面是一个简单的插入语句示例：```<insert id="insertUser" parameterType="User">insert into user(name, age) values(#{name}, #{age})</insert>```在这个示例中，我们使用了insert标签来编写插入语句。
其中id属性指定了这个插入语句的唯一标识符，parameterType属性指定了插入数据的类型。
在插入语句中，我们使用了#{name}和#{age}来表示插入的数据，这些值会在执行插入语句时被动态替换。
3. 更新语句更新语句用于修改数据库中已有的数据。
在MyBatis中，我们可以使用update标签来编写更新语句。
mybatis+oracle添加数据时如果数据存在就更新，如果不存在就插⼊<insert id="insertBill" parameterType="java.util.List"><!-- 普通的批量插⼊数据注意：mybatis的jdbcType的值必须是全部⼤写，#{item.billCode,jdbcType=VARCHAR}Mybatis中jdbcType的整数类型应该为NUMERIC，⽽不是oracle中的整形NUMBER-->insert all<foreach collection="list" item="item" index="index" >into T_INTERF_XUE_BILL_TLJ( bill_code, SEND_DATE, PIECE_NUMBER, BILL_WEIGHT,REGISTER_DATE, REGISTER_MAN, REGISTER_MAN_CODE, REGISTER_SITE, REGISTER_SITE_CODE)values(#{item.billCode,jdbcType=VARCHAR} ,#{item.sendDate,jdbcType=DATE} ,#{item.pieceNumber,jdbcType=NUMERIC} ,#{item.billWeight,jdbcType=NUMERIC} ,#{item.registerDate,jdbcType=DATE} ,#{item.registerMan,jdbcType=VARCHAR} ,#{item.registerManCode,jdbcType=VARCHAR} ,#{item.registerSite,jdbcType=VARCHAR},#{item.registerSiteCode,jdbcType=VARCHAR})</foreach>select 1 from dual</insert>但是⼤部分业务是这样的，添加数据时如果数据存在就更新，如果不存在就插⼊，<insert id="insertBill" parameterType="java.util.List">merge into T_INTERF_XUE_BILL_TLJ tusing(<foreach collection="list" item="item" index="index" separator="union">select#{item.billCode,jdbcType=VARCHAR} bill_code ,#{item.sendDate,jdbcType=DATE} send_date,#{item.pieceNumber,jdbcType=NUMERIC} piece_number ,#{item.billWeight,jdbcType=NUMERIC} bill_weight,#{item.registerDate,jdbcType=DATE} register_date,#{item.registerMan,jdbcType=VARCHAR} register_man,#{item.registerManCode,jdbcType=VARCHAR} register_man_code,#{item.registerSite,jdbcType=VARCHAR} register_site,#{item.registerSiteCode,jdbcType=VARCHAR} register_site_codefrom dual</foreach>) t1on (t.bill_code = t1.bill_code)when matched thenupdate sett.send_date = t1.send_date,t.piece_number = t1.piece_number,t.bill_weight = t1.bill_weight,t.register_date = t1.register_date,t.register_man = t1.register_man,t.register_man_code = t1.register_man_code,t.register_site = t1.register_site,t.register_site_code = t1.register_site_codewhen not matched theninsert(bill_code,send_date,piece_number,bill_weight,register_date,register_man,register_man_code,register_site,register_site_code)values(t1.bill_code,t1.send_date,t1.piece_number,t1.bill_weight,t1.register_date,t1.register_man,t1.register_man_code,t1.register_site,t1.register_site_code)</insert>上述sql格式如下：merge into 要修改的表名别名1using （select 要修改的字段1，要修改的字段2, 关联的字段 from 表名）别名2 on (别名1.关联字段 = 别名2. 关联字段)when matched then update set别名1.字段 = 别名2.字段别名1.字段 = 别名2.字段。
mybatis批量插⼊数据到Oracle的ORA-00933：SQL命令未正确结束问题最近在使⽤MyBatis操作Oracle数据库的时候，进⾏批量插⼊数据，思路是封装⼀个List集合通过Myabtis的foreach标签进⾏循环插⼊，可是搬照Mysql的批量插⼊会产⽣异常 ### Error updating database. Cause: java.sql.SQLSyntaxErrorException: ORA-00933: SQL 命令未正确结束错误的写法如下<insert id="insertExpenseItem" parameterType="List" >insert into expenseItem values<foreach collection="list" item="item" separator="," >(seq_item.nextval,#{item.expId},#{item.type},#{item.amount},#{item.itemDesc})</foreach></insert>捕捉到的SQL语句如下- ==> Preparing: insert into expenseItem values ( seq_item.nextval, ?, ?, ?, ? ) , ( seq_item.nextval, ?, ?, ?, ? ) - ==> Parameters: 11(Integer), 1(String), 1111.0(Double), 2(String), 11(Integer), 3(String), 1111.0(Double), 2222(String)即使在pl/sql上执⾏该语句依旧会报错！这样分析⼤概就是Oracle语法的问题了⾸先在度娘上找了MyBatis 之foreach插⼊的相关资料具体如下：foreach的主要⽤在构建in条件中，它可以在SQL语句中进⾏迭代⼀个集合。
mybatis使⽤foreach处理批量插⼊，in条件查询或更新有时候在操作数据库时，会进⾏⼀些批量操作，例如批量插⼊，in条件查询等，这时可以利⽤mybatis的动态sql，foreach元素进⾏批量操作，相对于在代码⾥⾯进⾏for循环批量操作数据库效率较⾼，以前⽤过很多次，现在特此记录⼀下，下次直接复制修改⼀下相关信息即可。
第⼀种情况：in条件查询select a.* from pcn.n_lat_trans_detail a ,pcn.n_lat_loan_rsp bwhere a.tran_status='3' and a.transaction_id=b.transation_idand b.rsp_sts='0000' and b.rsp_msg='succ'and date_format(b.create_time,'%Y%m%d') in<foreach collection="list" item="item" index="index" open="(" close=")" separator=",">#{item}</foreach>第⼆种情况：批量插⼊<insert id="batchInsert" parameterType="java.util.List">insert into doku_repay_rclerr_detail (id, out_transidmerchant, in_transidmerchant,rcl_task_id, chk_status, diff_reason,amount, pay_out_date, ext_field1,remark, create_date, update_date)VALUES<foreach collection="list" item="item" index="index" separator=",">(#{item.id,jdbcType=INTEGER},#{item.outTransidmerchant,jdbcType=VARCHAR},#{item.inTransidmerchant,jdbcType=VARCHAR},#{item.rclTaskId,jdbcType=VARCHAR},#{item.chkStatus,jdbcType=VARCHAR},#{item.diffReason,jdbcType=VARCHAR},#{item.amount,jdbcType=DECIMAL},#{item.payOutDate,jdbcType=VARCHAR},#{item.extField1,jdbcType=VARCHAR},#{item.remark,jdbcType=VARCHAR},#{item.createDate,jdbcType=TIMESTAMP},#{item.updateDate,jdbcType=TIMESTAMP})</foreach></insert>第三种情况：批量更新update n_lat_stppay_notify set backOne = '1'where cuentaBeneficiario in<foreach collection="list" item="item" index="index" open="(" close=")" separator=",">#{item}</foreach>其他动态sql元素参见：。
MyBatis动态SQLforeach标签实现批量插⼊的⽅法⽰例需求:查出给定id的记录:<select id="getEmpsByConditionForeach" resultType="comtestbeansEmployee">SELECT * FROM tb1_emplyee WHERE id IN<foreach collection="list" item="item_id" separator="," open="(" close=")">#{item_id}</foreach></select>关于foreach标签,有⼏个属性应该注意⼀下:collection：指定要遍历的集合：list类型的参数会特殊处理封装在map中，map的key就叫listitem：将当前遍历出的元素赋值给指定的变量separator:每个元素之间的分隔符open：遍历出所有结果拼接⼀个开始的字符close:遍历出所有结果拼接⼀个结束的字符index:索引。
遍历list的时候是index就是索引，item就是当前值遍历map的时候index表⽰的就是map的key，item就是map的值#{变量名}就能取出变量的值也就是当前遍历出的元素测试⽅法:@Testpublic void testDynamicSqlTest() throws IOException{SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();//1、获取到的SqlSession不会⾃动提交数据SqlSession openSession = sqlSessionFactoryopenSession();try{EmployeeMapperDymanicSQL mapper=openSessiongetMapper(EmployeeMapperDymanicSQLclass);/*Employee employee=new Employee(1,"lili",null,"1");*/List<Employee> emps=mappergetEmpsByConditionForeach(ArraysasList(1,2,3,4));for (Employee e:emps){Systemoutprintln(e);}}finally {openSessionclose();}}foreach标签也可以实现实现批量插⼊(删除)数据:这⾥以批量插⼊数据为例:<insert id="addEmps">INSERT INTO tb1_emplyee(last_name,email,gender,d_id)VALUES<foreach collection="emps" item="emp" separator=",">(#{emplastName},#{empemail},#{empgender},#{empdeptid})</foreach></insert>对应的接⼝:public void addEmps(@Param("emps")List<Employee> emps);测试⽅法@Testpublic void testBatchSave() throws IOException{SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();//1、获取到的SqlSession不会⾃动提交数据SqlSession openSession = sqlSessionFactoryopenSession();try{EmployeeMapperDymanicSQL mapper=openSessiongetMapper(EmployeeMapperDymanicSQLclass);List<Employee> emps=new ArrayList<Employee>();empsadd(new Employee(null,"Eminem","Eminem@com","1",new Department(1)));empsadd(new Employee(null,"2Pac","2Pac@com","1",new Department(1)));mapperaddEmps(emps);openSessioncommit();}finally {openSessionclose();}}到此这篇关于MyBatis动态SQL foreach标签实现批量插⼊的⽅法⽰例的⽂章就介绍到这了,更多相关MyBatis动态SQL foreach 批量插⼊内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持！。
mybatis动态sql之使⽤foreach进⾏批量插⼊的两种⽅式EmployeeMapperDynamicSql.javapackage com.gong.mybatis.mapper;import java.util.List;import java.util.Map;import org.apache.ibatis.annotations.MapKey;import org.apache.ibatis.annotations.Param;import com.gong.mybatis.bean.Employee;public interface EmployeeMapperDynamicSql {public List<Employee> getEmpByConditionIf(Employee employee);public void addEmp(@Param("emps") List<Employee> employee);}EmployeeMapperDynamicSql.xml<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE mapperPUBLIC "-////DTD Mapper 3.0//EN""/dtd/mybatis-3-mapper.dtd"><mapper namespace="com.gong.mybatis.mapper.EmployeeMapperDynamicSql"><!-- 查询，要查那个就带上那个条件 --><select id="getEmpByConditionIf" resultType="com.gong.mybatis.bean.Employee">select * from tbl_employee<where><choose><when test="id!=null">id=#{id}</when><when test="lastName!=null">last_name like #{lastName}</when><when test="email!=null">email=#{email}</when><otherwise></otherwise></choose></where></select><insert id="addEmp">insert into tbl_employee(last_name,gender,email,d_id)values<foreach collection="emps" item="emp" separator=",">(#{stName},#{emp.gender},#{emp.email},#{emp.dept.id})</foreach></insert></mapper>第⼀种⽅式如上所⽰：insert into tbl_employee(last_name,gender,email,d_id) values (?,?,?,?) , (?,?,?,?)进⾏测试：package com.gong.mybatis.test;import java.io.IOException;import java.io.InputStream;import java.util.ArrayList;import java.util.Arrays;import java.util.HashMap;import java.util.List;import java.util.Map;import org.apache.ibatis.io.Resources;import org.apache.ibatis.session.SqlSession;import org.apache.ibatis.session.SqlSessionFactory;import org.apache.ibatis.session.SqlSessionFactoryBuilder;import org.junit.Test;import com.gong.mybatis.bean.Department;import com.gong.mybatis.bean.Employee;import com.gong.mybatis.mapper.EmployeeMapperDynamicSql;public class TestMybatis3 {public SqlSessionFactory getSqlSessionFactory() throws IOException {String resource = "mybatis-config.xml";InputStream is = Resources.getResourceAsStream(resource);return new SqlSessionFactoryBuilder().build(is);}@Testpublic void test() throws IOException {SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();SqlSession openSession = sqlSessionFactory.openSession();try {EmployeeMapperDynamicSql mapper = openSession.getMapper(EmployeeMapperDynamicSql.class);List<Employee> emps = new ArrayList<>();Department d1 = new Department(1);Employee e1 = new Employee(null,"manwang","1","manwang@",d1);Department d2 = new Department(2);Employee e2 = new Employee(null,"timo","0","timo@",d2);emps.add(e1);emps.add(e2);mapper.addEmp(emps);List<Employee> es = mapper.getEmpByConditionIf(new Employee());for(Employee e:es) {System.out.println(e);}mit();} finally {openSession.close();}}}输出结果：DEBUG 01-21 21:16:38,183 ==> Preparing: insert into tbl_employee(last_name,gender,email,d_id) values (?,?,?,?) , (?,?,?,?) (BaseJdbcLogger.java:145)DEBUG 01-21 21:16:38,261 ==> Parameters: manwang(String), 1(String), manwang@(String), 1(Integer), timo(String), 0(String), timo@(String), 2(Integer) (BaseJdbcLogger.java:145)DEBUG 01-21 21:16:38,374 <== Updates: 2 (BaseJdbcLogger.java:145)DEBUG 01-21 21:16:38,385 ==> Preparing: select * from tbl_employee (BaseJdbcLogger.java:145)DEBUG 01-21 21:16:38,386 ==> Parameters: (BaseJdbcLogger.java:145)DEBUG 01-21 21:16:38,430 <== Total: 6 (BaseJdbcLogger.java:145)Employee [id=1, lastName=dema, gender=1, email=dema@, dept=null]Employee [id=2, lastName=jack, gender=1, email=675544321@, dept=null]Employee [id=3, lastName=⼩红, gender=0, email=xiaohong@, dept=null]Employee [id=4, lastName=⼩明, gender=0, email=xiaoming@, dept=null]Employee [id=5, lastName=manwang, gender=1, email=manwang@, dept=null]Employee [id=6, lastName=timo, gender=0, email=timo@, dept=null]第⼆种⽅式需要在配置连接数据源时使⽤：jdbc.url=jdbc:mysql://localhost:3306/mybatis?allowMultiQueries=true然后在xml⽂件中：<insert id="addEmp"><foreach collection="emps" item="emp" separator=";">insert into tbl_employee(last_name,gender,email,d_id)values(#{stName},#{emp.gender},#{emp.email},#{emp.dept.id})</foreach></insert>这种⽅式的sql形如：insert into tbl_employee(last_name,gender,email,d_id) values (?,?,?,?) ; insert into tbl_employee(last_name,gender,email,d_id) values (?,?,?,?)结果：DEBUG 01-21 21:34:32,747 ==> Preparing: insert into tbl_employee(last_name,gender,email,d_id) values (?,?,?,?) ; insert into tbl_employee(last_name,gender,email,d_id) values (?,?,?,?) (BaseJdbcLogger.java:145) DEBUG 01-21 21:34:32,823 ==> Parameters: manwang(String), 1(String), manwang@(String), 1(Integer), timo(String), 0(String), timo@(String), 2(Integer) (BaseJdbcLogger.java:145)DEBUG 01-21 21:34:32,889 <== Updates: 1 (BaseJdbcLogger.java:145)DEBUG 01-21 21:34:32,900 ==> Preparing: select * from tbl_employee (BaseJdbcLogger.java:145)DEBUG 01-21 21:34:32,902 ==> Parameters: (BaseJdbcLogger.java:145)DEBUG 01-21 21:34:32,966 <== Total: 8 (BaseJdbcLogger.java:145)Employee [id=1, lastName=dema, gender=1, email=dema@, dept=null]Employee [id=2, lastName=jack, gender=1, email=675544321@, dept=null]Employee [id=3, lastName=⼩红, gender=0, email=xiaohong@, dept=null]Employee [id=4, lastName=⼩明, gender=0, email=xiaoming@, dept=null]Employee [id=5, lastName=manwang, gender=1, email=manwang@, dept=null]Employee [id=6, lastName=timo, gender=0, email=timo@, dept=null]Employee [id=7, lastName=manwang, gender=1, email=manwang@, dept=null]Employee [id=8, lastName=timo, gender=0, email=timo@, dept=null]。
