mapper.xml文件

1. 概述

mybatis的真正强大在于它的映射语句。由于它的异常强大，映射器的XML文件就显得相对简单，如果拿它跟具有相同功能的JDBC代码进行对比，省掉将近95%的代码。mybatis是针对SQL构建的，并且比普通方法做的更好。

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

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

2. select

查询语句是mybatis中最常用的元素之一，多数应用也都是查询比修改要频繁。

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

这个语句被称作selectPerson，接受一个int类型的参数，并返回一个HashMap类型的对象，其中的key是列名，value是结果行中的对应值。

#{id}

这个高速mybatis创建一个预处理语句参数，通过JDBC，这样一个参数在SQL中会由一个？来标识，并被传递到一个新的预处理语句中，就像：

String selectPerson = "SELECT * FROM PERSON WHERE ID=?";
PreparedStatement ps = conn.prepareStatement(selectPerson);
ps.setInt(1,id);　　

当然，这需要很多单独的JDBC的代码来提取结果并将它们映射到对象实例中，这就是mybatis节省时间的地方。

select元素有很多属性允许配置：

属性	描述
id	在命名空间中唯一的标识符，可以被用来引用这条语句
parameterType	将会传入这条语句的参数类的完全限定名或别名。这个属性是可选的，因为mybatis可以通过TypeHandler推断出具体传入语句的参数，默认值为unset。
parameterMap	已废弃
resultType	从这条语句中返回的期望类型的类的完全限定名或别名。注意如果是集合情形，那应该是集合可以包含的类型，而不能是集合本身。使用resultType或resultMap，但不能同时使用。
resultMap	外部resultMap的命名引用。
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 中的一个，默认值为 unset （依赖驱动）。
databaseId	如果配置了 databaseIdProvider，MyBatis 会加载所有的不带 databaseId 或匹配当前 databaseId 的语句；如果带或者不带的语句都有，则不带的会被忽略。
resultOrdered	这个设置仅针对嵌套结果 select 语句适用：如果为 true，就是假设包含了嵌套结果集或是分组了，这样的话当返回一个主结果行的时候，就不会发生有对前面结果集的引用的情况。这就使得在获取嵌套的结果集的时候不至于导致内存不够用。默认值：false。
resultSets	这个设置仅对多结果集的情况适用，它将列出语句执行后返回的结果集并每个结果集给一个名称，名称是逗号分隔的。

3. insert，update，delete

insert

update

delete

相同属性的与select意义都是相同的，可以参考上面，下面只介绍不同的几个：

属性	描述
keyColumn	（仅对 insert 和 update 有用）通过生成的键值设置表中的列名，这个设置仅在某些数据库（像 PostgreSQL）是必须的，当主键列不是表中的第一列的时候需要设置。如果希望得到多个生成的列，也可以是逗号分隔的属性名称列表。
keyProperty	（仅对 insert 和 update 有用）唯一标记一个属性，MyBatis 会通过 getGeneratedKeys 的返回值或者通过 insert 语句的 selectKey 子元素设置它的键值，默认：unset。如果希望得到多个生成的列，也可以是逗号分隔的属性名称列表。
useGeneratedKeys	（仅对 insert 和 update 有用）这会令 MyBatis 使用 JDBC 的 getGeneratedKeys 方法来取出由数据库内部生成的主键（比如：像 MySQL 和 SQL Server 这样的关系数据库管理系统的自动递增字段），默认值：false。

在插入语句里面有一些额外的属性和子元素用来处理主键的生成，而且有多种生成方法。

首先，数据库支持自动生成主键的字段（mysql和sql Server），那么可以设置useGeneratedKeys=true，然后再把keyProperty设置到目标属性上就OK了。例如，author表堆id使用了自动生成的列类型，那么：

<insert id="insertUser" useGeneratedKeys="true" keyProperty="id">
  insert into user(user_name, birthday) values(#{user_name},#{birthday})
 </insert>　　

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

<insert id="insertManyUser">
  insert into user(user_name, birthday) values
  <foreach collection="list" item="item" separator="," >
    (#{item.user_name}, #{item.birthday})
  </foreach>
 </insert>

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

5. 参数

前面的所有语句中都是简单参数的例子，实际上参数是mybatis非常强大的元素，对于简单的做法，大概90%的情况参数都很少。

默认情况下，使用#{ }格式的语法会导致mybatis创建PreparedStatement参数并安全地设置参数，这样做更安全，更迅速，通常也是首选做法，不过有时你就是想直接在SQL语句中插入一个不转义的字符串，比如，像order by，可以这样：

ORDER BY ${columnName}　　

这里mybatis不会修改或转义字符串。

注意：用这种方式接受用户的输入，并将其用于语句中的参数是不安全的，会导致潜在的SQL注入攻击，因此要么不允许用户输入这些字段，要么自行转义并检验。

6. resultMap

6.1 基本用法

resultMap元素是mybatis中最重要最强大的元素，它可以让你从90%的JDBC ResultSets数据提取代码中解放出来。ResultMap的设计思想是，简单的语句不需要明确的结果映射，而复杂一点的语句只需要描述它们的关系就行了。

<select id="selectUserById" resultType="map">
  select * from user where id = #{id}
 </select>　　

上述语句只是简单地将所有的列映射到HashMap的key上，这由resultType属性指定。虽然在大部分情况下都够用，但是HashMap不是一个很好的领域模型。可以使用JavaBean或POJO（Plain Old Java Objects，普通Java对象）作为领域模型。

public class User implements Serializable {
    private static final long serialVersionUID = 1L;
    private int id;
    private String n;
    private Date birthday;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getN() {
        return n;
    }
    public void setUser_name(String user_name) {
        this.n = user_name;
    }
    public Date getBirthday() {
        return birthday;
    }
    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    @Override
    public String toString() {
        return "User [id=" + id + ", name=" + n + ", birthday=" + birthday + "]";
    } 

}

 <select id="selectUserById" resultType="org.mybatis.mapper.User">
  select * from user where id = #{id}
 </select>　　

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

mybatis会在幕后自动创建一个ResultMap，在基于属性名来映射列到JavaBean属性上。如果列名和属性名没有精确匹配，可以在Select语句中对列使用别名（这是SQL特性）。

下面的实例使用外部的resultMap，这也是解决列名不匹配的另外一种方式：

 <resultMap type="org.mybatis.mapper.User" id="UserMap">
    <id column="id" property="id"/>
    <result column="user_name" property="n"/>
    <result column="birthday" property="birthday"/>
 </resultMap>

 <select id="selectUserById" resultMap="UserMap">
  select * from user where id = #{id}
 </select>　　

引用语句使用resultMap属性就行了（去掉了resultType属性）。

6.2 高级结果映射

有如下表结构：user，role，user_role

6.2.1 id & result

id和result都讲一个列的值映射到一个简单数据类型（字符串，整型，双精度浮点数，日期等）的属性或字段。

这两者之间的唯一不同是，id标示的结果将是对象的标示属性，这会在比较对象实例时用到。

两个元素都有一些属性：

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

6.2.2 构造方法（constructor）

通过吸怪对象属性的方式，可以满足大多数的数据传输对象以及大部分领域模型的要求。但有些情况下你想使用不可变类。通常来说，很少或基本不变的、包含引用或查询数据的表，很适合使用不可变类。构造方法注入允许你在初始化时设置属性的值，而不用暴露公共方法。mybatis也支持私有属性和私有javabean属性来达到这个目的，但有些人更青睐于构造方法注入。

public User(int id, String name, Date birthday) {
        this.id = id;
        this.name = name;
        this.birthday = birthday;
    }　　

为了将结果注入构造方法，mybatis需要通过某种方法定位相应的构造方法。在下面的例子中，mybatis搜索一个声明了三个形参的构造方法，以int，String和Date的顺序排列。（可以通过添加name属性，不按照顺序排列）

<constructor>
   <idArg column="id" javaType="int"/>
   <arg column="name" javaType="String"/>
   <arg column="birthday" javaType="Date"/>
</constructor>

6.2.3 关联（association）　　

关联关系处理“有一个”类型的关系。比如，一个用户有一个角色。

关联中需要告诉mybatis如何加载关联数据。mybatis提供了2种不同的方式：

• 嵌套查询：通过执行另外一个SQL映射语句来返回预期的复杂类型；
• 嵌套结果：使用嵌套结果映射来处理重复的联合结果的子集。　　

（1）关联的嵌套查询

查询User信息，包括角色信息。

<resultMap type="org.mybatis.mapper.User" id="UserMap">
    <id column="id" property="id" />
    <result column="user_name" property="name"/>
    <result column="birthday" property="birthday"/>
    <association property="role" column="role_id" select="selectRoleById"/>
 </resultMap>

 <select id="selectUserById" resultMap="UserMap">
  select * from user where id = #{id}
 </select>

 <select id="selectRoleById" resultType="org.mybatis.mapper.Role">
  select * from role where id = #{id}
 </select>

属性	描述
column	来自数据库的列名,或重命名的列标签。这和通常传递给 resultSet.getString(columnName)方法的字符串是相同的。 column 注 意 : 要 处 理 复 合 主 键 , 你 可 以 指 定 多 个 列 名 通 过 column= ” {prop1=col1,prop2=col2} ” 这种语法来传递给嵌套查询语 句。这会引起 prop1 和 prop2 以参数对象形式来设置给目标嵌套查询语句。
select	另外一个映射语句的ID,可以加载这个属性映射需要的复杂类型。获取的在列属性中指定的列的值将被传递给目标select语句作为参数。表格后面有一个详细的示例。select注意 : 要处理复合主键,你可以指定多个列名通过 column= ” {prop1=col1,prop2=col2} ” 这种语法来传递给嵌套查询语句。这会引起prop1和prop2以参数对象形式来设置给目标嵌套查询语句。
fetchType	可选的。有效值为 lazy和eager。 如果使用了，它将取代全局配置参数lazyLoadingEnabled。

嵌套查询这种方式简单，但是对于大型数据集合和列表性能不好。会有“N + 1”问题：

1. 执行了一个单独的SQL语句来获取结果列表（1）
2. 对返回的每条记录，又执行了一个查询语句来为每个加载细节（N）　　

这个问题会导致成百上千的SQL语句被执行。

（2）关联嵌套结果

查询用户信息和角色信息：

<select id="selectUserAndRole" resultMap="userAndRoleMap">
    select u.id, u.user_name,u.birthday,u.role_id, r.id,r.role_name from user u left join role r on u.role_id = r.id where u.id = #{id}
 </select>

 <resultMap type="org.mybatis.mapper.User" id="userAndRoleMap">
    <id property="id" column="id"/>
    <result property="name" column="user_name"/>
    <result property="birthday" column="birthday"/>
    <association property="role" column="role_id" javaType="org.mybatis.mapper.Role">
        <id property="id" column="id"/>
        <result property="name" column="role_name"/>
    </association>
 </resultMap>

public class User implements Serializable {
    private static final long serialVersionUID = 1L;
    private int id;
    private String name;
    private Date birthday;
    private Role role;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Date getBirthday() {
        return birthday;
    }
    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
    public Role getRole() {
        return role;
    }
    public void setRole(Role role) {
        this.role = role;
    }
    @Override
    public String toString() {
        return "User [id=" + id + ", name=" + name + ", birthday=" + birthday + ", role=" + role + "]";
    }

}

6.2.4 集合（collection）

上面已经处理了“有一个”类型关联，但是“有很多”是怎样的？与关联是很相似的。

继续上面的实例，一个用户有一个角色，但是一个角色有多个用户。在角色类中，可以增加

private List<User> users;　　

要映射嵌套结果集合到List中，我们使用集合元素。就像关联元素一样，可以从连接中使用嵌套查询或嵌套结果。

（1）集合的嵌套查询

查询某个角色和所有用户

<select id="selectRole" resultMap="roleResult">
  select * from role where id = #{id}
 </select>
 <resultMap type="org.mybatis.mapper.Role" id="roleResult">
  <id property="id" column="id" />
  <result property="name" column="role_name" />
  <collection property="users" javaType="list" column="id"
   ofType="org.mybatis.mapper.Usesr" select="selectUserByRoleId" />
 </resultMap>
 <select id="selectUserByRoleId" resultType="org.mybatis.mapper.User">
  select * from user where role_id = #{id}
 </select>　　

运行及结果：

（2）集合的嵌套结果

如果两表联查，主表和明细表的主键都是id的话，明细表的多条只能查询出来第一条？

级联查询的时候，主表和从表有一样的字段名的时候，在mysql上命令查询是没问题的。但在mybatis中主从表需要为相同字段名设置别名。设置了别名就OK了。

<select id="selectRoleAndUsers" resultMap="roleAndUsers">
    select r.id, r.role_name, u.id as uid, u.user_name, u.birthday from role r left outer join user u on r.id = u.role_id where r.id = #{id}
</select>

<resultMap type="org.mybatis.mapper.Role" id="roleAndUsers">
    <id property="id" column="id"/>
    <result property="name" column="role_name"/>
    <collection property="users" ofType="org.mybatis.mapper.User" javaType="list">
        <id property="id" column="uid"/>
        <result property="name" column="user_name"/>
        <result property="birthday" column="birthday"/>
    </collection>
</resultMap>

6.2.5 鉴别器（discriminator）

鉴别器在于确定使用那个ResultMap来映射SQL查询语句，在实现中我们往往有一个基类，然后可以派生一些类。比如我们要选择一群人可以用List<Person>，然而Person里面有个性别sex，根据它还可以分为Male或者Female。鉴别器就要根据sex决定用Male还是用Female相关的Mapper进行映射。　　

7. 自动映射

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

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

自动映射甚至在特定的result map下也能工作。在这种情况下，对于每一个result map,所有的ResultSet提供的列， 如果没有被手工映射，则将被自动映射。自动映射处理完毕后手工映射才会被处理。　　

有是那种自动映射等级：

NONE：禁用自动映射，仅设置手动映射属性；

PARTIAL：将自动映射结果除了那些有内部定义内嵌结果映射的；

FULL：自动映射所有。

8. 缓存　　

默认情况下是没有开启缓存的，除了局部session一级缓存。要开启二级缓存，你需要在你的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 – 弱引用:更积极地移除基于垃圾收集器状态和弱引用规则的对象。

默认的是 LRU。

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

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

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

参照缓存　　

也许将来的某个时候，想在命名空间中共享相同的缓存配置和实例。在这样的情况下可以使用cache-ref元素来引用另外一个缓存：

<cache-ref namespace="xxx"/>

9. 动态SQL

9.1 if

动态SQL通常要做的事情是根据条件包含where子句的一部分，比如：

<select id="queryUser" resultType="org.mybatis.mapper.User" parameterType="int">
    select * from user
    <if test="id != null">
        where id = #{id}
    </if>
</select>　　

注：有可能出现如下错误https://blog.csdn.net/aitcax/article/details/44337271

9.2 choose，when，otherwise

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

实例：如果提供id就通过id查询，如果id未提供name提供则按照name查询，如果两个都不提供，则查询所有。

<select id="queryUser" resultType="org.mybatis.mapper.User">
    select * from user
    <choose>
        <when test="id != null">
            where id = #{id}
        </when>

        <when test="name != null">
            where user_name = #{name}
        </when>

        <otherwise></otherwise>
    </choose>
</select>

9.3 where，set

看下面的语句：每个分支里面都要写where。

<select id="queryUser" resultType="org.mybatis.mapper.User">
    select * from user
    <choose>
        <when test="id != null">
            where id = #{id}
        </when>

        <when test="name != null">
            where user_name = #{name}
        </when>

        <otherwise></otherwise>
    </choose>
</select>

可以改写为：

<select id="queryUser" resultType="org.mybatis.mapper.User">
    select * from user
    <where>
        <choose>
        <when test="id != null">
            id = #{id}
        </when>

        <when test="name != null">
            user_name = #{name}
        </when>

        <otherwise></otherwise>
    </choose>
    </where>
</select>　　

<where>元素只会在至少有一个子元素的条件返回SQL子句的情况下才去插入“Where”子句，而且，若语句的开头为“and”或“or”，where元素会将他们去除。

类似的用于动态更新语句的解决方案叫做set。set元素可以用于动态包含需要更新的列，而舍去其他的。比如：

<update id="updateUser">
    update user
    <set>
        <if test="id != null"> id = #{id},</if>
        <if test="name != null"> user_name = #{name},</if>
    </set>
</update>

这里，set元素会动态前置SET关键字，同时也会删掉无关的逗号，因为用了条件语句之后很可能就会在生成的 SQL语句的后面留下这些逗号。（译者注：因为用的是“if”元素，若最后一个“if”没有匹配上而前面的匹配上，SQL语句的最后就会有一个逗号遗留）　　

9.4 foreach

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

<select id="queryUser" resultType="org.mybatis.mapper.User">
    select * from user
    where id in
    <foreach collection="list" item ="item" open="(" close=")" separator=",">
        #{item}
    </foreach>
</select>　　

foreach元素，允许指定一个集合，声明可以在元素体内使用的集合项（item）和索引（index）变量。也允许你指定开头（open）语结尾（close）的字符串，以及在迭代结果之间放置分隔符（separator）。　　

注：可以迭代对象有list，set，map，数组等。当使用可迭代对象或数组时，index是当前迭代的次数，item是本次迭代获取的元素。当时用map时，index是key，item是value。

9.5 bind

bind元素可以从OGNL表达式中创建一个变量并将其绑定到上下文。比如：

<select id="queryUser" resultType="org.mybatis.mapper.User">
    <bind name="uid" value="2"/>
    select * from user where id = #{uid}
</select>　　

x. 参考资料

https://blog.csdn.net/ykzhen2015/article/details/51249963　　

http://www.mybatis.org/mybatis-3/zh/sqlmap-xml.html#Auto-mapping

https://blog.csdn.net/aitcax/article/details/44337271