Mybatis3详解（十一）----延迟加载

1、N+1问题

N+1问题主要是针对分步查询，分步查询就是使用association或collection标签中的select属性来执行另外一个 SQL 映射语句来返回预期的复杂类型，例如：

<association property="department" column="department_id" javaType="department" select="com.thr.mapper.DepartmentMapper.selectDeptByDeptId"/>

在前面的代码中（分步查询），我们所有的级联都已经成功了，但是这样会引发性能问题，就是我们查询数据时，级联的数据也会跟着全部查询出来。但是如果我们暂时只需要部门的信息，而不需要级联对象中的信息，这就会使数据库多执行几条毫无意义的SQL，导致数据库资源的损耗和系统性能的下降。而如果有多重级联的话则会更加明显，假如现在有N个级联，本来我们只要查询主数据，只要一次查询就可以了，但是由于级联的关系，其级联的数据也会跟着查询出来，后面的SQL语句还会执行N次，这样就造成了N+1问题。

以前面员工和部门的例子举例：我们本来要的是部门数据，根据部门id查询部门信息，但是由于一个部门可以有多个员工，级联数据会跟着查询出来，假如现在有N个员工，那么查询的语句如下：

根据部门id查询
SELECT * FROM t_department WHERE department_id = #{id}

级联的查询(分步查询)：
SELECT * FROM t_employee where department_id= 1
SELECT * FROM t_employee where department_id= 2
SELECT * FROM t_employee where department_id= 3
......
SELECT * FROM t_employee where department_id= n-1
SELECT * FROM t_employee where department_id= n

本来我们只需要部门的一条数据即可，但是查询了N+1次，这是不合理的。那么为了应对N+1问题，Mybatis提供了延迟加载功能。

2、什么是延迟加载

延迟加载也叫做懒加载、惰性加载。就是我们希望一次性把常用的级联数据通过SQL直接查询出来，对于那些不想要的级联数据则不要取出，而是等待要用的时候才取出来。在mybatis中，resultMap可以实现高级映射(使用association、collection实现一对一及一对多映射)，association、collection具备延迟加载功能。

3、如何开启延迟加载

开启延迟加载有两种方式：

①、全局配置延迟加载：这种方式就是给所有的级联配置延迟加载。Mybatis默认是不开启延迟加载的，需要我们去全局配置文件中打开延迟加载。

注意：这个aggressiveLazyLoading有点不好理解，下面会有介绍。

全局配置如下：

<settings>
    <!-- 开启延迟加载，不配置默认关闭该特性-->
    <setting name="lazyLoadingEnabled" value="true"></setting>
    <setting name="aggressiveLazyLoading" value="false"/>
</settings>

②、fetchType属性为局部配置延迟加载：这种方式需要用到fetchType属性，主要解决全局配置的缺点，因为不是所有的地方都要使用到延迟加载，fetchType出现在级联元素association和collection中，它存在两个值：

eager：立即加载对应的数据。
lazy：延迟加载对应的数据。

4、全局配置实现延迟加载

以前面部门Department和员工Employee为例，一个部门可以包含多名员工的一对多关系。

①、创建员工和部门实体类：

员工实体类：

/**
 * 员工实体类
 */
public class Employee {
    //员工id
    private Integer empId;
    //员工名称
    private String empName;
    //员工年龄
    private Integer empAge;
    //员工性别
    private Integer empSex;
    //员工邮箱
    private String empEmail;
    //员工地址
    private String empAddress;

    //员工所属部门，和部门表构成一对一的关系，一个员工只能在一个部门
    private Department department;

    //getter、setter、toString方法和一些构造方法省略...
}

部门实体类：

/**
 * 部门实体类
 */
public class Department {
    //部门id
    private Integer deptId;
    //部门名称
    private String deptName;

    //部门有哪些员工，一对多关系
    private List<Employee> employees;

    //getter、setter、toString方法和一些构造方法省略...
}

②、创建员工和部门Mapper接口

EmployeeMapper：

/**
 * 员工Mapper接口
 */
public interface EmployeeMapper {
    //据据员工表的department_id查询员工数据，用于一对多的关联查询
    Employee selectEmpByDeptId(@Param("id") Integer deptId);
}

DepartmentMapper：

/**
 * 部门Mapper接口
 */
public interface DepartmentMapper {
    //查询所有数据
    List<Department> selectAll();
    //根据部门id查询数据
    Department selectDeptByDeptId(@Param("id") Integer deptId);
}

③、创建员工和部门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.thr.mapper.EmployeeMapper">
    <resultMap id="employeeMap" type="com.thr.pojo.Employee">
        <id property="empId" column="employee_id"/>
        <result property="empName" column="employee_name"/>
        <result property="empAge" column="employee_age"/>
        <result property="empSex" column="employee_sex"/>
        <result property="empEmail" column="employee_email"/>
        <result property="empAddress" column="employee_address"/>
        <!-- 一对一关联对象-->
        <!--<association property="department" column="department_id" javaType="department"
                     select="com.thr.mapper.DepartmentMapper.selectDeptByDeptId"/>-->
    </resultMap>

    <!--根据员工表的department_id查询员工数据，用于一对多的关联查询-->
    <select id="selectEmpByDeptId" parameterType="int" resultMap="employeeMap">
        SELECT * FROM t_employee where department_id= #{id}
    </select>
</mapper>

DepartmentMapper.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.thr.mapper.DepartmentMapper">
    <resultMap id="departmentMap" type="com.thr.pojo.Department">
        <id property="deptId" column="department_id"/>
        <result property="deptName" column="department_name"/>
        <!--一对多关联对象，ofType指定的是映射到list集合属性中pojo的类型，也就是尖括号的泛型
        注意：这里的column属性首先是查询出t_department表的department_id，然后将它以参数的形式传递给select属性
        中的EmployeeMapper.selectEmpByDeptId方法，进而查询出当前部门下的员工-->
        <collection property="employees" ofType="employee" column="department_id"
                    select="com.thr.mapper.EmployeeMapper.selectEmpByDeptId">
        </collection>
    </resultMap>

    <!-- 查询所有数据-->
    <select id="selectAll" resultMap="departmentMap">
      SELECT * FROM t_department
    </select>

    <!--根据部门id查询数据-->
    <select id="selectDeptByDeptId" parameterType="int" resultMap="departmentMap">
        SELECT * FROM t_department WHERE department_id = #{id}
    </select>
</mapper>

④、在Mybatis的配置文件中开启全局延迟加载

<?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="db.properties"/>
    <!-- 全局配置参数，需要时再设置  -->
    <settings>
        <!-- 打开延迟加载的开关  -->
        <setting name="lazyLoadingEnabled" value="true"/>
        <setting name="aggressiveLazyLoading" value="false"/>
    </settings>
    <!--配置别名-->
    <typeAliases>
        <!-- 对包进行扫描，可以批量进行别名设置，设置规则是：获取类名称，将其第一个字母变为小写 -->
        <package name="com.thr.pojo"/>
    </typeAliases>
    <!-- 配置环境-->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="${database.driver}"/>
                <property name="url" value="${database.url}"/>
                <property name="username" value="${database.username}"/>
                <property name="password" value="${database.password}"/>
            </dataSource>
        </environment>
    </environments>

    <!--注册mapper，通过扫描的方式-->
    <mappers>
        <package name="com.thr.mapper"/>
    </mappers>
</configuration>

⑤、数据库连接和日志文件

db.properties：

#数据库连接配置
database.driver=com.mysql.cj.jdbc.Driver
database.url=jdbc:mysql://localhost:3306/mybatis?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf-8
database.username=root
database.password=root

log4j.properties：

log4j.rootLogger=DEBUG, Console
#Console
log4j.appender.Console=org.apache.log4j.ConsoleAppender
log4j.appender.Console.layout=org.apache.log4j.PatternLayout
log4j.appender.Console.layout.ConversionPattern=%d [%t] %-5p [%c] - %m%n
log4j.logger.java.sql.ResultSet=INFO
log4j.logger.org.apache=INFO
log4j.logger.java.sql.Connection=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG

⑥、测试代码

/**
 * 测试代码
 */
public class MybatisTest {
    //定义 SqlSession
    private SqlSession sqlSession = null;
    //定义 DepartmentMapper对象
    private DepartmentMapper mapper = null;

    @Before//在测试方法执行之前执行
    public void getSqlSession(){
        //1、加载 mybatis 全局配置文件
        InputStream is = MybatisTest.class.getClassLoader().getResourceAsStream("mybatis-config.xml");
        //2、创建SqlSessionFactory对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        //3、根据 sqlSessionFactory 产生 session
        sqlSession = sqlSessionFactory.openSession();
        //4、创建Mapper接口的的代理对象，getMapper方法底层会通过动态代理生成UserMapper的代理实现类
        mapper = sqlSession.getMapper(DepartmentMapper.class);
    }

    @After//在测试方法执行完成之后执行
    public void destroy() throws IOException {
        sqlSession.commit();
        sqlSession.close();

    }
    //查询所有数据
    @Test
    public void testSelectAll(){
        List<Department> departments = mapper.selectAll();
        for (Department department : departments) {
            System.out.println(department.getDeptId()+"--"+department.getDeptName());
            System.out.println("========");
            //执行getEmployees()去查询员工信息，这里实现按需加载
            //System.out.println(department.getEmployees());
        }
    }

    //根据部门id查询数据
    @Test
    public void testSelectDeptByDeptId(){
        Department department = mapper.selectDeptByDeptId(3);
        System.out.println(department.getDeptId()+"--"+department.getDeptName());
        System.out.println("========");
        //执行getEmployees()去查询员工信息，这里实现按需加载
        //System.out.println(department.getEmployees());
    }
}

⑦、测试结果

(1)、只使用部门数据，这时候不需要查询员工信息