Mapper XML 文件
基本的*Mapper.xml文件配置就不熬述了具体可参考：
http://www.mybatis.org/mybatis-3/zh/sqlmap-xml.html
1、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>
属性值可以用于包含的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>
上面这段SQL首先引用了someinclude然后再someinclude里面又引用了sometable。利用该功能配合if就能动态生成SQL语句了。
2、使用Mybatis优雅的解决N+1查询问题(关联的嵌套查询)
概括地讲,N+1 查询问题可以是这样引起的:
- 你执行了一个单独的 SQL 语句来获取结果列表(就是“+1”)。
- 对返回的每条记录,你执行了一个查询语句来为每个加载细节(就是“N”)。
以上问题可以使用关联嵌套查询来解决问题，以下介绍一下嵌套查询的标签<association>属性的作用。
- 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。
先举一个简单的例子：客户表customer和car是有一对多的关系，假设有实体类如下:
package com.zealzhangz.entity; import java.io.Serializable;
import java.util.List; public class Customer implements Serializable { private static final long serialVersionUID = 7500918067281634276L; private String name; // 名称 private String sex; // 性别 private String idCar; private Car customerCar; public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} public String getSex() {
return sex;
} public void setSex(String sex) {
this.sex = sex;
} public String getIdCar() {
return idCar;
} public void setIdCar(String idCar) {
this.idCar = idCar;
} public Car getCustomerCar() {
return customerCar;
} public void setCustomerCar(Car customerCar) {
this.customerCar = customerCar;
}
}
如果要获取客户和车辆的信息，一般的做法需要两次查询才能查出结果。当然可以换一种方式，把Car中字段拿到Customer中来，SQL JOIN查询也能查出结果，对于List<car>这种情况JOIN就无能为力了。但是mybatis已经提供了直接优雅
完成这种查询的功能SQL如下：
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="CustomerMapper">
<resultMap type="Customer" id="customerMap">
<association property="customerCar" column="idCar" javaType="Car" select="selectCar"/>
</resultMap>
<select id="selectCustomer" resultMap="customerMap" parameterType="string">
select name,sex,cc.id_car AS idCar from customer c INNER JOIN customer_car cc ON c.pk_id=cc.id_customer where c.pk_id = CAST(#{pk_id} AS UNSIGNED)
</select> <select id="selectCar" resultType="Car">
select car_prefix AS carPrefix,car_no AS carNo,vin,car_brand_name AS carBrandName, car_series_mame AS carSeriesMame from car where pk_id = CAST(#{id} AS UNSIGNED)
</select>
</mapper>
结果如下：
{
"customerCar": {
"carBrandName": "Jeep",
"carNo": "A666666",
"carPrefix": "苏",
"carSeriesMame": "Compass [指南者]",
"vin": "1C4NJCCA9CD645865"
},
"name": "张先生",
"sex": "先生"
}
更复杂的情形有多辆车的情况，这种情况我们稍后考虑。
注意：以上联合查询是一个分离的复杂的联合查询，下面这个是一个非常简单的示例 来说明它如何工作。代替了执行一个分离的语句：
<select id="selectCustomerCar" resultType="Customer" parameterType="string">
SELECT
name,
sex,
cc.id_car AS idCar,
r.car_prefix AS carPrefix,
r.car_no AS carNo,
vin,
car_brand_name AS carBrandName,
car_series_mame AS carSeriesMame
FROM
tm_customer c
INNER JOIN
tm_customer_car cc ON c.pk_id = cc.id_customer
INNER JOIN
tm_car r ON cc.id_car = r.pk_id
WHERE
c.pk_id = CAST(#{pk_id} AS UNSIGNED)
</select>
下面使用两个resultMap来联合映射上面的查询结果：
<resultMap id="customerCarResult" type="Customer">
<id property="idCustomer" column="idCustomer"/>
<result property="name" column="name"/>
<result property="sex" column="sex"/>
<association property="customerCar" column="idCar" javaType="Car" resultMap="carResult"/>
</resultMap> <resultMap id="carResult" type="Car">
<id property="idCar" column="idCar"/>
<result property="carPrefix" column="carPrefix"/>
<result property="carNo" column="carNo"/>
<result property="vin" column="vin"/>
<result property="carBrandName" column="carBrandName"/>
<result property="carSeriesMame" column="carSeriesMame"/>
</resultMap>
非常重要: id元素在嵌套结果映射中扮演着非 常重要的角色。你应该总是指定一个或多个可以唯一标识结果的属性。实际上如果你不指定它的话, MyBatis仍然可以工作,但是会有严重的性能问题。在可以唯一标识结果的情况下, 尽可能少的选择属性。主键是一个显而易见的选择（即使是复合主键）。
现在,上面的示例用了外部的结果映射元素来映射关联。这使得Car结果映射可以 重用。然而,如果你不需要重用它的话,或者你仅仅引用你所有的结果映射合到一个单独描 述的结果映射中。你可以嵌套结果映射。这里给出使用这种方式的相同示例:
<resultMap id="customerCarResultUnion" type="Customer">
<id property="idCustomer" column="idCustomer"/>
<result property="name" column="name"/>
<result property="sex" column="sex"/>
<association property="customerCar" javaType="Car">
<id property="idCar" column="idCar"/>
<result property="carPrefix" column="carPrefix"/>
<result property="carNo" column="carNo"/>
<result property="vin" column="vin"/>
<result property="carBrandName" column="carBrandName"/>
<result property="carSeriesMame" column="carSeriesMame"/>
</association>
</resultMap>
假设有一种业务，每个customer有一辆日常用车还有一辆备用车（这个业务现实中可能并不存在），客户实体就变成这个样子了：
import java.io.Serializable;
import java.util.List; public class Customer implements Serializable { private static final long serialVersionUID = 7500918067281634276L; private String idCustomer; private String name; // 名称 private String sex; // 性别 private String idCar; private Car customerCar; private Car backupCar; //备用车 public String getIdCustomer() {
return idCustomer;
} public void setIdCustomer(String idCustomer) {
this.idCustomer = idCustomer;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} public String getSex() {
return sex;
} public void setSex(String sex) {
this.sex = sex;
} public String getIdCar() {
return idCar;
} public void setIdCar(String idCar) {
this.idCar = idCar;
} public Car getCustomerCar() {
return customerCar;
} public void setCustomerCar(Car customerCar) {
this.customerCar = customerCar;
} public Car getBackupCar() {
return backupCar;
} public void setBackupCar(Car backupCar) {
this.backupCar = backupCar;
}
}
两个Car类型的字段：customerCar、backupCar，这个时候SQL查询怎么区分呢？
因为结果中的列名与resultMap中的列名不同。 你需要指定columnPrefix去重用映射ba_car结果的resultMap。
<resultMap id="carResult" type="Car">
<id property="idCar" column="idCar"/>
<result property="carPrefix" column="carPrefix"/>
<result property="carNo" column="carNo"/>
<result property="vin" column="vin"/>
<result property="carBrandName" column="carBrandName"/>
<result property="carSeriesMame" column="carSeriesMame"/>
</resultMap> <resultMap id="customerCarResultAll" type="Customer">
<id property="idCustomer" column="idCustomer"/>
<result property="name" column="name"/>
<result property="sex" column="sex"/>
<association property="customerCar" resultMap="carResult"/>
<association property="backupCar" resultMap="carResult" columnPrefix="ba_"/>
</resultMap> <select id="selectCustomerCarAll" resultMap="customerCarResultAll" parameterType="string">
SELECT
c.pk_id AS idCustomer,
c.name,
c.sex,
cc.id_car AS idCar,
r.car_prefix AS carPrefix,
r.car_no AS carNo,
r.vin,
r.car_brand_name AS carBrandName,
r.car_series_mame AS carSeriesMame,
'1314182348972' AS ba_idCar,
'云' AS ba_carPrefix,
'AR6248' AS ba_carNo,
'1231sdfhs623462e7' AS ba_vin,
'五羊' AS ba_carBrandName,
'本田' AS ba_carSeriesMame
FROM
tm_customer c
INNER JOIN
tm_customer_car cc ON c.pk_id = cc.id_customer
INNER JOIN
tm_car r ON cc.id_car = r.pk_id
WHERE
c.pk_id = CAST(#{pk_id} AS UNSIGNED)
</select>
结果如下：
{
"backupCar": {
"carBrandName": "五羊",
"carNo": "AR6248",
"carPrefix": "云",
"carSeriesMame": "本田",
"idCar": "1314182348972",
"vin": "1231sdfhs623462e7"
},
"customerCar": {
"carBrandName": "Jeep",
"carNo": "A666666",
"carPrefix": "苏",
"carSeriesMame": "Compass [指南者]",
"idCar": "10545406337939703159",
"vin": "1C4NJCCA9CD645865"
},
"idCustomer": "10545406337939703158",
"name": "张先生",
"sex": "先生"
}
集合的嵌套查询
假设这种场景，一个客户有很多辆车且车和车之间没有逻辑关系，这时候我们会用private List<Car> cars;来存储所有车辆的信息。这种情况改怎么写查询呢？
<resultMap id="customerCarListResult" type="Customer">
<id property="idCustomer" column="idCustomer"/>
<result property="name" column="name"/>
<result property="sex" column="sex"/>
<collection property="cars" javaType="ArrayList" column="idCustomer" ofType="Car" select="selectCarByIdCustomer"/>
</resultMap> <select id="selectCarByIdCustomer" resultType="Car">
SELECT
r.car_prefix AS carPrefix,
r.car_no AS carNo,
r.vin,
r.car_brand_name AS carBrandName,
r.car_series_mame AS carSeriesMame
FROM
tm_customer_car cc INNER JOIN
tm_car r ON cc.id_car = r.pk_id
WHERE
cc.id_customer = CAST(#{idCustomer} AS UNSIGNED)
</select> <select id="selectCustomerListCar" resultMap="customerCarListResult" parameterType="string">
select pk_id AS idCustomer,name,sex from tm_customer where pk_id = CAST(#{pk_id} AS UNSIGNED)
</select>
结果如下图：
{
"cars": [
{
"carBrandName": "Jeep",
"carNo": "A666666",
"carPrefix": "苏",
"carSeriesMame": "Compass [指南者]",
"vin": "1C4NJCCA9CD645865"
},
{
"carBrandName": "宝马",
"carNo": "A86866",
"carPrefix": "苏",
"carSeriesMame": "X5 xDrive35i",
"vin": "5UXZV4C51D0B11025"
}
],
"idCustomer": "10545406337939703158",
"name": "张先生",
"sex": "先生"
}
这里我们应该注意很多东西,但大部分代码和上面的关联元素是非常相似的。首先,你应 该注意我们使用的是集合元素。然后要注意那个新的“ofType”属性。这个属性用来区分 JavaBean(或字段)属性类型和集合包含的类型来说是很重要的。所以你可以读出下面这个 映射:
<collection property="cars" javaType="ArrayList" column="idCustomer" ofType="Car" select="selectCarByIdCustomer"/>
读作: “在Car类型的 ArrayList 中的 cars 的集合。”
javaType 属性是不需要的,因为 MyBatis 在很多情况下会为你算出来。所以你可以缩短 写法:
<collection property="cars" column="idCustomer" ofType="Car" select="selectCarByIdCustomer"/>
集合的嵌套结果
至此,我们可以猜测集合的嵌套结果是如何来工作的,因为它和关联完全相同,除了它应 用了一个“ofType”属性,请看如下SQL：
<select id="selectCustomerListCarUnion" resultMap="selectCustomerListCarUnionResult">
SELECT
c.pk_id AS idCustomer,
c.name,
c.sex,
cc.id_car AS idCar,
r.car_prefix AS carPrefix,
r.car_no AS carNo,
r.vin,
r.car_brand_name AS carBrandName,
r.car_series_mame AS carSeriesMame
FROM
tm_customer c
INNER JOIN
tm_customer_car cc ON c.pk_id = cc.id_customer
LEFT JOIN
tm_car r ON r.pk_id = cc.id_car
WHERE
c.pk_id = CAST(#{idCustomer} AS UNSIGNED)
</select>
我们在一个SQL中查询出了一个客户的所有车辆信息，查询的结果形式如下：
客户1 车辆1
客户1 车辆2
我们又一次联合了客户和车辆表,结果列标签的简单映射。现 在用汽车映射集合映射客户,可以简单写为:
<resultMap id="selectCustomerListCarUnionResult" type="Customer">
<id property="idCustomer" column="idCustomer"/>
<result property="name" column="name"/>
<result property="sex" column="sex"/>
<collection property="cars" ofType="Car">
<id property="idCar" column="idCar"/>
<result property="carPrefix" column="carPrefix"/>
<result property="carNo" column="carNo"/>
<result property="vin" column="vin"/>
<result property="carBrandName" column="carBrandName"/>
<result property="carSeriesMame" column="carSeriesMame"/>
</collection>
</resultMap>
注意这里的<collection property="cars" ofType="Car">和上面<association property="customerCar" javaType="Car">不同支出就是ofType是针对集合的。
同样,要记得 id 元素的重要性,如果你不记得了,请阅读上面的关联部分。
同样, 如果你引用更长的形式允许你的结果映射的更多重用, 你可以使用下面这个替代 的映射:
<resultMap id="selectCustomerListCarUnionCustomerResult" type="Customer">
<id property="idCustomer" column="idCustomer"/>
<result property="name" column="name"/>
<result property="sex" column="sex"/>
<collection property="cars" ofType="Car" resultMap="carListUnion" columnPrefix="car_"/>
</resultMap> <resultMap id="carListUnion" type="Car">
<id property="idCar" column="idCar"/>
<result property="carPrefix" column="carPrefix"/>
<result property="carNo" column="carNo"/>
<result property="vin" column="vin"/>
<result property="carBrandName" column="carBrandName"/>
<result property="carSeriesMame" column="carSeriesMame"/>
</resultMap> <select id="selectCustomerListCarUnion" resultMap="selectCustomerListCarUnionCustomerResult">
SELECT
c.pk_id AS idCustomer,
c.name,
c.sex,
cc.id_car AS car_idCar,
r.car_prefix AS car_carPrefix,
r.car_no AS car_carNo,
r.vin AS car_vin,
r.car_brand_name AS car_carBrandName,
r.car_series_mame AS car_carSeriesMame
FROM
tm_customer c
INNER JOIN
tm_customer_car cc ON c.pk_id = cc.id_customer
LEFT JOIN
tm_car r ON r.pk_id = cc.id_car
WHERE
c.pk_id = CAST(#{idCustomer} AS UNSIGNED)
</select>
鉴别器
有的时候结果集的映射需要根据结果集的每个字段进行动态映射，比如结果实体有继承关系时。 鉴别器非常容易理 解,因为它的表现很像 Java 语言中的 switch 语句。比如：
<select id="selectCarDiscriminator" resultMap="carResultDiscriminator">
SELECT
pk_id AS idCar,
car_prefix AS carPrefix,
car_no AS carNo,
vin AS vin,
car_brand_name AS carBrandName,
car_series_mame AS carSeriesMame,
2 AS flag
FROM
tm_car
WHERE
pk_id = CAST(#{pk_id} AS UNSIGNED)
</select> <resultMap id="carResultDiscriminator" type="Car">
<id property="idCar" column="idCar"/>
<result property="carPrefix" column="carPrefix"/>
<result property="carNo" column="carNo"/>
<result property="vin" column="vin"/>
<result property="carBrandName" column="carBrandName"/>
<result property="carSeriesMame" column="carSeriesMame"/>
<discriminator javaType="int" column="flag">
<case value="1" resultMap="test1Result"/>
<case value="2" resultMap="test2Result"/>
</discriminator>
</resultMap> <resultMap id="test1Result" type="Car">
<result property="test1" column="flag"/>
</resultMap>
<resultMap id="test2Result" type="Car">
<result property="test2" column="vin"/>
</resultMap>
以上逻辑<discriminator javaType="int" column="flag">中flag的值（1或2）动态映射test1Result或test2Result
以上result可简写为如下：
<resultMap id="carResultDiscriminator" type="Car">
<id property="idCar" column="idCar"/>
<result property="carPrefix" column="carPrefix"/>
<result property="carNo" column="carNo"/>
<result property="vin" column="vin"/>
<result property="carBrandName" column="carBrandName"/>
<result property="carSeriesMame" column="carSeriesMame"/>
<discriminator javaType="int" column="flag">
<case value="1" resultMap="test1Result">
<result property="test1" column="flag"/>
</case>
<case value="2" resultMap="test2Result">
<result property="test2" column="vin"/>
</case>
</discriminator>
</resultMap>
自动映射
当自动映射查询结果时，MyBatis会获取sql返回的列名并在java类中查找相同名字的属性（忽略大小写）。 这意味着如果Mybatis发现了ID列和id属性，Mybatis会将ID的值赋给id。通常数据库列使用大写单词命名，单词间用下划线分隔；而java属性一般遵循驼峰命名法。 为了在这两种命名方式之间启用自动映射，需要将 mapUnderscoreToCamelCase设置为true。
有三种自动映射等级：
- NONE - 禁用自动映射。仅设置手动映射属性。
- PARTIAL - 将自动映射结果除了那些有内部定义内嵌结果映射的(joins).
- FULL - 自动映射所有。
默认值是PARTIAL，这是有原因的。当使用FULL时，自动映射会在处理join结果时执行，并且join取得若干相同行的不同实体数据，因此这可能导致非预期的映射。比如两个实体都有id属性，SELECT出来的id就不知道映射给谁。
缓存
MyBatis 包含一个非常强大的查询缓存特性,它可以非常方便地配置和定制。MyBatis 3 中的缓存实现的很多改进都已经实现了,使得它更加强大而且易于配置。
默认情况下是没有开启缓存的,除了局部的 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
注意：如果手动修改了数据库的数据就可能会发生脏读，因为手动改数据触发不了mybatis的缓存更新机制。
使用自定义缓存
除了这些自定义缓存的方式, 你也可以通过实现你自己的缓存或为其他第三方缓存方案 创建适配器来完全覆盖缓存行为。
<cache type="com.domain.something.MyCustomCache"/>
这个示 例展 示了 如何 使用 一个 自定义 的缓 存实 现。type 属 性指 定的 类必 须实现 org.mybatis.cache.Cache 接口。这个接口是 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();
}
记得缓存配置和缓存实例是绑定在 SQL 映射文件的命名空间是很重要的。因此,所有 在相同命名空间的语句正如绑定的缓存一样。 语句可以修改和缓存交互的方式, 或在语句的 语句的基础上使用两种简单的属性来完全排除它们。默认情况下,语句可以这样来配置:
<select ... flushCache="false" useCache="true"/>
<insert ... flushCache="true"/>
<update ... flushCache="true"/>
<delete ... flushCache="true"/>
因为那些是默认的,你明显不能明确地以这种方式来配置一条语句。相反,如果你想改 变默认的行为,只能设置 flushCache 和 useCache 属性。比如,在一些情况下你也许想排除 从缓存中查询特定语句结果,或者你也许想要一个查询语句来刷新缓存。相似地,你也许有 一些更新语句依靠执行而不需要刷新缓存。
参照缓存
这个特殊命名空间的唯一缓存会被使用或者刷新相同命名空间内 的语句。也许将来的某个时候,你会想在命名空间*享相同的缓存配置和实例。在这样的 情况下你可以使用 cache-ref 元素来引用另外一个缓存。
<cache-ref namespace="com.someone.application.data.SomeMapper"/>