Mybatis—mapper.xml配置文件

识字粗堪供赋役，不须辛苦慕公卿。这篇文章主要讲述Mybatis—mapper.xml配置文件相关的知识，希望能为你提供帮助。
目录

select
- Select 元素的属性
insert, update 和 delete
- 示例
sql
参数 (parameterType...)
- 字符串替换(${} 和 #{}区别)
结果映射
- 高级结果映射
  - id & result
  - 关联association (实体类的属性是个实体类)
- 集合
  - 集合的嵌套 Select 查询
  - 集合的嵌套结果映射
  - 集合的多结果集（ResultSet）
- 自动映射
缓存（未完待续）

MyBatis 的真正强大在于它的映射语句，这是它的魔力所在。由于它的异常强大，映射器的 XML 文件就显得相对简单。如果拿它跟具有相同功能的 JDBC 代码进行对比，你会立即发现省掉了将近 95% 的代码。MyBatis 为聚焦于 SQL 而构建，以尽可能地为你减少麻烦。
SQL 映射文件只有很少的几个顶级元素（按照应被定义的顺序列出）：

cache – 对给定命名空间的缓存配置。 cache-ref – 对其他命名空间缓存配置的引用。 resultMap – 是最复杂也是最强大的元素，用来描述如何从数据库结果集中来加载对象。 parameterMap – 已被废弃！老式风格的参数映射。更好的办法是使用内联参数，此元素可能在将来被移除。 sql – 可被其他语句引用的可重用语句块。 insert – 映射插入语句 update – 映射更新语句 delete – 映射删除语句 select – 映射查询语句

select查询语句是 MyBatis 中最常用的元素之一，光能把数据存到数据库中价值并不大，只有还能重新取出来才有用，多数应用也都是查询比修改要频繁。对每个插入、更新或删除操作，通常间隔多个查询操作。这是 MyBatis 的基本原则之一，也是将焦点和努力放在查询和结果映射的原因。简单查询的 select 元素是非常简单的。比如：

< select id=" selectPerson" parameterType=" int" resultType=" hashmap" > SELECT * FROM PERSON WHERE ID = #{id} < /select>

这个语句被称作 selectPerson，接受一个 int（或 Integer）类型的参数，并返回一个 HashMap 类型的对象，其中的键是列名，值便是结果行中的对应值。
注意参数符号：** #{id} ** 这就告诉 MyBatis 创建一个预处理语句（PreparedStatement）参数
select 元素允许你配置很多属性来配置每条语句的作用细节。

< select id=" selectPerson" parameterType=" int" parameterMap=" deprecated" resultType=" hashmap" resultMap=" personResultMap" flushCache=" false" useCache=" true" timeout=" 10" fetchSize=" 256" statementType=" PREPARED" resultSetType=" FORWARD_ONLY" >

Select 元素的属性

属性	描述
id	在命名空间中唯一的标识符，可以被用来引用这条语句。
parameterType	将会传入这条语句的参数类的完全限定名或别名。这个属性是可选的，因为 MyBatis 可以通过类型处理器（TypeHandler）推断出具体传入语句的参数，默认值为未设置（unset）。
parameterMap	这是引用外部 parameterMap 的已经被废弃的方法。请使用内联参数映射和 parameterType 属性。
resultType	从这条语句中返回的期望类型的类的完全限定名或别名。注意如果返回的是集合，那应该设置为集合包含的类型，而不是集合本身。可以使用 resultType 或 resultMap，但不能同时使用。
resultMap	外部 resultMap 的命名引用。结果集的映射是 MyBatis 最强大的特性，如果你对其理解透彻，许多复杂映射的情形都能迎刃而解。可以使用 resultMap 或 resultType，但不能同时使用。
flushCache	将其设置为 true 后，只要语句被调用，都会导致本地缓存和二级缓存被清空，默认值：false。
useCache	将其设置为 true 后，将会导致本条语句的结果被二级缓存缓存起来，默认值：对 select 元素为 true。
timeout	这个设置是在抛出异常之前，驱动程序等待数据库返回请求结果的秒数。默认值为未设置（unset）（依赖驱动）。
fetchSize	这是一个给驱动的提示，尝试让驱动程序每次批量返回的结果行数和这个设置值相等。默认值为未设置（unset）（依赖驱动）。
statementType	STATEMENT，PREPARED 或 CALLABLE 中的一个。这会让 MyBatis 分别使用 Statement，PreparedStatement 或 CallableStatement，默认值：PREPARED。
resultSetType	FORWARD_ONLY，SCROLL_SENSITIVE, SCROLL_INSENSITIVE 或 DEFAULT（等价于 unset）中的一个，默认值为 unset （依赖驱动）。
databaseId	如果配置了数据库厂商标识（databaseIdProvider），MyBatis 会加载所有的不带 databaseId 或匹配当前 databaseId 的语句；如果带或者不带的语句都有，则不带的会被忽略。
resultOrdered	这个设置仅针对嵌套结果 select 语句适用：如果为 true，就是假设包含了嵌套结果集或是分组，这样的话当返回一个主结果行的时候，就不会发生有对前面结果集的引用的情况。这就使得在获取嵌套的结果集的时候不至于导致内存不够用。默认值：false。
resultSets	这个设置仅对多结果集的情况适用。它将列出语句执行后返回的结果集并给每个结果集一个名称，名称是逗号分隔的。

insert, update 和 delete** 注意点：增、删、改操作需要提交事务！ **

< insert id=" insertAuthor" parameterType=" domain.blog.Author" flushCache=" true" statementType=" PREPARED" keyProperty=" " keyColumn=" " useGeneratedKeys=" " timeout=" 20" > < update id=" updateAuthor" parameterType=" domain.blog.Author" flushCache=" true" statementType=" PREPARED" timeout=" 20" > < delete id=" deleteAuthor" parameterType=" domain.blog.Author" flushCache=" true" statementType=" PREPARED" timeout=" 20" >

Insert, Update, Delete 元素的属性
属性 | 描述
--|--|--
id | 命名空间中的唯一标识符，可被用来代表这条语句。
parameterType | 将要传入语句的参数的完全限定类名或别名。这个属性是可选的，因为 MyBatis 可以通过类型处理器推断出具体传入语句的参数，默认值为未设置（unset）。
parameterMap | 这是引用外部 parameterMap 的已经被废弃的方法。请使用内联参数映射和 parameterType 属性。
flushCache | 将其设置为 true 后，只要语句被调用，都会导致本地缓存和二级缓存被清空，默认值：true（对于 insert、update 和 delete 语句）。
timeout | 这个设置是在抛出异常之前，驱动程序等待数据库返回请求结果的秒数。默认值为未设置（unset）（依赖驱动）。
statementType | STATEMENT，PREPARED 或 CALLABLE 的一个。这会让 MyBatis 分别使用 Statement，PreparedStatement 或 CallableStatement，默认值：PREPARED。
useGeneratedKeys | （仅对 insert 和 update 有用）这会令 MyBatis 使用 JDBC 的 getGeneratedKeys 方法来取出由数据库内部生成的主键（比如：像 mysql 和 SQL Server 这样的关系数据库管理系统的自动递增字段），默认值：false。
keyProperty | （仅对 insert 和 update 有用）唯一标记一个属性，MyBatis 会通过 getGeneratedKeys 的返回值或者通过 insert 语句的 selectKey 子元素设置它的键值，默认值：未设置（unset）。如果希望得到多个生成的列，也可以是逗号分隔的属性名称列表。
keyColumn | （仅对 insert 和 update 有用）通过生成的键值设置表中的列名，这个设置仅在某些数据库（像 PostgreSQL）是必须的，当主键列不是表中的第一列的时候需要设置。如果希望使用多个生成的列，也可以设置为逗号分隔的属性名称列表。
databaseId | 如果配置了数据库厂商标识（databaseIdProvider），MyBatis 会加载所有的不带 databaseId 或匹配当前 databaseId 的语句；如果带或者不带的语句都有，则不带的会被忽略。
insert，update 和 delete 语句的示例：

< insert id=" insertAuthor" > insert into Author (id,username,password,email,bio) values (#{id},#{username},#{password},#{email},#{bio}) < /insert> < update id=" updateAuthor" > update Author set username = #{username}, password = #{password}, email = #{email}, bio = #{bio} where id = #{id} < /update> < delete id=" deleteAuthor" > delete from Author where id = #{id} < /delete>

示例插入语句的配置规则更加丰富，在插入语句里面有一些额外的属性和子元素用来处理主键的生成，而且有多种生成方式。
如果你的数据库支持自动生成主键的字段（比如 MySQL 和 SQL Server），那么你可以设置 useGeneratedKeys=”true”，然后再把 keyProperty 设置到目标属性上就 OK 了。例如，如果上面的 Author 表已经对 id 使用了自动生成的列类型，那么语句可以修改为：

< insert id=" insertAuthor" useGeneratedKeys=" true" keyProperty=" id" > insert into Author (username,password,email,bio) values (#{username},#{password},#{email},#{bio}) < /insert>

如果你的数据库还支持多行插入, 你也可以传入一个 Author 数组或集合，并返回自动生成的主键。

< insert id=" insertAuthor" useGeneratedKeys=" true" keyProperty=" id" > insert into Author (username, password, email, bio) values < foreach item=" item" collection=" list" separator=" ," > (#{item.username}, #{item.password}, #{item.email}, #{item.bio}) < /foreach> < /insert>

对于不支持自动生成类型的数据库或可能不支持自动生成主键的 JDBC 驱动，MyBatis 有另外一种方法来生成主键。

< insert id=" insertAuthor" > < selectKey keyProperty=" id" resultType=" int" order=" BEFORE" > select CAST(RANDOM()*1000000 as INTEGER) a from SYSIBM.SYSDUMMY1 < /selectKey> insert into Author (id, username, password, email,bio, favourite_section) values (#{id}, #{username}, #{password}, #{email}, #{bio}, #{favouriteSection,jdbcType=VARCHAR}) < /insert>

selectKey 元素中的语句将会首先运行，Author 的 id 会被设置，然后插入语句会被调用。这可以提供给你一个与数据库中自动生成主键类似的行为，同时保持了 java 代码的简洁。但是会影响数据库性能。
【Mybatis—mapper.xml配置文件】selectKey 元素描述如下：

< selectKey keyProperty=" id" resultType=" int" order=" BEFORE" statementType=" PREPARED" >

属性	描述
keyProperty	selectKey 语句结果应该被设置的目标属性。如果希望得到多个生成的列，也可以是逗号分隔的属性名称列表。
keyColumn	匹配属性的返回结果集中的列名称。如果希望得到多个生成的列，也可以是逗号分隔的属性名称列表。
resultType	结果的类型。MyBatis 通常可以推断出来，但是为了更加精确，写上也不会有什么问题。MyBatis 允许将任何简单类型用作主键的类型，包括字符串。如果希望作用于多个生成的列，则可以使用一个包含期望属性的 Object 或一个 Map。
order	这可以被设置为 BEFORE 或 AFTER。如果设置为 BEFORE，那么它会首先生成主键，设置 keyProperty 然后执行插入语句。如果设置为 AFTER，那么先执行插入语句，然后是 selectKey 中的语句 - 这和 Oracle 数据库的行为相似，在插入语句内部可能有嵌入索引调用。
statementType	与前面相同，MyBatis 支持 STATEMENT，PREPARED 和 CALLABLE 语句的映射类型，分别代表 PreparedStatement 和 CallableStatement 类型。

sql这个元素可以被用来定义可重用的 SQL 代码段，这些 SQL 代码可以被包含在其他语句中。它可以（在加载的时候）被静态地设置参数。在不同的包含语句中可以设置不同的值到参数占位符上。比如：

< sql id=" userColumns" > ${alias}.id,${alias}.username,${alias}.password < /sql>

这个 SQL 片段可以被包含在其他语句中，例如：

< select id=" selectUsers" resultType=" map" > select < include refid=" userColumns" > < property name=" alias" value=https://www.songbingjia.com/android/" t1" /> < /include> , < include refid=" userColumns" > < property name=" alias" value=" t2" /> < /include> from some_table t1 cross join some_table t2 < /select>

属性值也可以被用在 include 元素的 refid 属性里或 include 元素的内部语句中，例如：

< sql id=" sometable" > ${prefix}Table < /sql> < sql id=" someinclude" > from < include refid=" ${include_target}" /> < /sql> < select id=" select" resultType=" map" > select field1, field2, field3 < include refid=" someinclude" > < property name=" prefix" value=https://www.songbingjia.com/android/" Some" /> < property name=" include_target" value=" sometable" /> < /include> < /select>

参数 (parameterType...)

< select id=" selectUsers" resultType=" User" > select id, username, password from users where id = #{id} < /select>

上面的这个示例说明了一个非常简单的命名参数映射。参数类型被设置为 int，这样这个参数就可以被设置成任何内容。原始类型或简单数据类型（比如 Integer 和 String）因为没有相关属性，它会完全用参数值来替代。然而，如果传入一个复杂的对象，行为就会有一点不同了。比如：

< insert id=" insertUser" parameterType=" User" > insert into users (id, username, password) values (#{id}, #{username}, #{password}) < /insert>

如果 User 类型的参数对象传递到了语句中，id、username 和 password 属性将会被查找，然后将它们的值传入预处理语句的参数中。
字符串替换(${} 和 #{}区别)

@Select(" select * from user where id = #{id}" ) User findById(@Param(" id" ) long id); @Select(" select * from user where ${column} = #{value}" ) User findByColumn(@Param(" column" ) String column, @Param(" value" ) String value);

其中 ${column} 会被直接替换，而 #{value} 会被使用 ? 预处理。
用这种方式接受用户的输入，并将其用于语句中的参数是不安全的，会导致潜在的 SQL 注入攻击，因此要么不允许用户输入这些字段，要么自行转义并检验。
结果映射resultMap 元素是 MyBatis 中最重要最强大的元素。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对象：

public class User { private int id; private String username; private String hashedPassword; //get/set....}

这个类有 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>

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

< !-- mybatis-config.xml 中 --> < typeAlias type=" com.someapp.model.User" alias=" User" /> < !-- SQL 映射 XML 中 --> < 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_idas " id" , user_nameas " userName" , hashed_passwordas " hashedPassword" from some_table where id = #{id} < /select>

在列明和实体类属性名称不一致的情况下，外部使用resultMap的方法，也是我们在开发中经常使用的：

< resultMap id=" userResultMap" type=" User" > < id property=" id" column=" user_id" /> < result property=" username" column=" user_name" /> < result property=" password" column=" hashed_password" /> < /resultMap>

在引用它的语句中使用 resultMap 属性(注意我们去掉了 resultType 属性)

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

高级结果映射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=https://www.songbingjia.com/android/" 1" resultType=" DraftPost" /> < /discriminator> < /collection> < /resultMap>

结果映射（resultMap）

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

ResultMap 的属性列表
属性 | 描述
--|--|--
id | 当前命名空间中的一个唯一标识，用于标识一个结果映射。
type | 类的完全限定名, 或者一个类型别名（关于内置的类型别名，可以参考上面的表格）。
autoMapping | 如果设置这个属性，MyBatis将会为本结果映射开启或者关闭自动映射。这个属性会覆盖全局的属性 autoMappingBehavior。默认值：未设置（unset）。
id & result

< id property=" id" column=" post_id" /> < result property=" subject" column=" post_subject" />

id 和 result 元素都将一个列的值映射到一个简单数据类型（String, int, double, Date 等）的属性或字段。
这两者之间的唯一不同是，id 元素表示的结果将是对象的标识属性，这会在比较对象实例时用到。这样可以提高整体的性能，尤其是进行缓存和嵌套结果映射（也就是连接映射）的时候。
Id 和 Result 的属性
属性 | 描述
--|--|--
property | 映射到列结果的字段或属性。如果用来匹配的 JavaBean 存在给定名字的属性，那么它将会被使用。否则 MyBatis 将会寻找给定名称的字段。无论是哪一种情形，你都可以使用通常的点式分隔形式进行复杂属性导航。比如，你可以这样映射一些简单的东西：“username”，或者映射到一些复杂的东西上：“address.street.number”。
column | 数据库中的列名，或者是列的别名。一般情况下，这和传递给 resultSet.getString(columnName) 方法的参数一样。
javaType | 一个 Java 类的完全限定名，或一个类型别名（关于内置的类型别名，可以参考上面的表格）。如果你映射到一个 JavaBean，MyBatis 通常可以推断类型。然而，如果你映射到的是 HashMap，那么你应该明确地指定 javaType 来保证行为与期望的相一致。
jdbcType | JDBC 类型，所支持的 JDBC 类型参见这个表格之后的“支持的 JDBC 类型”。只需要在可能执行插入、更新和删除的且允许空值的列上指定 JDBC 类型。这是 JDBC 的要求而非 MyBatis 的要求。如果你直接面向 JDBC 编程，你需要对可能存在空值的列指定这个类型。
typeHandler | 我们在前面讨论过默认的类型处理器。使用这个属性，你可以覆盖默认的类型处理器。这个属性值是一个类型处理器实现类的完全限定名，或者是类型别名。
关联association (实体类的属性是个实体类)
关联的嵌套 Select 查询通过博客id获取博客信息，博客实体类属性有一个auther，也是一个实体类，这是后可以通过关联select进行查询，有两个 select 查询语句：一个用来加载博客（Blog），另外一个用来加载作者（Author），而且博客的结果映射描述了应该使用 selectAuthor 语句加载它的 author 属性。

< 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 id=" selectBlog" resultMap=" blogResult" > select B.idas blog_id, B.titleas blog_title, B.author_idas blog_author_id, A.idas author_id, A.usernameas author_username, A.passwordas author_password, A.emailas author_email, A.bioas author_bio from Blog B left outer join Author A on B.author_id = A.id where B.id = #{id} < /select>

< resultMap id=" blogResult" type=" Blog" > < id property=" id" column=" blog_id" /> < result property=" title" column=" blog_title" /> < association property=" author" column=" blog_author_id" javaType=" Author" resultMap=" authorResult" /> < /resultMap> < resultMap id=" authorResult" type=" 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" /> < /resultMap> < --也可以这么写,上面的示例使用了外部的结果映射元素来映射关联。这使得 Author 的结果映射可以被重用。如果你不打算重用,或者你更喜欢将你所有的结果映射放在一个具有描述性的结果映射元素中--> < resultMap id=" blogResult" type=" Blog" > < id property=" id" column=" blog_id" /> < 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" /> < /association> < /resultMap>

关联的多结果集（ResultSet）

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

某些数据库允许存储过程返回多个结果集，或一次性执行多个语句，每个语句返回一个结果集。我们可以利用这个特性，在不使用连接的情况下，只访问数据库一次就能获得相关数据。
在例子中，存储过程执行下面的查询并返回两个结果集。第一个结果集会返回博客（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” 关联：

< resultMap id=" blogResult" type=" Blog" > < id property=" id" column=" id" /> < result property=" title" column=" title" /> < association property=" author" javaType=" Author" resultSet=" authors" column=" author_id" foreignColumn=" id" > < id property=" id" column=" id" /> < result property=" username" column=" username" /> < result property=" password" column=" password" /> < result property=" email" column=" email" /> < result property=" bio" column=" bio" /> < /association> < /resultMap>

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

private List< Post> posts;

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

< resultMap id=" blogResult" type=" Blog" > < collection property=" posts" javaType=" ArrayList" column=" id" ofType=" Post" select=" selectPostsForBlog" /> < !-- “posts 是一个存储 Post 的 ArrayList 集合”--> < /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>

在一般情况下，MyBatis 可以推断 javaType 属性

< collection property=" posts" column=" id" ofType=" Post" select=" selectPostsForBlog" />

集合的嵌套结果映射

< 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>

< resultMap id=" blogResult" type=" Blog" > < id property=" id" column=" blog_id" /> < result property=" title" column=" blog_title" /> < collection property=" posts" ofType=" Post" > < id property=" id" column=" post_id" /> < result property=" subject" column=" post_subject" /> < result property=" body" column=" post_body" /> < /collection> < /resultMap>

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

< resultMap id=" blogResult" type=" Blog" > < id property=" id" column=" blog_id" /> < result property=" title" column=" blog_title" /> < collection property=" posts" ofType=" Post" resultMap=" blogPostResult" columnPrefix=" post_" /> < /resultMap> < resultMap id=" blogPostResult" type=" Post" > < id property=" id" column=" id" /> < result property=" subject" column=" subject" /> < result property=" body" column=" body" /> < /resultMap>

集合的多结果集（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” 结果集中的数据进行填充：

< resultMap id=" blogResult" type=" Blog" > < id property=" id" column=" id" /> < result property=" title" column=" title" /> < collection property=" posts" ofType=" Post" resultSet=" posts" column=" id" foreignColumn=" blog_id" > < id property=" id" column=" id" /> < result property=" subject" column=" subject" /> < result property=" body" column=" body" /> < /collection> < /resultMap>

自动映射在简单的场景下，MyBatis 可以为你自动映射查询结果。但如果遇到复杂的场景，你需要构建一个结果映射。在复杂的业务场景下，想要混用两种策略，我们可以通过自动映射。
自动映射查询结果时，MyBatis 会获取结果中返回的列名并在 Java 类中查找相同名字的属性（忽略大小写）。这意味着如果发现了 ID 列和 id 属性，MyBatis 会将列 ID 的值赋给 id 属性。
通常数据库列使用大写字母组成的单词命名，单词间用下划线分隔；而 Java 属性一般遵循驼峰命名法约定。为了在这两种命名方式之间启用自动映射，需要将 mapUnderscoreToCamelCase 设置为 true。
甚至在提供了结果映射后，自动映射也能工作。在这种情况下，对于每一个结果映射，在 ResultSet 出现的列，如果没有设置手动映射，将被自动映射。在自动映射处理完毕后，再处理手动映射。在下面的例子中，id 和 userName 列将被自动映射，hashed_password 列将根据配置进行映射。

< select id=" selectUsers" resultMap=" userResultMap" > select user_idas " id" , user_nameas " 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 属性来为指定的结果映射设置启用/禁用自动映射。