MyBatis映射文件 相关操作

一、MyBatis映射文件

1、简介

　　MyBatis 的真正强大在于它的映射语句，也是它的魔力所在。由于它的异常强大，映射器的 XML 文件就显得相对简单。如果拿它跟具有相同功能的 JDBC 代码进行对比，你会立即发现省掉了将近 95% 的代码。MyBatis 就是针对 SQL 构建的，并且比普通的方法做的更好。

　　学习 MyBatis，需要了解 其如何对参数进行处理、如何将返回值进行映射。

2、实现简单的增删改查

　　使用一个简单的增删改查小案例，快速明白 mybatis 映射文件使用的流程。

step1：文件结构

step2：完整代码

【主要文件】
    config/db.properties                   用于设置数据库的配置信息
    config/EmpMapper.xml                   sql映射文件，用于编写sql语句
    config/mybatis-config.xml              全局配置文件
    entity.Employee                        实体类
    mapper.EmpMapper                       接口类，用于定义sql方法
    test.Demo                              测试类，用于测试增删改查

【config/db.properties 】
jdbc.driver = com.mysql.cj.jdbc.Driver
jdbc.url = jdbc:mysql://localhost:3306/lyh?useUnicode=true&characterEncoding=utf8
jdbc.username = root
jdbc.password = 123456

【config/mybatis-config.xml】
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <properties resource="config/db.properties"></properties>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <!-- MyBatis自带连接池，只需配置数据库连接的一些数据即可
                       此处以MySql为例。
                   -->
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url"
                          value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>

    <!-- 加载SQL定义文件，需要修改
        若有多个SQL定义文件，可以使用<mapper />标签追加。
          文件路径中存在.的话，使用/分割
     -->
    <mappers>
        <mapper resource="config/EmpMapper.xml"/>
    </mappers>
</configuration>

【entity.Employee】
package entity;

import java.io.Serializable;

/**
 * 实体类
 */
public class Employee implements Serializable {
    private Integer id;
    private String name;
    private Double salary;
    private Integer age;

    public Employee() {
    }

    public Employee(Integer id, String name, Double salary, Integer age) {
        this.id = id;
        this.name = name;
        this.salary = salary;
        this.age = age;
    }

    public Integer getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public Double getSalary() {
        return salary;
    }

    public void setSalary(Double salary) {
        this.salary = salary;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", salary=" + salary +
                ", age=" + age +
                '}';
    }
}

【mapper.EmpMapper】
package mapper;

import entity.Employee;
import org.apache.ibatis.annotations.Select;

/**
 * 接口式编程，定义一系列方法，并根据方法映射到sql 的xml 文件中。
 * 其中，返回值类型可以是 Integer、Long、Boolean、void 、实体类
 */
public interface EmpMapper {
    public Employee getEmpById(Integer id);
    public Long addEmp(Employee emp);
    public Boolean updateEmp(Employee emp);
    public Integer deleteEmpById(Integer id);
}

【config/EmpMapper.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="mapper.EmpMapper">
    <insert id="addEmp">
        INSERT INTO emp(emp.name, emp.salary, emp.age) VALUES (#{name}, #{salary}, #{age})
    </insert>

    <delete id="deleteEmpById">
        DELETE FROM emp WHERE emp.id = #{id}
    </delete>

    <update id="updateEmp">
        UPDATE emp SET emp.salary = #{salary}, emp.age = #{age}, emp.name = #{name} WHERE emp.id = #{id}
    </update>

    <select id="getEmpById" resultType="entity.Employee">
        SELECT * FROM emp WHERE emp.id = #{id}
    </select>
</mapper>

【test.Demo】
package test;

import entity.Employee;
import mapper.EmpMapper;
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 java.io.IOException;
import java.io.InputStream;

public class Demo {

    private static SqlSessionFactory getSqlSessionFactory() throws IOException {
        // step1：读取配置文件
        String resource = "config/mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);

        // step2：创建一个 SqlSessionFactory 的对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        return sqlSessionFactory;
    }

    @Test
    public void testAddEmp() throws IOException {
        // 获取一个 SqlSessionFactory 的对象
        SqlSessionFactory sqlSessionFactory = Demo.getSqlSessionFactory();
        // 获取一个 SqlSession 的实例
        SqlSession session = sqlSessionFactory.openSession();
        try{
            EmpMapper empMapper = session.getMapper(EmpMapper.class);
            Long result = empMapper.addEmp(new Employee(null,"jarry", 4000.0, 33));
            System.out.println(result);
            // 增删改需要 commit
            session.commit();
        }finally {
            // step4：关闭 SqlSession 实例
            session.close();
        }
    }

    @Test
    public void testDeleteEmpById() throws IOException {
        // 获取一个 SqlSessionFactory 的对象
        SqlSessionFactory sqlSessionFactory = Demo.getSqlSessionFactory();
        // 获取一个 SqlSession 的实例
        SqlSession session = sqlSessionFactory.openSession();
        try{
            EmpMapper empMapper = session.getMapper(EmpMapper.class);
            Integer result = empMapper.deleteEmpById(5);
            System.out.println(result);
            // 增删改需要 commit
            session.commit();
        }finally {
            // step4：关闭 SqlSession 实例
            session.close();
        }
    }

    @Test
    public void testUpdateEmp() throws IOException {
        // 获取一个 SqlSessionFactory 的对象
        SqlSessionFactory sqlSessionFactory = Demo.getSqlSessionFactory();
        // 获取一个 SqlSession 的实例
        SqlSession session = sqlSessionFactory.openSession();
        try{
            EmpMapper empMapper = session.getMapper(EmpMapper.class);
            Boolean result = empMapper.updateEmp(new Employee(1,"jarry", 4000.0, 33));
            System.out.println(result);
            // 增删改需要 commit
            session.commit();
        }finally {
            // step4：关闭 SqlSession 实例
            session.close();
        }
    }

    @Test
    public void testGetEmpById() throws IOException {
        // 获取一个 SqlSessionFactory 的对象
        SqlSessionFactory sqlSessionFactory = Demo.getSqlSessionFactory();
        // 获取一个 SqlSession 的实例
        SqlSession session = sqlSessionFactory.openSession();
        try{
            EmpMapper empMapper = session.getMapper(EmpMapper.class);
            Employee result = empMapper.getEmpById(1);
            System.out.println(result);
            // 增删改需要 commit
            session.commit();
        }finally {
            // step4：关闭 SqlSession 实例
            session.close();
        }
    }
}

step3：测试截图
（1）添加一条数据

（2）删除一条数据

（3）更新一条数据

（4）查询一条数据

3、返回自增的主键（支持自增的数据库，比如mysql等）

　　需要使用 useGeneratedKeys（默认为false） 与 keyProperty（指定主键）。
　　mybatis 内部 会调用 getGeneratedKeys 方法并进行封装。

【对 测试 代码进行修改】
@Test
public void testAddEmp() throws IOException {
    // 获取一个 SqlSessionFactory 的对象
    SqlSessionFactory sqlSessionFactory = Demo.getSqlSessionFactory();
    // 获取一个 SqlSession 的实例
    SqlSession session = sqlSessionFactory.openSession();
    try{
        EmpMapper empMapper = session.getMapper(EmpMapper.class);
        Employee employee = new Employee(null,"tom", 4000.0, 33);
        System.out.println(employee);
        Long result = empMapper.addEmp(employee);
        System.out.println(employee);
        System.out.println(result);
        // 增删改需要 commit
        session.commit();
    }finally {
        // step4：关闭 SqlSession 实例
        session.close();
    }
}

不会自动返回主键。

增加 useGeneratedKeys 与 keyProperty。

【对sql映射文件进行修改】
<insert id="addEmp" useGeneratedKeys="true" keyProperty="id">
    INSERT INTO emp(emp.name, emp.salary, emp.age) VALUES (#{name}, #{salary}, #{age})
</insert>

会自动映射主键。

4、返回非自增的主键（使用mysql模拟非自增的数据库）

　　使用 selectKey 标签来指定。
　　创建一个表（不使用auto_increment定义自增主键）。

将sql映射文件的 表名 换为 emp2。进行增加数据操作。

<insert id="addEmp">
    INSERT INTO emp2(emp2.id, emp2.name, emp2.salary, emp2.age) VALUES (#{id}, #{name}, #{salary}, #{age})
</insert>

主键不会自动映射。

使用 selectKey ，可以指定 主键。 resultType 为返回值类型。 order 为 BEFORE|AFTER（决定什么时候执行）。

<insert id="addEmp">
    <selectKey keyProperty="id" order="BEFORE" resultType="Integer">
        SELECT max(id) + 10 FROM emp2
    </selectKey>
    INSERT INTO emp2(emp2.id, emp2.name, emp2.salary, emp2.age) VALUES (#{id}, #{name}, #{salary}, #{age})
</insert>

自动映射主键。

二、参数处理

1、单个参数

　　对于单个参数，直接使用 #{变量名} 即可获取。

【mapper.EmpMapper】
package mapper;

import entity.Employee;
import org.apache.ibatis.annotations.Select;

/**
 * 接口式编程，定义一系列方法，并根据方法映射到sql 的xml 文件中。
 * 其中，返回值类型可以是 Integer、Long、Boolean、void 、实体类
 */
public interface EmpMapper {
    public Employee getEmpById(Integer id);
}

【config/EmpMapper.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="mapper.EmpMapper">
    <select id="getEmpById" resultType="entity.Employee">
        SELECT * FROM emp WHERE emp.id = #{id}
    </select>
</mapper>

【test.Demo】
package test;

import entity.Employee;
import mapper.EmpMapper;
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 java.io.IOException;
import java.io.InputStream;

public class Demo {

    private static SqlSessionFactory getSqlSessionFactory() throws IOException {
        // step1：读取配置文件
        String resource = "config/mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);

        // step2：创建一个 SqlSessionFactory 的对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        return sqlSessionFactory;
    }

    @Test
    public void testGetEmpById() throws IOException {
        // 获取一个 SqlSessionFactory 的对象
        SqlSessionFactory sqlSessionFactory = Demo.getSqlSessionFactory();
        // 获取一个 SqlSession 的实例
        SqlSession session = sqlSessionFactory.openSession();
        try{
            EmpMapper empMapper = session.getMapper(EmpMapper.class);
            Employee result = empMapper.getEmpById(1);
            System.out.println(result);
            // 增删改需要 commit
            session.commit();
        }finally {
            // step4：关闭 SqlSession 实例
            session.close();
        }
    }
}

2、多个参数（少量）

　　对于多个参数，直接使用 #{变量名} 会抛出异常（可使用@param与之配合）。其内部会将其封装为一个map集合。

【mapper.EmpMapper】
package mapper;

import entity.Employee;
import org.apache.ibatis.annotations.Select;

/**
 * 接口式编程，定义一系列方法，并根据方法映射到sql 的xml 文件中。
 * 其中，返回值类型可以是 Integer、Long、Boolean、void 、实体类
 */
public interface EmpMapper {
    public Employee getEmpByIdAndName(Integer id, String name);
}

【config/EmpMapper.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="mapper.EmpMapper">

    <select id="getEmpByIdAndName" resultType="entity.Employee">
        SELECT * FROM emp WHERE emp.id = #{id} AND emp.name = #{name}
    </select>
</mapper>

【test.Demo】
package test;

import entity.Employee;
import mapper.EmpMapper;
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 java.io.IOException;
import java.io.InputStream;

public class Demo {

    private static SqlSessionFactory getSqlSessionFactory() throws IOException {
        // step1：读取配置文件
        String resource = "config/mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);

        // step2：创建一个 SqlSessionFactory 的对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        return sqlSessionFactory;
    }

    @Test
    public void testGetEmpByIdAndName() throws IOException {
        // 获取一个 SqlSessionFactory 的对象
        SqlSessionFactory sqlSessionFactory = Demo.getSqlSessionFactory();
        // 获取一个 SqlSession 的实例
        SqlSession session = sqlSessionFactory.openSession();
        try{
            EmpMapper empMapper = session.getMapper(EmpMapper.class);
            Employee result = empMapper.getEmpByIdAndName(1, "jack");
            System.out.println(result);
            // 增删改需要 commit
            session.commit();
        }finally {
            // step4：关闭 SqlSession 实例
            session.close();
        }
    }
}

參數名不对。修改如下

【config/EmpMapper.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="mapper.EmpMapper">

    <select id="getEmpByIdAndName" resultType="entity.Employee">
        SELECT * FROM emp WHERE emp.id = #{param1} AND emp.name = #{param2}
    </select>
</mapper>

若想使用 #{id} 等来获取参数， 可以使用 @param 注解并自定义名。

【mapper.EmpMapper.java】
package mapper;

import entity.Employee;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;

/**
 * 接口式编程，定义一系列方法，并根据方法映射到sql 的xml 文件中。
 * 其中，返回值类型可以是 Integer、Long、Boolean、void 、实体类
 */
public interface EmpMapper {
    public Employee getEmpByIdAndName(@Param("id") Integer id, @Param("name") String name);
}

【config/EmpMapper.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="mapper.EmpMapper">

    <select id="getEmpByIdAndName" resultType="entity.Employee">
        SELECT * FROM emp WHERE emp.id = #{id} AND emp.name = #{name}
    </select>
</mapper>

3、多个参数（过多）

　　对于参数过多的时候，在方法参数中一个个定义明显不可取。
　　此时可以传递一个 自定义类 或者 一个map 集合。

【mapper.EmpMapper】
package mapper;

import entity.Employee;
import org.apache.ibatis.annotations.Param;

import java.util.Map;

/**
 * 接口式编程，定义一系列方法，并根据方法映射到sql 的xml 文件中。
 * 其中，返回值类型可以是 Integer、Long、Boolean、void 、实体类
 */
public interface EmpMapper {
    public Employee getEmpByMap(Map<String, Object> map);
}

【config/EmpMapper.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="mapper.EmpMapper">

    <select id="getEmpByMap" resultType="entity.Employee">
        SELECT * FROM emp WHERE emp.id = #{id} AND emp.name = #{name}
    </select>
</mapper>

【test.Demo】
package test;

import entity.Employee;
import mapper.EmpMapper;
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 java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Map;

public class Demo {

    private static SqlSessionFactory getSqlSessionFactory() throws IOException {
        // step1：读取配置文件
        String resource = "config/mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);

        // step2：创建一个 SqlSessionFactory 的对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        return sqlSessionFactory;
    }

    @Test
    public void testGetEmpByMap() throws IOException {
        // 获取一个 SqlSessionFactory 的对象
        SqlSessionFactory sqlSessionFactory = Demo.getSqlSessionFactory();
        // 获取一个 SqlSession 的实例
        SqlSession session = sqlSessionFactory.openSession();
        try{
            EmpMapper empMapper = session.getMapper(EmpMapper.class);
            Map<String, Object> map = new HashMap<>();
            map.put("id", 1);
            map.put("name", "jack");
            Employee result = empMapper.getEmpByMap(map);
            System.out.println(result);
            // 增删改需要 commit
            session.commit();
        }finally {
            // step4：关闭 SqlSession 实例
            session.close();
        }
    }
}

4、对于List集合

　　可以使用 #{list[0]} 或者 #{collection[0]} 等格式来·获取参数。

【mapper.EmpMapper】
package mapper;

import entity.Employee;
import org.apache.ibatis.annotations.Param;

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

/**
 * 接口式编程，定义一系列方法，并根据方法映射到sql 的xml 文件中。
 * 其中，返回值类型可以是 Integer、Long、Boolean、void 、实体类
 */
public interface EmpMapper {
    public Employee getEmpByList(List<Integer> list);
}

【config/EmpMapper.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="mapper.EmpMapper">

    <select id="getEmpByList" resultType="entity.Employee">
        SELECT * FROM emp WHERE emp.id = #{collection[0]}
    </select>
</mapper>

【test.Demo】
package test;

import entity.Employee;
import mapper.EmpMapper;
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 java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;

public class Demo {

    private static SqlSessionFactory getSqlSessionFactory() throws IOException {
        // step1：读取配置文件
        String resource = "config/mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);

        // step2：创建一个 SqlSessionFactory 的对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        return sqlSessionFactory;
    }

    @Test
    public void testGetEmpByList() throws IOException {
        // 获取一个 SqlSessionFactory 的对象
        SqlSessionFactory sqlSessionFactory = Demo.getSqlSessionFactory();
        // 获取一个 SqlSession 的实例
        SqlSession session = sqlSessionFactory.openSession();
        try{
            EmpMapper empMapper = session.getMapper(EmpMapper.class);
            List<Integer> list = new ArrayList<>();
            list.add(1);
            list.add(2);
            list.add(3);
            Employee result = empMapper.getEmpByList(list);
            System.out.println(result);
            // 增删改需要 commit
            session.commit();
        }finally {
            // step4：关闭 SqlSession 实例
            session.close();
        }
    }
}

【或者config/EmpMapper.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="mapper.EmpMapper">

    <select id="getEmpByList" resultType="entity.Employee">
        SELECT * FROM emp WHERE emp.id = #{list[0]}
    </select>
</mapper>

5、#{} 与 ${} 的区别

　　使用 #{} 或者 ${} 都可以获取 参数的值。
　　但是 #{} 是以预编译的方式， 将参数设置到 sql 语句中。 类似于 PreparedStatement。
　　${} 是直接将值放在sql 语句中。类似于 Statement。

三、select的返回值映射处理--resultType

1、返回值类型为 List。

　　<select> 标签定义查询操作，
　　其中 id 唯一标识 sql（与接口的方法同名）。
　　resultType 为返回值类型。若返回的为List集合，则返回的为泛型而非 list。比如 List<Employee> ，则 resultType =“Employee”， 而非 resultType =“list”。

【mapper.EmpMapper】
package mapper;

import entity.Employee;

import java.util.List;

/**
 * 接口式编程，定义一系列方法，并根据方法映射到sql 的xml 文件中。
 * 其中，返回值类型可以是 Integer、Long、Boolean、void 、实体类
 */
public interface EmpMapper {
    public List<Employee> getAllEmp();
}

【config/EmpMapper.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="mapper.EmpMapper">
    <select id="getAllEmp" resultType="entity.Employee">
        SELECT * FROM emp
    </select>
</mapper>

【test.Demo】
package test;

import entity.Employee;
import mapper.EmpMapper;
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 java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class Demo {

    private static SqlSessionFactory getSqlSessionFactory() throws IOException {
        // step1：读取配置文件
        String resource = "config/mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);

        // step2：创建一个 SqlSessionFactory 的对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        return sqlSessionFactory;
    }

    @Test
    public void testGetEmpById() throws IOException {
        // 获取一个 SqlSessionFactory 的对象
        SqlSessionFactory sqlSessionFactory = Demo.getSqlSessionFactory();
        // 获取一个 SqlSession 的实例
        SqlSession session = sqlSessionFactory.openSession();
        try{
            EmpMapper empMapper = session.getMapper(EmpMapper.class);
            List<Employee> result = empMapper.getAllEmp();
            for(Employee emp : result){
                System.out.println(emp);
            }
        }finally {
            // step4：关闭 SqlSession 实例
            session.close();
        }
    }
}

2、返回值类型为map

　　若将一条数据返回为 map， 则 resultType = “map”。
　　若将多条数据返回为 map， 则 resultType = “value的类型”（需要使用@MapKey 指定key）。

【mapper.EmpMapper】
package mapper;

import entity.Employee;
import org.apache.ibatis.annotations.MapKey;

import java.util.Map;

/**
 * 接口式编程，定义一系列方法，并根据方法映射到sql 的xml 文件中。
 * 其中，返回值类型可以是 Integer、Long、Boolean、void 、实体类
 */
public interface EmpMapper {
    // 封装多条数据，且每个主键作为key，每条数据为 value
    @MapKey("id")
    public Map<Integer, Employee> getAllMap();

    // 封装一条数据，且每个字段名作为key，值为 value。
    public Map<String, Object> getEmpMap(Integer id);
}

【config/EmpMapper.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="mapper.EmpMapper">
    <select id="getAllMap" resultType="entity.Employee">
        SELECT * FROM emp
    </select>

    <select id="getEmpMap" resultType="map">
        SELECT * FROM emp WHERE id = #{id}
    </select>
</mapper>

【test.Demo】
package test;

import entity.Employee;
import mapper.EmpMapper;
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 java.io.IOException;
import java.io.InputStream;
import java.util.List;
import java.util.Map;

public class Demo {

    private static SqlSessionFactory getSqlSessionFactory() throws IOException {
        // step1：读取配置文件
        String resource = "config/mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);

        // step2：创建一个 SqlSessionFactory 的对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        return sqlSessionFactory;
    }

    @Test
    public void testGetAllMap() throws IOException {
        // 获取一个 SqlSessionFactory 的对象
        SqlSessionFactory sqlSessionFactory = Demo.getSqlSessionFactory();
        // 获取一个 SqlSession 的实例
        SqlSession session = sqlSessionFactory.openSession();
        try {
            EmpMapper empMapper = session.getMapper(EmpMapper.class);
            Map<Integer, Employee> result = empMapper.getAllMap();
            System.out.println(result);
        } finally {
            // step4：关闭 SqlSession 实例
            session.close();
        }
    }

    @Test
    public void testGetEmpMap() throws IOException {
        // 获取一个 SqlSessionFactory 的对象
        SqlSessionFactory sqlSessionFactory = Demo.getSqlSessionFactory();
        // 获取一个 SqlSession 的实例
        SqlSession session = sqlSessionFactory.openSession();
        try {
            EmpMapper empMapper = session.getMapper(EmpMapper.class);
            Map<String, Object> result = empMapper.getEmpMap(1);
            System.out.println(result);
        } finally {
            // step4：关闭 SqlSession 实例
            session.close();
        }
    }
}

四、select的返回值映射处理--resultMap

1、普通映射

　　使用resultMap 可以自定义结果集映射规则。使用 resultMap 与 resultType 时只能二选一。
　　比如：将 emp 的name 字段 修改为 last_name（但是实体类不做修改）。

【mapper.EmpMapper】
package mapper;

import entity.Employee;

import java.util.Map;

/**
 * 接口式编程，定义一系列方法，并根据方法映射到sql 的xml 文件中。
 * 其中，返回值类型可以是 Integer、Long、Boolean、void 、实体类
 */
public interface EmpMapper {
    public Employee getEmpById(Integer id);
}

【config/EmpMapper.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="mapper.EmpMapper">
    <select id="getEmpById" resultType="entity.Employee">
        SELECT * FROM emp WHERE id = #{id}
    </select>
</mapper>

【entity.Employee】
package entity;

import java.io.Serializable;

/**
 * 实体类
 */
public class Employee implements Serializable {
    private Integer id;
    private String name;
    private Double salary;
    private Integer age;

    public Employee() {
    }

    public Employee(Integer id, String name, Double salary, Integer age) {
        this.id = id;
        this.name = name;
        this.salary = salary;
        this.age = age;
    }

    public Integer getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public Double getSalary() {
        return salary;
    }

    public void setSalary(Double salary) {
        this.salary = salary;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", salary=" + salary +
                ", age=" + age +
                '}';
    }
}

【test.Demo】
package test;

import entity.Employee;
import mapper.EmpMapper;
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 java.io.IOException;
import java.io.InputStream;

public class Demo {

    private static SqlSessionFactory getSqlSessionFactory() throws IOException {
        // step1：读取配置文件
        String resource = "config/mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);

        // step2：创建一个 SqlSessionFactory 的对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        return sqlSessionFactory;
    }

    @Test
    public void testGetEmpByIdAndName() throws IOException {
        // 获取一个 SqlSessionFactory 的对象
        SqlSessionFactory sqlSessionFactory = Demo.getSqlSessionFactory();
        // 获取一个 SqlSession 的实例
        SqlSession session = sqlSessionFactory.openSession();
        try {
            EmpMapper empMapper = session.getMapper(EmpMapper.class);
            Employee result = empMapper.getEmpById(1);
            System.out.println(result);
        } finally {
            // step4：关闭 SqlSession 实例
            session.close();
        }
    }
}

使用 resultType 映射肯定会出现问题。

使用 resultMap 自定义映射规则， 将 last_name 映射到 name。

【config/EmpMapper.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="mapper.EmpMapper">
    <!--
        使用resultMap 定义一个自定义一个封装规则。
        id 用于唯一标识该规则。
        type 用于指定返回值类型
    -->
    <resultMap id="myEmp" type="entity.Employee">
        <!-- 使用 id 标签 用于指定主键，column 用于指定列，property 用于指定映射后的属性名 -->
        <id column="id" property="id"></id>
        <!-- result 用于指定 普通列 -->
        <result column="last_name" property="name"></result>
    </resultMap>
    <select id="getEmpById" resultMap="myEmp">
        SELECT * FROM emp WHERE id = #{id}
    </select>
</mapper>

2、关联映射 -- 级联查询

　　增加一个 department 表，并将其主键作为 emp 表的外键。

CREATE TABLE department(
    deptId INT(11) PRIMARY KEY AUTO_INCREMENT,
    deptName VARCHAR(255)
);

ALTER TABLE emp ADD COLUMN deptId INT(11);

ALTER TABLE emp ADD CONSTRAINT fk_emp_department
FOREIGN KEY(deptId) REFERENCES department(deptId)

使用 resultMap 将 查询的结果集 映射到 最终显示的结果集上。即（column -》 property）。
可以使用级联属性赋值。格式：A.B

【mapper.EmpMapper】
package mapper;

import entity.Employee;

/**
 * 接口式编程，定义一系列方法，并根据方法映射到sql 的xml 文件中。
 * 其中，返回值类型可以是 Integer、Long、Boolean、void 、实体类
 */
public interface EmpMapper {
    public Employee getEmpAndDeptById(Integer id);
}

【config/EmpMapper.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="mapper.EmpMapper">
    <resultMap id="myMap" type="entity.Employee">
        <id column="e_id" property="id"></id>
        <result column="e_name" property="name"></result>
        <result column="e_salary" property="salary"></result>
        <result column="e_age" property="age"></result>
        <result column="d_id" property="department.deptId"></result>
        <result column="d_name" property="department.deptName"></result>
    </resultMap>
    <select id="getEmpAndDeptById" resultMap="myMap">
        SELECT e.id e_id, e.last_name e_name, e.age e_age, e.salary e_salary, d.deptId d_id, d.deptName d_name
          FROM emp e, department d
         WHERE e.deptId = d.deptId
           AND e.id = #{id}
    </select>
</mapper>

【entity.Employee.java】
package entity;

import java.io.Serializable;

/**
 * 实体类
 */
public class Employee implements Serializable {
    private Integer id;
    private String name;
    private Double salary;
    private Integer age;
    private Department department;

    public Employee() {
    }

    public Employee(Integer id, String name, Double salary, Integer age) {
        this.id = id;
        this.name = name;
        this.salary = salary;
        this.age = age;
    }

    public Integer getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public Double getSalary() {
        return salary;
    }

    public void setSalary(Double salary) {
        this.salary = salary;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Department getDepartment() {
        return department;
    }

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

    @Override
    public String toString() {
        return "Employee{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", salary=" + salary +
                ", age=" + age +
                ", department=" + department +
                '}';
    }
}

【entity.Department.java】
package entity;

public class Department {
    private Integer deptId;
    private String deptName;

    public Integer getDeptId() {
        return deptId;
    }

    public void setDeptId(Integer deptId) {
        this.deptId = deptId;
    }

    public String getDeptName() {
        return deptName;
    }

    public void setDeptName(String deptName) {
        this.deptName = deptName;
    }

    @Override
    public String toString() {
        return "Department{" +
                "deptId=" + deptId +
                ", deptName='" + deptName + '\'' +
                '}';
    }
}

【test.Demo】
package test;

import entity.Employee;
import mapper.EmpMapper;
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 java.io.IOException;
import java.io.InputStream;

public class Demo {

    private static SqlSessionFactory getSqlSessionFactory() throws IOException {
        // step1：读取配置文件
        String resource = "config/mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);

        // step2：创建一个 SqlSessionFactory 的对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        return sqlSessionFactory;
    }

    @Test
    public void testGetEmpByIdAndName() throws IOException {
        // 获取一个 SqlSessionFactory 的对象
        SqlSessionFactory sqlSessionFactory = Demo.getSqlSessionFactory();
        // 获取一个 SqlSession 的实例
        SqlSession session = sqlSessionFactory.openSession();
        try {
            EmpMapper empMapper = session.getMapper(EmpMapper.class);
            Employee result = empMapper.getEmpAndDeptById(1);
            System.out.println(result);
        } finally {
            // step4：关闭 SqlSession 实例
            session.close();
        }
    }
}

3、关联映射 -- 使用association关联普通对象

　　除了级联属性赋值，可以使用 association 标签对关联的对象赋值。
　　对上例级联属性赋值代码进行修改。

【config/EmpMapper.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="mapper.EmpMapper">
    <resultMap id="myMap" type="entity.Employee">
        <id column="e_id" property="id"></id>
        <result column="e_name" property="name"></result>
        <result column="e_salary" property="salary"></result>
        <result column="e_age" property="age"></result>
        <!--
            property 用于指定 映射的属性
            JavaType 用于指定 映射的类型
         -->
        <association property="department" javaType="entity.Department">
            <result column="d_id" property="deptId"></result>
            <result column="d_name" property="deptName"></result>
        </association>
    </resultMap>
    <select id="getEmpAndDeptById" resultMap="myMap">
        SELECT e.id e_id, e.last_name e_name, e.age e_age, e.salary e_salary, d.deptId d_id, d.deptName d_name
          FROM emp e, department d
         WHERE e.deptId = d.deptId
           AND e.id = #{id}
    </select>
</mapper>

4、关联映射-- 分步查询 -- association

　　接着对上例进行修改。
　　使用 association 的 select 属性，可以调用 另外的sql 语句， 从而实现分步查询的操作。

【config/EmpMapper.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="mapper.EmpMapper">
    <resultMap id="myMap" type="entity.Employee">
        <id column="id" property="id"></id>
        <result column="last_name" property="name"></result>
        <result column="salary" property="salary"></result>
        <result column="age" property="age"></result>
        <association property="department" select="getDeptById" column="deptId">
        </association>
    </resultMap>
    <select id="getEmpAndDeptById" resultMap="myMap">
        SELECT * FROM emp WHERE id = #{id}
    </select>

    <select id="getDeptById" resultType="entity.Department">
        SELECT * FROM department WHERE deptId = #{deptId}
    </select>
</mapper>

5、关联映射 -- 关联集合对象 -- collection

　　比如映射的对象是个 list 集合。
　　使用 collection 标签定义集合类型的封装规则。其属性 ofType 为集合的泛型，property 为映射的属性名。

【entity.Department】
package entity;

import java.util.List;

public class Department {
    private Integer deptId;
    private String deptName;
    private List<Employee> employeeList;

    public Integer getDeptId() {
        return deptId;
    }

    public void setDeptId(Integer deptId) {
        this.deptId = deptId;
    }

    public String getDeptName() {
        return deptName;
    }

    public void setDeptName(String deptName) {
        this.deptName = deptName;
    }

    public List<Employee> getEmployeeList() {
        return employeeList;
    }

    public void setEmployeeList(List<Employee> employeeList) {
        this.employeeList = employeeList;
    }

    @Override
    public String toString() {
        return "Department{" +
                "deptId=" + deptId +
                ", deptName='" + deptName + '\'' +
                ", employeeList=" + employeeList +
                '}';
    }
}

【mapper.EmpMapper.java】
package mapper;

import entity.Department;

/**
 * 接口式编程，定义一系列方法，并根据方法映射到sql 的xml 文件中。
 * 其中，返回值类型可以是 Integer、Long、Boolean、void 、实体类
 */
public interface EmpMapper {
    public Department getDeptById(Integer id);
}

【config/EmpMapper.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="mapper.EmpMapper">

    <resultMap id="myMap" type="entity.Department">
        <id column="deptId" property="deptId"></id>
        <result column="deptName" property="deptName"></result>
        <!--
            collection 标签用于定义集合类型的封装规则。
            ofType 为集合的泛型
            property 为映射的属性名
        -->
        <collection property="employeeList" ofType="entity.Employee">
            <id column="e_id" property="id"></id>
            <result column="e_name" property="name"></result>
            <result column="e_salary" property="salary"></result>
            <result column="e_age" property="age"></result>
        </collection>
    </resultMap>
    <select id="getDeptById" resultMap="myMap">
        SELECT d.deptId deptId, d.deptName deptName, e.id e_id, e.last_name e_name, e.age e_age, e.salary e_salary
          FROM  department d
     LEFT JOIN emp e
            ON  e.deptId = d.deptId
         WHERE d.deptId = #{id}
    </select>
</mapper>

【test.Demo】
package test;

import entity.Department;
import entity.Employee;
import mapper.EmpMapper;
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 java.io.IOException;
import java.io.InputStream;

public class Demo {

    private static SqlSessionFactory getSqlSessionFactory() throws IOException {
        // step1：读取配置文件
        String resource = "config/mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);

        // step2：创建一个 SqlSessionFactory 的对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        return sqlSessionFactory;
    }

    @Test
    public void testGetDeptById() throws IOException {
        // 获取一个 SqlSessionFactory 的对象
        SqlSessionFactory sqlSessionFactory = Demo.getSqlSessionFactory();
        // 获取一个 SqlSession 的实例
        SqlSession session = sqlSessionFactory.openSession();
        try {
            EmpMapper empMapper = session.getMapper(EmpMapper.class);
            Department result = empMapper.getDeptById(1);
            System.out.println(result);
            for(Employee employee : result.getEmployeeList()){
                System.out.println(employee);
            }
        } finally {
            // step4：关闭 SqlSession 实例
            session.close();
        }
    }
}

6、关联映射-- 分步查询 -- collection

　　对上例代码稍作修改。即可实现分步查询。

【config/EmpMapper.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="mapper.EmpMapper">

    <resultMap id="myMap" type="entity.Department">
        <id column="deptId" property="deptId"></id>
        <result column="deptName" property="deptName"></result>
        <collection property="employeeList" select="getEmpByDeptId" column="deptId">
            <id column="e_id" property="id"></id>
            <result column="e_name" property="name"></result>
            <result column="e_salary" property="salary"></result>
            <result column="e_age" property="age"></result>
        </collection>
    </resultMap>
    <select id="getDeptById" resultMap="myMap">
        SELECT * FROM department WHERE deptId = #{id}
    </select>

    <select id="getEmpByDeptId" resultType="entity.Employee">
        SELECT * FROM emp WHERE deptId = #{deptId}
    </select>
</mapper>

注：
　　对于 collection 与 association的分步查询操作。

【若想传递多个参数，格式为：】
    column="{key1 = value1, key2 = value2}"

【使用时格式】
    #{key1}  或者 #{key2}

7、关联映射 -- 鉴别器 -- discriminator

　　使用鉴别器 discriminator， 可以监控某个列的值，并根据不同的值执行不同的行为。

　　如下例：对于 deptId =1 的数据，将部门名改为 1。对于 deptId =2 的数据，部门名不变。

【mapper.EmpMapper】
package mapper;

import entity.Department;

import java.util.List;

/**
 * 接口式编程，定义一系列方法，并根据方法映射到sql 的xml 文件中。
 * 其中，返回值类型可以是 Integer、Long、Boolean、void 、实体类
 */
public interface EmpMapper {
    public List<Department> getDeptById(Integer id);
}

【config/EmpMapper.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="mapper.EmpMapper">

    <resultMap id="myMap" type="entity.Department">
        <!--
            discriminator 标签为鉴别器，可以根据某列的值执行不同的行为
            javaType 指定某列的值的类型
            column 用于指定某列
        -->
        <discriminator javaType="Integer" column="deptId">
            <case value="1" resultType="entity.Department">
                <id column="deptId" property="deptId"></id>
                <id column="deptId" property="deptName"></id>
            </case>
            <case value="2" resultType="entity.Department">
                <id column="deptId" property="deptId"></id>
                <result column="deptName" property="deptName"></result>
            </case>
        </discriminator>
    </resultMap>
    <select id="getDeptById" resultMap="myMap">
        SELECT * FROM department
    </select>
</mapper>

【test.Demo】
package test;

import entity.Department;
import entity.Employee;
import mapper.EmpMapper;
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 java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class Demo {

    private static SqlSessionFactory getSqlSessionFactory() throws IOException {
        // step1：读取配置文件
        String resource = "config/mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);

        // step2：创建一个 SqlSessionFactory 的对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        return sqlSessionFactory;
    }

    @Test
    public void testGetDeptById() throws IOException {
        // 获取一个 SqlSessionFactory 的对象
        SqlSessionFactory sqlSessionFactory = Demo.getSqlSessionFactory();
        // 获取一个 SqlSession 的实例
        SqlSession session = sqlSessionFactory.openSession();
        try {
            EmpMapper empMapper = session.getMapper(EmpMapper.class);
            List<Department> result = empMapper.getDeptById(1);
            System.out.println(result);
        } finally {
            // step4：关闭 SqlSession 实例
            session.close();
        }
    }
}