09.resultMap（结果集映射）

1.自定义 `Java Bean` 封装规则

1.1 修改 User 实体类

别问为什么要闲得蛋疼的修改，现在要演示实体类属性和数据库列名不一致如何映射

java

package org.hong.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private Integer user_id;
    private String username;
    private String password;
}

1.2 Mapper 接口

java

package org.hong.mapper;

import org.hong.pojo.User;

import java.util.List;

public interface UserMapper {
    List<User> getAll();
}

1.3 Mapper.xml 文件

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="org.hong.mapper.UserMapper">
    <!--
        resultMap: 自定义结果集映射规则
            id: 唯一标识, 方便被引用
            type: 映射到的实体类的全类名
     -->
    <resultMap id="user" type="org.hong.pojo.User">
        <!--
            id: 映射实体类中与主键对应的属性
                column: 主键列的列名
                property: 主键列对应的属性
         -->
        <id property="user_id" column="id"></id>

        <!-- result: 映射普通属性 -->
        <result property="username" column="name"></result>
        <result property="password" column="pwd"></result>
    </resultMap>
    <!--
        如果javaBen属性名和列名不一致, 不应该再使用resultType配置返回值类型
        而是使用resultMap引用自定义的结果集映射规则
     -->
    <select id="getAll" resultMap="user">
        select * from user
    </select>
</mapper>

1.4 测试用例

java

package org.hong.test;

import org.apache.ibatis.session.SqlSession;
import org.hong.mapper.UserMapper;
import org.hong.pojo.User;
import org.hong.util.MyBatisUtil;
import org.junit.Test;

import java.util.List;

public class ResultMapTest {
    @Test
    public void tesResultMap(){
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        List<User> list = mapper.getAll();
        list.forEach(System.out :: println);

        sqlSession.commit();
        sqlSession.close();
    }
}

1.5 控制台打印

shell

## 虽然数据表的列名与实体类的属性名不一致, 但是我们配置了resultMap, 正常执行, 帅, 不愧是我
[main] [org.hong.mapper.UserMapper.getAll]-[DEBUG] ==>  Preparing: select * from user
[main] [org.hong.mapper.UserMapper.getAll]-[DEBUG] ==> Parameters:
[main] [org.hong.mapper.UserMapper.getAll]-[DEBUG] <==      Total: 5
User(user_id=1, username=谢禹宏, password=987654)
User(user_id=2, username=Tom, password=123456)
User(user_id=3, username=Jerry, password=123456)
User(user_id=4, username=SAVE ID, password=123)
User(user_id=5, username=SAVE ID, password=123)

2.环境搭建

接下来演示一个部门对应多个员工，一个员工对应一个部门的关系映射。

2.1 SQL

sql

CREATE TABLE `dept` (
  `id` INT(10) NOT NULL,
  `name` VARCHAR(30) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8

INSERT INTO dept(`id`, `name`) VALUES (1, '开发部');
INSERT INTO dept(`id`, `name`) VALUES (2, '测试部');

CREATE TABLE `employee` (
  `id` INT(10) NOT NULL,
  `name` VARCHAR(30) DEFAULT NULL,
  `did` INT(10) DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `fkdid` (`did`),
  CONSTRAINT `fkdid` FOREIGN KEY (`did`) REFERENCES `dept` (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8

INSERT INTO `employee` (`id`, `name`, `did`) VALUES ('1', '小明', '1');
INSERT INTO `employee` (`id`, `name`, `did`) VALUES ('2', '小红', '2');
INSERT INTO `employee` (`id`, `name`, `did`) VALUES ('3', '小张', '1');
INSERT INTO `employee` (`id`, `name`, `did`) VALUES ('4', '小李', '2');
INSERT INTO `employee` (`id`, `name`, `did`) VALUES ('5', '小王', '1');

2.2 实体类

java

package org.hong.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Dept {
    private Integer id;
    private String name;
}

java

package org.hong.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Employee {
    private Integer id;
    private String name;
    // 多对一, 查询N方的同时获取到1方
    private Dept dept;
}

2.3 MyBatisUtil 工具类

java

package org.hong.util;

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 java.io.IOException;
import java.io.InputStream;

public class MyBatisUtil {

    private static SqlSessionFactory sqlSessionFactory;

    static {
        try {
            // 获取sqlSessionFactory对象
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 既然有了 SqlSessionFactory，顾名思义，我们可以从中获得 SqlSession 的实例。
    // SqlSession 提供了在数据库执行 SQL 命令所需的所有方法
    public static SqlSession getSqlSession(){
        // openSession(): 此方式打开SQL会话, 事务是开启状态
        // openSession(true): 此方式打开SQL会话, 事务是关闭状态
        return sqlSessionFactory.openSession();
    }

    public static SqlSessionFactory getSqlSessionFactory() {
        return sqlSessionFactory;
    }
}

2.4 jdbc.properties

bash

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?userSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8
username=root
password=1234

2.5 log4j.properties

bash

log4j.rootLogger=DEBUG,A1

log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=[%t] [%c]-[%p] %m%n

2.6 MyBatis 核心配置文件

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: 核心配置文件 -->
<configuration>

    <!-- 导入外部配置文件, 放在最前面 -->
    <properties resource="jdbc.properties"/>

    <!-- 设置日志输出, 方便观察sql语句和参数 -->
    <settings>
        <setting name="logImpl" value="LOG4J"/>
    </settings>

    <!--
        environments配置项目的运行环境, 可以配置多个
        default: 启用的环境
     -->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <!-- 数据库连接信息 -->
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>

    <!-- 每一个Mapper.xml都需要在MyBatis核心配置文件中注册!!! -->
    <mappers>
        <package name="org.hong.mapper"/>
    </mappers>

</configuration>

3.多对一

3.1 实体类

java

package org.hong.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Dept {
    private Integer id;
    private String name;
}

java

package org.hong.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Employee {
    private Integer id;
    private String name;
    // 多对一, 查询N方的同时获取到1方
    private Dept dept;
}

3.2 联合查询

3.2.1 DeptMapper.java

java

package org.hong.mapper;

import org.hong.pojo.Dept;

public interface DeptMapper {

}

3.2.2 EmployeeMapper.java

java

package org.hong.mapper;

import org.hong.pojo.Employee;

import java.util.List;

public interface EmployeeMapper {
    List<Employee> getAll();
}

3.2.3 DeptMapper.xml

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="org.hong.mapper.DeptMapper">
    <resultMap id="deptBase" type="org.hong.pojo.Dept">
        <id property="id" column="did"></id>
        <result property="name" column="dname"></result>
    </resultMap>
</mapper>

3.2.4 EmployeeMapper.xml

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="org.hong.mapper.EmployeeMapper">
    <!-- 创建一个只封装普通属性的resultMap映射规则 -->
    <resultMap id="employeeBase" type="org.hong.pojo.Employee">
        <id property="id" column="id"></id>
        <result property="name" column="name"></result>
    </resultMap>

    <!-- 使用extends属性继承一个resultMap可以获得指定的resultMap定义过的映射规则, 就可以省略普通属性, 只写级联属性的规则 -->
    <resultMap id="employee1" type="org.hong.pojo.Employee" extends="employeeBase">
        <!-- 方式一: 联合查询, 级联属性封装结果 -->
        <result property="dept.id" column="did"></result>
        <!-- 两张表都有name字段, 在进行封装的时候就会出现问题, 要么查询的时候取别名, 要么在建表的时候就避免 -->
        <result property="dept.name" column="dname"></result>
    </resultMap>

    <resultMap id="employee2" type="org.hong.pojo.Employee" extends="employeeBase">
        <!--
            方式二: 给指定联合的javaBean对象编写映射规则
                association:定义关联对象的封装规则
                    property: 指定哪个属性是联合的对象
                    javaType: 指定这个属性对象的类型[不能省略]
         -->
        <association property="dept" javaType="org.hong.pojo.Dept">
            <id property="id" column="did"></id>
            <result property="name" column="dname"></result>
        </association>
    </resultMap>

    <resultMap id="employee3" type="org.hong.pojo.Employee" extends="employeeBase">
        <!-- 方式三: 使用association节点的resultMap属性指定级联对象的映射规则, 而不是再写一份 -->
        <association property="dept" resultMap="org.hong.mapper.DeptMapper.deptBase"></association>
    </resultMap>

    <!-- 查询Employee的同时查询出对应Dept, 此时使用resultType就做不到了, 需要使用resultMap引用自自定义的映射规则 -->
    <select id="getAll" resultMap="employee3">
        <!-- 内连接 -->
        select e.*, d.id did, d.name dname from employee e inner join dept d on e.did = d.id
    </select>
</mapper>

3.3 嵌套查询

3.3.1 DeptMapper.java

java

package org.hong.mapper;

import org.hong.pojo.Dept;

public interface DeptMapper {
    Dept get(int id);
}

3.3.2 EmployeeMapper.java

java

package org.hong.mapper;

import org.hong.pojo.Employee;

import java.util.List;

public interface EmployeeMapper {
    List<Employee> getAll();
}

3.3.3 DeptMapper.xml

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="org.hong.mapper.DeptMapper">
    <select id="get" resultType="org.hong.pojo.Dept">
        select * from dept where id = #{id}
    </select>
</mapper>

3.3.4 EmployeeMapper.xml

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="org.hong.mapper.EmployeeMapper">
    <!--
        思路:
            1.查询所有员工的信息
            2.根据查询出来的员工的did查询对应的部门
 	-->
    <resultMap id="employee" type="org.hong.pojo.Employee">
        <id property="id" column="id"></id>
        <result property="name" column="name"></result>
        <!--
            association:定义关联对象的封装规则
             	select: 表明当前属性是调用select指定的方法查出的结果
             	column: 指定将那一列的值传给select
         -->
        <association property="dept"
                     column="did"
                     javaType="org.hong.pojo.Dept"
                     select="org.hong.mapper.DeptMapper.get"></association>
    </resultMap>

    <!-- 查询Employee的同时查询出对应Dept, 此时使用resultType就做不到了, 需要使用resultMap -->
    <select id="getAll" resultMap="employee">
        select * from employee
    </select>
</mapper>

3.4 测试用例

java

package org.hong.test;

import org.apache.ibatis.session.SqlSession;
import org.hong.mapper.EmployeeMapper;
import org.hong.pojo.Employee;
import org.hong.util.MyBatisUtil;
import org.junit.Test;

import java.util.List;

public class ResultTest {
    @Test
    public void testManyToOne(){
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        EmployeeMapper mapper = sqlSession.getMapper(EmployeeMapper.class);

        List<Employee> list = mapper.getAll();
        list.forEach(e -> System.out.println(e.getName()));
        list.forEach(e -> System.out.println(e.getDept().getName()));

        sqlSession.commit();
        sqlSession.close();
    }
}

3.5 控制台打印

3.5.1 联合查询

shell

## 联合查询的控制台打印, 只发送一条sql
[main] [org.hong.mapper.EmployeeMapper.getAll]-[DEBUG] ==>  Preparing: select e.*, d.id did, d.name dname from employee e inner join dept d on e.did = d.id
[main] [org.hong.mapper.EmployeeMapper.getAll]-[DEBUG] ==> Parameters:
[main] [org.hong.mapper.EmployeeMapper.getAll]-[DEBUG] <==      Total: 5
小明
小张
小王
小红
小李
开发部
开发部
开发部
测试部
测试部

3.5.2 嵌套查询

可以发现，似乎并没有懒加载，直接一次把所有 sql 发出去了，这是因为我们还没有开启 MyBatis 的懒加载功能

shell

## 先发送查询Employee表的ssql
[main] [org.hong.mapper.EmployeeMapper.getAll]-[DEBUG] ==>  Preparing: select * from employee
[main] [org.hong.mapper.EmployeeMapper.getAll]-[DEBUG] ==> Parameters:
## 再发送查询Dept表的sql
[main] [org.hong.mapper.DeptMapper.get]-[DEBUG] ====>  Preparing: select * from dept where id = ?
[main] [org.hong.mapper.DeptMapper.get]-[DEBUG] ====> Parameters: 1(Integer)
[main] [org.hong.mapper.DeptMapper.get]-[DEBUG] <====      Total: 1
[main] [org.hong.mapper.DeptMapper.get]-[DEBUG] ====>  Preparing: select * from dept where id = ?
[main] [org.hong.mapper.DeptMapper.get]-[DEBUG] ====> Parameters: 2(Integer)
[main] [org.hong.mapper.DeptMapper.get]-[DEBUG] <====      Total: 1
[main] [org.hong.mapper.EmployeeMapper.getAll]-[DEBUG] <==      Total: 5
小明
小红
小张
小李
小王
开发部
测试部
开发部
测试部
开发部

4.一对多

4.1 实体类

java

package org.hong.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.List;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Dept {
    private Integer id;
    private String name;
    private List<Employee> employees;
}

java

package org.hong.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Employee {
    private Integer id;
    private String name;
}

4.2 联合查询

4.2.1 DeptMapper.java

java

package org.hong.mapper;

import org.hong.pojo.Dept;

public interface DeptMapper {
    Dept get(int id);
}

4.2.2 EmployeeMapper.java

java

package org.hong.mapper;

import org.hong.pojo.Employee;

import java.util.List;

public interface EmployeeMapper {

}

4.2.3 DeptMapper.xml

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="org.hong.mapper.DeptMapper">
    <resultMap id="deptBase" type="org.hong.pojo.Dept">
        <id column="id" property="id"></id>
        <result column="name" property="name"></result>
    </resultMap>

    <resultMap id="dept2" type="org.hong.pojo.Dept" extends="deptBase">
        <!-- 方式一 -->
        <collection property="employees" ofType="org.hong.pojo.Employee">
            <id column="eid" property="id"></id>
            <result column="ename" property="name"></result>
        </collection>
    </resultMap>

    <resultMap id="dept3" type="org.hong.pojo.Dept" extends="deptBase">
        <!-- 方式二 -->
        <!--
			collection: 表示查询的多条数据
				ofType: 指定集合中属性对象的类型[不能省略];
						需要注意的是, collection使用ofType来指定集合中对象的类型, 而不是javaType
 		-->
        <collection property="employees"
                    ofType="org.hong.pojo.Employee"
                    resultMap="org.hong.mapper.EmployeeMapper.employeeBase">
        </collection>
    </resultMap>

    <select id="get" resultMap="dept2">
        select d.*, e.id eid, e.name ename from dept d inner join employee e on d.id = e.did where d.id = #{id}
    </select>
</mapper>

4.2.4 EmployeeMapper.xml

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="org.hong.mapper.EmployeeMapper">
    <resultMap id="employeeBase" type="org.hong.pojo.Employee">
        <id column="eid" property="id"></id>
        <id column="ename" property="name"></id>
    </resultMap>
</mapper>

4.3 嵌套查询

4.3.1 DeptMapper.java

java

package org.hong.mapper;

import org.hong.pojo.Dept;

public interface DeptMapper {
    Dept get(int id);
}

4.3.2 EmployeeMapper.java

java

package org.hong.mapper;

import org.hong.pojo.Employee;

import java.util.List;

public interface EmployeeMapper {
    List<Employee> getByDid(int did);
}

4.3.3 DeptMapper.xml

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="org.hong.mapper.DeptMapper">
    <resultMap id="deptBase" type="org.hong.pojo.Dept">
        <id column="id" property="id"></id>
        <result column="name" property="name"></result>
    </resultMap>
    <resultMap id="dept1" type="org.hong.pojo.Dept" extends="deptBase">
        <!--
			collection: 定义关联集合类型的属性的封装规则
                ofType: 指定集合里面元素的类型
                select: 表明当前属性是调用select指定的方法查出的结果
                column: 指定将那一列的值传给select
		 -->
        <collection property="employees"
                    column="id"
                    select="org.hong.mapper.EmployeeMapper.getByDid"></collection>
    </resultMap>

    <select id="get" resultMap="dept1">
        select * from dept where id = #{id}
    </select>
</mapper>

4.3.4 EmployeeMapper.xml

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="org.hong.mapper.EmployeeMapper">
    <select id="getByDid" resultType="org.hong.pojo.Employee">
        select * from employee where did = #{did}
    </select>
</mapper>

4.4 测试用例

java

package org.hong.test;

import org.apache.ibatis.session.SqlSession;
import org.hong.mapper.DeptMapper;
import org.hong.pojo.Dept;
import org.hong.util.MyBatisUtil;
import org.junit.Test;

public class ResultTest {
    @Test
    public void testOneToMany(){
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        DeptMapper mapper = sqlSession.getMapper(DeptMapper.class);

        Dept dept = mapper.get(1);
        System.out.println(dept);

        sqlSession.commit();
        sqlSession.close();
    }
}

4.5 控制台打印

4.5.1 联合查询

shell

[main] [org.hong.mapper.DeptMapper.get]-[DEBUG] ==>  Preparing: select d.*, e.id eid, e.name ename from dept d inner join employee e on d.id = e.did where d.id = ?
[main] [org.hong.mapper.DeptMapper.get]-[DEBUG] ==> Parameters: 1(Integer)
[main] [org.hong.mapper.DeptMapper.get]-[DEBUG] <==      Total: 3
Dept(id=1, name=开发部, employees=[Employee(id=1, name=小明), Employee(id=3, name=小张), Employee(id=5, name=小王)])

4.5.2 嵌套查询

shell

[main] [org.hong.mapper.DeptMapper.get]-[DEBUG] ==>  Preparing: select * from dept where id = ?
[main] [org.hong.mapper.DeptMapper.get]-[DEBUG] ==> Parameters: 1(Integer)
[main] [org.hong.mapper.DeptMapper.get]-[DEBUG] <==      Total: 1
[main] [org.hong.mapper.EmployeeMapper.getByDid]-[DEBUG] ==>  Preparing: select * from employee where did = ?
[main] [org.hong.mapper.EmployeeMapper.getByDid]-[DEBUG] ==> Parameters: 1(Integer)
[main] [org.hong.mapper.EmployeeMapper.getByDid]-[DEBUG] <==      Total: 3
Dept(id=1, name=开发部, employees=[Employee(id=1, name=小明), Employee(id=3, name=小张), Employee(id=5, name=小王)])

5.嵌套查询的懒加载

5.1 全局懒加载

修改 MyBatis 的核心配置文件

xml

<settings>
    <setting name="logImpl" value="LOG4J"/>
    <!--
        aggressiveLazyLoading:
            启用时: 有延迟加载属性的对象在被调用时将会完全加载任意属性。
            禁用时: 调用哪个懒载属性就加载哪个属性, 按需加载
     -->
    <setting name="aggressiveLazyLoading" value="false"/>
    <!--
        lazyLoadingEnabled:
            全局启用或禁用延迟加载。
			禁用时: 所有关联对象都会即时加载。
     -->
    <setting name="lazyLoadingEnabled" value="true"/>
</settings>

5.2 局部懒加载

xml

<resultMap id="employee" type="org.hong.pojo.Employee">
    <id property="id" column="id"></id>
    <result property="name" column="name"></result>
    <!--
        association:定义关联对象的封装规则
           select: 表明当前属性是调用select指定的方法查出的结果
           column: 指定将那一列的值传给select
           fetchType: 关联属性的加载策略, 可以覆盖全局的lazyLoadingEnabled, fetchType属性同样可以作用于collection标签
               lazy: 延迟加载
               eager: 即时加载
     -->
    <association property="dept"
                 column="did"
                 javaType="org.hong.pojo.Dept"
                 fetchType="lazy"
                 select="org.hong.mapper.DeptMapper.get"></association>
</resultMap>

6.总结

嵌套查询的方式在查询时会向数据库发送多次SQL 语句
联合查询的方式只会向数据库发送一次SQL 语句

resultMap：自定义某个 javaBean 的封装规则
resultMap 的属性：
- id：唯一标识
- type：自定义规则的 java 类型
resultMap 包含的标签：
- result：指定其余键的封装规则
- id：指定主键的封装规则, id 定义主键底层会有优化
  - column：指定数据库的列
  - property：指定对应的 javaBean 属性

association：定义关联对象的封装规则
collection：定义关联集合类型的属性的封装规则
- property：当前封装的对象的属性
- javaType：指定实体类中属性的类型
- ofType：指定映射到 List 或集合中的 pojo 类型，泛型中的约束类型
- select：表明当前属性是调用 select 指定的方法查出的结果
- column：指定将哪一列的值传给 select

java

// 传递多列的值
column="{key1=column1, key2=column2}"
 key: select指定的查询的#{key}中的key
 colnmn: 列名

  -  流程：使用 select 指定的方法(传入 column 指定的列的参数值)查出对象, 并封装给 property

fetchType：在全局配置中设置了延迟加载的情况下可以将联合属性修改为立即加载
- lazy: 延迟, 默认
- eager: 立即

09.resultMap（结果集映射） ​

1.自定义 Java Bean 封装规则 ​

1.1 修改 User 实体类 ​

1.2 Mapper 接口 ​

1.3 Mapper.xml 文件 ​

1.4 测试用例 ​

1.5 控制台打印 ​

2.环境搭建 ​

2.1 SQL ​

2.2 实体类 ​

2.3 MyBatisUtil 工具类 ​

2.4 jdbc.properties ​

2.5 log4j.properties ​

2.6 MyBatis 核心配置文件 ​

3.多对一 ​

3.1 实体类 ​

3.2 联合查询 ​

3.2.1 DeptMapper.java ​

3.2.2 EmployeeMapper.java ​

3.2.3 DeptMapper.xml ​

3.2.4 EmployeeMapper.xml ​

3.3 嵌套查询 ​

3.3.1 DeptMapper.java ​

3.3.2 EmployeeMapper.java ​

3.3.3 DeptMapper.xml ​

3.3.4 EmployeeMapper.xml ​

3.4 测试用例 ​

3.5 控制台打印 ​

3.5.1 联合查询 ​

3.5.2 嵌套查询 ​

4.一对多 ​

4.1 实体类 ​

4.2 联合查询 ​

4.2.1 DeptMapper.java ​

4.2.2 EmployeeMapper.java ​

4.2.3 DeptMapper.xml ​

4.2.4 EmployeeMapper.xml ​

4.3 嵌套查询 ​

4.3.1 DeptMapper.java ​

4.3.2 EmployeeMapper.java ​

4.3.3 DeptMapper.xml ​

4.3.4 EmployeeMapper.xml ​

4.4 测试用例 ​

4.5 控制台打印 ​

4.5.1 联合查询 ​

4.5.2 嵌套查询 ​

5.嵌套查询的懒加载 ​

5.1 全局懒加载 ​

5.2 局部懒加载 ​

6.总结 ​

09.resultMap（结果集映射）

1.自定义 `Java Bean` 封装规则

1.1 修改 User 实体类

1.2 Mapper 接口

1.3 Mapper.xml 文件

1.4 测试用例

1.5 控制台打印

2.环境搭建

2.1 SQL

2.2 实体类

2.3 MyBatisUtil 工具类

2.4 jdbc.properties

2.5 log4j.properties

2.6 MyBatis 核心配置文件

3.多对一

3.1 实体类

3.2 联合查询

3.2.1 DeptMapper.java

3.2.2 EmployeeMapper.java

3.2.3 DeptMapper.xml

3.2.4 EmployeeMapper.xml

3.3 嵌套查询

3.3.1 DeptMapper.java

3.3.2 EmployeeMapper.java

3.3.3 DeptMapper.xml

3.3.4 EmployeeMapper.xml

3.4 测试用例

3.5 控制台打印

3.5.1 联合查询

3.5.2 嵌套查询

4.一对多

4.1 实体类

4.2 联合查询

4.2.1 DeptMapper.java

4.2.2 EmployeeMapper.java

4.2.3 DeptMapper.xml

4.2.4 EmployeeMapper.xml

4.3 嵌套查询

4.3.1 DeptMapper.java

4.3.2 EmployeeMapper.java

4.3.3 DeptMapper.xml

4.3.4 EmployeeMapper.xml

4.4 测试用例

4.5 控制台打印

4.5.1 联合查询

4.5.2 嵌套查询

5.嵌套查询的懒加载

5.1 全局懒加载

5.2 局部懒加载

6.总结