SQL 映射文件几个顶级元素（按照它们应该被定义的顺序）为：

• cache – 给定命名空间的缓存配置。
• cache-ref – 其他命名空间缓存配置的引用。
• resultMap – 是最复杂也是最强大的元素，用来描述如何从数据库结果集中来加载对象。
• sql – 可被其他语句引用的可重用语句块。
• insert – 映射插入语句
• update – 映射更新语句
• delete – 映射删除语句
• select – 映射查询语句

select

<select> 元素的使用示例如下：

<select id="selectUserById1" parameterType="int" resultType="hashmap">
    select * from tb_user where id = #{id}
</select>

这个语句被称作 selectUserById1，接受一个 int（或 Integer）类型的参数，并返回一个 HashMap 类型的对象，其中的键是列名，值便是结果行中的对应值。参数符号 #{id} 告诉 MyBatis 创建一个预处理语句参数

select 元素的属性有：

insert, update 和 delete

insert, update 和 delete 的属性有：

<insert> 元素的使用示例如下：

<insert id="insertUser" parameterType="User" statementType="PREPARED" keyProperty="id" useGeneratedKeys="true">
    insert into tb_user(username, password) values(#{username}, #{password})
</insert>

属性 useGeneratedKeys="true" 使用数据库的自动生成主键，并设置 keyProperty="id" 到对应的 JavaBean 属性，这使得自动生成的 key 添加到传进的参数 User 对应的属性 id

SqlSession session = sqlSessionFactory.openSession();
try {
    User user = new User();
    user.setUsername("lianwx");
    user.setPassword("123456");
    session.insert("insertUser", user);
    System.out.println("id :" + user.getId());
    // 一般情况下不会自动提交
    session.commit();
} catch (Exception e) {
    session.rollback();
    e.printStackTrace();
} finally {
    session.close();
}

属性 statementType="PREPARED" 表示使用预编译，如果需要使用非预编译，使用 statementType="STATEMENT"

<update> 元素的使用示例如下：

<update id="updateUser" parameterType="User">
    update tb_user set username = #{username}, password = #{password} where id = #{id}
</update>

SqlSession session = sqlSessionFactory.openSession();
try {
    User user = new User();
    user.setId(2);
    user.setUsername("lianwx");
    user.setPassword("654321");
    session.update("updateUser", user);
    session.commit();
} catch (Exception e) {
    session.rollback();
    e.printStackTrace();
} finally {
    session.close();
}

<delete> 元素的使用示例如下：

<delete id="deleteUser" parameterType="User">
    delete from tb_user where id = #{id}
</delete>

SqlSession session = sqlSessionFactory.openSession();
try {
    User user = new User();
    user.setId(2);
    session.delete("deleteUser", user);
    session.commit();
} catch (Exception e) {
    session.rollback();
    e.printStackTrace();
} finally {
    session.close();
}

ResultMap —— 解决复杂查询的映射问题

前面在映射文件中使用的：

<select id="selectUserById1" resultType="User" parameterType="Integer">
    select * from tb_user where id = #{id}
</select>

实际上 myBatis 会在幕后自动创建一个 ResultMap ，基于属性名来映射列到 JavaBean 的属性上。实际如下：

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

<select id="selectUserById1" resultMap="userResultMap" parameterType="Integer">
    select * from tb_user where id = #{id}
</select>

ResultMap 指明了对象的属性到列名的关系

<id> 元素声明为主键，<result> 元素声明为其他属性。<id> 元素也可以用<result> 元素替代，但会严重影响查询性能。 property 属性指对应 javaBean 的属性名，column 属性指查询返回表的列名。

<resultMap> 元素的概念视图:

• constructor - 类在实例化时,用来注入结果到构造方法中
  • idArg - ID 参数;标记结果作为 ID 可以帮助提高整体效能
  • arg - 注入到构造方法的一个普通结果
• id – 一个 ID 结果;标记结果作为 ID 可以帮助提高整体效能
• result – 注入到字段或 JavaBean 属性的普通结果
• association – 一个复杂的类型关联;许多结果将包成这种类型
  • 嵌入结果映射 – 结果映射自身的关联,或者参考一个
• collection – 复杂类型的集
  • 嵌入结果映射 – 结果映射自身的集,或者参考一个
• discriminator – 使用结果值来决定使用哪个结果映射
  • case – 基于某些值的结果映射
    • 嵌入结果映射 – 这种情形结果也映射它本身,因此可以包含很多相 同的元素,或者它可以参照一个外部的结果映射

<resultMap> 的属性：

<id> & <result> 属性：

PS1：<resultMap> 还支持构造器的构造方法 <constructor> 元素( 包含 <idArg> 和 <arg> 子元素 )，相关属性见附录 - <constructor> 的子元素 <idArg> & <arg> 属性

PS2：支持的 JDBC 类型见附录 - jdbcType支持的 JDBC 类型

关联查询（联合查询）

假设除了前面的 tb_user 表外还有另外一张表：tb_user_detail ，表示用户的详细资料，表字段为：id, realname, address。并修改表 tb_user 增加字段 detail_id 外键关联表 tb_user_detail 字段 id

我们可以在程序中添加 JavaBean :

public class UserDetail {
    private int id;
    private String realname;
    private String address;
    
    // 省略 getter 和 setter
}

并修改 User :

public class User {

    private Integer id;
    private String username;
    private String password;
    // 新添加的属性
    private UserDetail userDetail;
    
    // 省略 getter 和 setter
}

则在映射文件 UserMapper.xml 中添加：

<resultMap id="userResultMap" type="User">
    <id property="id" column="user_id"/>
    <result property="username" column="username"/>
    <result property="password" column="password"/>
    <association property="userDetail" javaType="UserDetail">
        <id property="id" column="detail_id"/>
        <result property="realname" column="realname"/>
        <result property="address" column="address"/>
    </association>
</resultMap>

<select id="selectUserUsingResultMap" resultMap="userResultMap" parameterType="Integer">
    select 
        A.id as user_id,
        A.username as username,
        A.password as password,
        B.id as detail_id,
        B.realname as realname,
        B.address as address
    from tb_user A
        inner join tb_user_detail B on A.detail_id = B.id
    where A.id = #{id}
</select>

查询：

SqlSession session = sqlSessionFactory.openSession();
try {
    User user = session.selectOne("selectUserUsingResultMap", 1);
    System.out.println("username :" + user.getUsername());
    System.out.println("realname :" + user.getUserDetail().getRealname());
    session.commit();
} catch (Exception e) {
    session.rollback();
    e.printStackTrace();
} finally {
    session.close();
}

上述映射文件 <select> 用 inner join 内联接建立一个关联查询，在对应 <resultMap> 中使用 <association> 映射这种关联关系

<association> 中属性 javaType 指明对应 javaBean 的类

上面的映射文件也可以写成如下，这种写法使得 UserDetail 结果映射可以重用

<resultMap id="userResultMap" type="User">
    <id property="id" column="user_id"/>
    <result property="username" column="username"/>
    <result property="password" column="password"/>
    <association property="userDetail" column="detail_id" javaType="UserDetail" resultMap="authorResultMap">
    </association>
</resultMap>

<resultMap id="authorResultMap" type="UserDetail">
  <id property="id" column="detail_id"/>
  <result property="realname" column="realname"/>
  <result property="address" column="address"/>
</resultMap>

<select id="selectUserUsingResultMap" resultMap="userResultMap" parameterType="Integer">
    select 
        A.id as user_id,
        A.username as username,
        A.password as password,
        B.id as detail_id,
        B.realname as realname,
        B.address as address
    from tb_user A
        inner join tb_user_detail B on A.detail_id = B.id
    where A.id = #{id}
</select>

PS：在进行联合查询时，必须确保没有重名的字段，如果有，则必须用** as **进行区分

<association> 的属性1：

子查询（嵌套查询）

上面的联合查询，可以用子查询来实现，即先查询 tb_user 表，再根据 tb_user 表中字段 detail_id 的值再查询 tb_user_detail 表

上述查询在映射文件中为：

<resultMap type="User" id="userResultMap2">
    <!-- 其他属性自动映射，可省略 -->
    <association property="userDetail" column="detail_id" javaType="UserDetail" select="selectUserDetail">          
    </association>
</resultMap>

<select id="selectUserDetail" resultType="UserDetail">
    select * from tb_user_detail where id = #{id}
</select>

<select id="selectUserBySubQuery" resultMap="userResultMap2" parameterType="int">
    select * from tb_user where id = #{id}
</select>

<association> 的属性2：

PS：子查询与联合查询的比较见附录 - 子查询与联合查询的比较

集合查询

假设除了前面的 tb_user 表外还有另外一张表：tb_item ，表示用户的所拥有的物品，表字段为：id, user_id, item_name。

我们可以在程序中添加 JavaBean :

public class Item {
    private int id;
    private User user;
    private String itemName;
    
    // 省略 getter 和 setter
}

并修改 User :

public class User {

    private Integer id;
    private String username;
    private String password;
    private UserDetail userDetail;
    // 新添加的属性
    private List<Item> items;
    
    // 省略 getter 和 setter
}

则在映射文件 UserMapper.xml 中添加：

<resultMap id="userWithCollectionMap" type="User">
    <id property="id" column="user_id" />
    <result property="username" column="username" />
    <result property="password" column="password" />
    <association property="userDetail" javaType="UserDetail">
        <id property="id" column="detail_id" />
        <result property="realname" column="realname" />
        <result property="address" column="address" />
    </association>
    <collection property="items" javaType="ArrayList" ofType="Item">
        <id property="id" column="item_id" />
        <result property="itemName" column="item_name" />
    </collection>
</resultMap>

<select id="selectUserWithCollection" resultMap="userWithCollectionMap"
    parameterType="int">
    select
    A.id as user_id,
    A.username,
    A.password,
    B.id as detail_id,
    B.realname,
    B.address,
    C.id as item_id,
    C.item_name
    from tb_user A
    inner join tb_user_detail B on A.detail_id = B.id
    inner join tb_item C on A.id = C.user_id
    where A.id = #{id}
</select>

同理，该映射文件的 <association 和 <collection 可借助 resultMap 属性分离出另外的 <resultMap> 实现重用

查询：

SqlSession session = sqlSessionFactory.openSession();
try {
    User user = session.selectOne("selectUserWithCollection", 1);
    System.out.println("username :" + user.getUsername());
    System.out.println("realname :" + user.getUserDetail().getRealname());
    for (Item item : user.getItems()) {
        System.out.println("item"+ item.getId() +" :" + item.getItemName());
    }
    session.commit();
} catch (Exception e) {
    session.rollback();
    e.printStackTrace();
} finally {
    session.close();
}

上面的映射文件也可写成如下，即使用子查询的形式

<resultMap id="userWithCollectionMap2" type="User">
    <id property="id" column="id" />
    <result property="username" column="username" />
    <result property="password" column="password" />
    <association property="userDetail" column="detail_id" javaType="UserDetail" select="userWithCollectionMap2Sub1" />
    <collection property="items" javaType="ArrayList" column="id" ofType="Item" select="userWithCollectionMap2Sub2"/>
</resultMap>

<select id="userWithCollectionMap2Sub1" resultType="UserDetail">
    select * from tb_user_detail where id = #{id}
</select>

<select id="userWithCollectionMap2Sub2" resultType="Item">
    select id,user_id,item_name as itemName from tb_item where user_id = #{id}
</select>

<select id="selectUserWithCollection" resultMap="userWithCollectionMap2" parameterType="int">
    select * from tb_user where id = #{id}
</select>

鉴别器

缓存

MyBatis 包含一个非常强大的查询缓存特性,它可以非常方便地配置和定制

默认情况下是没有开启缓存的,除了局部的 session 缓存,可以增强变现而且处理循环依赖也是必须的

要开启二级缓存，首先确保在 mybatis XML配置文件的 <settings> 元素中

<setting name="cacheEnabled" value="true" />

为默认的开始状态。

其次，需要在 SQL 映射文件中添加一行：

<cache/>

它的效果有：

• 映射语句文件中的所有 select 语句将会被缓存。
• 映射语句文件中的所有 insert,update 和 delete 语句会刷新缓存。
• 缓存会使用 Least Recently Used(LRU,最近最少使用的)算法来收回。
• 根据时间表(比如 no Flush Interval,没有刷新间隔), 缓存不会以任何时间顺序来刷新。
• 缓存会存储列表集合或对象(无论查询方法返回什么)的 1024 个引用。
• 缓存会被视为是 read/write (可读/可写)的缓存，意味着对象检索不是共享的，而且可以安全地被调用者修改，而不干扰其他调用者或线程所做的潜在修改。

所有的这些属性都可以通过缓存元素的属性来修改。比如:

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

这个更高级的配置创建了一个 FIFO 缓存,并每隔 60 秒刷新,存数结果对象或列表的 512 个引用,而且返回的对象被认为是只读的,因此在不同线程中的调用者之间修改它们会导致冲突。

可用的收回策略有:

• LRU – 最近最少使用的:移除最长时间不被使用的对象。
• FIFO – 先进先出:按对象进入缓存的顺序来移除它们。
• SOFT – 软引用:移除基于垃圾回收器状态和软引用规则的对象。
• WEAK – 弱引用:更积极地移除基于垃圾收集器状态和弱引用规则的对象。

flushInterval(刷新间隔)可以被设置为任意的正整数,而且它们代表一个合理的毫秒 形式的时间段。默认情况是不设置,也就是没有刷新间隔,缓存仅仅调用语句时刷新。

size(引用数目)可以被设置为任意正整数,要记住你缓存的对象数目和你运行环境的 可用内存资源数目。默认值是 1024。

readOnly(只读)属性可以被设置为 true 或 false。只读的缓存会给所有调用者返回缓 存对象的相同实例。因此这些对象不能被修改。这提供了很重要的性能优势。可读写的缓存 会返回缓存对象的拷贝(通过序列化) 。这会慢一些,但是安全,因此默认是 false。

第三，在具体的SQL语句处指定使用缓存( 属性 useCache )，默认是开启的

<select id="selectCount" useCache="true">
...
</select>

自定义缓存

参照缓存

动态 SQL

MyBatis 的强大特性之一便是它的动态 SQL。利用动态 SQL 这一特性可以彻底摆脱根据不同条件拼接 SQL 语句这种痛苦

if

动态 SQL 通常要做的事情是有条件地包含 where 子句的一部分。比如:

<select id="findActiveBlogWithTitleLike" resultType="Blog">
  SELECT * FROM BLOG 
  WHERE state = ‘ACTIVE’ 
  <if test="title != null">
    AND title like #{title}
  </if>
</select>

如果没有传入“title”，则 <if>所包含的 SQL 语句不会添加到最后的查询 SQL 语句中

choose, when, otherwise

有些时候，我们不想用到所有的条件语句，而只想从中择其一二。针对这种情况，MyBatis 提供了 choose 元素，它有点像 Java 中的 switch 语句

<select id="findActiveBlogLike"
     resultType="Blog">
  SELECT * FROM BLOG WHERE state = ‘ACTIVE’
  <choose>
    <when test="title != null">
      AND title like #{title}
    </when>
    <when test="author != null and author.name != null">
      AND author_name like #{author.name}
    </when>
    <otherwise>
      AND featured = 1
    </otherwise>
  </choose>
</select>

上面表示提供了“title”就按“title”查找，提供了“author”就按“author”查找，若两者都没有提供，就返回所有符合条件的BLOG

where, set, trim

现在考虑回到“if”示例，这次我们将“ACTIVE = 1”也设置成动态的条件

<select id="findActiveBlogLike"
     resultType="Blog">
  SELECT * FROM BLOG 
  WHERE 
  <if test="state != null">
    state = #{state}
  </if> 
  <if test="title != null">
    AND title like #{title}
  </if>
</select>

这种情况下，如果两个条件都不符合，则 SQL 语句多出了一个 WHERE；如果 state 不符合 title 符合，则多出了一个 AND ，导致查询失败

上述查询使用 <where> 元素：

<select id="findActiveBlogLike"
     resultType="Blog">
  SELECT * FROM BLOG 
  <where> 
      <if test="state != null">
        state = #{state}
      </if> 
      <if test="title != null">
        AND title like #{title}
      </if>
  </where>
</select>

<where> 元素知道只有在一个以上的if条件有值的情况下才去插入“WHERE”子句。而且，若最后的内容是“AND”或“OR”开头的，where 元素也知道如何将他们去除

类似的 <set> 元素可以被用于动态包含需要更新的列，而舍去其他的，同时也会消除无关的逗号：

<update id="updateAuthorIfNecessary">
  update Author
    <set>
      <if test="username != null">username=#{username},</if>
      <if test="password != null">password=#{password},</if>
      <if test="email != null">email=#{email},</if>
      <if test="bio != null">bio=#{bio}</if>
    </set>
  where id=#{id}
</update>

<trim> 元素可用于自定义需要的规则，如 <where> 元素等价于：

<trim prefix="WHERE" prefixOverrides="AND |OR ">
  ... 
</trim>

<set> 元素等价于：

<trim prefix="SET" suffixOverrides=",">
  ...
</trim>

<trim> 元素的属性有：

• prefix
• suffix
• prefixOverrides
• suffixOverrides

foreach

动态 SQL 的另外一个常用的必要操作是需要对一个集合进行遍历，通常是在构建 IN 条件语句的时候

<select id="selectPostIn" resultType="domain.blog.Post">
  SELECT *
  FROM POST P
  WHERE ID in
  <foreach item="item" index="index" collection="list" open="(" separator="," close=")">
        #{item}
  </foreach>
</select>

<foreach> 元素的属性有：

• item 表示集合中每一个元素进行迭代时的别名，
• index 指定一个名字，用于表示在迭代过程中，每次迭代到的位置，
• open 表示该语句以什么开始，
• separator 表示在每次进行迭代之间以什么符号作为分隔符，
• close 表示以什么结束。
• collection
  当使用可迭代对象或者数组时，index是当前迭代的次数，item的值是本次迭代获取的元素

bind

Multi-db vendor support

动态 SQL 中可插拔的脚本语言

其它

参数

形如 #{id} 的符号为预处理语句参数，通过 JDBC，这样的一个参数在 SQL 中会由一个“?”来标识，并被传递到一个新的预处理语句中

虽然像 MyBatis 的剩余部分一样，参数的 javaType 通常可以从参数对象中来去确定，前提是只要对象不是一个 HashMap参数，但亦可明确指定一个数据类型：

#{id,javaType=int,jdbcType=INTEGER}

也可以指定一个特殊的类型处理器类（或所指定的对应的别名）：

#{id,javaType=int,jdbcType=INTEGER,typeHandler=MyTypeHandler}

对于数值类型，还有一个小数保留位数的设置，来确定小数点后保留的位数：

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

mode 属性允许你指定 IN，OUT 或 INOUT 参数。如果参数为 OUT 或 INOUT，参数对象属性的真实值将会被改变，就像你在获取输出参数时所期望的那样。如果 mode 为 OUT（或 INOUT），而且 jdbcType 为 CURSOR(也就是 Oracle 的 REFCURSOR)，你必须指定一个 resultMap 来映射结果集到参数类型。要注意这里的 javaType 属性是可选的，如果左边的空白是 jdbcType 的 CURSOR 类型，它会自动地被设置为结果集。

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

MyBatis 也支持很多高级的数据类型，比如结构体，但是当注册 out 参数时你必须告诉它语句类型名称

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

尽管所有这些强大的选项很多时候你只简单指定属性名，其他的事情 MyBatis 会自己去推断，最多你需要为可能为空的列名指定 jdbcType

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

定义可重用的 SQL 代码段 —— sql

<sql> 元素可以被用来定义可重用的 SQL 代码段，可以包含在其他语句中。它可以被静态地(在加载参数) 参数化. 不同的属性值通过包含的实例变化

<sql id="userColumns"> 
    ${alias}.id,${alias}.username,${alias}.password 
</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>

属性值可以用于包含的refid属性或者包含的字句里面的属性值

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

JavaBean 属性名与数据库字段的对应 —— 自动映射

当自动映射查询结果时，MyBatis会获取sql返回的列名并在java类中查找相同名字的属性（忽略大小写）

如果没有被手工映射，则将被自动映射。自动映射处理完毕后手工映射才会被处理

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

在 mybatis 的 XML配置文件中的 <settings> 元素有一个 autoMappingBehavior 的设置项，它有三种自动映射等级：

• NONE - 禁用自动映射。仅设置手动映射属性。
• PARTIAL - 将自动映射结果除了那些有内部定义内嵌结果映射的(joins).
• FULL - 自动映射所有。

默认值是 PARTIAL。当使用FULL时，自动映射会在处理join结果时执行，并且join取得若干相同行的不同实体数据，因此这可能导致非预期的映射。
以前面的数据库表 tb_user 和 tb_user_detail 为例，这两张表都有一个字段名为 id

<resultMap id="userResultMap" type="User">
    <association property="userDetail" resultMap="authorResultMap">
    </association>
</resultMap>

<resultMap id="authorResultMap" type="UserDetail">
</resultMap>

<select id="selectUserUsingResultMap" resultMap="userResultMap" parameterType="Integer">
    select 
        A.id,
        A.username,
        A.password,
        B.id,
        B.realname,
        B.address
    from tb_user A
        inner join tb_user_detail B on A.detail_id = B.id
    where A.id = #{id}
</select>

在映射等级为 FULL 的情况下，id 也会映射到 UserDetail 中名为 id 的属性。所以需要谨慎使用 FULL

附录

jdbcType支持的 JDBC 类型

<constructor> 的子元素 <idArg> & <arg> 属性

子查询与联合查询的比较

联合查询：一次性查询，占用资源较大
子查询的问题就是 “N+1 查询问题”。概括地讲,N+1 查询问题可以是这样引起的:

• 你执行了一个单独的 SQL 语句来获取结果列表(就是“+1”)。
• 对返回的每条记录,你执行了一个查询语句来为每个加载细节(就是“N”)

但是 MyBatis 的延迟加载在不需要迅速迭代来访问嵌套的数据时可以分散这些语句同时运行的消耗