入门案例

现有一张数据表：

mysql> use mybatis;
Database changed
mysql> select * from tbl_employee;
+----+-----------+--------+-------------+
| id | last_name | gender | email       |
+----+-----------+--------+-------------+
|  1 | tom       | 0      | tom@163.com |
+----+-----------+--------+-------------+
1 row in set (0.00 sec)

该如何通过MyBatis对其进行查询？

首先创建对应的Java类：

package com.wwj.mybatis.bean;

public class Employee {
    
    private Integer id;
    private String lastName;
    private String email;
    private String gender;
    
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getLastName() {
        return lastName;
    }
    public void setLastName(String lastName) {
        this.lastName = lastName;
    }
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }
    public String getGender() {
        return gender;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }
    
    @Override
    public String toString() {
        return "Employee [id=" + id + ", lastName=" + lastName + ", email=" + email + ", gender=" + gender + "]";
    }
}

其次编写MyBatis的全局配置文件(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>
     <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
                  <dataSource type="POOLED">
                    <property name="driver" value="com.mysql.jdbc.Driver"/>
                    <property name="url" value="jdbc:mysql:///mybatis"/>
                      <property name="username" value="root"/>
                    <property name="password" value="123456"/>
                  </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="EmployeeMapper.xml"/>
    </mappers>
</configuration>

全局配置文件中主要配置的是数据源信息，然后是最后的mappers标签，该标签配置的是sql语句的映射文件。

所以我们接着创建sql语句的映射文件(EmployeeMapper.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.wwj.mybatis.bean.Employee">
     <select id="selectEmp" resultType="com.wwj.mybatis.bean.Employee">
        select id,last_name lastName,email,gender from tbl_employee where id = #{id}
      </select>
</mapper>

其中mapper标签的namespace属性设置的是需要映射的类全名；select标签表示查询语句，其中的id属性是该sql的唯一标识，resultType表示返回值的类型；然后在select标签中编写需要执行的sql语句。

一切准备就绪后，开始编写测试代码：

@Test
void test() throws IOException {
    String resource = "mybatis-config.xml";
    InputStream inputStream = Resources.getResourceAsStream(resource);
    SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    SqlSession session = sessionFactory.openSession();
    Employee employee = session.selectOne("com.wwj.mybatis.bean.Employee.selectEmp",1);
    System.out.println(employee);
    session.close();
}

通过全局的配置文件去创建一个SqlSessionFactory，并通过该对象获得SqlSession，就可以使用SqlSession进行增删改查了。这里调用了selectOne方法，表示从数据表中查询一行数据，其中的第一个参数需要填入刚才在sql映射文件中设置的id，但为了避免该id与其它sql语句重复，一般都会在id前加上namespace；第二个参数则是需要传入sql的参数。

增删改查的新方式

在入门案例中我们已经成功通过MyBatis查询了数据表的数据，但是这种方式的缺点也是显而易见的，为此，MyBatis提供了一种更加完美的方式来操作数据表。

定义一个接口：

package com.wwj.mybatis.dao;

public interface EmployeeMapper {
    
    public Employee getEmpById(Integer id);
}

MyBatis神奇的地方就在于你不需要去实现该接口，只需要将该接口与对应的sql映射文件绑定即可，MyBatis会自动创建代理对象调用对应的方法。

所以我们需要对sql的映射文件做一个小小的改动：

<?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.wwj.mybatis.dao.EmployeeMapper">
     <select id="getEmpById" resultType="com.wwj.mybatis.bean.Employee">
        select id,last_name lastName,email,gender from tbl_employee where id = #{id}
      </select>
</mapper>

首先是namespace，现在该属性应该指向的是接口的全类名；然后是select标签的id属性，该属性也应该指向接口中对应的方法名，其它地方不变。

测试代码：

@Test
void test2() throws IOException{
    String resource = "mybatis-config.xml";
    InputStream inputStream = Resources.getResourceAsStream(resource);
    SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    SqlSession session = sessionFactory.openSession();
    //Mybatis会为接口自动创建代理对象，并由代理对象执行增删改查
    EmployeeMapper mapper = session.getMapper(EmployeeMapper.class);
    Employee employee = mapper.getEmpById(1);
    System.out.println(employee);
    session.close();
}

这里同样是通过全局配置文件创建SqlSessionFactory，并通过该对象获得SqlSession，不同的是，这里需要通过SqlSession对象调用getMapper方法去获得指定的接口的实现类，该实现类是MyBatis自动生成的代理对象，并通过该对象调用指定的方法完成数据表的操作。

通过properties标签引入外部属性文件

这个操作已经是再熟悉不过了，这里直接贴出代码：

<?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标签引入外部的属性文件内容 -->
    <properties resource="dbconfig.properties"></properties>
    
     <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
                  <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>
    <mappers>
        <mapper resource="EmployeeMapper.xml"/>
    </mappers>
</configuration>

typeAliases

这是一个全局配置文件的标签，通过该标签能够为某个Java类型设置别名，比如：

<typeAliases>
    <!-- type:指定要起别名的类型全类名，默认别名为类名字母小写:employee 
         也可以使用alias属性为其设置指定的别名
    -->
    <typeAlias type="com.wwj.mybatis.bean.Employee" alias="employee"/>
</typeAliases>

这样我们就可以修改sql映射文件中的返回值类型：

<select id="getEmpById" resultType="employee">
    select * from tbl_employee where id = #{id}
</select>

该标签还能够批量起别名，比如：

<typeAliases>
    <!-- 
        批量起别名
        name:指定包名(为当前包及其子包下的所有类都起一个默认别名) 
    -->
    <package name="com.wwj.mybatis.bean"/>
</typeAliases>

若是子包下也有一个重名的类，则MyBatis会因为别名重复而报错，为此，可以通过@Alias注解在类上设置新的别名。

environments

全局配置文件标签，可以通过其子标签environment配置多种环境，比如：

<environments default="development">
    <environment id="development">
        <transactionManager type="JDBC"/>
            <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>
        
    <environment id="test">
        <transactionManager type="JDBC"></transactionManager>
        <dataSource type="POOLED"></dataSource>
    </environment>
</environments>

environment需要配置两个子标签：transactionManager和dataSource，否则就会报错。

transactionManager标签的type属性可以指定两个属性值：

JDBC：这个配置直接使用了 JDBC 的提交和回滚设施，它依赖从数据源获得的连接来管理事务作用域
MANAGED：这个配置几乎没做什么。它从不提交或回滚一个连接，而是让容器来管理事务的整个生命周期(比如 JEE 应用服务器的上下文)，默认情况下它会关闭连接

dataSource标签的type属性可以指定三个属性值：

UNPOOLED ：这个数据源的实现会每次请求时打开和关闭连接。虽然有点慢，但对那些数据库连接可用性要求不高的简单应用程序来说，是一个很好的选择。性能表现则依赖于使用的数据库，对某些数据库来说，使用连接池并不重要，这个配置就很适合这种情形。
POOLED：这种数据源的实现利用“池”的概念将 JDBC 连接对象组织起来，避免了创建新的连接实例时所必需的初始化和认证时间。这种处理方式很流行，能使并发 Web 应用快速响应请求
JNDI：这个数据源实现是为了能在如 EJB 或应用服务器这类容器中使用，容器可以集中或在外部配置数据源，然后放置一个 JNDI 上下文的数据源引用

mappers

sql映射文件标签，用于将sql映射注册到全局配置中，比如：

<mappers>
    <mapper resource="EmployeeMapper.xml"/>
</mappers>

使用子标签mapper注册一个sql映射。

mapper还有一个用法，就是注册接口，比如：

<mappers>
    <mapper class="com.wwj.mybatis.dao.EmployeeMapper"/>
</mappers>

需要注意的是，若要通过这样的方式注册接口，则需要将该sql映射文件名设置为与接口名一致，并与接口放在同一目录下。

mappers同样支持批量注册，使用package标签即可，若使用批量注册，sql映射文件也需要与接口同目录，否则MyBatis将无法找到文件而报错。

增删改查

熟悉了MyBatis配置文件中的一些标签后，我们来看看MyBatis是如何实现增删改查操作的？

插入数据

仿照着实现查询的方式，我们很容易写出增删改查，先修改接口：

package com.wwj.mybatis.dao;

public interface EmployeeMapper {
    
    public Employee getEmpById(Integer id);
    
    public void addEmp(Employee employee);
    
    public void updateEmp(Employee employee);
    
    public void deleteEmp(Integer id);
}

在接口中新添加了三个方法，分别对应着增删改。

然后修改sql映射文件：

<?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.wwj.mybatis.dao.EmployeeMapper">
     <select id="getEmpById" resultType="employee">
        select * from tbl_employee where id = #{id}
      </select>
      
      <insert id="addEmp" parameterType="com.wwj.mybatis.bean.Employee">
          insert into tbl_employee(last_name,email,gender) values(#{lastName},#{email},#{gender})
      </insert>
      
      <update id="updateEmp">
          update tbl_employee set last_name = #{lastName},email = #{email},gender = #{gender} where id = #{id}
      </update>
      
      <delete id="deleteEmp">
          delete from tbl_employee where id = #{id}
      </delete>
</mapper>

这已经很简单了，无需做过多解释，唯一要说的是parameterType属性，该属性的作用是指定方法参数的类型，该属性可以省略不写。这样准备工作就完成了，来测试一下：

@Test
void test3() throws IOException{
    String resource = "mybatis-config.xml";
    InputStream inputStream = Resources.getResourceAsStream(resource);
    SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    SqlSession session = sessionFactory.openSession();
    EmployeeMapper mapper = session.getMapper(EmployeeMapper.class);
    Employee employee = new Employee(null,"Jack","jack@163.com","1");
    mapper.addEmp(employee);
    session.commit();
    session.close();
}

需要注意的是，SqlSession是不会自动提交数据的，所以在进行增删改操作的时候，最后一定要记得提交。

删除数据

做删除操作只需要改变一下调用的方法即可：

@Test
void test3() throws IOException{
    String resource = "mybatis-config.xml";
    InputStream inputStream = Resources.getResourceAsStream(resource);
    SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    SqlSession session = sessionFactory.openSession();
    EmployeeMapper mapper = session.getMapper(EmployeeMapper.class);
    mapper.deleteEmp(2);
    session.commit();
    session.close();
}

修改数据

修改数据同样是这样：

@Test
void test3() throws IOException{
    String resource = "mybatis-config.xml";
    InputStream inputStream = Resources.getResourceAsStream(resource);
    SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    SqlSession session = sessionFactory.openSession();
    EmployeeMapper mapper = session.getMapper(EmployeeMapper.class);
    Employee employee = new Employee(1,"Jack","jack@163.com","0");
    mapper.updateEmp(employee);
    session.commit();
    session.close();
}

Mybatis还直接允许增删改操作直接定义以下返回值：Integer、Long、Boolean，直接在接口方法上定义即可，比如：

public interface EmployeeMapper {
    
    public Long addEmp(Employee employee);
}

查询数据

查询就不说了，入门案例已经写过了。

获取自增主键的值

MyBatis支持获取自增主键的值，而且非常方便：

<insert id="addEmp" useGeneratedKeys="true" keyProperty="id">
      insert into tbl_employee(last_name,email,gender) values(#{lastName},#{email},#{gender})
</insert>

只需要设置useGeneratedKeys属性值为true即可，MyBatis就会将主键的值封装到keyProperty属性指定的参数中，这里指定了id，表示将自增主键的值获取出来并存入Employee对象的id属性中，接下来要想获取主键的值就可以直接获取该对象的id属性了。

参数处理

下面介绍一下MyBatis对于参数的处理，在前面的案例中，我们都是通过#{参数名}的方式来获取参数，而事实上，对于单个的参数，MyBatis不会对其进行特殊处理，这个参数名是可以随便写的，写个a、b、c都可以，比如：

<select id="getEmpById" resultType="employee">
    select * from tbl_employee where id = #{aaa}
</select>

那么对于多参数的方法该如何处理呢？

package com.wwj.mybatis.dao;

public interface EmployeeMapper {
    
    //新增一个多参数的方法
    public Employee getEmpByIdAndLastName(String id,String lastName);
    
    public Employee getEmpById(Integer id);
    
    public void addEmp(Employee employee);
    
    public void updateEmp(Employee employee);
    
    public void deleteEmp(Integer id);
}

在接口中新增一个getEmpByIdAndLastName方法，并添加对应的sql配置：

<select id="getEmpByIdAndLastName" resultType="employee">
     select * from tbl_employee where id = #{id} and last_name = #{lastName}
</select>

可能大家会想当然地这样写，但告诉大家，这样是错误的。

MyBatis会对多个参数进行特殊处理，将这些参数封装成一个map，所以我们需要从map中取值，如下：

<select id="getEmpByIdAndLastName" resultType="employee">
     select * from tbl_employee where id = #{param1} and last_name = #{param2}
</select>

MyBatis有着自己的封装规则，它将传递过来的参数封装到map中，指定键为：param1、param2、param3．．．，而这些键对应的就是我们需要取出的值。

当然，你也可以这样写：

<select id="getEmpByIdAndLastName" resultType="employee">
     select * from tbl_employee where id = #{0} and last_name = #{1}
</select>

通过索引获取map中的值。

命名参数

这两种获取参数方式的缺点是显而易见的，当参数足够多时，这样的参数名会使开发者眼花缭乱，为此，我们应该使用命名参数的方式进行参数值的获取。

这里需要借助@Param注解对map的键重命名：

//新增一个多参数的方法
public Employee getEmpByIdAndLastName(@Param("id")String id,@Param("lastName")String lastName);

这样我们就能直接通过指定的参数名从map中获取值了：

<select id="getEmpByIdAndLastName" resultType="employee">
     select * from tbl_employee where id = #{id} and last_name = #{lastName}
</select>

处理POJO

若是传入的参数过多，而且正好符合业务逻辑的模型对象，我们就可以直接传入POJO，在取出数据值的时候就可以直接使用POJO的属性名：#{POJO属性名}。

而如果多个参数并不符合模型对象，为了方便，我们也可以自己将其封装成一个map，比如：

//新增一个多参数的方法
public Employee getEmpByIdAndLastName(Map<String, Object> map);

那么你在传递参数的时候就需要传递一个map：

@Test
void test4() throws IOException{
    String resource = "mybatis-config.xml";
    InputStream inputStream = Resources.getResourceAsStream(resource);
    SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    SqlSession session = sessionFactory.openSession();
    //Mybatis会为接口自动创建代理对象，并由代理对象执行增删改查
    EmployeeMapper mapper = session.getMapper(EmployeeMapper.class);
    Map<String, Object> map = new HashMap<String, Object>();
    map.put("id", "1");
    map.put("lastName", "Jack");
    Employee employee = mapper.getEmpByIdAndLastName(map);
    System.out.println(employee);
    session.close();
}

而在取出map数据的时候就可以直接通过键获取：

<select id="getEmpByIdAndLastName" resultType="employee">
     select * from tbl_employee where id = #{id} and last_name = #{lastName}
</select>

特别需要注意的是，Mybatis会对Collection类型及数组做特殊处理，比如：

public Employee getEmpById(List<Integer> ids);

该参数是一个id的集合，若是想从该集合中获取第一个id的值，则需要#{list[0]}。

因为对于Collection类型，包括：Collection、List、Set，MyBatis都会将其封装到map中，其对应的键为collection，如果是List类型，还可以使用list作为键，数组的键为array。

{}与${}的区别

MyBatis中除了可以使用#{}取值外，还可以使用${},它们的用法是相同的，那么这两种方式到底有什么区别呢？

我分别用#{}和${}进行取值，并执行测试代码，下面是运行结果：

DEBUG 04-16 13:46:27,992 ==>  Preparing: select * from tbl_employee where id = ? and last_name = ?   (BaseJdbcLogger.java:145)

DEBUG 04-16 14:31:13,054 ==>  Preparing: select * from tbl_employee where id = 1 and last_name = Jack   (BaseJdbcLogger.java:145)

会发现，两者的区别在于，${}会将传递的参数显示到生成的sql语句上。

select元素

select标签用来定义查询操作，其中有三个比较重要的参数：

id：唯一标识符，用来引用这条语句，需要与接口的方法名一致
parameterType：参数类型，可以不传，MyBatis会根据TypeHandler自动判断
resultType：返回值类型，别名或者全类名，如果返回的是集合，则写的是集合中元素的类型；不能与resultMap同时使用

在前面的案例中，我们已经使用过select标签，接下来让我们深入了解一下该标签。

比如在接口中定义这样的一个方法：

public List<Employee> getEmpsByLastNameLike(String lastName);

该方法的返回值是集合类型，那么在编写sql配置的时候就得这样写：

<select id="getEmpsByLastNameLike" resultType="employee">
     select * from tbl_employee where last_name like #{lastName}
</select>

resultType写的是集合中的元素类型。

若凡返回值是map类型，比如：

public Map<String,Object> getEmpMapById(Integer id);

sql配置应该这样写：

<select id="getEmpMapById" resultType="map">
     select * from tbl_employee where id = #{id}
</select>

resultType写的是map，为什么能够直接写map而不用写全类名，因为MyBatis已经帮我们取好了别名。

通过这样的方式，MyBatis会将表中的列名和记录作为键和值一一封装到map中。

我们还可以通过返回map来查询表中的某一行数据，并直接将其封装成对象返回：

@MapKey("id")
public Map<Integer,Employee> getEmpByLastNameLike(String lastName);

该方法能将查询到的每一行数据封装成一个对象，其键由@MapKey注解指定，比如这里是指定以id为键，接下来是sql配置：

<select id="getEmpByLastNameLike" resultType="employee">
     select * from tbl_employee where last_name like #{lastName}
</select>

resultType同样是集合元素类型，但是通过该sql查询返回的结果将是以id为键，对应的行数据为值的map集合。

当然，select标签可不止id、parameterType和resultType这三个参数，下面介绍一下该标签的一些其它参数。

resultMap

我们知道，通过resultType指定返回值类型后，MyBatis会自动将得到的数据封装进去，然而当数据表的列名和返回值属性不一致时，就会导致封装失败，这时候我们会有两种办法：一种就是设置别名；另一种就是使用resultMap来自定义返回值类型。

比如：

public Employee getEmpById(Integer id);

按照之前的写法，应该是这样：

<select id="getEmpById" resultType="employee">
    select * from tbl_employee where id = #{id}
 </select>

但现在，倘若Employee类中的某些属性名和表中的列名并不一致，此时MyBatis将无法进行自动封装，我们就需要通过resultMap来自定义封装规则。

<!-- 自定义某个JavaBean的封装规则 -->
<resultMap type="employee" id="emp">
    <!-- 
         指定主键列的封装规则
         column:指定哪一列
         property:指定对应的JavaBean属性 
     -->
     <id column="id" property="id"/>
     <!-- 指定非主键列的封装规则 -->
         <result column="last_name" property="lastName"/>
         <result column="email" property="email"/>
         <result column="gender" property="gender"/>
     </resultMap>
 
<select id="getEmpById" resultMap="emp">
    select * from tbl_employee where id = #{id}
</select>

事实上，对于主键列，你也可以使用result标签来指定规则，但是使用id标签的好处就是MyBatis会知道该属性是主键从而自动设置一些功能，对于一些属性名和列名已经一致的属性，你也可以不进行自定义，MyBatis还是会自动进行封装的。

resultMap可以用来解决数据表的联合查询问题，现有两张数据表，一张员工表：

+-----------+--------------+------+-----+---------+----------------+
| Field     | Type         | Null | Key | Default | Extra          |
+-----------+--------------+------+-----+---------+----------------+
| id        | int(11)      | NO   | PRI | NULL    | auto_increment |
| last_name | varchar(255) | YES  |     | NULL    |                |
| gender    | char(1)      | YES  |     | NULL    |                |
| email     | varchar(255) | YES  |     | NULL    |                |
| d_id      | int(11)      | YES  | MUL | NULL    |                |
+-----------+--------------+------+-----+---------+----------------+

一张部门表：

+-----------+--------------+------+-----+---------+----------------+
| Field     | Type         | Null | Key | Default | Extra          |
+-----------+--------------+------+-----+---------+----------------+
| id        | int(11)      | NO   | PRI | NULL    | auto_increment |
| dept_name | varchar(255) | YES  |     | NULL    |                |
+-----------+--------------+------+-----+---------+----------------+

其中员工表的d_id列与部门表的id列存在外键约束关系。

若有这样的需求，查询员工表的某位员工信息，同时查出它的部门信息，该需求涉及到联合查询的问题，resultMap则能够很好地解决这一问题。

首先我们创建两张数据表对应的类，员工类：

package com.wwj.mybatis.bean;

public class Employee {
    
    private Integer id;
    private String lastName;
    private String email;
    private String gender;
    private Department department;
    
    public Employee() {
        
    }

    public Department getDepartment() {
        return department;
    }

    public void setDepartment(Department department) {
        this.department = department;
    }
    
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getLastName() {
        return lastName;
    }
    public void setLastName(String lastName) {
        this.lastName = lastName;
    }
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }
    public String getGender() {
        return gender;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }
}

部门类：

package com.wwj.mybatis.bean;

public class Department {
    
    private Integer id;
    private String departmentName;
    
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getDepartmentName() {
        return departmentName;
    }
    public void setDepartmentName(String departmentName) {
        this.departmentName = departmentName;
    }
}

那么接下来就非常简单了，在接口中定义查询方法：

public Employee getEmpAndDept(Integer id);

编写sql配置：

<resultMap type="employee" id="empy">
     <id column="id" property="id"/>
     <result column="last_name" property="lastName"/>
     <result column="gender" property="gender"/>
     <result column="did" property="dept.id"/>
     <result column="dept_name" property="dept.departmentName"/>
</resultMap>
<select id="getEmpAndDept" resultMap="empy">
    select * from tbl_employee e,tbl_dept d where e.d_id=d.id and e.id=#{id}
</select>

这里通过级联属性为部门类的属性定义规则。

除了级联属性，你也可以使用association标签来定义规则：

<resultMap type="employee" id="empy">
     <id column="id" property="id"/>
     <result column="last_name" property="lastName"/>
     <result column="gender" property="gender"/>
     <!-- 
         association可以指定联合的Java对象
        property:指定哪个属性为联合的Java对象
        javaType:指定联合Java对象的类型
    -->
     <association property="dept" javaType="com.wwj.mybatis.bean.Department">
         <id column="did" property="id"/>
         <result column="dept_name" property="departmentName"/>
     </association>
</resultMap>
<select id="getEmpAndDept" resultMap="empy">
     select * from tbl_employee e,tbl_dept d where e.d_id=d.id and e.id=#{id}
</select>

而有些情况，我们在查询员工信息的时候并不需要查询它的部门信息，此时可以使用延迟加载，实现非常简单，在MyBatis的配置文件中进行两个配置即可：

<settings>
    <setting name="lazyLoadingEnabled" value="true"></setting>
    <setting name="aggressiveLazyLoading" value="false"/>
</settings>

此时当我们不去查询员工的部门信息时，Mybatis就不会发送sql去查询部门表，避免了资源的浪费。

而当查询对象中包含集合数据时，比如：

package com.wwj.mybatis.bean;

public class Department {
    
    private Integer id;
    private String departmentName;
    private List<Employee> emps;
    
    public List<Employee> getEmps() {
        return emps;
    }
    public void setEmps(List<Employee> emps) {
        this.emps = emps;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer 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 + ", emps=" + emps + "]";
    }
}

一个部门包含若干员工，这些员工将封装到一个集合中，该如何对其进行处理呢？

在接口中定义方法：

public Department getDeptById(Integer id);

sql配置：

<resultMap type="com.wwj.mybatis.bean.Department" id="MyDept">
     <id column="did" property="id"/>
     <result column="dept_name" property="departmentName"/>
     <collection property="emps" ofType="com.wwj.mybatis.bean.Employee">
         <!-- 定义集合中的元素封装规则 -->
         <id column="eid" property="id"/>
         <result column="last_name" property="lastName"/>
         <result column="email" property="email"/>
         <result column="gender" property="gender"/>
     </collection>
 </resultMap>
 <!-- 查询部门的时候将部门对应的所有员工信息查询出来 -->
 <select id="getDeptById" resultMap="MyDept">
     SELECT * FROM tbl_dept d LEFT JOIN tbl_employee e ON d.id=e.d_id WHERE d.id=#{id} 
 </select>

其中collection用于定义集合中的元素封装规则，ofType属性指定集合的元素类型。

轻松掌握Mybatis(上)