MyBatis映射文件持续创作，加速成长！这是我参与「掘金日新计划 · 6 月更文挑战」的第20天，点击查看活动详情增

持续创作，加速成长！这是我参与「掘金日新计划 · 6 月更文挑战」的第20天，点击查看活动详情

增删改查

1 在Mapper接口类中定义方法

package site.exciter.mybatis.dao;

import org.apache.ibatis.annotations.Mapper;
import site.exciter.mybatis.model.Employee;

@Mapper
public interface EmployeeMapper {
    /**
     * 查询数据
     *
     * @param id id
     * @return 数据
     */
    Employee getEmployeeById(int id);

    /**
     * 添加数据
     *
     * @param e 数据
     */
    Boolean addEmployee(Employee e);

    /**
     * 更新数据
     *
     * @param e 数据
     */
    Boolean updateEmployee(Employee e);

    /**
     * 删除数据
     *
     * @param id id
     */
    Long deleteEmployee(Integer id);
}

2 在Mapper映射文件中写SQL语句

<!--查询数据 获取参数的方式 #{key}-->
<select id="getEmployeeById" resultType="emp">
    select id, last_name, gender, email
    from table_employee
    where id = #{id}
</select>

<!--增加数据 parameterType可以省略-->
<insert id="addEmployee" parameterType="emp">
    insert into table_employee(last_name, gender, email)
    values (#{lastName}, #{gender}, #{email})
</insert>

<!--更新数据-->
<update id="updateEmployee">
    update table_employee
    set last_name=#{lastName},
        gender=#{gender},
        email=#{email}
    where id = #{id}
</update>

<!--删除数据-->
<delete id="deleteEmployee">
    delete
    from table_employee
    where id =
    #{id}
</delete>

3 在代码中使用

注意：
1、MyBatis允许增删改查直接返回一个值：Integer、Long、Boolean。
2、可能需要sqlSession.commit()手动提交数据。

sqlSessionFactory.openSession() 需要手动提交
sqlSessionFactory.openSession(true) 不需要手动提交

	/**
     * 查询数据
     *
     * @throws IOException
     */
    @Test
    public void getEmployeeById() throws IOException {
        SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
        SqlSession sqlSession = sqlSessionFactory.openSession();
        try {
            EmployeeMapper mapper = sqlSession.getMapper(EmployeeMapper.class);
            Employee employee = mapper.getEmployeeById(1);
            System.out.println(employee);
        } finally {
            sqlSession.close();
        }
    }

    /**
     * 添加数据
     *
     * @throws IOException
     */
    @Test
    public void addEmployee() throws IOException {
        SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
        //1、获取到的Session不会自动提交
        SqlSession sqlSession = sqlSessionFactory.openSession();
        try {
            EmployeeMapper mapper = sqlSession.getMapper(EmployeeMapper.class);
            Employee employee = new Employee();
            employee.setLastName("小团团");
            employee.setGender("女");
            employee.setEmail("111@qq.com");
            Boolean b = mapper.addEmployee(employee);
            System.out.println("addEmployee success:" + b);
            //2、手动提交
            sqlSession.commit();
        } finally {
            sqlSession.close();
        }
    }

    /**
     * 更新数据
     *
     * @throws IOException
     */
    @Test
    public void updateEmployee() throws IOException {
        SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
        //1、获取到的Session不会自动提交
        SqlSession sqlSession = sqlSessionFactory.openSession();
        try {
            EmployeeMapper mapper = sqlSession.getMapper(EmployeeMapper.class);
            Employee employee = new Employee();
            employee.setId(1);
            employee.setLastName("小团团");
            employee.setGender("女");
            employee.setEmail("111@qq.com");
            Boolean b = mapper.updateEmployee(employee);
            System.out.println("updateEmployee success:" + b);
            //2、手动提交
            sqlSession.commit();
        } finally {
            sqlSession.close();
        }
    }

    /**
     * 删除数据
     *
     * @throws IOException
     */
    @Test
    public void deleteEmployee() throws IOException {
        SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
        //1、获取到的Session不会自动提交
        SqlSession sqlSession = sqlSessionFactory.openSession();
        try {
            EmployeeMapper mapper = sqlSession.getMapper(EmployeeMapper.class);
            Long l = mapper.deleteEmployee(1);
            System.out.println("deleteEmployee count:" + l);
            //2、手动提交
            sqlSession.commit();
        } finally {
            sqlSession.close();
        }
    }

insert时获取主键值

1 获取自增主键的值

mysql支持自增主键，在映射文件中配置useGeneratedKeys后，MyBatis可以根据statement.getGenreatedKeys()去获取插入数据的id。

<insert id="addEmployee" parameterType="emp" useGeneratedKeys="true" keyProperty="id">
        insert into table_employee(last_name, gender, email)
        values (#{lastName}, #{gender}, #{email})
</insert>

useGeneratedKeys：true启用|false禁用
keyProperty：主键key

插入数据后即可获取这条数据的id：

Boolean b = mapper.addEmployee(employee);
System.out.println("addEmployee success:" + b+"  id:"+employee.getId());

2 获取非自增主键的值

oracle不支持自增主键，Oracle使用序列来模拟自增；每次插入的数据的主键是从序列中拿到的值。

<insert id="addEmp" databaseId="oracle">
		<!-- 
		keyProperty:查出的主键值封装给javaBean的哪个属性
		order="BEFORE":当前sql在插入sql之前运行
			   AFTER：当前sql在插入sql之后运行
		resultType:查出的数据的返回值类型
		
		BEFORE运行顺序：
			先运行selectKey查询id的sql；查出id值封装给javaBean的id属性
			在运行插入的sql；就可以取出id属性对应的值
		AFTER运行顺序：
			先运行插入的sql（从序列中取出新值作为id）；
			再运行selectKey查询id的sql；
		 -->
		<selectKey keyProperty="id" order="BEFORE" resultType="Integer">
			<!-- 编写查询主键的sql语句 -->
			<!-- BEFORE-->
			select EMPLOYEES_SEQ.nextval from dual 
			<!-- AFTER：
			 select EMPLOYEES_SEQ.currval from dual -->
		</selectKey>
		
		<!-- 插入时的主键是从序列中拿到的 -->
		<!-- BEFORE:-->
		insert into employees(EMPLOYEE_ID,LAST_NAME,EMAIL) 
		values(#{id},#{lastName},#{email<!-- ,jdbcType=NULL -->}) 
		<!-- AFTER：
		insert into employees(EMPLOYEE_ID,LAST_NAME,EMAIL) 
		values(employees_seq.nextval,#{lastName},#{email}) -->
	</insert>

参数处理

1 单个参数

处理： mybatis不会做特殊处理。

方式： #{参数名/任意名} 取出参数值。

示例：

Employee getEmployeeById(int id);

<select id="getEmployeeById" resultType="emp">
        select id, last_name, gender, email
        from table_employee
        where id = #{id}
</select>

2 多个参数（参数较少）

处理： mybatis会做特殊处理，多个参数会被封装成一个map，map的结构为[1, 0, param1, param2]。

key：param1...paramN,或者参数的索引也可以
value：传入的参数值

方式1： #{param1，param2} 取出参数值。

示例：

Employee getEmployeeByIdAndLastName(Integer id, String lastName);

<select id="getEmployeeByIdAndLastName" resultType="emp">
        select id, last_name, gender, email
        from table_employee
        where id = #{param1}
          and last_name = #{param2}
</select>

方式2： 用注解命名参数：@Param("id")

多个参数会被封装成一个map：

key：使用@Param注解指定的值

value：参数值

#{指定的key}取出对应的参数值

Employee getEmployeeByIdAndLastName(@Param("id") Integer id, @Param("lastName") String lastName);

<select id="getEmployeeByIdAndLastName" resultType="emp">
        select id, last_name, gender, email
        from table_employee
        where id = #{id}
          and last_name = #{lastName}
</select>

3 多个参数（参数较多）

3.1 POJO

POJO（Plain Ordinary Java Object）简单的Java对象，实际就是普通JavaBeans，是为了避免和EJB混淆所创造的简称。

如果多个参数正好是我们业务逻辑的数据模型，我们就可以直接传入pojo：

#{属性名} 取出传入的pojo的属性值

3.2 Map

方式： 如果多个参数不是业务模型中的数据，没有对应的pojo，不经常使用，为了方便，我们也可以传入map。

#{key} 取出map中对应的值方式

示例：

Employee getEmployeeByMap(Map<String, Object> map);

<select id="getEmployeeByMap" resultType="emp">
        select id, last_name, gender, email
        from table_employee
        where id = #{id}
          and last_name = #{lastName}
</select>

3.3 TO

如果多个参数不是业务模型中的数据，但是经常要使用，推荐来编写一个TO（Transfer Object）数据传输对象。

Page{

int index;

int size;

}

4 其他情况

public Employee getEmp(@Param("id")Integer id,String lastName);

取值：id==>#{id/param1} lastName==>#{param2}

public Employee getEmp(Integer id,@Param("e")Employee emp);

取值：id==>#{param1} lastName===>#{param2.lastName/e.lastName}

特别注意：如果是Collection（List、Set）类型或者是数组，也会特殊处理。也是把传入的list或者数组封装在map中。

key：Collection（collection）,如果是List还可以使用这个key(list)，数组(array)。

public Employee getEmpById(List<Integer> ids);

取值：取出第一个id的值 #{list[0]}

5 参数值的获取

5.1 两种方式：`#{}` `${}`

#{}

#log
Preparing: select id, last_name, gender, email from table_employee where id = 5 and last_name = ?

${}

#log
Preparing: select id, last_name, gender, email from table_employee where id = ? and last_name = ?

区别：

#{} 是以预编译的形式，将参数设置到sql语句中(PreparedStatement)，能防止sql注入。

${} 取出的值直接拼装在sql语句中，会有安全问题。

使用：

1、大多情况下，我们去参数的值都应该去使用#{}；

2、原生jdbc不支持占位符的地方我们就可以使用${}进行取值比如分表、排序...

栗子：按照年份分表拆分

select * from ${year}_salary where xxx;

select * from ${tableName} order by ${f_name} ${order}; 如果tableName用#{}，那么就会报错，找不到该表。

<select id="getEmployeeByMap" resultType="emp">
        select id, last_name, gender, email
        from ${tableName}
        where id = ${id}
          and last_name = #{lastName}
</select>

@Test
    public void getEmployeeByMap() throws IOException {
        SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
        SqlSession sqlSession = sqlSessionFactory.openSession();
        try {
            EmployeeMapper mapper = sqlSession.getMapper(EmployeeMapper.class);
            Map<String, Object> map = new HashMap<>();
            map.put("id", 5);
            map.put("lastName", "小团团");
            map.put("tableName", "table_employee");
            Employee employee = mapper.getEmployeeByMap(map);
            System.out.println(employee);
        } finally {
            sqlSession.close();
        }
    }

Preparing: select id, last_name, gender, email from table_employee where id = 5 and last_name = ?

5.2 #{}更丰富的用法

规定参数的一些规则：

javaType、 jdbcType、 mode（存储过程）、 numericScale、resultMap、 typeHandler、 jdbcTypeName、 expression（未来准备支持的功能）；

jdbcType通常需要在某种特定的条件下被设置：

在我们数据为null的时候，有些数据库可能不能识别mybatis对null的默认处理。比如Oracle（报错）：

JdbcType OTHER：无效的类型；因为mybatis对所有的null都映射的是原生Jdbc的OTHER类型，oracle不能正确处理。

由于全局配置中：jdbcTypeForNull默认为OTHER；oracle不支持。

两种办法解决：

#{email,jdbcType=OTHER};
jdbcTypeForNull=NULL：

select-返回list和map

1 返回List

接口：

 /**
     * 根据名字模糊查询集合
     *
     * @param lastName 名字
     * @return 数据集合
     */
    List<Employee> getEmployeesByLastNameLike(String lastName);

SQL：

<!--查询集合 如果返回的是一个集合，则resultType为集合中的元素类型-->
    <select id="getEmployeesByLastNameLike" resultType="emp">
        select *
        from table_employee
        where last_name like #{lastName}
    </select>

调用：

/**
     * 根据名字模糊查询集合
     *
     * @throws IOException
     */
    @Test
    public void getEmployeesByLastNameLike() throws IOException {
        SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
        SqlSession sqlSession = sqlSessionFactory.openSession();
        try {
            EmployeeMapper mapper = sqlSession.getMapper(EmployeeMapper.class);
            List<Employee> employees = mapper.getEmployeesByLastNameLike("%团%");
            for (Employee employee : employees) {
                System.out.println(employee);
            }
        } finally {
            sqlSession.close();
        }
    }

Log：

==>  Preparing: select * from table_employee where last_name like ?
==> Parameters: %团%(String)
<==    Columns: id, last_name, gender, email
<==        Row: 2, 一条小团团, 女, 456@qq.com
<==        Row: 5, 小团团, 女, 111@qq.com
<==        Row: 6, 小团团, 女, 111@qq.com
<==        Row: 7, 小团团, 女, 111@qq.com
<==      Total: 4
Employee{id=2, lastName='一条小团团', gender='女', email='456@qq.com'}
Employee{id=5, lastName='小团团', gender='女', email='111@qq.com'}
Employee{id=6, lastName='小团团', gender='女', email='111@qq.com'}
Employee{id=7, lastName='小团团', gender='女', email='111@qq.com'}

2 返回Map

2.1 返回一条记录的map

Map<String, Object> getEmployeeByIdReturnMap(Integer id);

 <!--返回一条数据的map resultType为map-->
    <select id="getEmployeeByIdReturnMap" resultType="map">
        select *
        from table_employee
        where id = #{id}
    </select>

2.2 返回多条记录的map

 /**
     * 返回多条数据的map
     * 通过注解@MapKey("id")指定map的key为id或者其他字段
     *
     * @param lastName 名字
     * @return 数据
     */
    @MapKey("id")
    Map<String, Employee> getEmployeeByLastNameLikeReturnMap(String lastName);

 <!--返回多条数据的map resultType为map的value的类型-->
    <select id="getEmployeeByLastNameLikeReturnMap" resultType="emp">
        select *
        from table_employee
        where last_name like #{lastName}
    </select>

select-resultMap

1 自定义结果映射规则

Employee getEmployeeById(Integer id);

<mapper namespace="site.exciter.mybatis.dao.EmployeeMapperPlus">

    <!--自定义某个JavaBean的封装规则 id：唯一id方便引用 type：需要定义的JavaBean-->
    <resultMap id="MyEmp" type="site.exciter.mybatis.model.Employee">
        <!--column：指定哪一列；property：指定对应的JavaBean里的属性-->
        <!--id定义主键的封装规则，用id标签会进行底层优化-->
        <id column="id" property="id"/>
        <!--result定义普通列的封装规则-->
        <result column="last_name" property="lastName"/>
        <!--其他列和JavaBean属性对应的可以不写，会自动封装，但是建议所有的字段都写上 -->
        <result column="gender" property="gender"/>
        <result column="email" property="email"/>
    </resultMap>

    <!--用resultMap指定 结果集映射规则-->
    <select id="getEmployeeById" resultMap="MyEmp">
        select * from table_employee where id=#{id}
    </select>

</mapper>

2 关联查询

2.1 环境搭建

#创建员工表
CREATE TABLE table_employee(
	id INT PRIMARY KEY AUTO_INCREMENT,
	last_name VARCHAR(255),
	gender CHAR(1),
	email VARCHAR(255)
);
#插入数据
INSERT INTO table_employee(last_name,gender,email) 
VALUES('井川里予','女','123@qq.com'),
('一条小团团','女','456@qq.com'),
('Lili','女','789@qq.com');
#创建部门表
create table table_department(
	id int primary key auto_increment,
    department_name varchar(255)
);
#给员工表添加部门id
alter table table_employee add column department_id int(11);
#将员工表的部门id设为外键，和部门表关联起来
alter table table_employee add constraint fk_emp_dept 
foreign key(department_id) references table_department(id);
#查数据
select e.id,e.last_name,e.gender,e.email,e.department_id,d.department_name
from table_employee as e
inner join table_department as d on e.department_id=d.id
where e.id=1;

2.2 级联属性封装结果

场景：根据id查询对应员工的信息和部门

创建Department.java:

package site.exciter.mybatis.model;

public class Department {
    private int id;
    private String departmentName;

    public int getId() {
        return id;
    }

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

    public String getDepartmentName() {
        return departmentName;
    }

    public void setDepartmentName(String departmentName) {
        this.departmentName = departmentName;
    }

    @Override
    public String toString() {
        return "Department{" +
                "id=" + id +
                ", departmentName='" + departmentName + ''' +
                '}';
    }
}

Employee.java中添加Department对象：

package site.exciter.mybatis.model;

import org.apache.ibatis.type.Alias;

@Alias("emp")
public class Employee {
    private int id;
    private String lastName;
    private String gender;
    private String email;
    private Department department;

    public int getId() {
        return id;
    }

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

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public Department getDepartment() {
        return department;
    }

    public void setDepartment(Department department) {
        this.department = department;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "id=" + id +
                ", lastName='" + lastName + ''' +
                ", gender='" + gender + ''' +
                ", email='" + email + ''' +
                ", department=" + department +
                '}';
    }
}

定义接口方法：

Employee getEmpAndDeptById(Integer id);

映射文件中添加SQL：

 <!--联合查询：级联属性封装结果集-->
    <resultMap id="MyEmpAndDept" type="site.exciter.mybatis.model.Employee">
        <id column="id" property="id"/>
        <result column="last_name" property="lastName"/>
        <result column="gender" property="gender"/>
        <result column="department_id" property="department.id"/>
        <result column="department_name" property="department.departmentName"/>
    </resultMap>

    <select id="getEmpAndDeptById" resultMap="MyEmpAndDept">
        select e.id,e.last_name,e.gender,e.email,e.department_id,d.department_name
        from table_employee as e
        inner join table_department as d on e.department_id=d.id
        where e.id=#{id}
    </select>

2.3 association定义关联对象封装规则[关联单个对象]

<!--使用association定义关联的单个对象的封装规则-->
    <resultMap id="MyEmpAndDept2" type="site.exciter.mybatis.model.Employee">
        <id column="id" property="id"/>
        <result column="last_name" property="lastName"/>
        <result column="gender" property="gender"/>
        <result column="email" property="email"/>
        <!--association可以指定联合的javaBean对象
              property="department"：指定哪个属性是联合的对象
              javaType:指定这个属性对象的类型[不能省略]
        -->
        <association property="department" javaType="site.exciter.mybatis.model.Department">
            <id column="department_id" property="id"/>
            <result column="department_name" property="departmentName"/>
        </association>
    </resultMap>

    <select id="getEmpAndDeptById2" resultMap="MyEmpAndDept2">
        select e.id,e.last_name,e.gender,e.email,e.department_id,d.department_name
        from table_employee as e
        inner join table_department as d on e.department_id=d.id
        where e.id=#{id}
    </select>

2.4 association分步查询

创建DepartmentMapper.java并定义查询接口：

package site.exciter.mybatis.dao;

import org.apache.ibatis.annotations.Mapper;
import site.exciter.mybatis.model.Department;

@Mapper
public interface DepartmentMapper {

    Department getDeptById(Integer id);
}

创建Department对应的映射文件：

<?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="site.exciter.mybatis.dao.DepartmentMapper">

    <select id="getDeptById" resultType="site.exciter.mybatis.model.Department">
    select  id,department_name as departmentName from table_department where id=#{id}
</select>

</mapper>

在Emplyoee接口类中添加查询接口：

Employee getEmpAndDeptByIdStep(Integer id);

在Employee映射文件中新建查询：

<!--使用association进行分步查询-->
<!-- 使用association进行分步查询：
		1、先按照员工id查询员工信息
		2、根据查询员工信息中的department_id值去部门表查出部门信息
		3、部门设置到员工中；
	 -->
    <resultMap id="MyEmpAndDeptStep" type="site.exciter.mybatis.model.Employee">
        <id column="id" property="id"/>
        <result column="last_name" property="lastName"/>
        <result column="gender" property="gender"/>
        <result column="email" property="email"/>
		<!-- association定义关联对象的封装规则
	 		select:表明当前属性是调用select指定的方法查出的结果
	 		column:指定将哪一列的值传给这个方法
	 		流程：使用select指定的方法（传入column指定的这列参数的值）查出对象，并封装给property指定的属性
	 	 -->
        <association property="department"
                     select="site.exciter.mybatis.dao.DepartmentMapper.getDeptById"
                     column="department_id">
        </association>
    </resultMap>

    <select id="getEmpAndDeptByIdStep" resultMap="MyEmpAndDeptStep">
        select * from table_employee  where id=#{id}
    </select>

log中有两条查询语句：

==>  Preparing: select * from table_employee where id=?
==> Parameters: 1(Integer)
<==    Columns: id, last_name, gender, email, department_id
<==        Row: 1, 井川里予, 女, 123@qq.com, 1
====>  Preparing: select id,department_name as departmentName from table_department where id=?
====> Parameters: 1(Integer)

2.5 association分步查询&延迟加载

分步查询的基础之上，在全局配置文件中添加两个配置，开启延迟加载：

<!--开启懒加载(延迟加载)-->
<setting name="lazyLoadingEnabled" value="true" />
<setting name="aggressiveLazyLoading" value="false"/>

只有在需要的时候才会进行相应的查询：

当只需要获取员工名的时候System.out.println(employee.getLastName());

Preparing: select * from table_employee where id=?

当需要获取部门信息的时候System.out.println(employee.getDepartment());

Preparing: select * from table_employee where id=?
Preparing: select id,department_name as departmentName from table_department where id=?

2.6 collection定义关联对象封装集合[关联集合]

示例：查询部门以及部门下的员工集合

修改Department.java:

package site.exciter.mybatis.model;

import java.util.List;

public class Department {
    private int id;
    private String departmentName;
    private List<Employee> employees;

    public int getId() {
        return id;
    }

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

    public String getDepartmentName() {
        return departmentName;
    }

    public void setDepartmentName(String departmentName) {
        this.departmentName = departmentName;
    }

    public List<Employee> getEmployees() {
        return employees;
    }

    public void setEmployees(List<Employee> employees) {
        this.employees = employees;
    }

    @Override
    public String toString() {
        return "Department{" +
                "id=" + id +
                ", departmentName='" + departmentName + ''' +
                ", employees=" + employees +
                '}';
    }
}

DepartmentMapper.java添加接口方法：

Department getDeptByIdPlus(Integer id);

添加映射：

<!--嵌套结果集的方式，使用collection标签定义关联的集合类型的属性封装规则-->
    <!--注意两个表中相同字段名中需要用别名区分开，比如下面的id-->
    <resultMap id="MyDept" type="site.exciter.mybatis.model.Department">
        <id column="did" property="id"/>
        <result column="department_name" property="departmentName"/>
        <!--
			collection定义关联集合类型的属性的封装规则
			ofType:指定集合里面元素的类型
		-->
        <collection property="employees" ofType="site.exciter.mybatis.model.Employee">
            <!-- 定义这个集合中元素的封装规则 -->
            <id column="eid" property="id"/>
            <result column="last_name" property="lastName"/>
            <result column="gender" property="gender"/>
            <result column="email" property="email"/>
        </collection>
    </resultMap>

    <select id="getDeptByIdPlus" resultMap="MyDept">
        select d.id as did,d.department_name,e.id as eid,e.last_name,e.gender,e.email
        from table_department as d
        left join table_employee as e on d.id=e.department_id
        where d.id=#{id}
    </select>

2.7 collection分步查询&延迟加载

Department接口类中定义查询方法：

/**
     * 分步查询部门和部门下的员工
     *
     * @param id id
     * @return
     */
    Department getDeptByIdStep(Integer id);

    /**
     * 根据部门id查询员工
     *
     * @param id id
     * @return
     */
    List<Employee> getEmployeesById(Integer id);

<!--collection分步查询&异步加载-->
    <resultMap id="MyDeptStep" type="site.exciter.mybatis.model.Department">
        <id column="id" property="id"/>
        <!--select引入下一步的查询语句-->
        <result column="department_name" property="departmentName"/>
        <collection property="employees" select="getEmployeesById" column="id"></collection>
    </resultMap>

    <select id="getDeptByIdStep" resultMap="MyDeptStep">
        select id,department_name from table_department  where id=#{id}
    </select>

    <select id="getEmployeesById" resultType="site.exciter.mybatis.model.Employee">
        select * from table_employee where  department_id=#{id}
    </select>

2.7 分步查询传递多列值&fetchType

扩展： 多列的值传递过去：将多列的值封装map传递；

column="{key1=column1,key2=column2}"

fetchType="lazy"：表示使用延迟加载；

lazy：延迟
eager：立即

<collection property="employees" select="getEmployeesById" column="{departmentId=id}" fetchType="lazy"/>

2.8 鉴别器discriminator

定义接口：

 /**
     * discriminator 使用鉴别器
     *
     * @param id
     * @return
     */
    Employee getEmpAndDeptByIdDis(Integer id);

添加映射：

<!--鉴别器：discriminator-->
    <!-- <discriminator javaType=""></discriminator>
		鉴别器：mybatis可以使用discriminator判断某列的值，然后根据某列的值改变封装行为
		封装Employee：
			如果查出的是女生：就把部门信息查询出来，否则不查询；
			如果是男生，把last_name这一列的值赋值给email;
	 -->
    <resultMap id="MyEmpDis" type="site.exciter.mybatis.model.Employee">
        <id column="id" property="id"/>
        <result column="last_name" property="lastName"/>
        <result column="email" property="email"/>
        <result column="gender" property="gender"/>
        <!--column：指定判定的列名；javaType：列值对应的java类型-->
        <discriminator javaType="string" column="gender">
            <!--女生  resultType:指定封装的结果类型；不能缺少。-->
            <case value="女">
                <association property="department"
                             select="site.exciter.mybatis.dao.DepartmentMapper.getDeptById"
                             column="department_id"/>
            </case>
            <!--男生，把last_name这一列的值赋值给email-->
            <case value="男">
                <id column="id" property="id"/>
                <result column="last_name" property="lastName"/>
                <result column="last_name" property="email"/>
                <result column="gender" property="gender"/>
            </case>
        </discriminator>
    </resultMap>

    <select id="getEmpAndDeptByIdDis" resultMap="MyEmpDis">
        select e.id,e.last_name,e.gender,e.email,e.department_id,d.department_name
        from table_employee as e
        inner join table_department as d on e.department_id=d.id
        where e.id=#{id}
    </select>

关注木水小站 (zhangmushui.cn)和微信公众号【木水Code】，及时获取更多最新技术干货。

MyBatis映射文件

增删改查

1 在Mapper接口类中定义方法

2 在Mapper映射文件中写SQL语句

3 在代码中使用

insert时获取主键值

1 获取自增主键的值

2 获取非自增主键的值

参数处理

1 单个参数

2 多个参数（参数较少）

3 多个参数（参数较多）

3.1 POJO

3.2 Map

3.3 TO

4 其他情况

5 参数值的获取

5.1 两种方式：#{} ${}

5.2 #{}更丰富的用法

select-返回list和map

1 返回List

2 返回Map

2.1 返回一条记录的map

2.2 返回多条记录的map

select-resultMap

1 自定义结果映射规则

2 关联查询

2.1 环境搭建

2.2 级联属性封装结果

2.3 association定义关联对象封装规则[关联单个对象]

2.4 association分步查询

2.5 association分步查询&延迟加载

2.6 collection定义关联对象封装集合[关联集合]

2.7 collection分步查询&延迟加载

2.7 分步查询传递多列值&fetchType

2.8 鉴别器discriminator

5.1 两种方式：`#{}` `${}`