【Java開源框架】持久層框架mybatis之XML 映射文件及緩存說明3

 

XML 映射文件

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）參數，在 JDBC 中，這樣的一個參數在 SQL 中會由一個“?”來標識，並被傳遞到一個新的預處理語句中，就像這樣：

// 近似的 JDBC 代碼，非 MyBatis 代碼...
String selectPerson = "SELECT * FROM PERSON WHERE ID=?";
PreparedStatement ps = conn.prepareStatement(selectPerson);
ps.setInt(1,id);

當然，使用 JDBC 意味着需要更多的代碼來提取結果並將它們映射到對象實例中，而這就是 MyBatis 節省你時間的地方。參數和結果映射還有更深入的細節。這些細節會分別在後面單獨的小節中呈現。

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，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 有另外一種方法來生成主鍵。

這裏有一個簡單（甚至很傻）的示例，它可以生成一個隨機 ID（你最好不要這麼做，但這裏展示了 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 代碼的簡潔。

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="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="Some"/>
    <property name="include_target" value="sometable"/>
  </include>
</select>

參數

你之前見到的所有語句中，使用的都是簡單參數。實際上參數是 MyBatis 非常強大的元素。對於簡單的使用場景，大約 90% 的情況下你都不需要使用複雜的參數，比如：

<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 屬性將會被查找，然後將它們的值傳入預處理語句的參數中。

對向語句中傳遞參數來說，這真是既簡單又有效。不過參數映射的功能遠不止於此。

首先，像 MyBatis 的其他部分一樣，參數也可以指定一個特殊的數據類型。

#{property,javaType=int,jdbcType=NUMERIC}

像 MyBatis 的其它部分一樣，javaType 幾乎總是可以根據參數對象的類型確定下來，除非該對象是一個 HashMap。這個時候，你需要顯式指定 javaType 來確保正確的類型處理器（TypeHandler）被使用。

提示 JDBC 要求，如果一個列允許 null 值，並且會傳遞值 null 的參數，就必須要指定 JDBC Type。閱讀 PreparedStatement.setNull()的 JavaDoc 文檔來獲取更多信息。

要更進一步地自定義類型處理方式，你也可以指定一個特殊的類型處理器類（或別名），比如：

#{age,javaType=int,jdbcType=NUMERIC,typeHandler=MyTypeHandler}

儘管看起來配置變得越來越繁瑣，但實際上，很少需要如此繁瑣的配置。

對於數值類型，還有一個小數保留位數的設置，來指定小數點後保留的位數。

#{height,javaType=double,jdbcType=NUMERIC,numericScale=2}

最後，mode 屬性允許你指定 IN，OUT 或 INOUT 參數。如果參數的 mode 爲 OUT 或 INOUT，就像你在指定輸出參數時所期望的行爲那樣，參數對象的屬性實際值將會被改變。 如果 mode 爲 OUT（或 INOUT），而且 jdbcType 爲 CURSOR（也就是 Oracle 的 REFCURSOR），你必須指定一個 resultMap 引用來將結果集 ResultMap 映射到參數的類型上。要注意這裏的 javaType 屬性是可選的，如果留空並且 jdbcType 是 CURSOR，它會被自動地被設爲 ResultMap。

#{department, mode=OUT, jdbcType=CURSOR, javaType=ResultSet, resultMap=departmentResultMap}

MyBatis 也支持很多高級的數據類型，比如結構體（structs），但是當使用 out 參數時，你必須顯式設置類型的名稱。比如（再次提示，在實際中要像這樣不能換行）：

#{middleInitial, mode=OUT, jdbcType=STRUCT, jdbcTypeName=MY_TYPE, resultMap=departmentResultMap}

儘管所有這些選項很強大，但大多時候你只須簡單地指定屬性名，其他的事情 MyBatis 會自己去推斷，頂多要爲可能爲空的列指定 jdbcType。

#{firstName}
#{middleInitial,jdbcType=VARCHAR}
#{lastName}

字符串替換

默認情況下,使用 #{} 格式的語法會導致 MyBatis 創建 PreparedStatement 參數佔位符並安全地設置參數（就像使用 ? 一樣）。 這樣做更安全，更迅速，通常也是首選做法，不過有時你就是想直接在 SQL 語句中插入一個不轉義的字符串。 比如，像 ORDER BY，你可以這樣來使用：ORDER BY ${columnName}

這裏 MyBatis 不會修改或轉義字符串。

當 SQL 語句中的元數據（如表名或列名）是動態生成的時候，字符串替換將會非常有用。 舉個例子，如果你想通過任何一列從表中 select 數據時，不需要像下面這樣寫：

@Select("select * from user where id = #{id}")
User findById(@Param("id") long id);

@Select("select * from user where name = #{name}")
User findByName(@Param("name") String name);

@Select("select * from user where email = #{email}")
User findByEmail(@Param("email") String email);

// and more "findByXxx" method

可以只寫這樣一個方法：

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

其中 ${column} 會被直接替換，而 #{value} 會被使用 ? 預處理。 因此你就可以像下面這樣來達到上述功能：

User userOfId1 = userMapper.findByColumn("id", 1L);
User userOfNameKid = userMapper.findByColumn("name", "kid");
User userOfEmail = userMapper.findByColumn("email", "[email protected]");

這個想法也同樣適用於用來替換表名的情況。

注意：用這種方式接受用戶的輸入，並將其用於語句中的參數是不安全的，會導致潛在的 SQL 注入攻擊，因此要麼不允許用戶輸入這些字段，要麼自行轉義並檢驗。

結果映射

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>

類型別名是你的好幫手。使用它們，你就可以不用輸入類的完全限定名稱了。比如：

<!-- 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_id             as "id",
    user_name           as "userName",
    hashed_password     as "hashedPassword"
  from some_table
  where id = #{id}
</select>

ResultMap 最優秀的地方在於，雖然你已經對它相當瞭解了，但是根本就不需要顯式地用到他們。 上面這些簡單的示例根本不需要下面這些繁瑣的配置。 但出於示範的原因，讓我們來看看最後一個示例中，如果使用外部的 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="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 元素，因此可以具有相同的結構和元素，或者從別處引用一個

ResultMap屬性說明：

屬性	描述
id	當前命名空間中的一個唯一標識，用於標識一個結果映射。
type	類的完全限定名, 或者一個類型別名（關於內置的類型別名，可以參考上面的表格）。
autoMapping	如果設置這個屬性，MyBatis將會爲本結果映射開啓或者關閉自動映射。 這個屬性會覆蓋全局的屬性 autoMappingBehavior。默認值：未設置（unset）。

 最好一步步地建立結果映射。單元測試可以在這個過程中起到很大幫助。 如果你嘗試一次創建一個像上面示例那樣的巨大的結果映射，那麼很可能會出現錯誤而且很難去使用它來完成工作。 從最簡單的形態開始，逐步迭代。而且別忘了單元測試！ 使用框架的缺點是有時候它們看上去像黑盒子（無論源代碼是否可見）。 爲了確保你實現的行爲和想要的一致，最好的選擇是編寫單元測試。提交 bug 的時候它也能起到很大的作用。

下一部分將詳細說明每個元素。

id & result

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

這些是結果映射最基本的內容。id 和 result 元素都將一個列的值映射到一個簡單數據類型（String, int, double, Date 等）的屬性或字段。

這兩者之間的唯一不同是，id 元素表示的結果將是對象的標識屬性，這會在比較對象實例時用到。 這樣可以提高整體的性能，尤其是進行緩存和嵌套結果映射（也就是連接映射）的時候。

兩個元素都有一些屬性：

屬性	描述
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	我們在前面討論過默認的類型處理器。使用這個屬性，你可以覆蓋默認的類型處理器。 這個屬性值是一個類型處理器實現類的完全限定名，或者是類型別名。

支持的 JDBC 類型

爲了以後可能的使用場景，MyBatis 通過內置的 jdbcType 枚舉類型支持下面的 JDBC 類型。

BIT	FLOAT	CHAR	TIMESTAMP	OTHER	UNDEFINED
TINYINT	REAL	VARCHAR	BINARY	BLOB	NVARCHAR
SMALLINT	DOUBLE	LONGVARCHAR	VARBINARY	CLOB	NCHAR
INTEGER	NUMERIC	DATE	LONGVARBINARY	BOOLEAN	NCLOB
BIGINT	DECIMAL	TIME	NULL	CURSOR	ARRAY

構造方法

通過修改對象屬性的方式，可以滿足大多數的數據傳輸對象（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 的順序給出。

<constructor>
   <idArg column="id" javaType="int"/>
   <arg column="username" javaType="String"/>
   <arg column="age" javaType="_int"/>
</constructor>

當你在處理一個帶有多個形參的構造方法時，很容易搞亂 arg 元素的順序。 從版本 3.4.3 開始，可以在指定參數名稱的前提下，以任意順序編寫 arg 元素。 爲了通過名稱來引用構造方法參數，你可以添加 @Param 註解，或者使用 '-parameters' 編譯選項並啓用 useActualParamName 選項（默認開啓）來編譯項目。下面是一個等價的例子，儘管函數簽名中第二和第三個形參的順序與 constructor 元素中參數聲明的順序不匹配。

<constructor>
   <idArg column="id" javaType="int" name="id" />
   <arg column="age" javaType="_int" name="age" />
   <arg column="username" javaType="String" name="username" />
</constructor>

如果存在名稱和類型相同的屬性，那麼可以省略 javaType 。

剩餘的屬性和規則和普通的 id 和 result 元素是一樣的。

屬性	描述
column	數據庫中的列名，或者是列的別名。一般情況下，這和傳遞給 resultSet.getString(columnName) 方法的參數一樣。
javaType	一個 Java 類的完全限定名，或一個類型別名（關於內置的類型別名，可以參考上面的表格）。 如果你映射到一個 JavaBean，MyBatis 通常可以推斷類型。然而，如果你映射到的是 HashMap，那麼你應該明確地指定 javaType 來保證行爲與期望的相一致。
jdbcType	JDBC 類型，所支持的 JDBC 類型參見這個表格之前的“支持的 JDBC 類型”。 只需要在可能執行插入、更新和刪除的且允許空值的列上指定 JDBC 類型。這是 JDBC 的要求而非 MyBatis 的要求。如果你直接面向 JDBC 編程，你需要對可能存在空值的列指定這個類型。
typeHandler	我們在前面討論過默認的類型處理器。使用這個屬性，你可以覆蓋默認的類型處理器。 這個屬性值是一個類型處理器實現類的完全限定名，或者是類型別名。
select	用於加載複雜類型屬性的映射語句的 ID，它會從 column 屬性中指定的列檢索數據，作爲參數傳遞給此 select 語句。具體請參考關聯元素。
resultMap	結果映射的 ID，可以將嵌套的結果集映射到一個合適的對象樹中。 它可以作爲使用額外 select 語句的替代方案。它可以將多表連接操作的結果映射成一個單一的 ResultSet。這樣的 ResultSet 將會將包含重複或部分數據重複的結果集。爲了將結果集正確地映射到嵌套的對象樹中，MyBatis 允許你 “串聯”結果映射，以便解決嵌套結果集的問題。想了解更多內容，請參考下面的關聯元素。
name	構造方法形參的名字。從 3.4.3 版本開始，通過指定具體的參數名，你可以以任意順序寫入 arg 元素。參看上面的解釋。

關聯

<association property="author" column="blog_author_id" javaType="Author">
  <id property="id" column="author_id"/>
  <result property="username" column="author_username"/>
</association>

關聯（association）元素處理“有一個”類型的關係。 比如，在我們的示例中，一個博客有一個用戶。關聯結果映射和其它類型的映射工作方式差不多。 你需要指定目標屬性名以及屬性的javaType（很多時候 MyBatis 可以自己推斷出來），在必要的情況下你還可以設置 JDBC 類型，如果你想覆蓋獲取結果值的過程，還可以設置類型處理器。

關聯的不同之處是，你需要告訴 MyBatis 如何加載關聯。MyBatis 有兩種不同的方式加載關聯：

• 嵌套 Select 查詢：通過執行另外一個 SQL 映射語句來加載期望的複雜類型。
• 嵌套結果映射：使用嵌套的結果映射來處理連接結果的重複子集。

首先，先讓我們來看看這個元素的屬性。你將會發現，和普通的結果映射相比，它只在 select 和 resultMap 屬性上有所不同。

屬性	描述
property	映射到列結果的字段或屬性。如果用來匹配的 JavaBean 存在給定名字的屬性，那麼它將會被使用。否則 MyBatis 將會尋找給定名稱的字段。 無論是哪一種情形，你都可以使用通常的點式分隔形式進行復雜屬性導航。 比如，你可以這樣映射一些簡單的東西：“username”，或者映射到一些複雜的東西上：“address.street.number”。
javaType	一個 Java 類的完全限定名，或一個類型別名（關於內置的類型別名，可以參考上面的表格）。 如果你映射到一個 JavaBean，MyBatis 通常可以推斷類型。然而，如果你映射到的是 HashMap，那麼你應該明確地指定 javaType 來保證行爲與期望的相一致。
jdbcType	JDBC 類型，所支持的 JDBC 類型參見這個表格之前的“支持的 JDBC 類型”。 只需要在可能執行插入、更新和刪除的且允許空值的列上指定 JDBC 類型。這是 JDBC 的要求而非 MyBatis 的要求。如果你直接面向 JDBC 編程，你需要對可能存在空值的列指定這個類型。
typeHandler	我們在前面討論過默認的類型處理器。使用這個屬性，你可以覆蓋默認的類型處理器。 這個屬性值是一個類型處理器實現類的完全限定名，或者是類型別名。

關聯的嵌套 Select 查詢

 

屬性	描述
column	數據庫中的列名，或者是列的別名。一般情況下，這和傳遞給 resultSet.getString(columnName) 方法的參數一樣。 注意：在使用複合主鍵的時候，你可以使用 column="{prop1=col1,prop2=col2}" 這樣的語法來指定多個傳遞給嵌套 Select 查詢語句的列名。這會使得 prop1 和 prop2 作爲參數對象，被設置爲對應嵌套 Select 語句的參數。
select	用於加載複雜類型屬性的映射語句的 ID，它會從 column 屬性指定的列中檢索數據，作爲參數傳遞給目標 select 語句。 具體請參考下面的例子。注意：在使用複合主鍵的時候，你可以使用 column="{prop1=col1,prop2=col2}" 這樣的語法來指定多個傳遞給嵌套 Select 查詢語句的列名。這會使得 prop1 和 prop2 作爲參數對象，被設置爲對應嵌套 Select 語句的參數。
fetchType	可選的。有效值爲 lazy 和 eager。 指定屬性後，將在映射中忽略全局配置參數 lazyLoadingEnabled，使用屬性的值。

<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 能夠對這樣的查詢進行延遲加載，因此可以將大量語句同時運行的開銷分散開來。 然而，如果你加載記錄列表之後立刻就遍歷列表以獲取嵌套的數據，就會觸發所有的延遲加載查詢，性能可能會變得很糟糕。

所以還有另外一種方法。

關聯的嵌套結果映射

屬性	描述
resultMap	結果映射的 ID，可以將此關聯的嵌套結果集映射到一個合適的對象樹中。 它可以作爲使用額外 select 語句的替代方案。它可以將多表連接操作的結果映射成一個單一的 ResultSet。這樣的 ResultSet 有部分數據是重複的。 爲了將結果集正確地映射到嵌套的對象樹中, MyBatis 允許你“串聯”結果映射，以便解決嵌套結果集的問題。使用嵌套結果映射的一個例子在表格以後。
columnPrefix	當連接多個表時，你可能會不得不使用列別名來避免在 ResultSet 中產生重複的列名。指定 columnPrefix 列名前綴允許你將帶有這些前綴的列映射到一個外部的結果映射中。 詳細說明請參考後面的例子。
notNullColumn	默認情況下，在至少一個被映射到屬性的列不爲空時，子對象纔會被創建。 你可以在這個屬性上指定非空的列來改變默認行爲，指定後，Mybatis 將只在這些列非空時才創建一個子對象。可以使用逗號分隔來指定多個列。默認值：未設置（unset）。
autoMapping	如果設置這個屬性，MyBatis 將會爲本結果映射開啓或者關閉自動映射。 這個屬性會覆蓋全局的屬性 autoMappingBehavior。注意，本屬性對外部的結果映射無效，所以不能搭配 select 或 resultMap 元素使用。默認值：未設置（unset）。

之前，你已經看到了一個非常複雜的嵌套關聯的例子。 下面的例子則是一個非常簡單的例子，用於演示嵌套結果映射如何工作。 現在我們將博客表和作者表連接在一起，而不是執行一個獨立的查詢語句，就像這樣：

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

注意查詢中的連接，以及爲確保結果能夠擁有唯一且清晰的名字，我們設置的別名。 這使得進行映射非常簡單。現在我們可以映射這個結果：

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

在上面的例子中，你可以看到，博客（Blog）作者（author）的關聯元素委託名爲 “authorResult” 的結果映射來加載作者對象的實例。

非常重要： id 元素在嵌套結果映射中扮演着非常重要的角色。你應該總是指定一個或多個可以唯一標識結果的屬性。 雖然，即使不指定這個屬性，MyBatis 仍然可以工作，但是會產生嚴重的性能問題。 只需要指定可以唯一標識結果的最少屬性。顯然，你可以選擇主鍵（複合主鍵也可以）。

現在，上面的示例使用了外部的結果映射元素來映射關聯。這使得 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>

那如果博客（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 的結果映射定義如下：

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

由於結果中的列名與結果映射中的列名不同。你需要指定 columnPrefix 以便重複使用該結果映射來映射 co-author 的結果。

<resultMap id="blogResult" type="Blog">
  <id property="id" column="blog_id" />
  <result property="title" column="blog_title"/>
  <association property="author"
    resultMap="authorResult" />
  <association property="coAuthor"
    resultMap="authorResult"
    columnPrefix="co_" />
</resultMap>

關聯的多結果集（ResultSet）

 

屬性	描述
column	當使用多個結果集時，該屬性指定結果集中用於與 foreignColumn 匹配的列（多個列名以逗號隔開），以識別關係中的父類型與子類型。
foreignColumn	指定外鍵對應的列名，指定的列將與父類型中 column 的給出的列進行匹配。
resultSet	指定用於加載複雜類型的結果集名字。

從版本 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” 關聯：

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

你已經在上面看到了如何處理“有一個”類型的關聯。但是該怎麼處理“有很多個”類型的關聯呢？這就是我們接下來要介紹的。

集合

<collection property="posts" ofType="domain.blog.Post">
  <id property="id" column="post_id"/>
  <result property="subject" column="post_subject"/>
  <result property="body" column="post_body"/>
</collection>

集合元素和關聯元素幾乎是一樣的，它們相似的程度之高，以致於沒有必要再介紹集合元素的相似部分。 所以讓我們來關注它們的不同之處吧。

我們來繼續上面的示例，一個博客（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（或字段）屬性的類型和集合存儲的類型區分開來。 所以你可以按照下面這樣來閱讀映射：

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

讀作： “posts 是一個存儲 Post 的 ArrayList 集合”

在一般情況下，MyBatis 可以推斷 javaType 屬性，因此並不需要填寫。所以很多時候你可以簡略成：

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

集合的嵌套結果映射

現在你可能已經猜到了集合的嵌套結果映射是怎樣工作的——除了新增的 “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>

我們再次連接了博客表和文章表，並且爲每一列都賦予了一個有意義的別名，以便映射保持簡單。 要映射博客裏面的文章集合，就這麼簡單：

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

再提醒一次，要記得上面 id 元素的重要性，如果你不記得了，請閱讀關聯部分的相關部分。

如果你喜歡更詳略的、可重用的結果映射，你可以使用下面的等價形式：

<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 的好處在於，可以在不對你的代碼引入重大變更（如果有）的情況下，允許你之後改變你的想法。

高級關聯和集合映射是一個深度話題。文檔的介紹只能到此爲止。配合少許的實踐，你會很快了解全部的用法。

鑑別器

<discriminator javaType="int" column="draft">
  <case value="1" resultType="DraftPost"/>
</discriminator>

有時候，一個數據庫查詢可能會返回多個不同的結果集（但總體上還是有一定的聯繫的）。 鑑別器（discriminator）元素就是被設計來應對這種情況的，另外也能處理其它情況，例如類的繼承層次結構。 鑑別器的概念很好理解——它很像 Java 語言中的 switch 語句。

一個鑑別器的定義需要指定 column 和 javaType 屬性。column 指定了 MyBatis 查詢被比較值的地方。 而 javaType 用來確保使用正確的相等測試（雖然很多情況下字符串的相等測試都可以工作）。例如：

<resultMap id="vehicleResult" type="Vehicle">
  <id property="id" column="id" />
  <result property="vin" column="vin"/>
  <result property="year" column="year"/>
  <result property="make" column="make"/>
  <result property="model" column="model"/>
  <result property="color" column="color"/>
  <discriminator javaType="int" column="vehicle_type">
    <case value="1" resultMap="carResult"/>
    <case value="2" resultMap="truckResult"/>
    <case value="3" resultMap="vanResult"/>
    <case value="4" resultMap="suvResult"/>
  </discriminator>
</resultMap>

在這個示例中，MyBatis 會從結果集中得到每條記錄，然後比較它的 vehicle type 值。 如果它匹配任意一個鑑別器的 case，就會使用這個 case 指定的結果映射。 這個過程是互斥的，也就是說，剩餘的結果映射將被忽略（除非它是擴展的，我們將在稍後討論它）。 如果不能匹配任何一個 case，MyBatis 就只會使用鑑別器塊外定義的結果映射。 所以，如果 carResult 的聲明如下：

<resultMap id="carResult" type="Car">
  <result property="doorCount" column="door_count" />
</resultMap>

那麼只有 doorCount 屬性會被加載。這是爲了即使鑑別器的 case 之間都能分爲完全獨立的一組，儘管和父結果映射可能沒有什麼關係。在上面的例子中，我們當然知道 cars 和 vehicles 之間有關係，也就是 Car 是一個 Vehicle。因此，我們希望剩餘的屬性也能被加載。而這只需要一個小修改。

<resultMap id="carResult" type="Car" extends="vehicleResult">
  <result property="doorCount" column="door_count" />
</resultMap>

現在 vehicleResult 和 carResult 的屬性都會被加載了。

可能有人又會覺得映射的外部定義有點太冗長了。 因此，對於那些更喜歡簡潔的映射風格的人來說，還有另一種語法可以選擇。例如：

<resultMap id="vehicleResult" type="Vehicle">
  <id property="id" column="id" />
  <result property="vin" column="vin"/>
  <result property="year" column="year"/>
  <result property="make" column="make"/>
  <result property="model" column="model"/>
  <result property="color" column="color"/>
  <discriminator javaType="int" column="vehicle_type">
    <case value="1" resultType="carResult">
      <result property="doorCount" column="door_count" />
    </case>
    <case value="2" resultType="truckResult">
      <result property="boxSize" column="box_size" />
      <result property="extendedCab" column="extended_cab" />
    </case>
    <case value="3" resultType="vanResult">
      <result property="powerSlidingDoor" column="power_sliding_door" />
    </case>
    <case value="4" resultType="suvResult">
      <result property="allWheelDrive" column="all_wheel_drive" />
    </case>
  </discriminator>
</resultMap>

提示 請注意，這些都是結果映射，如果你完全不設置任何的 result 元素，MyBatis 將爲你自動匹配列和屬性。所以上面的例子大多都要比實際的更復雜。 這也表明，大多數數據庫的複雜度都比較高，我們不太可能一直依賴於這種機制。

自動映射

正如你在前面一節看到的，在簡單的場景下，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 屬性來爲指定的結果映射設置啓用/禁用自動映射。

<resultMap id="userResultMap" type="User" autoMapping="false">
  <result property="password" column="hashed_password"/>
</resultMap>

緩存

MyBatis 內置了一個強大的事務性查詢緩存機制，它可以非常方便地配置和定製。 爲了使它更加強大而且易於配置，我們對 MyBatis 3 中的緩存實現進行了許多改進。

默認情況下，只啓用了本地的會話緩存，它僅僅對一個會話中的數據進行緩存。 要啓用全局的二級緩存，只需要在你的 SQL 映射文件中添加一行：

<cache/>

基本上就是這樣。這個簡單語句的效果如下:

• 映射語句文件中的所有 select 語句的結果將會被緩存。
• 映射語句文件中的所有 insert、update 和 delete 語句會刷新緩存。
• 緩存會使用最近最少使用算法（LRU, Least Recently Used）算法來清除不需要的緩存。
• 緩存不會定時進行刷新（也就是說，沒有刷新間隔）。
• 緩存會保存列表或對象（無論查詢方法返回哪種）的 1024 個引用。
• 緩存會被視爲讀/寫緩存，這意味着獲取到的對象並不是共享的，可以安全地被調用者修改，而不干擾其他調用者或線程所做的潛在修改。

提示 緩存只作用於 cache 標籤所在的映射文件中的語句。如果你混合使用 Java API 和 XML 映射文件，在共用接口中的語句將不會被默認緩存。你需要使用 @CacheNamespaceRef 註解指定緩存作用域。

這些屬性可以通過 cache 元素的屬性來修改。比如：

<cache
  eviction="FIFO"
  flushInterval="60000"
  size="512"
  readOnly="true"/>

這個更高級的配置創建了一個 FIFO 緩存，每隔 60 秒刷新，最多可以存儲結果對象或列表的 512 個引用，而且返回的對象被認爲是隻讀的，因此對它們進行修改可能會在不同線程中的調用者產生衝突。

可用的清除策略有：

• LRU – 最近最少使用：移除最長時間不被使用的對象。
• FIFO – 先進先出：按對象進入緩存的順序來移除它們。
• SOFT – 軟引用：基於垃圾回收器狀態和軟引用規則移除對象。
• WEAK – 弱引用：更積極地基於垃圾收集器狀態和弱引用規則移除對象。

默認的清除策略是 LRU。

flushInterval（刷新間隔）屬性可以被設置爲任意的正整數，設置的值應該是一個以毫秒爲單位的合理時間量。 默認情況是不設置，也就是沒有刷新間隔，緩存僅僅會在調用語句時刷新。

size（引用數目）屬性可以被設置爲任意正整數，要注意欲緩存對象的大小和運行環境中可用的內存資源。默認值是 1024。

readOnly（只讀）屬性可以被設置爲 true 或 false。只讀的緩存會給所有調用者返回緩存對象的相同實例。 因此這些對象不能被修改。這就提供了可觀的性能提升。而可讀寫的緩存會（通過序列化）返回緩存對象的拷貝。 速度上會慢一些，但是更安全，因此默認值是 false。

提示 二級緩存是事務性的。這意味着，當 SqlSession 完成並提交時，或是完成並回滾，但沒有執行 flushCache=true 的 insert/delete/update 語句時，緩存會獲得更新。

使用自定義緩存

除了上述自定義緩存的方式，你也可以通過實現你自己的緩存，或爲其他第三方緩存方案創建適配器，來完全覆蓋緩存行爲。

<cache type="com.domain.something.MyCustomCache"/>

這個示例展示瞭如何使用一個自定義的緩存實現。type 屬性指定的類必須實現 org.mybatis.cache.Cache 接口，且提供一個接受 String 參數作爲 id 的構造器。 這個接口是 MyBatis 框架中許多複雜的接口之一，但是行爲卻非常簡單。

public interface Cache {
  String getId();
  int getSize();
  void putObject(Object key, Object value);
  Object getObject(Object key);
  boolean hasKey(Object key);
  Object removeObject(Object key);
  void clear();
}

爲了對你的緩存進行配置，只需要簡單地在你的緩存實現中添加公有的 JavaBean 屬性，然後通過 cache 元素傳遞屬性值，例如，下面的例子將在你的緩存實現上調用一個名爲 setCacheFile(String file) 的方法：

<cache type="com.domain.something.MyCustomCache">
  <property name="cacheFile" value="/tmp/my-custom-cache.tmp"/>
</cache>

你可以使用所有簡單類型作爲 JavaBean 屬性的類型，MyBatis 會進行轉換。 你也可以使用佔位符（如 ${cache.file}），以便替換成在配置文件屬性中定義的值。

從版本 3.4.2 開始，MyBatis 已經支持在所有屬性設置完畢之後，調用一個初始化方法。 如果想要使用這個特性，請在你的自定義緩存類裏實現 org.apache.ibatis.builder.InitializingObject 接口。

public interface InitializingObject {
  void initialize() throws Exception;
}

提示 上一節中對緩存的配置（如清除策略、可讀或可讀寫等），不能應用於自定義緩存。

請注意，緩存的配置和緩存實例會被綁定到 SQL 映射文件的命名空間中。 因此，同一命名空間中的所有語句和緩存將通過命名空間綁定在一起。 每條語句可以自定義與緩存交互的方式，或將它們完全排除於緩存之外，這可以通過在每條語句上使用兩個簡單屬性來達成。 默認情況下，語句會這樣來配置：

<select ... flushCache="false" useCache="true"/>
<insert ... flushCache="true"/>
<update ... flushCache="true"/>
<delete ... flushCache="true"/>

鑑於這是默認行爲，顯然你永遠不應該以這樣的方式顯式配置一條語句。但如果你想改變默認的行爲，只需要設置 flushCache 和 useCache 屬性。比如，某些情況下你可能希望特定 select 語句的結果排除於緩存之外，或希望一條 select 語句清空緩存。類似地，你可能希望某些 update 語句執行時不要刷新緩存。

cache-ref

回想一下上一節的內容，對某一命名空間的語句，只會使用該命名空間的緩存進行緩存或刷新。 但你可能會想要在多個命名空間中共享相同的緩存配置和實例。要實現這種需求，你可以使用 cache-ref 元素來引用另一個緩存。

<cache-ref namespace="com.someone.application.data.SomeMapper"/>