Mapper映射器文件

MyBatis 的真正强大在于它的语句映射，这是它的魔力所在。由于它的异常强大，映射器的 XML 文件就显得相对简单。如果拿它跟具有相同功能的 JDBC 代码进行对比，你会立即发现省掉了将近 95% 的代码。MyBatis 致力于减少使用成本，让用户能更专注于 SQL 代码。mybatis为了减轻用户心智负担,只提供了如下SQL元素:

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

**

1 Select

查询语句是Mybatis中最常见的元素,MyBatis 在查询和结果映射做了相当多的改进,Select元素的属性描述如下:

使用select元素的注意事项:
(1).parameterType属性用于指定入参的参数类型(参数类型的类全限定类名,例如java.lang.String),parameterType属性是可选的,Mybatis通过类型处理器得到入参的参数类型。在Mybatis中通过#{参数名} 的形式来接收入参的值。
(2).resultType和resultMap用于指定查询语句返回的类型,resultType和resultMap属性只能存在一个,resultType用于返回单个映射实体,resultMap用于返回映射实体集合。

2 Insert、Update、Delete

以上是Inster、Update、Delete元素的属性,在写Inster、Update、Delete元素没有resultType或resultMap属性,因为Inster、Update、Delete元素返回的是操作后受影响行数,即操作成功了返回1,操作失败返回0。

3.参数

Select、Update、Insert、Delete元素中使用参数以#{参数名}的格式,对应的Mapper接口方法无需指定参数的类型,即使你传入的是一个实体对象,Mybatis通过反射获取方法的参数类型然后通过类型处理器处理,对于普通参数类型(Integer、String这种)因为没有其它属性,会用它们的值来作为参数。对于复杂的对象Mybatis会挨个查找对象的属性,然后将它们的值传入预处理语句的参数。例如下面的例子:

<!-- 传入普通参数 -->
<select id="getUserById" resultType="com.fly.User">
    SELECT * FROM `User` WHERE ID=#{id}
</select>
<!-- 传入复杂的对象,例如传入一个User实体对象,如果 User 类型的参数对象传递到了语句中，
会查找 uname、sex 和 address 属性，然后将它们的值传入预处理语句的参数中。 -->
<insert id="addUser" parameterType="User">
   INSERT into `user`(uname,sex,address) values(#{uname},#{sex},#{address});
</insert>

另外参数海设置其他的配置,例如指定参数类型:

<!-- javaType用于指定对应的java类型,jdbcType用于指定数据库类型。
Mybatis几乎可以根据参数对象的类型确定 javaType,除非参数是一个HashMap,
此时需要显式指定 javaType 来确保正确的类型处理器（TypeHandler）被使用
-->
#{参数名,javaType=int,jdbcType=NUMERIC}

javaType用于指定对应的java类型,jdbcType用于指定数据库类型。Mybatis几乎可以根据参数对象的类型确定 javaType,除非参数是一个HashMap,此时需要显式指定 javaType 来确保正确的类型处理器（TypeHandler）被使用。

同样你可以通过typeHandler指定一个特殊的类型处理器类(或别名),例如:

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

对于数值类型,还可以设置 numericScale 指定小数点后保留的位数。

#{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}

尽管上面这些选项很强大，但大多时候，你只须简单指定属性名，顶多要为可能为空的列指定 jdbcType，其他的事情交给 MyBatis 自己去推断就行了。

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

字符串替换
默认情况下，使用 #{} 参数语法时，MyBatis 会创建 PreparedStatement 参数占位符，并通过占位符安全地设置参数（就像使用 ? 一样）。 这样做更安全，更迅速，通常也是首选做法，不过有时你就是想直接在 SQL 语句中直接插入一个不转义的字符串。 比如 ORDER BY 子句，这时候你可以:

ORDER BY ${columnName}

${}** 和 #{}区别在于,${}会被传入的参数直接替换掉,而#{}会使用?号占位进行预处理。**

4.resultMap(结果映射)

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

4.1 隐式映射

Mybatis可以隐式的映射结果,无需显式的编写resultMap,对于一些复杂的情况需要显式的编写resultMap。例如下面的例子并没有显式的指定resultMap,Mybatis会简单地将所有的列映射到 HashMap 的键上，这由 resultType 属性指定,虽然在大部分情况下都够用，但是 HashMap 并不是一个很好的领域模型。你的程序更可能会使用 JavaBean 或 POJO（Plain Old Java Objects，普通老式 Java 对象）作为领域模型。

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

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

对应Mapper文件:

<!-- 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的隐式映射规则是如果查询的列名与JavaBean 的属性,那么会将查询的结果填充到与之匹配的属性当中。但有时查询的列名与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>

4.2 显式映射

ResultMap 的优秀之处——你完全可以不用显式地配置它们,但对于复杂的情况我们显示的配置结果映射,例如解决上面例子列名与JavaBean属性不匹配的另外一种方式。显示使用结果映射只需定义resultMap,然后设置select元素的resultMap属性即可,例如下面的例子。

<resultMap id="userResultMap" type="User">
  <id property="id" column="user_id" />
  <result property="username" column="user_name" javaType="java.lang.String" 
          jdbcType="VARCHAR" typeHandler="org.apache.ibatis.type.StringTypeHandler"/>
  <result property="password" column="hashed_password"/>
</resultMap>

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

那什么时候使用resultMap和resultType?一般来说查询单条记录使用resultType,查询多条记录使用resultMap。

4.3 高级映射

有时候SQL语句由于业务原因会变得尤为复杂,好在Mybatis支持高级映射,例如下面的SQL语句:

<!-- 非常复杂的语句 -->
<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实现复杂的结果映射:

<!-- 非常复杂的结果映射 -->
<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元素中还有其他子元素,子元素介绍如下:

• constructor- 用于在实例化类时，注入结果到构造方法中
  • idArg - ID 参数；标记出作为 ID 的结果可以帮助提高整体性能。
  • arg - 将被注入到构造方法的一个普通结果。
• id – 一个 ID 结果;标记出作为 ID 的结果可以帮助提高整体性能,一般用于映射数据库主键列,也可以用于其他普通列,id元素必须写在result元素前面,不然映射文件会发出警告。
• result – 注入到字段或 JavaBean 属性的普通结果。
• association– 一个复杂类型的关联;许多结果将包装成这种类型,association元素一般用于数据表一对一关系。
  • 嵌套结果映射 – 关联可以是 resultMap 元素，或是对其它结果映射的引用
• collection– 一个复杂类型的集合,collection元素一般用于数据表一对多关系。
  • 嵌套结果映射 – 集合可以是 resultMap 元素，或是对其它结果映射的引用
• discriminator– 使用结果值来决定使用哪个resultMap
  • case– 基于某些值的结果映射
    • 嵌套结果映射 – case 也是一个结果映射，因此具有相同的结构和元素；或者引用其它的结果映射

ResultMap 的属性列表

4.4 id & result元素

id 和 result 元素都将一个列的值映射到一个简单数据类型（String, int, double, Date 等）的属性或字段，这两者之间的唯一不同是，id 元素对应的属性会被标记为对象的标识符，在比较对象实例时使用。 这样可以提高整体的性能，尤其是进行缓存和嵌套结果映射（也就是连接映射）的时候。它们的共同属性如下:

支持的jdbcType如下:

4.5 构造方法(constructor)

通过修改对象属性的方式，可以满足大多数的数据传输对象（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 元素是一样的。如下:

4.6 关联(association)

association元素用于处理一对一的关系,例如一个博客有一个用户。关联结果映射和其它类型的映射工作方式差不多。 你需要指定目标属性名以及属性的javaType（很多时候 MyBatis 可以自己推断出来），在必要的情况下你还可以设置 JDBC 类型，如果你想覆盖获取结果值的过程，还可以设置类型处理器。
关联的不同之处是，你需要告诉 MyBatis 如何加载关联。MyBatis 有两种不同的方式加载关联:

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

association元素的属性如下: