MyBatis中映射器之结果映射详解

Dear 丶 2023-01-23 10:57 326阅读 0赞

mybatis官网中文文档：[https://mybatis.org/mybatis-3/zh/sqlmap-xml.html\#Result\_Maps][https_mybatis.org_mybatis-3_zh_sqlmap-xml.html_Result_Maps]

关联博文：[MyBatis中XML映射器使用详解][MyBatis_XML]

# 【1】结果映射 #

`resultMap` 元素是 MyBatis 中最重要最强大的元素。它可以让你从 90% 的 `JDBC ResultSets` 数据提取代码中解放出来，并在一些情形下允许你进行一些 JDBC 不支持的操作。实际上，在为一些比如连接的复杂语句编写映射代码的时候，一份 resultMap 能够代替实现同等功能的数千行代码。ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了。

之前你已经见过简单映射语句的示例，它们没有显式指定 resultMap。比如：

<select id="selectUsers" resultType="map">
      select id, username, hashedPassword
      from some_table
      where id = #{id}
    </select>

上述语句只是简单地将所有的列映射到 HashMap 的键上，这由 `resultType` 属性指定。虽然在大部分情况下都够用，但是 HashMap 并不是一个很好的领域模型。你的程序更可能会使用 `JavaBean 或 POJO（Plain Old Java Objects，普通老式 Java 对象）`作为领域模型。MyBatis 对两者都提供了支持。看看下面这个 `JavaBean`：

package com.someapp.model;
    public class User { 
      private int id;
      private String username;
      private String hashedPassword;
    
      public int getId() { 
        return id;
      }
      public void setId(int id) { 
        this.id = id;
      }
      public String getUsername() { 
        return username;
      }
      public void setUsername(String username) { 
        this.username = username;
      }
      public String getHashedPassword() { 
        return hashedPassword;
      }
      public void setHashedPassword(String hashedPassword) { 
        this.hashedPassword = hashedPassword;
      }
    }

基于 JavaBean 的规范，上面这个类有 3 个属性：`id，username 和 hashedPassword`。这些属性会对应到 `select` 语句中的列名。

这样的一个 `JavaBean` 可以被映射到 `ResultSet`，就像映射到 `HashMap` 一样简单。

<select id="selectUsers" resultType="com.someapp.model.User">
      select id, username, hashedPassword
      from some_table
      where id = #{id}
    </select>

类型别名是你的好帮手。使用它们，你就可以不用输入类的全限定名了。比如：

<typeAlias type="com.someapp.model.User" alias="User"/>
    
    
    <select id="selectUsers" resultType="User">
      select id, username, hashedPassword
      from some_table
      where id = #{id}
    </select>

在这些情况下，`MyBatis 会在幕后自动创建一个 ResultMap，再根据属性名来映射列到 JavaBean 的属性上`。如果列名和属性名不能匹配上，可以在 SELECT 语句中设置列别名（这是一个基本的 SQL 特性）来完成匹配。比如：

<select id="selectUsers" resultType="User">
      select
        user_id             as "id",
        user_name           as "userName",
        hashed_password     as "hashedPassword"
      from some_table
      where id = #{id}
    </select>

在学习了上面的知识后，你会发现上面的例子没有一个需要显式配置 `ResultMap`，这就是 `ResultMap` 的优秀之处——`你完全可以不用显式地配置它们`。 虽然上面的例子不用显式配置 ResultMap。 但为了讲解，我们来看看如果在刚刚的示例中，显式使用外部的 resultMap 会怎样，这也是解决列名不匹配的另外一种方式。

然后在引用它的语句中设置 resultMap 属性就行了（注意我们去掉了 resultType 属性）。比如:

<select id="selectUsers" resultMap="userResultMap">
      select user_id, user_name, hashed_password
      from some_table
      where id = #{id}
    </select>

如果这个世界总是这么简单就好了。

# 【2】高级结果映射 #

MyBatis 创建时的一个思想是：数据库不可能永远是你所想或所需的那个样子。 我们希望每个数据库都具备良好的`第三范式或 BCNF 范式`，可惜它们并不都是那样。 如果能有一种数据库映射模式，完美适配所有的应用程序，那就太好了，但可惜也没有。 而 ResultMap 就是 MyBatis 对这个问题的答案。

比如，我们如何映射下面这个语句？

<select id="selectBlogDetails" resultMap="detailedBlogResultMap">
      select
           B.id as blog_id,
           B.title as blog_title,
           B.author_id as blog_author_id,
           A.id as author_id,
           A.username as author_username,
           A.password as author_password,
           A.email as author_email,
           A.bio as author_bio,
           A.favourite_section as author_favourite_section,
           P.id as post_id,
           P.blog_id as post_blog_id,
           P.author_id as post_author_id,
           P.created_on as post_created_on,
           P.section as post_section,
           P.subject as post_subject,
           P.draft as draft,
           P.body as post_body,
           C.id as comment_id,
           C.post_id as comment_post_id,
           C.name as comment_name,
           C.comment as comment_text,
           T.id as tag_id,
           T.name as tag_name
      from Blog B
           left outer join Author A on B.author_id = A.id
           left outer join Post P on B.id = P.blog_id
           left outer join Comment C on P.id = C.post_id
           left outer join Post_Tag PT on PT.post_id = P.id
           left outer join Tag T on PT.tag_id = T.id
      where B.id = #{id}
    </select>

你可能想把它映射到一个智能的对象模型，这个对象表示了一篇博客，它由某位作者所写，有很多的博文，每篇博文有零或多条的评论和标签。 我们先来看看下面这个完整的例子，它是一个非常复杂的结果映射（假设作者，博客，博文，评论和标签都是类型别名）。 不用紧张，我们会一步一步地来说明。虽然它看起来令人望而生畏，但其实非常简单。

<resultMap id="detailedBlogResultMap" type="Blog">
      <constructor>
        <idArg column="blog_id" javaType="int"/>
      </constructor>
      
      <result property="title" column="blog_title"/>
      
      <association property="author" javaType="Author">
        <id property="id" column="author_id"/>
        <result property="username" column="author_username"/>
        <result property="password" column="author_password"/>
        <result property="email" column="author_email"/>
        <result property="bio" column="author_bio"/>
        <result property="favouriteSection" column="author_favourite_section"/>
      </association>
      
      <collection property="posts" ofType="Post">
        <id property="id" column="post_id"/>
        <result property="subject" column="post_subject"/>
        <association property="author" javaType="Author"/>
        <collection property="comments" ofType="Comment">
          <id property="id" column="comment_id"/>
        </collection>
        <collection property="tags" ofType="Tag" >
          <id property="id" column="tag_id"/>
        </collection>
        
        <discriminator javaType="int" column="draft">
          <case value="1" resultType="DraftPost"/>
        </discriminator>
      </collection>
    </resultMap>

`resultMap` 元素有很多子元素和一个值得深入探讨的结构。 下面是`resultMap` 元素的概念视图。

## **结果映射（resultMap）** ##

*  constructor - 用于在实例化类时，注入结果到构造方法中
    
     *  idArg - ID 参数；标记出作为 ID 的结果可以帮助提高整体性能
     *  arg - 将被注入到构造方法的一个普通结果
 *  id – 一个 ID 结果；标记出作为 ID 的结果可以帮助提高整体性能
 *  result – 注入到字段或 JavaBean 属性的普通结果
 *  association – 一个复杂类型的关联；许多结果将包装成这种类型
    
     *  嵌套结果映射 – 关联可以是 resultMap 元素，或是对其它结果映射的引用
 *  collection – 一个复杂类型的集合
    
     *  嵌套结果映射 – 集合可以是 resultMap 元素，或是对其它结果映射的引用
 *  discriminator – 使用结果值来决定使用哪个 resultMap
    
     *  case – 基于某些值的结果映射
        
         *  嵌套结果映射 – case 也是一个结果映射，因此具有相同的结构和元素；或者引用其它的结果映射

**ResultMap 的属性列表**

<table> 
 <thead> 
  <tr> 
   <th>属性</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>id</td> 
   <td align="left">当前命名空间中的一个唯一标识，用于标识一个结果映射。</td> 
  </tr> 
  <tr> 
   <td>type</td> 
   <td align="left">类的完全限定名, 或者一个类型别名。</td> 
  </tr> 
  <tr> 
   <td>autoMapping</td> 
   <td align="left">如果设置这个属性，MyBatis 将会为本结果映射开启或者关闭自动映射。 这个属性会覆盖全局的属性 autoMappingBehavior。默认值：未设置（unset）。</td> 
  </tr> 
 </tbody> 
</table>

**最佳实践** `最好逐步建立结果映射`。

> 单元测试可以在这个过程中起到很大帮助。 如果你尝试一次性创建像上面示例那么巨大的结果映射，不仅容易出错，难度也会直线上升。 所以，从最简单的形态开始，逐步迭代。而且别忘了单元测试！ 有时候，框架的行为像是一个黑盒子（无论是否开源）。因此，为了确保实现的行为与你的期望相一致，最好编写单元测试。 并且单元测试在提交 bug 时也能起到很大的作用。

下一部分将详细说明每个元素。

## id & result ##

这些元素是结果映射的基础。`id 和 result` 元素都将一个列的值映射到一个简单数据类型（`String, int, double, Date` 等）的属性或字段。

`这两者之间的唯一不同是`，id 元素对应的属性会被标记为对象的标识符，在比较对象实例时使用。 这样可以提高整体的性能，尤其是进行`缓存和嵌套结果映射（也就是连接映射）`的时候。

**Id 和 Result 的属性**

<table> 
 <thead> 
  <tr> 
   <th>属性</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>property</td> 
   <td align="left">映射到列结果的字段或属性。如果 JavaBean 有这个名字的属性（property），会先使用该属性。否则 MyBatis 将会寻找给定名称的字段（field）。 无论是哪一种情形，你都可以使用常见的点式分隔形式进行复杂属性导航。 比如，你可以这样映射一些简单的东西：“<code>username</code>”，或者映射到一些复杂的东西上：“<code>address.street.number</code>”。</td> 
  </tr> 
  <tr> 
   <td>column</td> 
   <td align="left">数据库中的列名，或者是列的别名。一般情况下，这和传递给 <code>resultSet.getString(columnName)</code> 方法的参数一样。</td> 
  </tr> 
  <tr> 
   <td>javaType</td> 
   <td align="left">一个 Java 类的全限定名，或一个类型别名（关于内置的类型别名，可以参考上面的表格）。 如果你映射到一个 JavaBean，MyBatis 通常可以推断类型。然而，如果你映射到的是 HashMap，那么你应该明确地指定 javaType 来保证行为与期望的相一致。</td> 
  </tr> 
  <tr> 
   <td>jdbcType</td> 
   <td align="left">JDBC 类型，所支持的 JDBC 类型参见这个表格之后的“支持的 JDBC 类型”。 只需要在可能执行插入、更新和删除的且允许空值的列上指定 JDBC 类型。这是 JDBC 的要求而非 MyBatis 的要求。如果你直接面向 JDBC 编程，你需要对可以为空值的列指定这个类型。</td> 
  </tr> 
  <tr> 
   <td>typeHandler</td> 
   <td align="left">我们在前面讨论过默认的类型处理器。使用这个属性，你可以覆盖默认的类型处理器。 这个属性值是一个类型处理器实现类的全限定名，或者是类型别名。</td> 
  </tr> 
 </tbody> 
</table>

**支持的 JDBC 类型**

为了以后可能的使用场景，MyBatis 通过内置的 jdbcType 枚举类型支持下面的 JDBC 类型。

<table> 
 <thead> 
  <tr> 
   <th>BIT</th> 
   <th>FLOAT</th> 
   <th>CHAR</th> 
   <th>TIMESTAMP</th> 
   <th>OTHER</th> 
   <th>UNDEFINED</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>TINYINT</td> 
   <td>REAL</td> 
   <td>VARCHAR</td> 
   <td>BINARY</td> 
   <td>BLOB</td> 
   <td>NVARCHAR</td> 
  </tr> 
  <tr> 
   <td>SMALLINT</td> 
   <td>DOUBLE</td> 
   <td>LONGVARCHAR</td> 
   <td>VARBINARY</td> 
   <td>CLOB</td> 
   <td>NCHAR</td> 
  </tr> 
  <tr> 
   <td>INTEGER</td> 
   <td>NUMERIC</td> 
   <td>DATE</td> 
   <td>LONGVARBINARY</td> 
   <td>BOOLEAN</td> 
   <td>NCLOB</td> 
  </tr> 
  <tr> 
   <td>BIGINT</td> 
   <td>DECIMAL</td> 
   <td>TIME</td> 
   <td>NULL</td> 
   <td>CURSOR</td> 
   <td>ARRAY</td> 
  </tr> 
 </tbody> 
</table>

## 构造方法 ##

通过修改对象属性的方式，可以满足大多数的数据传输对象（`Data Transfer Object, DTO`）以及绝大部分领域模型的要求。但有些情况下你想使用不可变类。 一般来说，很少改变或基本不变的包含引用或数据的表，很适合使用不可变类。 `构造方法注入允许你在初始化时为类设置属性的值，而不用暴露出公有方法`。MyBatis 也支持`私有属性和私有 JavaBean` 属性来完成注入，但有一些人更青睐于通过构造方法进行注入。 constructor 元素就是为此而生的。

看看下面这个构造方法:

public class User {
       //...
       public User(Integer id, String username, int age) {
         //...
      }
    //...
    }

为了将结果注入构造方法，MyBatis 需要通过某种方式定位相应的构造方法。 在下面的例子中，MyBatis 搜索一个`声明了三个形参的构造方法`，参数类型以 `java.lang.Integer, java.lang.String 和 int` 的顺序给出。

当你在处理一个带有多个形参的构造方法时，很容易搞乱 `arg` 元素的顺序。 从版本 `3.4.3` 开始，可以在指定参数名称的前提下，以任意顺序编写 `arg` 元素。 为了通过名称来引用构造方法参数，你可以添加 `@Param` 注解，或者使用 `'-parameters'` 编译选项并启用 `useActualParamName` 选项（默认开启）来编译项目。

下面是一个等价的例子，尽管函数签名中第二和第三个形参的顺序与 constructor 元素中参数声明的顺序不匹配。

如果存在名称和类型相同的属性，那么可以省略 javaType 。

剩余的属性和规则和普通的 id 和 result 元素是一样的。

<table> 
 <thead> 
  <tr> 
   <th>属性</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>column</td> 
   <td align="left">数据库中的列名，或者是列的别名。一般情况下，这和传递给 <code>resultSet.getString(columnName)</code> 方法的参数一样。</td> 
  </tr> 
  <tr> 
   <td>javaType</td> 
   <td align="left">一个 Java 类的完全限定名，或一个类型别名（关于内置的类型别名，可以参考上面的表格）。 如果你映射到一个 JavaBean，MyBatis 通常可以推断类型。然而，如果你映射到的是 HashMap，那么你应该明确地指定 javaType 来保证行为与期望的相一致。</td> 
  </tr> 
  <tr> 
   <td>jdbcType</td> 
   <td align="left">JDBC 类型，所支持的 JDBC 类型参见这个表格之前的<code>“支持的 JDBC 类型”</code>。 只需要在可能执行插入、更新和删除的且允许空值的列上指定 JDBC 类型。这是 JDBC 的要求而非 MyBatis 的要求。如果你直接面向 JDBC 编程，你需要对可能存在空值的列指定这个类型。</td> 
  </tr> 
  <tr> 
   <td>typeHandler</td> 
   <td align="left">我们在前面讨论过默认的类型处理器。使用这个属性，你可以覆盖默认的类型处理器。 这个属性值是一个类型处理器实现类的完全限定名，或者是类型别名。</td> 
  </tr> 
  <tr> 
   <td>select</td> 
   <td align="left">用于加载复杂类型属性的映射语句的 ID，它会从 column 属性中指定的列检索数据，作为参数传递给此 select 语句。具体请参考关联元素。</td> 
  </tr> 
  <tr> 
   <td>resultMap</td> 
   <td align="left">结果映射的 ID，可以将嵌套的结果集映射到一个合适的对象树中。 它可以作为使用额外 select 语句的替代方案。它可以将多表连接操作的结果映射成一个单一的 <code>ResultSet</code>。这样的 <code>ResultSet</code> 将会将包含重复或部分数据重复的结果集。为了将结果集正确地映射到嵌套的对象树中，MyBatis 允许你 <code>“串联”结果映射</code>，以便解决嵌套结果集的问题。想了解更多内容，请参考下面的关联元素。</td> 
  </tr> 
  <tr> 
   <td>name</td> 
   <td align="left">构造方法形参的名字。从 3.4.3 版本开始，通过指定具体的参数名，你可以以任意顺序写入 arg 元素。参看上面的解释。</td> 
  </tr> 
 </tbody> 
</table>

--------------------

# 【3】关联 #

## association ##

**关联（association）** 元素`处理“有一个”类型`的关系。 比如，在我们的示例中，一个博客有一个用户。关联结果映射和其它类型的映射工作方式差不多。 你需要指定目标属性名以及属性的javaType（很多时候 MyBatis 可以自己推断出来），在必要的情况下你还可以设置 JDBC 类型，如果你想覆盖获取结果值的过程，还可以设置类型处理器。

关联的不同之处是，你需要告诉 MyBatis 如何加载关联。MyBatis 有两种不同的方式加载关联：

*  嵌套 Select 查询：通过执行另外一个 SQL 映射语句来加载期望的复杂类型。
 *  嵌套结果映射：使用嵌套的结果映射来处理连接结果的重复子集。

首先，先让我们来看看这个元素的属性。你将会发现，和普通的结果映射相比，它只在 `select 和 resultMap` 属性上有所不同。

<table> 
 <thead> 
  <tr> 
   <th>属性</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>property</td> 
   <td align="left">映射到列结果的字段或属性。如果用来匹配的 JavaBean 存在给定名字的属性，那么它将会被使用。否则 MyBatis 将会寻找给定名称的字段。 无论是哪一种情形，你都可以使用通常的点式分隔形式进行复杂属性导航。 比如，你可以这样映射一些简单的东西：“username”，或者映射到一些复杂的东西上：“address.street.number”。</td> 
  </tr> 
  <tr> 
   <td>javaType</td> 
   <td align="left">一个 Java 类的完全限定名，或一个类型别名（关于内置的类型别名，可以参考上面的表格）。 如果你映射到一个 JavaBean，MyBatis 通常可以推断类型。然而，如果你映射到的是 HashMap，那么你应该明确地指定 javaType 来保证行为与期望的相一致。</td> 
  </tr> 
  <tr> 
   <td>jdbcType</td> 
   <td align="left">JDBC 类型，所支持的 JDBC 类型参见这个表格之前的“支持的 JDBC 类型”。 只需要在可能执行插入、更新和删除的且允许空值的列上指定 JDBC 类型。这是 JDBC 的要求而非 MyBatis 的要求。如果你直接面向 JDBC 编程，你需要对可能存在空值的列指定这个类型。</td> 
  </tr> 
  <tr> 
   <td>typeHandler</td> 
   <td align="left">我们在前面讨论过默认的类型处理器。使用这个属性，你可以覆盖默认的类型处理器。 这个属性值是一个类型处理器实现类的完全限定名，或者是类型别名。</td> 
  </tr> 
 </tbody> 
</table>

### 关联的嵌套 Select 查询(N+1问题) ###

<table> 
 <thead> 
  <tr> 
   <th>属性</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>column</td> 
   <td align="left">数据库中的列名，或者是列的别名。一般情况下，这和传递给 <code>resultSet.getString(columnName)</code> 方法的参数一样。 注意：在使用复合主键的时候，你可以使用 <code>column="{prop1=col1,prop2=col2}"</code> 这样的语法来指定多个传递给嵌套 Select 查询语句的列名。这会使得 prop1 和 prop2 作为参数对象，被设置为对应嵌套 Select 语句的参数。</td> 
  </tr> 
  <tr> 
   <td>select</td> 
   <td align="left">用于加载复杂类型属性的映射语句的 ID，它会从 column 属性指定的列中检索数据，作为参数传递给目标 select 语句。 具体请参考下面的例子。注意：在使用复合主键的时候，你可以使用 <code>column="{prop1=col1,prop2=col2}"</code> 这样的语法来指定多个传递给嵌套 Select 查询语句的列名。这会使得 prop1 和 prop2 作为参数对象，被设置为对应嵌套 Select 语句的参数。</td> 
  </tr> 
  <tr> 
   <td>fetchType</td> 
   <td align="left">可选的。有效值为 <code>lazy</code> 和 <code>eager</code>。 指定属性后，将在映射中忽略全局配置参数 <code>lazyLoadingEnabled</code>，使用属性的值。</td> 
  </tr> 
 </tbody> 
</table>

**示例：**

<resultMap id="blogResult" type="Blog">
      <association property="author" column="author_id" javaType="Author" select="selectAuthor"/>
    </resultMap>
    
    <select id="selectBlog" resultMap="blogResult">
      SELECT * FROM BLOG WHERE ID = #{ id}
    </select>
    
    <select id="selectAuthor" resultType="Author">
      SELECT * FROM AUTHOR WHERE ID = #{ id}
    </select>

就是这么简单。我们有两个 select 查询语句：一个用来加载博客（Blog），另外一个用来加载作者（Author），而且博客的结果映射描述了应该使用 selectAuthor 语句加载它的 author 属性。

其它所有的属性将会被自动加载，只要它们的列名和属性名相匹配。

这种方式虽然很简单，`但在大型数据集或大型数据表上表现不佳。这个问题被称为“N+1 查询问题`”。 概括地讲，N+1 查询问题是这样子的：

*  你执行了一个单独的 SQL 语句来获取结果的一个列表（就是“+1”）。
 *  对列表返回的每条记录，你执行一个 select 查询语句来为每条记录加载详细信息（就是“N”）。

这个问题会导致成百上千的 SQL 语句被执行。有时候，我们不希望产生这样的后果。

好消息是，MyBatis 能够对这样的查询进行延迟加载，因此可以将大量语句同时运行的开销分散开来。 然而，如果你加载记录列表之后立刻就遍历列表以获取嵌套的数据，就会触发所有的延迟加载查询，性能可能会变得很糟糕。

所以还有另外一种方法。

### 关联的嵌套结果映射 ###

<table> 
 <thead> 
  <tr> 
   <th>属性</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>resultMap</td> 
   <td align="left">结果映射的 ID，可以将此关联的嵌套结果集映射到一个合适的对象树中。 它可以作为使用额外 select 语句的替代方案。它可以将多表连接操作的结果映射成一个单一的 ResultSet。这样的 ResultSet 有部分数据是重复的。 为了将结果集正确地映射到嵌套的对象树中, MyBatis 允许你“串联”结果映射，以便解决嵌套结果集的问题。使用嵌套结果映射的一个例子在表格以后。</td> 
  </tr> 
  <tr> 
   <td>columnPrefix</td> 
   <td align="left">当连接多个表时，你可能会不得不使用列别名来避免在 ResultSet 中产生重复的列名。指定 columnPrefix 列名前缀允许你将带有这些前缀的列映射到一个外部的结果映射中。 详细说明请参考后面的例子。</td> 
  </tr> 
  <tr> 
   <td>notNullColumn</td> 
   <td align="left">默认情况下，在至少一个被映射到属性的列不为空时，子对象才会被创建。 你可以在这个属性上指定非空的列来改变默认行为，指定后，Mybatis 将只在这些列非空时才创建一个子对象。可以使用逗号分隔来指定多个列。默认值：未设置（unset）。</td> 
  </tr> 
  <tr> 
   <td>autoMapping</td> 
   <td align="left">如果设置这个属性，MyBatis 将会为本结果映射开启或者关闭自动映射。 这个属性会覆盖全局的属性 autoMappingBehavior。注意，本属性对外部的结果映射无效，所以不能搭配 select 或 resultMap 元素使用。默认值：未设置（unset）。</td> 
  </tr> 
 </tbody> 
</table>

之前，你已经看到了一个非常复杂的嵌套关联的例子。 下面的例子则是一个非常简单的例子，用于演示嵌套结果映射如何工作。 现在我们将博客表和作者表连接在一起，而不是执行一个独立的查询语句，就像这样：

<select id="selectBlog" resultMap="blogResult">
      select
        B.id            as blog_id,
        B.title         as blog_title,
        B.author_id     as blog_author_id,
        A.id            as author_id,
        A.username      as author_username,
        A.password      as author_password,
        A.email         as author_email,
        A.bio           as author_bio
      from Blog B 
      left outer join Author A on B.author_id = A.id
      where B.id = #{id}
    </select>

注意查询中的连接，以及为确保结果能够拥有唯一且清晰的名字，我们设置的别名。 这使得进行映射非常简单。现在我们可以映射这个结果：

在上面的例子中，你可以看到，博客（`Blog`）作者（`author`）的关联元素委托名为 “`authorResult`” 的结果映射来加载作者对象的实例。

**非常重要**： id 元素在嵌套结果映射中扮演着非常重要的角色。你应该总是指定一个或多个可以唯一标识结果的属性。 虽然，即使不指定这个属性，MyBatis 仍然可以工作，但是会产生严重的性能问题。 只需要指定可以唯一标识结果的最少属性。显然，你可以选择主键（复合主键也可以）。

现在，上面的示例使用了外部的结果映射元素来映射关联。这使得 Author 的结果映射可以被重用。 然而，如果你不打算重用它，或者你更喜欢将你所有的结果映射放在一个具有描述性的结果映射元素中。 你可以直接将结果映射作为子元素嵌套在内。这里给出使用这种方式的等效例子：

那如果博客（blog）有一个共同作者（co-author）该怎么办？select 语句看起来会是这样的：

<select id="selectBlog" resultMap="blogResult">
      select
        B.id            as blog_id,
        B.title         as blog_title,
        A.id            as author_id,
        A.username      as author_username,
        A.password      as author_password,
        A.email         as author_email,
        A.bio           as author_bio,
        CA.id           as co_author_id,
        CA.username     as co_author_username,
        CA.password     as co_author_password,
        CA.email        as co_author_email,
        CA.bio          as co_author_bio
      from Blog B
      left outer join Author A on B.author_id = A.id
      left outer join Author CA on B.co_author_id = CA.id
      where B.id = #{id}
    </select>

回忆一下，Author 的结果映射定义如下：

由于结果中的列名与结果映射中的列名不同。你需要指定 `columnPrefix` 以便重复使用该结果映射来映射 `co-author` 的结果。

**针对`当前对象有一个关联对象`，也可以使用如下方式处理**

<resultMap type="com.bean.Employee" id="MyDifEmp">
    	<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>

### 关联的多结果集（ResultSet） ###

<table> 
 <thead> 
  <tr> 
   <th>属性</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>column</td> 
   <td align="left">当使用多个结果集时，该属性指定结果集中用于与 foreignColumn 匹配的列（多个列名以逗号隔开），以识别关系中的父类型与子类型。</td> 
  </tr> 
  <tr> 
   <td>foreignColumn</td> 
   <td align="left">指定外键对应的列名，指定的列将与父类型中 column 的给出的列进行匹配。</td> 
  </tr> 
  <tr> 
   <td>resultSet</td> 
   <td align="left">指定用于加载复杂类型的结果集名字。</td> 
  </tr> 
 </tbody> 
</table>

**从版本 3.2.3 开始，MyBatis 提供了另一种解决 N+1 查询问题的方法。**

`某些数据库允许存储过程返回多个结果集，或一次性执行多个语句，每个语句返回一个结果集`。 我们可以利用这个特性，在不使用连接的情况下，只访问数据库一次就能获得相关数据。

在例子中，存储过程执行下面的查询并返回两个结果集。第一个结果集会返回博客（Blog）的结果，第二个则返回作者（Author）的结果。

SELECT * FROM BLOG WHERE ID = #{id}
    
    SELECT * FROM AUTHOR WHERE ID = #{id}

在映射语句中，必须通过 resultSets 属性为每个结果集指定一个名字，多个名字使用逗号隔开。

<select id="selectBlog" resultSets="blogs,authors" resultMap="blogResult" statementType="CALLABLE">
      {
       call getBlogsAndAuthors(#{id,jdbcType=INTEGER,mode=IN})}
    </select>

现在我们可以指定使用 `“authors”` 结果集的数据来填充 `“author”` 关联：

你已经在上面看到了如何处理`“有一个”类型`的关联。但是该怎么处`理“有很多个”类型的关联呢？`这就是我们接下来要介绍的。

--------------------

## 集合 ##

集合元素和关联元素几乎是一样的，它们相似的程度之高，以致于没有必要再介绍集合元素的相似部分。 所以让我们来关注它们的不同之处吧。

我们来继续上面的示例，一个博客（Blog）只有一个作者（Author)。但一个博客有很多文章（Post)。 在博客类中，这可以用下面的写法来表示：

private List<Post> posts;

要像上面这样，`映射嵌套结果集合到一个 List 中，可以使用集合元素`。 和关联元素一样，我们可以使用`嵌套 Select 查询，或基于连接的嵌套结果映射集合`。

### 集合的嵌套 Select 查询 ###

首先，让我们看看如何使用`嵌套 Select 查询`来为博客加载文章。

<resultMap id="blogResult" type="Blog">
    
      <collection property="posts" javaType="ArrayList" column="id" ofType="Post" select="selectPostsForBlog"/>
    </resultMap>
    
    
    <select id="selectBlog" resultMap="blogResult">
      SELECT * FROM BLOG WHERE ID = #{id}
    </select>
    
    <select id="selectPostsForBlog" resultType="Post">
      SELECT * FROM POST WHERE BLOG_ID = #{id}
    </select>

你可能会立刻注意到几个不同，但大部分都和我们上面学习过的关联元素非常相似。 首先，你会注意到我们使用的是`集合元素`。 接下来你会注意到有一个新的 `“ofType”` 属性。这个属性非常重要，它用来将 `JavaBean（或字段）属性的类型和集合存储的类型`区分开来。 所以你可以按照下面这样来阅读映射：

读作： “posts 是一个存储 Post 的 ArrayList 集合”

在一般情况下，MyBatis 可以推断 javaType 属性，因此并不需要填写。所以很多时候你可以简略成：

### 集合的嵌套结果映射 ###

现在你可能已经猜到了集合的嵌套结果映射是怎样工作的——除了新增的 `“ofType”` 属性，它和关联的完全相同。

首先, 让我们看看对应的 SQL 语句：

<select id="selectBlog" resultMap="blogResult">
      select
      B.id as blog_id,
      B.title as blog_title,
      B.author_id as blog_author_id,
      P.id as post_id,
      P.subject as post_subject,
      P.body as post_body,
      from Blog B
      left outer join Post P on B.id = P.blog_id
      where B.id = #{id}
    </select>

我们再次连接了博客表和文章表，并且为每一列都赋予了一个有意义的别名，以便映射保持简单。 要映射博客里面的文章集合，就这么简单：

再提醒一次，要记得上面 id 元素的重要性，如果你不记得了，请阅读关联部分的相关部分。

如果你喜欢更详略的、可重用的结果映射，你可以使用下面的等价形式：

### 集合的多结果集（ResultSet） ###

像关联元素那样，我们可以通过执行存储过程实现，它会执行两个查询并返回两个结果集，一个是博客的结果集，另一个是文章的结果集：

SELECT * FROM BLOG WHERE ID = #{id}
    
    SELECT * FROM POST WHERE BLOG_ID = #{id}

在映射语句中，必须通过 `resultSets` 属性为每个结果集指定一个名字，多个名字使用逗号隔开。

<select id="selectBlog" resultSets="blogs,posts" resultMap="blogResult">
      {
       call getBlogsAndPosts(#{id,jdbcType=INTEGER,mode=IN})}
    </select>

我们指定 `“posts”` 集合将会使用存储在 `“posts”` 结果集中的数据进行填充：

**注意** 对关联或集合的映射，并没有深度、广度或组合上的要求。但在映射时要留意性能问题。 在探索最佳实践的过程中，应用的单元测试和性能测试会是你的好帮手。 而 MyBatis 的好处在于，可以在不对你的代码引入重大变更（如果有）的情况下，允许你之后改变你的想法。

高级关联和集合映射是一个深度话题。文档的介绍只能到此为止。配合少许的实践，你会很快了解全部的用法。

--------------------

## 鉴别器 ##

有时候，一个数据库查询可能会返回多个不同的结果集（但总体上还是有一定的联系的）。 `鉴别器（discriminator）`元素就是被设计来应对这种情况的，另外也能处理其它情况，例如类的继承层次结构。 鉴别器的概念很好理解——它很像 Java 语言中的 switch 语句。

`一个鉴别器的定义需要指定 column 和 javaType 属性`。column 指定了 MyBatis 查询被比较值的地方。 而 javaType 用来确保使用正确的相等测试（虽然很多情况下字符串的相等测试都可以工作）。例如：

在这个示例中，MyBatis 会从结果集中得到每条记录，然后比较它的 vehicle type 值。 如果它匹配任意一个鉴别器的 case，就会使用这个 case 指定的结果映射。 这个过程是互斥的，也就是说，剩余的结果映射将被忽略（除非它是扩展的，我们将在稍后讨论它）。 如果不能匹配任何一个 case，MyBatis 就只会使用鉴别器块外定义的结果映射。 所以，如果 carResult 的声明如下：

那么只有 doorCount 属性会被加载。这是为了即使鉴别器的 case 之间都能分为完全独立的一组，尽管和父结果映射可能没有什么关系。在上面的例子中，我们当然知道 `cars 和 vehicles` 之间有关系，也就是 `Car 是一个 Vehicle`。因此，我们希望剩余的属性也能被加载。而这只需要一个小修改。

现在 vehicleResult 和 carResult 的属性都会被加载了。

可能有人又会觉得映射的外部定义有点太冗长了。 因此，对于那些更喜欢简洁的映射风格的人来说，还有另一种语法可以选择。例如：

**提示** 请注意，这些都是结果映射，如果你完全不设置任何的 result 元素，MyBatis 将为你自动匹配列和属性。所以上面的例子大多都要比实际的更复杂。 这也表明，大多数数据库的复杂度都比较高，我们不太可能一直依赖于这种机制。

另外一个使用鉴别器的实例：

# 【4】自动映射 #

正如你在前面一节看到的，在简单的场景下，MyBatis 可以为你自动映射查询结果。但如果遇到复杂的场景，你需要构建一个结果映射。 但是在本节中，你将看到，你可以混合使用这两种策略。让我们深入了解一下自动映射是怎样工作的。

> **当自动映射查询结果时，MyBatis 会获取结果中返回的列名并在 Java 类中查找相同名字的属性（忽略大小写）。 这意味着如果发现了 ID 列和 id 属性，MyBatis 会将列 ID 的值赋给 id 属性。**

通常数据库列使用大写字母组成的单词命名，单词间用下划线分隔；而 Java 属性一般遵循驼峰命名法约定。为了在这两种命名方式之间启用自动映射，需要将 `mapUnderscoreToCamelCase` 设置为 true。

`甚至在提供了结果映射后，自动映射也能工作`。在这种情况下，对于每一个结果映射，在 ResultSet 出现的列，如果没有设置手动映射，将被自动映射。在自动映射处理完毕后，再处理手动映射。 在下面的例子中，`id 和 userName` 列将被自动映射，`hashed_password` 列将根据配置进行映射。

<select id="selectUsers" resultMap="userResultMap">
      select
        user_id             as "id",
        user_name           as "userName",
        hashed_password
      from some_table
      where id = #{id}
    </select>
    
    <resultMap id="userResultMap" type="User">
      <result property="password" column="hashed_password"/>
    </resultMap>

**有三种自动映射等级：**

*  NONE - 禁用自动映射。仅对手动映射的属性进行映射。
 *  PARTIAL - 对除在内部定义了嵌套结果映射（也就是连接的属性）以外的属性进行映射
 *  FULL - 自动映射所有属性。

默认值是 `PARTIAL`，这是有原因的。当对连接查询的结果使用 `FULL` 时，连接查询会在同一行中获取多个不同实体的数据，因此可能导致非预期的映射。 下面的例子将展示这种风险：

<select id="selectBlog" resultMap="blogResult">
      select
        B.id,
        B.title,
        A.username,
      from Blog B left outer join Author A on B.author_id = A.id
      where B.id = #{id}
    </select>
    
    <resultMap id="blogResult" type="Blog">
      <association property="author" resultMap="authorResult"/>
    </resultMap>
    
    <resultMap id="authorResult" type="Author">
      <result property="username" column="author_username"/>
    </resultMap>

在该结果映射中，Blog 和 Author 均将被自动映射。`但是注意 Author 有一个 id 属性，在 ResultSet 中也有一个名为 id 的列，所以 Author 的 id 将填入 Blog 的 id，这可不是你期望的行为。 所以，要谨慎使用 FULL`。

无论设置的自动映射等级是哪种，你都可以通过在结果映射上设置 `autoMapping` 属性来为指定的结果映射设置`启用/禁用`自动映射。

参考博文：  
[MyBatis中对象映射关联之association使用实践][MyBatis_association]  
[Mybatis中对象映射关联之collection使用][Mybatis_collection]

[https_mybatis.org_mybatis-3_zh_sqlmap-xml.html_Result_Maps]: https://mybatis.org/mybatis-3/zh/sqlmap-xml.html#Result_Maps
[MyBatis_XML]: https://janus.blog.csdn.net/article/details/70196848
[MyBatis_association]: https://janus.blog.csdn.net/article/details/53418937
[Mybatis_collection]: https://janus.blog.csdn.net/article/details/53432992