MyBatis框架浅析之 Mapper.xml 映射文件

Mapper XML 文件

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

同样需要介绍定级元素: 

mapper 

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

1.mapper 根节点

有且必须只有一个属性值:namespace, 建议设置为Mapper接口的全限定名

<mapper namespace="com.baoxian.dao.UserInfoMapper">
    ...
</mapper>

 

2.select 元素

2.1 简单的select语句

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

解释一下上面配置:

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

　　

假如调用该条SQL传入的 参数为 1,selectPerson(1)
原来的sql语句经过处理后相当于 SELECT * FROM PERSON WHERE ID = ?  
?相当于参数的占位符
调用时传入的 参数值 将会被替换

2.2  select元素中的所有属性

<select
  id="selectPerson"　　　　　　#必须
  parameterType="int"  　　　 #可选,写出来会更加直观
  parameterMap="deprecated"　#已不使用
  resultType="hashmap"　　　　#必须指定
  resultMap="personResultMap"#自定义结果集的映射
  flushCache="false"         #调用该语句是否刷新缓存,一般insert update delete 会配置成true
  useCache="true"            #
  timeout="10000"            # 语句最大等待时间 10S
  fetchSize="256"　　　　　　  # 
  statementType="PREPARED"
  resultSetType="FORWARD_ONLY">
Select Attributes
属性描述
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 中的一个，默认值为 unset （依赖驱动）。
databaseId 如果配置了 databaseIdProvider，MyBatis 会加载所有的不带 databaseId 或匹配当前 databaseId 的语句；如果带或者不带的语句都有，则不带的会被忽略。
resultOrdered 这个设置仅针对嵌套结果 select 语句适用：如果为 true，就是假设包含了嵌套结果集或是分组了，这样的话当返回一个主结果行的时候，就不会发生有对前面结果集的引用的情况。这就使得在获取嵌套的结果集的时候不至于导致内存不够用。默认值：false。
resultSets 这个设置仅对多结果集的情况适用，它将列出语句执行后返回的结果集并每个结果集给一个名称，名称是逗号分隔的。

 

2.3 insert ,update,delete

<insert
  id="insertAuthor"
  parameterType="domain.blog.Author"
  flushCache="true"
  statementType="PREPARED"
  keyProperty=""      #将JDBC生成的主键值 赋值给keyProperty对应的属性名
  keyColumn=""
  useGeneratedKeys="" #取出JDBC生成的主键
  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">

 

属性描述
id 命名空间中的唯一标识符，可被用来代表这条语句。
parameterType 将要传入语句的参数的完全限定类名或别名。这个属性是可选的，因为 MyBatis 可以通过 TypeHandler 推断出具体传入语句的参数，默认值为 unset。
parameterMap 这是引用外部 parameterMap 的已经被废弃的方法。使用内联参数映射和 parameterType 属性。
flushCache 将其设置为 true，任何时候只要语句被调用，都会导致本地缓存和二级缓存都会被清空，默认值：true（对应插入、更新和删除语句）。
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>

如果设置了主键自增,则上述insert语句可以更改为:

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

如果数据库支持多行插入(例如MySQL数据库),则insert语句可以修改为:

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

其中foreach 会对集合进行迭代 , item 表示集合中每个元素,collection 表示集合的类型, separator表示分隔符,并且智能的在最后一个元素后去除分隔符

 

如果数据库不支持自动生成主键,则可以使用另外一种 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>

上述语句的执行顺序是,先执行自动生成随机ID的语句, 并将随机生成的值转成int类型 再通过set方法 设置到Author的id属性中,从而执行插入时,id属性值将对应数据库的id列,插入到数据库中

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 类型。

 

2.4 sql

sql元素可以用来定义可复用的sql代码:

<sql id="fromClause">
    /*通过${}取调用者传递的属性值*/
    from ${tableName}
</sql>

使用<include>元素调用定义的sql元素,以下是简单的实现了复用的效果,往往实际中会更加复杂:

<!--通过ID查找用户-->
  <select id="selectUserById" resultMap="BaseResultMap" parameterType="java.lang.Long" >
    select id,userName,age
    /*通过property属性 向sql元素动态传递参数值,两边规定好property的属性名称即可*/
    <include refid="fromClause">
      <property name="tableName" value="userinfo"/>
    </include>
    where id = #{id}
  </select>

  <!--查询出所有用户-->
  <select id="selectAll" resultMap="BaseResultMap" >
    select id, username,age
    <include refid="fromClause">
      <property name="tableName" value="userinfo"/>
    </include>
  </select>

此外,调用者传递过的属性值,同样也可以使用在include 元素的 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>

2.5 参数 parameters

sql语句接收的参数有两种类型,一种是基本类型,另一种是复杂的对象类型

如果sql语句 接收的参数是一个对象.那么传递过来的对象要提供相应的getter方法,此时mybatis才能正确的取出属性值

例如:

<!--通过ID更新用户-->
  <update id="updateByPrimaryKey" parameterType="com.baoxian.domain.UserInfo" >
    update UserInfo
    set username = #{userName},age = #{age}
    where id = #{id}
  </update>

每一个参数都支持为其指定特殊的类型

格式如下:

<!--通过ID更新用户-->
  <update id="updateByPrimaryKey" parameterType="com.baoxian.domain.UserInfo" >
    update UserInfo
    set username = #{userName},age = #{age,javaType=int,jdbcType=NUMERIC}
    where id = #{id}
  </update>

其中age参数,指明java类型是int , jdbcType是NUMERIC

如果传递一个为null的参数值到数据库中,并且该列允许为null,那么必须为该参数指定javaType

除了javaType,与 jdbcType之外,还可以指定以下:

typeHandler: 需要特殊类型处理器处理参数的映射 (几乎不用这么做)
numericScale:如果参数值是一个小数,希望保存进数据库的值 保留小数点后两位 ,则可以通这样实现: #{salary,javaType=double,jdbcType=NUMERIC,numericScale=2}

mode:该属性有三个可选值,IN,OUT,及INOUT;如果参数为 OUT 或 INOUT，参数对象属性的真实值将会被改变，就像你在获取输出参数时所期望的那样。

如果 mode 为 OUT（或 INOUT），而且 jdbcType 为 CURSOR(也就是 Oracle 的 REFCURSOR)，你必须指定一个 resultMap 来映射结果集 ResultMap 到参数类型。
要注意这里的 javaType 属性是可选的，如果留空并且 jdbcType 是 CURSOR，它会被自动地被设为 ResultMap。

 

说了那么多,其实更多时候,我们90%的情况是不需要为参数指定什么额外属性,MyBatis已经帮你做好该做的

最多在java参数为null时,指定javaType即可

 

2.6 字符串替换

使用#{} 会生成一个预处理参数,提高了SQL的安全性, 但有时不希望对参数值进行转义,保持参数原本的值,则可以使用 ${}进行取值

但是${} 会引起SQL注入的问题

 

2.7 resultMap

具体说resultMap之间先说下resultType

正常情况,如果我们仅仅是需要查询的结果,那么将resultType设置成 map即可

但是很多时候,我们希望将表中查询出的数据封装成Java对象,此时只需要将resultType 设置为相应类的全限定名 或 别名即可;

假设实体类如下,已提供相应的setter getter方法

表的设计如下:

 

 此时表中的字段名与实体类中的属性名一致, 使用resultType, myBatis 会自动将对应列的值封装进同名的属性中;

 

但是并不是任何情况下,列名都能与java的属性名对应上.此时我们将userInfo表中的userName列名修改为user_name

那遇到这种不匹配的情况怎么去解决呢?

 

方式一:在select语句中对查询出的列使用别名 ,保证别名与java属性名一致即可,例如:

  <select id="selectUserById" resultType="UserInfo" parameterType="java.lang.Long" >
    select id,user_name as username ,age
    from userInfo
    where id = #{id}
  </select>

方式二:使用resultMap,自定义查询结果集中列到java属性的映射关系:

<resultMap id="userResultMap" type="userinfo">
    <result column="user_name" property="userName"/>
  </resultMap>
<select id="selectUserById" resultMap="userResultMap" parameterType="java.lang.Long" >
  select id,user_name as username ,age
  from userInfo
  where id = #{id}
</select>

 

此时发现两种解决方式,都是差不多,甚至方式1可能更简单一些.没错,对于简单的sql语句与javaBean.确实只需要使用方式一即可.

 

但是如果以下情况出现,你还会觉得方式一好吗?

1.表的列数与java的字段有多个,大多数列名与属性名都不能完全对应

2.在情景1的情况下,同一个Mapper.xml文件中有多处select语句,需要将结果映射到java对象中,此时每个select语句都写大量重复的别名

   会造成工作量的重复

3.如果对象的属性不全为简单类型,属性可能也是对象. 例如:Employee 类中,包含属性 department.此时通过别名是无法完成映射的

 

对于上述情景2的情况,定义一次resultMap,可以在多处使用.不会造成同样语句的多次书写,同时resultMap也可以像情景3中那样,完成复杂的映射关系

那么就来介绍一下resultMap元素:

2.7.1 resultMap的属性

<resultMap id="userResultMap" type="userinfo" autoMapping="true">
      <id column="id" property="id"  />
      <result column="age" property="age"  />
      <result column="user_name" property="userName"/>
  </resultMap>

 

id:　　当前命名空间中的一个唯一标识，用于标识一个result map.

type:　resultMap需要映射的目标Java对象的类型,可以是类的全限定名 也可以是别名

autoMapping :　　两种值:true/false　是否开启自动列名 到 属性名的自动映射,默认开启.(true)

 

2.7.2 resultMap的子元素

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

写在前面,在resultMap中,使用最多的元素有:id,result,association,collection , 不常用的有 constructor 与 discriminator

constructor 

public class User {
   //...
   public User(Integer id, String username, int age) {
     //...
  }
//...
}

此时可以通过constructor元素,将值注入到User对象中:

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

但是必须要严格按照构造器的参数顺序注入

myBatis 3.4.3版本开始后,可以指定构造器中的参数名称,此时可以不用按照顺序书写

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

 

id元素:标识主键列 与对象唯一标识时使用

result元素:非主键,基本类型的属性使用

association元素:当属性也是一个对象类型时使用

　　association元素中的属性值介绍:

　　property:需要注入的属性名称

　　javaType:需要注入的属性类型

　　

　　#其中 select 与 column 一同用于额外sql查询时

　　select:需要额外执行的sql语句 (nameSpace.selectName)

　　column:发送额外sql语句时,该SQL语句的所需的参数 

　　

　　#以下四个属性,当需要联表查询注入子对象属性时,才会使用

　　resultMap:需要使用的结果集映射

　　columnPrefix:同一位resultMap中的column列 指定前缀

　　notNullColumn:该属性指定的列名不可为空,如果那一列为空,则该子对象不创建,可以指定对个.默认不创建

　　autoMapping:是否开启自动同名映射

collection元素:当属性是集合类型时使用:

　　collection除了ofType属性代替了javaType外,其他属性值与association属性值,几乎使用方法完全一致

　　ofType:表示集合中的元素类型 可以为类的全限定名 或者 类别名

 

 

现在有Employee 与 Department java类,同时数据库中存在相应的表

public class Employee {
    private long id;
    private String eName;
    private Department department;

    //getter...

    //setter...
}
public class Department {
    private long id;
    private String dName;
    private List<Employee> employees;

    //getter...

    //setter...
}

employee表:

 

 department表:

 

 

 

 

如果想在查询Employee对象时 ,不仅查询出基本类型的id,e_name,还想额外注入department属性怎么做呢?

此时可以使用resultMap中的association 元素完成department属性的注入,实现的方式有两种:

 

方式一:通过发送额外SQL语句的方式,根据结果集中的dept_id ,查询出department对象:

<resultMap id="employeeResultMap" type="employee">
    <id column="e_id" property="id"/>
    <result column="e_name" property="eName"/>
    <association property="department" column="dept_id" javaType="department" select="com.baoxian.dao.DepartmentMapper.selectDepartmentById"/>
  </resultMap>

<!--根据e_id查询员工-->
  <select id="selectEmployeeById" resultMap="employeeResultMap" parameterType="java.lang.Long" >
    select e_id,e_name,dept_id
    from employee
    where e_id = #{id}
  </select>

 

 

此时查看额外sql语句 selectDepartmentById:

<resultMap id="departResultMap" type="department" autoMapping="false">
    <id column="d_id" property="id"/>
    <result column="d_name" property="dName"/>
  </resultMap>

<!--根据d_id查询部门_供employee使用-->
  <select id="selectDepartmentById" resultMap="departResultMap" parameterType="java.lang.Long" >
    select d_id ,d_name
    from department
    where d_id = #{id}
  </select>

 

方式二:通过联表的方式,将结果集中的内容分别注入到employee 与department中:

非常重要: id元素在嵌套结果映射中扮演着非 常重要的角色。你应该总是指定一个或多个可以唯一标识结果的属性。实际上如果你不指定它的话, MyBatis仍然可以工作,但是会有严重的性能问题。在可以唯一标识结果的情况下, 尽可能少的选择属性。主键是一个显而易见的选择（即使是复合主键）。

<resultMap id="emp_ResultMap" type="employee">
    <id column="e_id" property="id"/>
    <result column="e_name" property="eName"/>
    <association property="department" javaType="department" columnPrefix="d_" >
      <id column="id" property="id"/>
      <result column="name" property="dName"/>
    </association>
  </resultMap>

  <!--根据e_id 关联employee 与 department表查询-->
  <select id="queryEmployeeById" resultMap="emp_ResultMap" parameterType="java.lang.Long" >
    select
          e_id,
          e_name,
          dept_id as deptId,
          d_id,
          d_name
    from employee
    left join department
    on employee.dept_id = department.d_id
    where e_id = #{id}
  </select>

association元素 通过resultMap属性可以指定一个定义好的resultMap,从而替换子元素Id,type,如下:

<resultMap id="emp_ResultMap" type="employee">
    <id column="e_id" property="id"/>
    <result column="e_name" property="eName"/>
    <association property="department" resultMap="com.baoxian.dao.DepartmentMapper.dept_resultMap" columnPrefix="d_" />
  </resultMap>

<!--在departmentMapper.xml中-->
<resultMap id="dept_resultMap" type="department"  >
    <id column="id" property="id"/>
    <result column="name" property="dName"/>
  </resultMap>

 

通过上述我们可知,发送额外SQL的方式 与 联表查询都可以完成 对象属性的注入,下面来介绍下两者的优缺点:

发送额外SQL:

　　优点:直观,select语句可以复用

　　缺点:会出现N + 1 的问题

　　

　　何为N + 1 ? 

　　个人认为应该读作 1+ N , 就根据上述的Employee查询,每次查询出1条employee记录,都要额外的发送1条sql

　　如果1条sql语句中,查询出N条employee记录, 那么就要额外的发送N条sql语句,查询部门的信息

　　此时本想执行1条,却额外多执行了N条sql语句 , 这就是 N + 1的问题

 　　

　　可以通过懒加载的方式,尽可能的减少N + 1问题:

　　解决方式1:在mybatis的配置文件中,配置lazyLoadingEnabled 当使用到关联对象的任意属性时,才会发送额外SQL查询:

<settings>
        <setting name="lazyLoadingEnabled" value="true"/>
</settings>

　　解决方式2:同样在mybaits中,配置aggressiveLazyLoading,只有当明确访问对象的某一属性时,才会发送额外SQL查询:

<setting name="aggressiveLazyLoading" value="false"/>

 

联表查询:

　　优点:没有N + 1的问题

　　缺点:联表也是非常耗时的操作

 

嵌套查询与发送额外SQL查询,两种方式如何进行选择?
　　1.当One方比较多时,例如:部门比较多,此时由于N+1的情况的存在,选择嵌套查询的方式会更好一些
　　2.当One方比较少时,同时嵌套查询关联的字段比较多,因为关联表是非常消耗性能,此时因为一级缓存的特点,使用发送额外SQL的方式会更好一些

collection元素:

当对象中的属性类型为集合时,就要使用到colleciton元素进行映射

同样可以使用发送额外SQL与 联表查询 实现 collection的映射:

 

发送额外SQL:

<resultMap id="departmentResultMap" type="department">
    <id column="d_id" property="id"/>
    <result column="d_name" property="dName"/>
    <collection property="employees" column="d_id" ofType="employee" select="com.baoxian.dao.EmployeeMapper.selectEmployeeByDeptId"/>
  </resultMap>

<select id="selectDepartById" resultMap="departmentResultMap" parameterType="java.lang.Long" >
    select d_id ,d_name
    from department
    where d_id = #{id}
  </select>

<!--EmployeeMapper.xml文件中-->
<!--根据部门id查询该部门下所有员工-->
  <select id="selectEmployeeByDeptId" resultMap="employeeResultMap" parameterType="java.lang.Long" >
    select e_id,e_name
    from employee
    where dept_id = #{id}
  </select>

 

联表查询:

<resultMap id="department_ResultMap" type="department">
    <id column="d_id" property="id"/>
    <result column="d_name" property="dName"/>
    <collection property="employees"  ofType="employee" columnPrefix="e_">
      <id column="id" property="id"/>
      <result column="name" property="eName"/>
    </collection>
  </resultMap>

<select id="selectDepartmentAndEmployeeById" resultMap="department_ResultMap" parameterType="java.lang.Long" >
    select
      d_id ,
      d_name,
      e_id,
      e_name,
      dept_id
    from department
    left join employee on department.d_id = employee.dept_id
    where d_id = #{id}
  </select>

联表查询,同样也可以指定collection中的 resultMap属性,在此不做演示,参考association元素

 

discriminator 鉴别器元素

简单的说,非常类似java中的switch语句:

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

当结果集中列或者列的别名,vehicle_type值为1时,选择相应的resultType 并加载各自的result

 

自动映射

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

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

即:

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

对于resultMap,如果没有被手动映射的列,将会被自动映射,自动映射处理完后手动映射才会处理,因此resultMap可以这么写:

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

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

自动映射的配置:

<setting name="autoMappingBehavior" value="PARTIAL"/>

值有三种可选:NONE, PARTIAL, FULL

NONE: 表示取消自动映射；

PARTIAL: 只会自动映射没有定义嵌套结果集映射的结果集。

FULL : 会自动映射任意复杂的结果集（无论是否嵌套）。

当使用FULL时，自动映射会在处理join结果时执行，并且join取得若干相同行的不同实体数据，因此这可能导致非预期的映射。

通过设置select元素的autoMapping属性值 true / false 决定当前resultMap是否启用自动映射

例如:

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

 

至此最重要的resultMap元素已彻底结束;

 
posted @ 2018-08-01 07:11  yi杆烟枪  阅读(4602)  评论(0)  编辑  收藏  举报