mybatis的mapper映射配置文件、个别场景记录_mybatis配置文件mapper映射

mybatis的mapper映射配置文件详解

一、常用属性标签

1、namespace的作用

在MyBatis中，Mapper中的namespace用于绑定Dao接口的，即面向接口编程。namespace属性的值要和对应的Mapper接口的全限定名保持一致

它的好处在于当使用了namespace之后就可以不用写接口实现类，业务逻辑会直接通过这个绑定寻找到相对应的SQL语句进行对应的数据处理

2、常用标签介绍

insert,update,delete,select,sql,resultMap

sql:可被其它语句引用的可重用语句块；

resultMap:确定实体类属性与表中字段对应关系；

3、parametetType属性

在,,,标签中,可以通过parameterType指定输入参数的类型，类型可以是简单类型、hashmap、pojo的包装类型。

parameterType属性是可以省略的.MyBatis框架可以根据SqlSession接口中方法的参数来判断输入参数的实际数据类型.

4、resultType属性

4.1、resultType属性存在标签.负责将查询结果进行映射.

4.2、resultType属性可以指定一个基本类型也可以是一个实体类类型

4.3、resultType属性无法与resultMap属性同时出现.

5、resultMap

MyBatis框架中是根据表中字段名到实体类定位同名属性的.如果出现了实体类属性名与表中字段名不一致的情况,则无法自动进行对应.此时可以使用resultMap来重新建立实体类与字段名之间对应关系.

	<!--mybatis-config文件配置，可以为一些类定义别名-->
    <!--<typeAliases>
        <typeAlias type="com.xyxy.pojo.Emp" alias="emp"></typeAlias>
    </typeAliases>-->
    <!-- type属性里面使用别名就可以不用全路径 -->
    <resultMap id="empMapper" type="emp">
        <id property="empId" column="emp_id"></id>
        <result property="empName" column="emp_name"></result>
        <result property="empSalary" column="emp_salary"></result>
    </resultMap>
    <select id="findAll" resultMap="empMapper">
        select * from t_emp
    </select>
1
2
3
4
5
6
7
8
9
10
11
12
13

6、sql

sql:里面可以写入一个共同的sql代码，用于提取重复的代码。 要使用该代码的时候就直接使用标签 id:为提取的sql代码，取一个id，起标识作用

	<!-- 公共代码 -->
	<sql id="select">
        <!-- select * from t_emp -->
        select emp_id empId,emp_name empName,emp_salary empSalary from t_emp
    </sql>
        
    <!--select标签的id与接口的方法名对应，resultType和返回结果封装的Bean一致-->
    <select id="findById" resultType="com.xyxy.pojo.Emp">
        <!-- include:用于加载提取公共的sql语句，与<sql>标签对应
		       refid:填写<sql>标签中的id属性-->
        <include refid="select"></include>
        where emp_id=#{empId}
    </select>
        
    <select id="findByIdOrName" parameterType="Emp" resultType="emp">
        <!-- 引入公共代码 -->
        <include refid="select"></include>
        <!-- where标签:一个where条件语句，通常和<if>标签混合使用 -->
        <where>
            <!-- if标签:执行一个判断语句，成立才会执行标签体内的sql语句,test:写上条件判断语句
			注意:这里每一个if前面都尽量加上and，如果你是第一个条件，框架会自动帮你把and截取，
                如果是第二个if就不能省略and-->
            <if test="empId != null and empId != ''">
                and emp_id=#{empId}
            </if>
            <if test="empName != null and empName != ''">
                and emp_name like '%${empName}%'
            </if>
        </where>
    </select>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

二、数据输入

1、在SQL语句中获取参数

1. #{}的方式

Mybatis会在运行过程中，把配置文件中的SQL语句里面的**#{}转换为“?**”占位符，发送给数据库执行。

配置文件中的SQL：

<delete id="deleteEmployeeById" parameterType="int">
    delete from t_emp where emp_id=#{empId}
</delete>
1
2
3

实际执行的SQL：

delete from t_emp where emp_id=?
1

2. ${}的方式

Mybatis会在运行过程中， 将来会根据${}拼字符串

配置文件中的SQL语句

<select id="selectEmployeeByName" resultType="com.xyxy.pojo.Employee">
    select emp_id empId,emp_name empName,emp_salary empSalary from t_emp where emp_name like '%${empName}%'
</select>
1
2
3

Mapper接口:

注意：由于Mapper接口中方法名是作为SQL语句标签的id，不能重复，所以Mapper接口中不能出现重名的方法，不允许重载！

#{} : 采用预编译方式,可以防止SQL注入

${}: 采用直接赋值方式,无法阻止SQL注入攻击

2、 单个简单类型参数

Mapper接口中的抽象方法

Employee selectEmployee(Integer empId);
1

映射配置文件：此时SQL语句中获取参数#{任意字符串}

<select id="selectEmployee" resultType="com.xyxy.pojo.Employee">
    select emp_id empId,emp_name empName,emp_salary empSalary from t_emp where emp_id=#{empId}
</select>
1
2
3

3、 多个简单类型参数

Mapper接口中抽象方法: 此时每个方法需要使用Param注解命名

int updateEmployee(@Param("empId") Integer empId,@Param("empSalary") Double empSalary);
1

映射配置文件：此时SQL语句中获取参数#{Param注解命的名}

<update id="updateEmployee">
    update t_emp set emp_salary=#{empSalary} where emp_id=#{empId}
</update>
1
2
3

4、实体类类型参数

Mapper接口中抽象方法:

int insertEmployee(Employee employee);
1

映射配置文件：此时SQL语句获取参数#{getXXX方法对应的名字,首字母改小写}

<insert id="insertEmployee">
    insert into t_emp(emp_name,emp_salary) values(#{empName},#{empSalary})
</insert>
1
2
3

Mybatis会根据#{}中传入的数据，加工成getXxx()方法，通过反射在实体类对象中调用这个方法，从而获取到对应的数据。填充到#{}这个位置。

5、Map类型参数

Mapper接口中抽象方法:

int updateEmployeeByMap(Map<String, Object> paramMap);
1

映射配置文件: 此时SQL语句获取参数#{Map的key}

<update id="updateEmployeeByMap">
    update t_emp set emp_salary=#{empSalaryKey} where emp_id=#{empIdKey}
</update>
1
2
3

三、 数据输出

数据输出是针对查询数据的方法返回查询结果

1、 返回单个简单类型数据

Mapper接口中的抽象方法：方法的返回值是简单数据类型

/**
     * 统计员工数量
     * @return
     */
Long selectEmployeeCount();
1
2
3
4
5

映射配置文件: 此时标签的resultType的类型对应抽象方法的返回值类型

<!--
        返回简单类型:
        resultType表示结果类型:结果集返回的类型,要和Mapper接口中对应的方法的返回值类型保持一致
    -->
<select id="selectEmployeeCount" resultType="long">
    select count(emp_id) from t_emp
</select>
1
2
3
4
5
6
7

2、 返回一条数据

1. 返回实体类对象

Mapper接口中的抽象方法：方法的返回值是POJO类型

Employee selectEmployee(Integer empId);
1

映射配置文件: 此时标签的resultType的类型对应抽象方法的返回值类型的全限定名

<!-- 编写具体的SQL语句，使用id属性唯一的标记一条SQL语句 -->
<!-- resultType属性：指定封装查询结果的Java实体类的全类名 -->
<select id="selectEmployee" resultType="com.xyxy.pojo.Employee">
    <!-- Mybatis负责把SQL语句中的#{}部分替换成“?”占位符 -->
    <!-- 给每一个字段设置一个别名，让别名和Java实体类中属性名一致 -->
    select emp_id empId,emp_name empName,emp_salary empSalary from t_emp where emp_id=#{maomi}
</select>
1
2
3
4
5
6
7

通过给数据库表字段加别名，让查询结果的每一列都和Java实体类中属性对应起来。

增加全局配置自动映射驼峰命名规则

在Mybatis的核心配置文件中做下面的配置，select语句中可以不给字段设置别名

<!-- 在全局范围内对Mybatis进行配置 -->
<settings>
    <!-- 具体配置 -->
    <!-- 从org.apache.ibatis.session.Configuration类中可以查看能使用的配置项 -->
    <!-- 将mapUnderscoreToCamelCase属性配置为true，表示开启自动映射驼峰式命名规则 -->
    <!-- 规则要求数据库表字段命名方式：单词_单词 -->
    <!-- 规则要求Java实体类属性名命名方式：首字母小写的驼峰式命名 -->
    <setting name="mapUnderscoreToCamelCase" value="true"/>
</settings>
1
2
3
4
5
6
7
8
9

2. 返回Map类型

适用于SQL查询返回的各个字段综合起来并不和任何一个现有的实体类对应，没法封装到实体类对象中。能够封装成实体类类型的，就不使用Map类型。

Mapper接口中的抽象方法：方法的返回值是Map类型

/**
* 根据empId查询员工信息，并且将结果集封装到Map中
* @param empId
* @return
*/
Map selectEmployeeMapByEmpId(Integer empId);
1
2
3
4
5
6

映射配置文件: 此时标签的resultType的类型为map

<!--
        返回Map类型:
        resultType表示结果类型: 就是Map的全限定名或者别名
    -->
<select id="selectEmployeeMapByEmpId" resultType="map">
    select * from t_emp where emp_id=#{empId}
</select>
1
2
3
4
5
6
7

3、 返回多行数据

1. 返回List<POJO>

查询结果返回多个实体类对象，希望把多个实体类对象放在List集合中返回。此时不需要任何特殊处理，在resultType属性中还是设置实体类类型即可。

Mapper接口中的抽象方法：方法的返回值是List<POJO>

List<Employee> selectAll();
1

映射配置文件: 此时标签的resultType的类型为POJO类的全限定名

<!-- List<Employee> selectAll(); -->
<select id="selectAll" resultType="com.xyxy.pojo.Employee">
    select emp_id empId,emp_name empName,emp_salary empSalary from t_emp
</select>
1
2
3
4

2. 返回List<Map>

查询结果返回多个Map对象，希望把多个Map对象放在List集合中返回。此时不需要任何特殊处理，在resultType属性中还是设置map即可。

Mapper接口中的抽象方法：方法的返回值是List<Map>类型

List<Map> selectAllMap();
1

映射配置文件: 此时标签的resultType的类型为map

<select id="selectAllMap" resultType="map">
    select emp_id empId,emp_name empName,emp_salary empSalary
    from t_emp
</select>
1
2
3
4

4、 返回自增主键

1. 使用场景

例如：保存订单信息。需要保存Order对象和List<OrderItem>。其中，OrderItem对应的数据库表，包含一个外键，指向Order对应表的主键。

在保存List<OrderItem>的时候，需要使用下面的SQL：

insert into t_order_item(item_name,item_price,item_count,order_id) values(...)
1

这里需要用到的order_id，是在保存Order对象时，数据库表以自增方式产生的，需要特殊办法拿到这个自增的主键值。

2. 实现方案

Mapper接口中的抽象方法：

int insertEmployee(Employee employee);
1

映射配置文件:

<!-- int insertEmployee(Employee employee); -->
<!-- useGeneratedKeys属性字面意思就是“使用生成的主键” -->
<!-- keyProperty属性可以指定主键在实体类对象中对应的属性名，Mybatis会将拿到的主键值存入这个属性 -->
<insert id="insertEmployee" useGeneratedKeys="true" keyProperty="empId">
    insert into t_emp(emp_name,emp_salary)
    values(#{empName},#{empSalary})
</insert>
1
2
3
4
5
6
7

junit测试代码:

@Test
public void testSaveEmp() {
    
    EmployeeMapper employeeMapper = session.getMapper(EmployeeMapper.class);
    
    Employee employee = new Employee();
        
    employee.setEmpName("john");
    employee.setEmpSalary(666.66);
    
    employeeMapper.insertEmployee(employee);
    //打印自动返回存入对象的主键值
    System.out.println("employee.getEmpId() = " + employee.getEmpId());
    
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

注意:

Mybatis是将自增主键的值设置到实体类对象中，而不是以Mapper接口方法返回值的形式返回。

另一种做法

<insert id="insertEmployee">
    insert into t_emp (emp_name,emp_salary) values (#{empName},#{empSalary})
    <!--
            keyColumn="emp_id"表示要查询的主键的列名
            keyProperty="empId"表示将查询到的主键值赋给JavaBean的哪个属性
            resultType="int"表示查询的结果类型
            order="AFTER" 表示这个查询是执行在insert之前还是之后呢?如果为AFTER表示之后，BEFORE表示之前
        -->
    <selectKey keyColumn="emp_id" keyProperty="empId" resultType="int" order="AFTER">
        select last_insert_id()
    </selectKey>
</insert>
1
2
3
4
5
6
7
8
9
10
11
12

3. 不支持自增主键的数据库怎么获取主键值(以下代码仅供参考)

而对于不支持自增型主键的数据库（例如 Oracle），则可以使用 selectKey 子元素：selectKey元素将会首先运行，id 会被设置，然后插入语句会被调用

<insert id="insertEmployee" 
        parameterType="com.atguigu.mybatis.beans.Employee"  
            databaseId="oracle">
        <selectKey order="BEFORE" keyProperty="id" 
                                       resultType="integer">
            select employee_seq.nextval from dual 
        </selectKey>    
        insert into orcl_employee(id,last_name,email,gender) values(#{id},#{lastName},#{email},#{gender})
</insert>
1
2
3
4
5
6
7
8
9

或者:

<insert id="insertEmployee" 
        parameterType="com.atguigu.mybatis.beans.Employee"  
            databaseId="oracle">
        <selectKey order="AFTER" keyProperty="id" 
                                         resultType="integer">
            select employee_seq.currval from dual 
        </selectKey>    
    insert into orcl_employee(id,last_name,email,gender) values(employee_seq.nextval,#{lastName},#{email},#{gender})
</insert>
1
2
3
4
5
6
7
8
9

5、 结果集的字段和实体类属性对应关系

1. 自动映射

Mybatis在做结果集与POJO类的映射关系的时候，会自动将结果集的字段名与POJO的属性名(其实是和getXXX方法)进行对应映射，结果集的数据会自动映射给POJO对象中同名的属性; 所以当我们遇到表的字段名和POJO属性名不一致的情况，我们可以在编写查询语句的时候，给结果集的字段取别名，让别名与POJO的属性名一致以保证结果集的正确映射

2. 全局配置自动识别驼峰式命名规则

因为我们表中字段的命名规则采用"_",而POJO的属性名命名规则采用驼峰命名法，所以导致我们在执行查询语句的时候总是要对查询的字段取别名，以确保正确地进行结果集映射

Mybatis框架当然也注意到了这个问题，所以它提供了一种自动识别驼峰命名规则的配置，我们只要做了该配置，那么全局的所有查询语句的执行都会自动识别驼峰命名规则

在Mybatis全局配置文件加入如下配置：

<!-- 使用settings对Mybatis全局进行设置 -->
<settings>
    <!-- 将xxx_xxx这样的列名自动映射到xxXxx这样驼峰式命名的属性名 -->
    <setting name="mapUnderscoreToCamelCase" value="true"/>
</settings>
1
2
3
4
5

SQL语句中可以不使用别名:

<!-- Employee selectEmployee(Integer empId); -->
<select id="selectEmployee" resultType="com.atguigu.mybatis.entity.Employee">
    select emp_id,emp_name,emp_salary from t_emp where emp_id=#{empId}
</select>
1
2
3
4

3. 手动映射

使用resultMap标签手动指定结果集字段与POJO属性的映射关系,可以非常灵活地进行结果集的映射

<!--
        手动映射:通过resultMap标签配置映射规则
            1. id属性:表示这个手动映射规则的唯一表示
            2. type属性: 表示这个手动映射规则是将结果集映射给哪个类的对象，就是JavaBean类的全限定名
        resultMap标签中的子标签就是一一指定映射规则:
            1. id标签:指定主键的映射规则
            2. result标签:指定非主键的映射规则
        id标签和result标签的属性:
            1. column:要进行映射的结果集的字段名
            2. property:要进行映射的JavaBean的属性名
    -->
<resultMap id="EmployeeInfoMap" type="com.xyxy.pojo.EmployeeInfo">
    <id column="emp_id" property="id"/>
    <result column="emp_name" property="name"/>
    <result column="emp_salary" property="salary"/>
</resultMap>


<!--
        在select标签中通过resultMap属性来指定使用哪个手动映射规则
    -->
<select id="selectEmployeeInfoByEmpId" resultMap="EmployeeInfoMap">
    select * from t_emp where emp_id=#{empId}
</select>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

四、多表关联查询

物理建模

CREATE TABLE `t_customer` (
     `customer_id` INT NOT NULL AUTO_INCREMENT, 
     `customer_name` CHAR(100), 
     PRIMARY KEY (`customer_id`) 
);
CREATE TABLE `t_order` ( 
    `order_id` INT NOT NULL AUTO_INCREMENT, 
    `order_name` CHAR(100), 
    `customer_id` INT, 
    PRIMARY KEY (`order_id`) 
); 
INSERT INTO `t_customer` (`customer_name`) VALUES ('c01');
INSERT INTO `t_customer` (`customer_name`) VALUES ('c02');
INSERT INTO `t_order` (`order_name`, `customer_id`) VALUES ('o1', '1'); 
INSERT INTO `t_order` (`order_name`, `customer_id`) VALUES ('o2', '1'); 
INSERT INTO `t_order` (`order_name`, `customer_id`) VALUES ('o3', '1'); 
INSERT INTO `t_order` (`order_name`, `customer_id`) VALUES ('o4', '2'); 
INSERT INTO `t_order` (`order_name`, `customer_id`) VALUES ('o5', '2'); 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

t_customer表和t_order表示一对多关系，反之t_order表和t_customer表可以看成一对一或者多对一关系

1、一对一或多对一查询

1.任务

​ 根据订单ID查询出订单信息，并且查询出该订单所属的顾客信息，将查询到的结果集封装到Order对象中

2.POJO封装结果集

public class Order {
    private Integer orderId;
    private String orderName;
    //表示Order和Customer的对一关系
    private Customer customer;
}
1
2
3
4
5
6

public class Customer {
    private Integer customerId;
    private String customerName;
}
1
2
3
4

2.接口方法

public interface OrderMapper{
    Order findByOrderId(Integer orderId);
}
1
2
3

3.在全局配置文件中配置

	<!--全局配置自动映射驼峰命名-->
    <settings>
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>
    
    <!--实体类取别名-->
    <typeAliases>
        <package name="com.xyxy.pojo"/>
    </typeAliases>
        
    <!-- Mapper注册：指定Mybatis映射文件的具体位置 -->
    <!-- mappers标签：配置一个具体的Mapper映射文件 -->
    <!-- resource属性：指定Mapper映射文件的实际存储位置，这里需要使用一个以类路径根目录
    <mappers>
        <!-- 包下的所有Mapper配置文件将被自动加载、注册，比较方便。 -->
        <package name="com.xyxy.mapper"/>
    </mappers>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

4.映射配置文件OrderMapper.xml

<?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.xyxy.mapper.OrderMapper">
    <resultMap id="order" type="Order" autoMapping="true">
        <!-- autoMapping属性设置为true开启自动映射 -->
        <association property="customer" javaType="Customer">
            <id column="customer_id" property="customerId"></id>
            <result column="customer_name" property="customerName"></result>
        </association>
    </resultMap>
    <select id="findByOrderId" resultMap="order">
        select * from t_order o left join t_customer c on o.customer_id=c.customer_id where order_id=#{orderId}
    </select>
</mapper>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

5.测试

2、一对多查询

1.任务

​ 根据客户的ID查询客户信息，并且查询出该客户的所有订单信息,将查询的订单信息结果集封装到Customer对象中

2.POJO封装结果集

public class Customer {
    private Integer customerId;
    private String customerName;
    //客户和订单的一对多关系
    private List<Order> orderList;
}
1
2
3
4
5
6

public class Order {
    private Integer orderId;
    private String orderName;
}
1
2
3
4

3.CustomerMapper接口中的抽象方法

public interface CustomerMapper {
    Customer findCustomerAndOrders(Integer customerId);
}
1
2
3

4.映射配置文件CustomerMapper.xml

<?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.xyxy.mapper.CustomerMapper">
    <resultMap id="customer" type="Customer" >
        <id column="customer_id" property="customerId"/>
        <result column="customer_name" property="customerName"/>
        <collection property="orderList" ofType="Order" autoMapping="true">
            <!--
            进行一对多映射,使用collection标签
                ofType属性指的是orderList的泛型
            -->
        </collection>
    </resultMap>
    <select id="findCustomerAndOrders" resultMap="customer">
        SELECT * FROM t_customer c,t_order o WHERE o.customer_id=c.customer_id AND c.customer_id=#{customerId}
    </select>
</mapper>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

5.测试

五、记录一些场景的实现方式

1、数据库的时间字段为String类型时使用SQL语句实现时间范围查询

1、数据库的时间字段为varchar，格式为2022-04-22

2、传入两个参数，开始时间和结束时间，查找时间在这个范围内的数据

​ 传入参数的格式：String startTime = 2022-03-23

​ String endTime = 2022-04-23

3、mybatis的SQL语句编写

<!-- 时间范围查询商品-->
<select id="listByTime" resultType="com.atguigu.jxc.entity.DamageList">
    select * from t_damage_list
    <where>
        <if test="sTime != null and sTime != ''">
            and STR_TO_DATE(damage_date,'%Y-%m-%d') &gt;= STR_TO_DATE(#{startTime},'%Y-%m-%d')
        </if>
        <if test="eTime != null and eTime != ''">
            and STR_TO_DATE(damage_date,'%Y-%m-%d') &lt;= STR_TO_DATE(#{endTime},'%Y-%m-%d')
        </if>
    </where>
</select>
1
2
3
4
5
6
7
8
9
10
11
12

4、如果你的时间格式是年月日时分秒的格式2022-04-22 10:50:24，那么转换时间格式的时候使用

STR_TO_DATE(damage_date,'%Y-%m-%d %H:%i:%s')
1

2、Mybatis新增返回自增主键

需求：添加记录后返回自增主键的值，方便后后续使用

介绍相关属性

方法一

设置属性

<insert id="insert" parameterType="com.atguigu.jxc.entity.DamageList" useGeneratedKeys="true" keyProperty="damageListId">
        INSERT INTO t_damage_list (
          damage_number,
          damage_date,
          remarks,
          user_id
        )
        VALUES
          (
            #{damageNumber},
            #{damageDate},
            #{remarks},
            #{userId}
          ) ;
    </insert>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

方法二

使用返回主键标签

<insert id="insert" parameterType="com.atguigu.jxc.entity.DamageList">
        INSERT INTO t_damage_list (
          damage_number,
          damage_date,
          remarks,
          user_id
        )
        VALUES
          (
            #{damageNumber},
            #{damageDate},
            #{remarks},
            #{userId}
          ) ;
          <!-- resultType设置返回值，keyProperty主键对应的实体属性，order次序 -->
          <selectKey resultType="int" keyProperty="damageListId" order="AFTER">
              select @@identity
          </selectKey>
    </insert>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

<insert id="insert" parameterType="com.atguigu.jxc.entity.DamageList">
        INSERT INTO t_damage_list (
          damage_number,
          damage_date,
          remarks,
          user_id
        )
        VALUES
          (
            #{damageNumber},
            #{damageDate},
            #{remarks},
            #{userId}
          ) ;
          <!-- resultType设置返回值，keyProperty主键对应的实体属性，order次序 -->
          <selectKey resultType="int" keyProperty="damageListId" order="AFTER">
              select LAST_INSERT_ID()
          </selectKey>
    </insert>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

方法三

注解使用

@Insert("INSERT INTO t_damage_list (damage_number,damage_date,remarks,user_id) VALUES(#{damageNumber},#{damageDate},#{remarks},#{userId});")
@Options(useGeneratedKeys = true, keyProperty = "damageListId", keyColumn = "damage_list_id")
void insert(DamageList damageList);
1
2
3

3、mybatis——动态SQL（使用foreach实现批量插入数据）

（1）在UserMapper接口类写批量插入数据的接口

void insertList(List<User> list);
1

（2）在对应的UserMapper.xml文件里写SQL语句

<mapper namespace="com.xyxy.mapper.UserMapper">
    <insert id="insertList">
        insert into  my_user
        values
        <foreach collection="list" item="item" separator="," index="index">
            (null,#{item.name},#{item.age},#{item.email})
        </foreach>
    </insert>
</mapper>
1
2
3
4
5
6
7
8
9

通过 item指定了循环变量名后，在引用值的时候使用的是“属性.属性”的方式，如user.userName