mybatis学习系列二

1 参数处理（封装map过程）(23)

1.1）F5进入断点：Employee employee1=mapper.selectEmployeeByMap(map);

1.2）进入MapperProxy的invoke方法，跟踪到mapperMethod.execute(sqlSession, args);

1.3）进入MapperMethod的execute方法，可以看到增删改查均有对应case：

  Object result;

    switch (command.getType()) {

      case INSERT: {

     Object param = method.convertArgsToSqlCommandParam(args);

        result = rowCountResult(sqlSession.insert(command.getName(), param));

        break;

      }

1.4）进入method.convertArgsToSqlCommandParam(args);方法--》 paramNameResolver.getNamedParams(args);

1.5）ParamNameResolver类的关键方法：

/**

   * <p>

   * A single non-special parameter is returned without a name.<br />

   * Multiple parameters are named using the naming rule.<br />

   * In addition to the default names, this method also adds the generic names (param1, param2,

   * ...).

   * </p>

   */

 public Object getNamedParams(Object[] args) {

final int paramCount = names.size();

//为null或0个参数直接返回null

    if (args == null || paramCount == 0) {

      return null;

    //单个参数且没有param注解：args[0];直接返回

    } else if (!hasParamAnnotation && paramCount == 1) {

      return args[names.firstKey()];

//多个参数或有param注解

    } else {

      final Map<String, Object> param = new ParamMap<Object>();

      int i = 0;

//遍历names集合：{0=id,1=lastName,2=2}

      for (Map.Entry<Integer, String> entry : names.entrySet()) {

//封装效果：{id:args[0],lastName:args[1],2=args[2]}

        param.put(entry.getValue(), args[entry.getKey()]);

        // add generic param names (param1, param2, ...)

        final String genericParamName = GENERIC_NAME_PREFIX + String.valueOf(i + 1);

        // ensure not to overwrite parameter named with @Param

//除了按注解方式保存外，额外将每个参数也保存到map中，使用新的key:param1,...,paramN

        if (!names.containsValue(genericParamName)) {

          param.put(genericParamName, args[entry.getKey()]);

        }

        i++;

      }

      return param;

    }

  }

（@Param(“id”) Integer id,@Param(“lastName”) String lastName）

ParamNameResolver解析参数封装map的：

1、names：{0=id,1=lastName}构造器时即确定好

  确定流程：

1）获取每个param注解参数的@Param值：id，lastName;赋值给name

2）每次解析一个参数给map中保存信息：（key：参数索引，value：name的值）

  Name的值：

标注了param注解则为注解的值

没有标注：

1）全局配置：isUseActualParamName ：name=参数名

2）Name=map.size()相当于当前元素的索引{0=id,1=lastName,2=2}

2参数处理#与$区别(24，25)

获取参数方法	作用	备注
#	#{}； 1)一般用法：以预编译形式，将参数设置到sql中，类似于preparedstatement；防止sql注入 2)更丰富用法： 规定参数规则：javaType,jdbcType,mode(存储过程），numericScale,resultmap,typehandler,jdbctypename,expression(未来准备支持的) 其中jdbcType在某种特定条件下设置（数据为null时，有些数据库可能不能识别mybatis对null的默认处理，如oracle（会报错）。因为mybatis对所有的null都映射为原生jdbc的other类型，由于全局配置中，jdbcTypeForNull=other而oracle不支持	占位符? 大部分情况下使用# 可在全局配置文件中配置 jdbcTypeForNull设置为null <setting name=”jdbcTypeForNull” value=”NULL”/>
$	${}：取出的值直接拼接sql中，会有安全问题	原生jdbc不支持占位符的地方： 1）查询表名（分表操作，如按年份分表拆分） Select * from ${year}_salary where ***; 2）排序(order) Select * from salary order by ${name}  ${order};

示例：

select * from myemployeee where id = ${id}

and last_name=#{lastName}

对应执行情况：

select * from myemployeee where id = 2

and last_name=？

Parameters：test（string)

3select 返回list(26)

<select id="selectEmployeeByName" resultType="com.mybatis.bean.Employee">

    select * from myemployeee where last_name=#{lastName}

  </select>

//返回list

List<Employee> selectEmployeeByName(String name);

3select 返回封装为map(27)

单条记录

<!-- 返回封装为map -->

  <select id="selectEmployeeMap" resultType="map">

    select * from myemployeee where last_name=#{lastName}

  </select>

//返回map(单个）

Map<String,Object> selectEmployeeMap(String name);

Map<String,Object> returnMap= mapper.selectEmployeeMap("test");

  System.out.println(returnMap);

多条记录：

<!-- 返回封装为map，多条 -->

  <select id="selectEmployeeMaps" resultType="com.mybatis.bean.Employee">

    select * from myemployeee where last_name like #{lastName}

  </select>

//返回map（多条） Map<Integer,Employee> 键：主键；值：Employee

@MapKey("id")  //通过@MapKey注解封装map时使用指定属性作为key

Map<Integer,Employee> selectEmployeeMaps(String name);

Map<Integer,Employee> returnMap2= mapper.selectEmployeeMaps("%test%");

  System.out.println(returnMap2);

也可以将id改为lastName使用名字作为key。

返回结果：

{test3=com.mybatis.bean.Employee@c81cdd1, test=com.mybatis.bean.Employee@1fc2b765}

4select resultMap自定义结果映射规则(28)

<!-- 自定义结果映射规则

type: 自定义规则的java类型

id：该映射的唯一标识，方便映射

-->

<resultMap type="com.mybatis.bean.Employee" id="resultMap">

<!-- column:数据库列；property:javabean属性 -->

<id column="id" property="id" jdbcType="INTEGER"/>

<result column="last_name" property="lastName" jdbcType="VARCHAR"/>

<!-- 其他不指定的列会自动封装 -->

</resultMap>

//返回list

List<Employee> selectEmployeeByName(String name);

List<Employee> selectEmployeeByName = mapper.selectEmployeeByName("test");

  System.out.println(selectEmployeeByName);

5select resultMap关联查询(级联属性)(30)

联合查询：级联属性封装结果集

1) bean对象

public class Employee {

private Integer id;

private String lastName;

private String email;

private String gender;

private MyDept myDept;

public class MyDept {

private Integer deptno;

private String dname;

private String dbSource;

2) mybatis xml文件配置

 

<resultMap type="com.mybatis.bean.Employee" id="DeptResultMap">

<!-- column:数据库列；property:javabean属性 -->

<id column="id" property="id" jdbcType="INTEGER"/>

<result column="last_name" property="lastName" jdbcType="VARCHAR"/>

<!-- 其他不指定的列会自动封装 -->

<result column="deptno" property="myDept.deptno"/>

<result column="dname" property="myDept.dname"/>

<result column="db_source" property="myDept.dbSource"/>

</resultMap>

  <select id="selectEmployeeAndDept" resultMap="DeptResultMap">

    select e.id,e.last_name,e.email,e.gender

     ,d.deptno,d.dname,d.db_source

     from myemployeee e,mydept d where e.dept_id=d.deptno and e.id = #{id}

  </select>

3）测试

 Map<String,Object> map=new HashMap<String,Object>();

  map.put("id", 1);

  map.put("lastName","test");

//   List<Employee> selectEmployeeByName = mapper.selectEmployeeByName("test");

  Employee selectEmployeeAndDept = mapper.selectEmployeeAndDept(1);

  System.out.println(selectEmployeeAndDept.getMyDept().getDbSource()+"=="+selectEmployeeAndDept.getMyDept().getDname());

6select resultMap关联查询(association)(31)

1) Xml

<resultMap type="com.mybatis.bean.Employee" id="DeptResultMap2">

<!-- column:数据库列；property:javabean属性 -->

<id column="id" property="id" jdbcType="INTEGER"/>

<result column="last_name" property="lastName" jdbcType="VARCHAR"/>

<!-- 其他不指定的列会自动封装 -->

<!-- assocation可以指定联合的javabean对象

 property=dept,指定哪个属性是联合的对象

 javatype:指定整个属性对象的类型，不能省略 -->

 <association property="myDept" javaType="com.mybatis.bean.MyDept">

  <id column="deptno" property="deptno"/>

  <result column="dname" property="dname"/>

  <result column="db_source" property="dbSource"/>

 </association>

</resultMap>

2)测试

 Map<String,Object> map=new HashMap<String,Object>();

  map.put("id", 1);

  map.put("lastName","test");

//   List<Employee> selectEmployeeByName = mapper.selectEmployeeByName("test");

  Employee selectEmployeeAndDept = mapper.selectEmployeeAndDept(1);

  System.out.println(selectEmployeeAndDept.getMyDept().getDbSource()+"=="+selectEmployeeAndDept.getMyDept().getDname());

  

7select resultMap关联查询(association分步查询)(32)

1）创建mapper文件

public interface MyDeptMapper {

//查询

MyDept getMyDeptById(Integer id);

}

2）创建xml文件

<mapper namespace="com.mybatis.dao.MyDeptMapper">

  <select id="getMyDeptById" resultType="com.mybatis.bean.MyDept">

    select * from mydept d where d.deptno=#{deptno}

  </select>

</mapper>

3）employee.xml文件中

<!-- 分步查询

1、根据员工id查询员工信息

2、根据员工信息中id查询部门信息

3、部门设置到员工中-->

<resultMap type="com.mybatis.bean.Employee" id="DeptResultByStep">

<!-- column:数据库列；property:javabean属性 -->

<id column="id" property="id" jdbcType="INTEGER"/>

<result column="last_name" property="lastName" jdbcType="VARCHAR"/>

<!-- 其他不指定的列会自动封装 -->

<!-- assocation定义关联对象的封装规则

property:指定关联的对象

select:表明当前属性是调用select指定的方法查出的结果

column:指定哪一列的值传给这个方法

流程：使用select指定的方法（传入column指定的这列参数的值）

查出对象，并封装给property指定的属性

 -->

 <association property="myDept" select="com.mybatis.dao.MyDeptMapper.getMyDeptById"

  column="dept_id" >

 </association>

</resultMap>

 

<select id="selectEmployeeAndDept" resultMap="DeptResultByStep">

    select * from myemployeee where id = #{id}

  </select>

3）测试

  Employee selectEmployeeAndDept = mapper.selectEmployeeAndDept(1);

  System.out.println(selectEmployeeAndDept.getMyDept().getDbSource()+"=="+selectEmployeeAndDept.getMyDept().getDname());

8select resultMap关联查询(association分步查询，延迟加载)(33)

默认为全加载，可在全局配置文件中配置

<settings>

   <!-- 设置懒加载 -->

   <setting name="lazyLoadingEnabled" value="true"/>

  <!-- name：设置项名，value：设置项值 --> 

   <setting name="mapUnderscoreToCamelCase" value="true"/><!--映射数据库下划线-java bean驼峰命名规则 -->

  </settings>

9select resultMap关联查询(collection关联集合封装规则)(34)

上面association是针对一对一情况（一个员工对应一个部门），查询一对多（一个部门下所有员工信息）情况使用collection。

1）javabean配置

public class MyDept {

private Integer deptno;

private String dname;

private String dbSource;

private List<Employee> employees;

2）mapper接口

public interface MyDeptMapper {

//查询

MyDept getMyDeptById(Integer id);

//查询（带员工）

MyDept getMyDeptAndEmployeeById(Integer id);

}

3）xml配置

 <resultMap type="com.mybatis.bean.MyDept" id="DeptAndEmployeeResultMap">

   <id column="deptno" property="deptno"/>

   <result column="db_source" property="dbSource"/>

   <result column="dname" property="dname"/>

   <!--

   collection:定义关联集合类型的属性的封装规则

   ofType:指定集合里面元素的类型

   collection中的属性对应employee属性

    -->

   <collection property="employees" ofType="com.mybatis.bean.Employee">

   <!-- 定义这个集合中元素的封装规则 -->

   <id column="id" property="id"/>

   <result column="last_name" property="lastName"/>

   <result column="dept_id" property="deptId"/>

   <result column="email" property="email"/>

   <result column="gender" property="gender"/>

   <result column="dept_id" property="deptId"/>

   </collection>

  </resultMap>

  

  <select id="getMyDeptAndEmployeeById" resultMap="DeptAndEmployeeResultMap">

   select d.*,e.* from mydept d,myemployeee e where d.deptno=e.dept_id and d.deptno=#{deptno}

  </select>

  

 

注意！需要的属性必须列出，否则为null。

如：

<collection property="employees" ofType="com.mybatis.bean.Employee">

   <!-- 定义这个集合中元素的封装规则 -->

   <id column="id" property="id"/>

   <result column="last_name" property="lastName"/>

   <result column="dept_id" property="deptId"/>

   <!-- <result column="email" property="email"/>

   <result column="gender" property="gender"/>

   <result column="dept_id" property="deptId"/> -->

   </collection>

 

对应输出结果:

test null null 1

test3 null null 4

属性列出后输出结果：

test [email protected] 男 1

test3 [email protected] 男 4

10select resultMap关联查询(collection分步查询)(35)

1) Employmapper.xml

<select id="selectEmployeeByDeptno" resultType="com.mybatis.bean.Employee">

    select * from myemployeee where dept_id = #{deptno}

  </select>

2) Mydeptmapper.xml

<!-- 分步查询 -->

  <resultMap type="com.mybatis.bean.MyDept" id="DeptAndEmployeeByStepResultMap">

   <id column="deptno" property="deptno"/>

   <result column="db_source" property="dbSource"/>

   <result column="dname" property="dname"/>

   <!--

   collection:定义关联集合类型的属性的封装规则

   ofType:指定集合里面元素的类型

   collection中的属性对应employee属性

    -->

   <collection property="employees" select="com.mybatis.dao.EmployeeMapper.selectEmployeeByDeptno" column="deptno">

   </collection>

  </resultMap>

  <select id="getMyDeptAndEmployeeStepById" resultMap="DeptAndEmployeeByStepResultMap">

   select * from mydept d where d.deptno=#{deptno}

  </select>

3) 接口MyDeptMapper

public interface MyDeptMapper {

//查询

MyDept getMyDeptById(Integer id);

//查询（带员工）

MyDept getMyDeptAndEmployeeById(Integer id);

//查询（带员工），分步查询

MyDept getMyDeptAndEmployeeStepById(Integer id);

}

 

4) 测试

 //collection测试

MyDeptMapper mapper=session.getMapper(MyDeptMapper.class);

MyDept myDeptAndEmployeeById = mapper.getMyDeptAndEmployeeStepById(1);

if (null!=myDeptAndEmployeeById && !myDeptAndEmployeeById.getEmployees().isEmpty()) {

for(Employee e:myDeptAndEmployeeById.getEmployees()) {

System.out.println(e.getLastName()+" "+e.getEmail()+" "+e.getGender()+" "+e.getId());

}

}

 

11select resultMap关联查询(collection分步查询传递多列值)(36)

多列传值，将多列的值封装map传递column=”{key1=column1,key2=column2}”

fetchType=”lazy”表示使用延迟加载

-lazy:延迟；-eager：立即

<collection property="employees"  select="com.mybatis.dao.EmployeeMapper.selectEmployeeByDeptno" 

   column="deptno" fetchType="lazy">

   </collection>

11select resultMap关联查询discriminator鉴别器(37)

鉴别器：mybatis可以使用discriminator判断某列的值，然后根据某列值改变封装行为。

示例：

Employee：查出女生就把部门信息查询出来，否则不查询。

1）修改employeemapper

<resultMap type="com.mybatis.bean.Employee" id="DeptResultByStep">

<!-- column:数据库列；property:javabean属性 -->

<id column="id" property="id"/>

<result column="last_name" property="lastName"/>

<result column="gender" property="gender"/>

<!-- 其他不指定的列会自动封装 -->

<!-- assocation定义关联对象的封装规则

property:指定关联的对象

select:表明当前属性是调用select指定的方法查出的结果

column:指定哪一列的值传给这个方法

流程：使用select指定的方法（传入column指定的这列参数的值）

查出对象，并封装给property指定的属性

 -->

<!-- column:指定判定的列名

     javatype：列值对应的java类型 -->

   <discriminator javaType="string" column="gender">

   <!-- 女生resultType:指定封装的结果类型 -->

   <case value="女" resultType="com.mybatis.bean.Employee">

   <association property="myDept" select="com.mybatis.dao.MyDeptMapper.getMyDeptById"

  column="dept_id" >

  </association>

   </case>

   <case value="男" resultType="com.mybatis.bean.Employee">

   <id column="id" property="id"/>

   <result column="gender" property="gender"/>

   <result column="last_name" property="lastName" jdbcType="VARCHAR"/>

   </case>

   </discriminator>

</resultMap>

2）测试类

//discriminator鉴别器

EmployeeMapper mapper=session.getMapper(EmployeeMapper.class);

Employee employee1=mapper.selectEmployeeAndDept(4);

    System.out.println(employee1.getLastName()+" "+employee1.getEmail());

12动态sql(38-39)

OGNL（object graph navigation language)对象图导航语言（apache）。类似el，sqel等表达式

1）Mapper

//返回map

List<Map<String,Object>> selectEmployeeByMap(@Param("employee") Map<String,Object> map);

 

2) Xml

<!-- 返回封装为map

   动态sql：

   特殊子父需要使用转义字符

    -->

  <select id="selectEmployeeByMap" resultType="map">

    select * from myemployeee where

    1=1

    <if test=" null  != employee.lastName and employee.lastName != '' ">

     and last_name like CONCAT('%',#{employee.lastName,jdbcType=VARCHAR},'%')

    </if>

    <if test="null!=employee.id and employee.id != '' ">

     and id=#{employee.id,jdbcType=INTEGER}

    </if>

  </select>

3) 测试

 Map<String,Object> map=new HashMap<String,Object>();

//   map.put("id", 1);

  map.put("lastName","test");

  EmployeeMapper mapper=session.getMapper(EmployeeMapper.class);

  List<Map<String,Object>> selectEmployeeByMap = mapper.selectEmployeeByMap(map);

  System.out.println(selectEmployeeByMap.toString());

 

 

报错：

Caused by: java.sql.SQLException: Parameter index out of range (1 > number of parameters, which is 0).

原因：sql语句like查询为

and last_name like'%#{employee.lastName,jdbcType=VARCHAR}%'

导致报错，修改为concat即可

13动态sql-where查询条件(40)

1）xml修改

<where>

    <if test=" null  != employee.lastName and employee.lastName != '' ">

     and last_name like CONCAT('%',#{employee.lastName,jdbcType=VARCHAR},'%')

    </if>

    <if test="null!=employee.id and employee.id != '' ">

     and id=#{employee.id,jdbcType=INTEGER}

    </if>

</where>

 

2）测试

Map<String,Object> map=new HashMap<String,Object>();

//   map.put("id", 1);

  map.put("lastName","test");

  EmployeeMapper mapper=session.getMapper(EmployeeMapper.class);

  List<Map<String,Object>> selectEmployeeByMap = mapper.selectEmployeeByMap(map);

  System.out.println(selectEmployeeByMap.toString());

 

14动态sql-trim自定义字符串截取(41)

后面多出的and或or，where标签不能解决

1）xml文件

<!-- trim自定义字符串截取

     prefix:前缀，给拼串后的整个字符串加一个前缀

     prefixOverrides:前缀覆盖，去掉整个字符串前面多余字符

     suffix:后缀，给拼串后的整个字符串加一个后缀

     suffixOverrides:后缀覆盖,去掉整个字符串后面多余的字符

     -->

    <trim prefix="where" prefixOverrides="and" suffixOverrides="and">

     <if test=" null  != employee.lastName and employee.lastName != '' ">

     and last_name like CONCAT('%',#{employee.lastName,jdbcType=VARCHAR},'%')

    </if>

    <if test="null!=employee.id and employee.id != '' ">

     and id=#{employee.id,jdbcType=INTEGER}

    </if>

    </trim>

  </select>

2）测试

 Map<String,Object> map=new HashMap<String,Object>();

//   map.put("id", 1);

  map.put("lastName","test");

  EmployeeMapper mapper=session.getMapper(EmployeeMapper.class);

  List<Map<String,Object>> selectEmployeeByMap = mapper.selectEmployeeByMap(map);

  System.out.println(selectEmployeeByMap.toString());

 

15动态sql-choose分支选择(42)

If:判断

Choose：（when，otherwise）：分支选择，switch-case

如果带了id就用id查，如果带了lastname就用lastname查，只选择一个

Trim:字符串截取

Where

Set：封装修改

Forearch:

 

 

1）xml修改

 <!-- choose 分支选择

     只选择一个

     -->

<where>

<choose>

<when test=" null  != employee.lastName and employee.lastName != '' ">

last_name like CONCAT('%',#{employee.lastName,jdbcType=VARCHAR},'%')

</when>

<when test=" null!=employee.id and employee.id != '' ">

id=#{employee.id,jdbcType=INTEGER}

</when>

<otherwise>

gender='男'

</otherwise>

</choose>

</where>

  </select>

 

16动态sql-set与if结合的动态更新(43)

1）set方式

<update id="updateEmp" parameterType="com.mybatis.bean.Employee">

   update myemployeee mm 

   <set>

   <if test="lastName !=null and lastName!='' ">

   mm.last_name=#{lastName,jdbcType=VARCHAR},

   </if>

   <if test="email !=null and email !='' ">

   mm.email=#{email,jdbcType=VARCHAR},

   </if>

   <if test="gender !=null and gender !='' ">

   mm.gender=#{gender,jdbcType=VARCHAR}

   </if>

   </set>

   where mm.id=#{id,jdbcType=INTEGER}

  </update>

 

2）trim方式

<trim prefix="set" suffixOverrides=",">

   <if test="lastName !=null and lastName!='' ">

   mm.last_name=#{lastName,jdbcType=VARCHAR},

   </if>

   <if test="email !=null and email !='' ">

   mm.email=#{email,jdbcType=VARCHAR},

   </if>

   <if test="gender !=null and gender !='' ">

   mm.gender=#{gender,jdbcType=VARCHAR},

   </if>

   </trim>

   where mm.id=#{id,jdbcType=INTEGER}

  </update>

 

17动态sql-forearch遍历集合(44)

Collection:指定要遍历的集合

List类型的参数会特殊处理在map中，map的key就叫list

Item：将当前遍历出来的元素赋值给指定变量。

#{变量名}即可取出

 

1）Xml

<!-- 根据list查询 -->

  <select id="selectEmployeeByIds" resultMap="resultMap" >

    select * from myemployeee

    <!-- collection：指定要遍历的集合

     list类型的参数会特殊处理封装在map中，map的key即叫list

      item：将当前遍历出的元素赋值给指定的变量

       #{变量名}即可取出变量的值（即当前遍历出的元素）

      index:索引，遍历list时为索引；遍历map时表示map的key（item是值）

       -->

      where id in

    <foreach collection="list" item="item" open="("

     separator="," close=")">

     #{item,jdbcType=INTEGER}

    </foreach>

  </select>

 

2）Javabean

public Employee(Integer id, String lastName, String email, String gender,Integer deptId) {

super();

this.id = id;

this.lastName = lastName;

this.email = email;

this.gender = gender;

this.deptId=deptId;

}

 

3）测试

 //list查询

  EmployeeMapper mapper=session.getMapper(EmployeeMapper.class);

  List<Integer> ids=new ArrayList<Integer>();

  ids=Arrays.asList(1,2,3);

  List<Employee> selectEmployeeByIds = mapper.selectEmployeeByIds(ids);

  for(Employee e:selectEmployeeByIds) {

  System.out.println(e.toString());

  }

 

或者

<foreach collection="list" item="item" open="where id in ("

     separator="," close=")">

     #{item,jdbcType=INTEGER}

    </foreach>

 

18动态sql-forearch批量插入的2种方式(45)

1）Xml

<!-- 方式一：直接list对象

   addEmps(List<Employee> emps)

Insert into (),(),()

    -->

<!-- insert into myemployeee(last_name,email,gender,dept_id)

   values

   <foreach collection="list" item="emp" separator=",">

   (#{emp.lastName,jdbcType=VARCHAR},#{emp.email,jdbcType=VARCHAR},

   #{emp.gender,jdbcType=VARCHAR},#{emp.deptId,jdbcType=INTEGER})

   </foreach> -->

2）Mapper

//批量插入

Integer addEmps(List<Employee> emps);

 

3）测试

//批量插入

EmployeeMapper mapper=session.getMapper(EmployeeMapper.class);

List<Employee> emps=new ArrayList<Employee>();

emps.add(new Employee(null,"addemps1","[email protected]","男",1));

emps.add(new Employee(null,"addemps2","[email protected]","女",2));

System.out.println(mapper.addEmps(emps));

 

方式二：

<!-- 方式二：封装为map

   addEmps(@Param("emps") List<Employee> emps);

    -->

   insert into myemployeee(last_name,email,gender,dept_id)

   values

   <foreach collection="emps" item="emp" separator=",">

   (#{emp.lastName,jdbcType=VARCHAR},#{emp.email,jdbcType=VARCHAR},

   #{emp.gender,jdbcType=VARCHAR},#{emp.deptId,jdbcType=INTEGER})

   </foreach>

 

 

方式三：一次执行多个语句

<!-- 方式三：封装为map，且使用;分割为多个插入语句，

     一次执行多个语句；

     需要配置连接属性：&allowMultiQueries=true

jdbc.url=jdbc:mysql://localhost:3306/mytest?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&useSSL=false&serverTimezone=GMT%2B8&allowMultiQueries=true

   addEmps(@Param("emps") List<Employee> emps);

    -->

   <foreach collection="emps" item="emp" separator=";">

   insert into myemployeee(last_name,email,gender,dept_id)

   values

   (#{emp.lastName,jdbcType=VARCHAR},#{emp.email,jdbcType=VARCHAR},

   #{emp.gender,jdbcType=VARCHAR},#{emp.deptId,jdbcType=INTEGER})

   </foreach>

 

以上为mysql情况下；下面为oracle批量插入

 

oracle批量插入

注意：oracle不支持values(),(),()

Oracle使用

Begin

Insert into myemployeee(last_name,email,gender,dept_id)

Values (#{emp.lastName,jdbcType=VARCHAR},#{emp.email,jdbcType=VARCHAR},

   #{emp.gender,jdbcType=VARCHAR},#{emp.deptId,jdbcType=INTEGER});

 

Insert into myemployeee(last_name,email,gender,dept_id)

Values (#{emp.lastName,jdbcType=VARCHAR},#{emp.email,jdbcType=VARCHAR},

   #{emp.gender,jdbcType=VARCHAR},#{emp.deptId,jdbcType=INTEGER});

End;

 

包括在begin和end中间