一、MyBatis 简介
【1】MyBatis 是支持定制化 SQL，存储过程以及高级映射的优秀持久化框架。
【2】MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取查询结果集。
【3】MyBatis 可以使用简单的 XML 或者注解用于配置和原始映射，将接口和 Java 的 POJO 映射成数据库中的记录。
二、为什么要是用 MyBatis
【1】MyBatis 是一个半自动的持久化框架。
【2】JDBC 缺点：SQL 夹在代码块里，耦合度高导致硬编码内伤。维护不易且实际开发中 SQL 是有变化的，频繁修改很常见。
【3】 Hibernate 和 JPA：复杂的 SQL 对于 Hibernate 而言很难处理，内部自动生成 SQL 不易特殊优化，基于全映射全自动框架，大量字段的 POJO 进行映射会比较困难，降低性能。
【4】对开发者而言，核心 SQL 还是掌握在自己手中比较好，方便优化。
【5】SQL 和 Java 编码分开，功能边界清晰，一个专注业务，一个专注数据库。
MyBatis 是面向接口编程的，所以每一个接口都对应一个 xml 映射文件书写 SQL 语句，接口的全类名对应 xml 的namespace，接口的方法名对应 xml 的 id。但是我们要获取实体类对象需要通过 session 的 getMapper(接口.class)
三、Mybatis配置文件用properties引入外部配置文件
在 MyBatis 配置文件中可以使用 properties 来引入外部 properties配置文件的内容：
<properties resource="dbconfig.properties"></properties>
四、settings 标签
这是 MyBatis 中极为重要的调整设置，他们会改变 MyBatis 的运行行为
例如：驼峰命名(数据库中字段LAST_NAME，通过对象中的 lastName)。mybatis-config.xml中配置如下：
1 <settings>
2 <setting name="mapUnderscoreToCamelCase" value="true"></setting>
3 </settings>
五、mapper 映射配置
将写好的 SQL映射文件（EmployeeMapper.xml）一定注册到全局配置文件（mybatis-config.xml）中
1 <!-- mappers：将sql映射注册到全局配置中 -->
2 <mappers>
3 <!--
4 mapper:注册一个sql映射
5 注册配置文件
6 resource：引用类路径下的sql映射文件
7 mybatis/mapper/EmployeeMapper.xml
8 url：引用网路路径或者磁盘路径下的sql映射文件
9 file:///var/mappers/AuthorMapper.xml
10
11 注册接口
12 class：引用（注册）接口，
13 1、有sql映射文件，映射文件名必须和接口同名，并且放在与接口同一目录下；
14 2、没有sql映射文件，所有的sql都是利用注解写在接口上;
15 推荐：
16 比较重要的，复杂的Dao接口我们来写sql映射文件
17 不重要，简单的Dao接口为了开发快速可以使用注解；
18 -->
19 <!-- <mapper resource="mybatis/mapper/EmployeeMapper.xml"/> -->
20 <!-- <mapper class="com.atguigu.mybatis.dao.EmployeeMapperAnnotation"/> -->
21
22 <!-- 批量注册： -->
23 <package name="com.atguigu.mybatis.dao"/>
24 </mappers>
六、Mysql 获取自增主键的值
Mybatis 允许增删改直接定义以下类型返回值 Integer、Long（表示成功的个数）、Boolean、void；
1 <!--mysql支持自增主键，自增主键值的获取，mybatis也是利用statement.getGenreatedKeys()；
2 useGeneratedKeys="true"；使用自增主键获取主键值策略
3 keyProperty；指定对应的主键属性，也就是mybatis获取到主键值以后，将这个值封装给javaBean的哪个属性
4 -->
5 <insert id="addEmp" parameterType="com.atguigu.mybatis.bean.Employee"
6 useGeneratedKeys="true" keyProperty="id" databaseId="mysql">
7 insert into tbl_employee(last_name,email,gender)
8 values(#{lastName},#{email},#{gender})
9 </insert>
七、Oracle 不支持自增
Oracle 使用序列来模拟自增；获取非自增主键的值，每次插入的数据的主键是从序列中拿到的值；如何获取到这个值。
1 <insert id="addEmp" databaseId="oracle" parameterType="com.atguigu.mybatis.bean.Employee">
2 <!--
3 keyProperty:查出的主键值封装给javaBean的哪个属性
4 order="BEFORE":当前sql在插入sql之前运行
5 AFTER：当前sql在插入sql之后运行
6 resultType:查出的数据的返回值类型
7
8 BEFORE运行顺序：
9 先运行selectKey查询id的sql；查出id值封装给javaBean的id属性
10 在运行插入的sql；就可以取出id属性对应的值
11 -->
12 <selectKey keyProperty="id" order="BEFORE" resultType="Integer">
13 <!-- 编写查询主键的sql语句 -->
14 select EMPLOYEES_SEQ.nextval from dual
15 </selectKey>
16
17 <!-- 插入时的主键是从序列中拿到的 -->
18 insert into employees(EMPLOYEE_ID,LAST_NAME,EMAIL)
19 values(#{id},#{lastName},#{email<!-- ,jdbcType=NULL -->})
20 </insert>
八、参数说明
【1】单个参数：Mybatis 不会做特殊处理，#{参数名/任意名}：取出参数值。
【2】多个参数：Mybatis 会做特殊处理。多个参数会被封装成 一个 Map，key：param1...paramN，或者参数的索引（0,1,2....）也可以，value：传入的参数值，#{} 就是从 map 中获取指定的 key 的值；
【命名参数】：明确指定封装参数时 map 的 key；@Param("id")，多个参数会被封装成 一个 Map，key：使用 @Param 注解指定的值；value：参数值； #{指定的key}取出对应的参数值；
public Employee getEmpByIdAndLastName(@Param("id")Integer id,@Param("lastName")String lastName);
POJO：如果多个参数正好是我们业务逻辑的数据模型，我们就可以直接传入 pojo； #{属性名}：取出传入的 pojo 的属性值；
Map：如果多个参数不是业务模型中的数据，没有对应的 pojo，不经常使用，为了方便，我们也可以传入map；#{key}：取出map 中对应的值；
TO：如果多个参数不是业务模型中的数据，但是经常要使用，推荐来编写一个TO（Transfer Object）数据传输对象；
1 Page{
2 int index;
3 int size;
4 }
九、 #{} 和 ${} 区别
都可以获取 Map 中的值或者 pojo 对象属性的值
1 select * from tbl_employee where id=${id} and last_name=#{lastName}
2 Preparing: select * from tbl_employee where id=2 and last_name=?
区别：【1】#{}：是以预编译的形式，将参数设置到 sql 语句中；PreparedStatement；防止 sql 注入；
【2】${}：取出的值直接拼装在 sql 语句中；会有安全问题；
【3】大多情况下，我们去参数的值都应该去使用 #{}；
【4】原生 jdbc 不支持占位符的地方我们就可以使用 ${} 进行取值，比如分表、排序。。。；按照年份分表拆分；
select * from ${year}_salary where xxx;
select * from tbl_employee order by ${f_name} ${order}
十、#{} 更丰富的用法
规定参数的一些规则： javaType、jdbcType、 mode（存储过程）、numericScale、resultMap、typeHandler、jdbcTypeName、expression（未来准备支持的功能）；
JdbcType 通常需要在某种特定的条件下被设置：
【1】 在我们数据为 null 的时候，有些数据库可能不能识别 Mybatis对 null的默认处理。比如Oracle（报错）；
【2】Oracle 报：JdbcType OTHER：无效的类型；因为 Mybatis 对所有的 null 都映射的是原生 Jdbc 的 OTHER 类型，oracle 不能正确处理；
【3】由于全局配置中：jdbcTypeForNull=OTHER；oracle不支持；两种办法
1）、修改 xml 语句，也是最常用的方法：#{email,jdbcType=VARCHAR}；
2）、修改 MyBatis 配置文件：
<setting name="jdbcTypeForNull" value="NULL"/>
十一、多条记录封装一个 map
Map<Integer,Employee>：键是这条记录的主键，值是记录封装后的 javaBean；@MapKey：告诉 Mybatis 封装这个 map 的时候使用哪个属性作为 map 的 key；
1 @MapKey("lastName")
2 public Map<String, Employee> getEmpByLastNameLikeReturnMap(String lastName);
EmployeeMapper.xml 中
1 <!--public Map<Integer, Employee> getEmpByLastNameLikeReturnMap(String lastName); -->
2 <select id="getEmpByLastNameLikeReturnMap" resultType="com.atguigu.mybatis.bean.Employee">
3 select * from tbl_employee where last_name like #{lastName}
4 </select>
十二、常用标签
【1】resultMap 标签使用（常用）
1 <resultMap type="com.atguigu.mybatis.bean.Employee" id="MySimpleEmp">
2 <!--指定主键列的封装规则
3 id定义主键会底层有优化；
4 column：指定哪一列
5 property：指定对应的javaBean属性
6 -->
7 <id column="id" property="id"/>
8 <!-- 定义普通列封装规则 -->
9 <result column="last_name" property="lastName"/>
10 <!-- 其他不指定的列会自动封装：我们只要写resultMap就把全部的映射规则都写上。 -->
11 <result column="email" property="email"/>
12 <result column="gender" property="gender"/>
13 </resultMap>
14
15 <!-- resultMap:自定义结果集映射规则； -->
16 <!-- public Employee getEmpById(Integer id); -->
17 <select id="getEmpById" resultMap="MySimpleEmp">
18 select * from tbl_employee where id=#{id}
19 </select>
【2】查询 Employee 的同时查询员工对应的部门，Employee===Department 一个员工有与之对应的部门信息；
1 <!-- 使用association定义关联的单个对象的封装规则；-->
2 <resultMap type="com.atguigu.mybatis.bean.Employee" id="MyDifEmp2">
3 <id column="id" property="id"/>
4 <result column="last_name" property="lastName"/>
5 <result column="gender" property="gender"/>
6
7 <!-- association可以指定联合的javaBean对象
8 property="dept"：指定哪个属性是联合的对象
9 javaType:指定这个属性对象的类型[不能省略]
10 -->
11 <association property="dept" javaType="com.atguigu.mybatis.bean.Department">
12 <id column="did" property="id"/>
13 <result column="dept_name" property="departmentName"/>
14 </association>
15 </resultMap>
16
17 <!-- public Employee getEmpAndDept(Integer id);-->
18 <select id="getEmpAndDept" resultMap="MyDifEmp">
19 SELECT e.id id,e.last_name last_name,e.gender gender,e.d_id d_id,
20 d.id did,d.dept_name dept_name FROM tbl_employee e,tbl_dept d
21 WHERE e.d_id=d.id AND e.id=#{id}
22 </select>
也可以通过对象.属性获取
1 <!--联合查询：级联属性封装结果集-->
2 <resultMap type="com.atguigu.mybatis.bean.Employee" id="MyDifEmp">
3 <id column="id" property="id"/>
4 <result column="last_name" property="lastName"/>
5 <result column="gender" property="gender"/>
6 <result column="did" property="dept.id"/>
7 <result column="dept_name" property="dept.departmentName"/>
8 </resultMap>
【3】使用 association 进行分步查询，涉及到两个 mapper。EmployeeMapper.xml 文件如下：
1 <!-- 使用association进行分步查询：
2 1、先按照员工id查询员工信息
3 2、根据查询员工信息中的d_id值去部门表查出部门信息
4 3、部门设置到员工中；
5 -->
6
7 <!-- id last_name email gender d_id -->
8 <resultMap type="com.atguigu.mybatis.bean.Employee" id="MyEmpByStep">
9 <id column="id" property="id"/>
10 <result column="last_name" property="lastName"/>
11 <result column="email" property="email"/>
12 <result column="gender" property="gender"/>
13 <!-- association定义关联对象的封装规则
14 select:表明当前属性是调用select指定的方法查出的结果
15 column:指定将哪一列的值传给这个方法
16
17 流程：使用select指定的方法（传入column指定的这列参数的值）查出对象，并封装给property指定的属性
18 -->
19 <association property="dept"
20 select="com.atguigu.mybatis.dao.DepartmentMapper.getDeptById"
21 column="d_id">
22 </association>
23 </resultMap>
24 <!-- public Employee getEmpByIdStep(Integer id);-->
25 <select id="getEmpByIdStep" resultMap="MyEmpByStep">
26 select * from tbl_employee where id=#{id}
27 </select>
DepatermentMapper.xml 文件
1 <mapper namespace="com.atguigu.mybatis.dao.DepartmentMapper">
2 <!--public Department getDeptById(Integer id); -->
3 <select id="getDeptById" resultType="com.atguigu.mybatis.bean.Department">
4 select id,dept_name departmentName from tbl_dept where id=#{id}
5 </select>
6 </mapper>
十三、 可以使用延迟加载（懒加载）
(按需加载) Employee 中的 Dept 对象：不开启懒加载时，我们每次查询 Employee 对象的时候，都将全部信息查询出来。开启后部门信息在我们使用的时候再去查询；开启懒加载只需要在分段查询的基础之上加上两个配置：mybatis-config.xml中添加如下：
1 <settings>
2 <!--显示的指定每个我们需要更改的配置的值，即使他是默认的。防止版本更新带来的问题 -->
3 <setting name="lazyLoadingEnabled" value="true"/>
4 <setting name="aggressiveLazyLoading" value="false"/>
5 </settings>
十四、关联查询
查询部门的时候将部门对应的所有员工信息也查询出来：DepartmentMapper.xml 内容如下：
1 <!--嵌套结果集的方式，使用collection标签定义关联的集合类型的属性封装规则 -->
2 <resultMap type="com.atguigu.mybatis.bean.Department" id="MyDept">
3 <id column="did" property="id"/>
4 <result column="dept_name" property="departmentName"/>
5 <!--
6 collection定义关联集合类型的属性的封装规则
7 ofType:指定集合里面元素的类型
8 -->
9 <collection property="emps" ofType="com.atguigu.mybatis.bean.Employee">
10 <!-- 定义这个集合中元素的封装规则 -->
11 <id column="eid" property="id"/>
12 <result column="last_name" property="lastName"/>
13 <result column="email" property="email"/>
14 <result column="gender" property="gender"/>
15 </collection>
16 </resultMap>
17 <!-- public Department getDeptByIdPlus(Integer id); -->
18 <select id="getDeptByIdPlus" resultMap="MyDept">
19 SELECT d.id did,d.dept_name dept_name,
20 e.id eid,e.last_name last_name,e.email email,e.gender gender
21 FROM tbl_dept d
22 LEFT JOIN tbl_employee e
23 ON d.id=e.d_id
24 WHERE d.id=#{id}
25 </select>
十五、collection：分段查询
与单个对象分段查询一致：
1 <!-- collection：分段查询 -->
2 <resultMap type="com.atguigu.mybatis.bean.Department" id="MyDeptStep">
3 <id column="id" property="id"/>
4 <id column="dept_name" property="departmentName"/>
5 <collection property="emps"
6 select="com.atguigu.mybatis.dao.EmployeeMapperPlus.getEmpsByDeptId"
7 column="{deptId=id}" fetchType="lazy"><!--也可以传递多个条件，通过key=value键值对-->
8 </collection>
9 </resultMap>
10 <!-- public Department getDeptByIdStep(Integer id); -->
11 <select id="getDeptByIdStep" resultMap="MyDeptStep">
12 select id,dept_name from tbl_dept where id=#{id}
13 </select>
EmployeeMapper.xml 中被关联内容：
1 <select id="getEmpsByDeptId" resultType="com.atguigu.mybatis.bean.Employee">
2 select * from tbl_employee where d_id=#{deptId}
3 </select>
十六、鉴别器
通过对返回值的判断，取相应的值：
1 <!-- <discriminator javaType=""></discriminator>
2 鉴别器：mybatis可以使用discriminator判断某列的值，然后根据某列的值改变封装行为
3 封装Employee：
4 如果查出的是女生：就把部门信息查询出来，否则不查询；
5 如果是男生，把last_name这一列的值赋值给email;
6 -->
7 <resultMap type="com.atguigu.mybatis.bean.Employee" id="MyEmpDis">
8 <id column="id" property="id"/>
9 <result column="last_name" property="lastName"/>
10 <result column="email" property="email"/>
11 <result column="gender" property="gender"/>
12 <!--
13 column：指定判定的列名
14 javaType：列值对应的java类型 -->
15 <discriminator javaType="string" column="gender">
16 <!--女生 resultType:指定封装的结果类型；不能缺少。/resultMap-->
17 <case value="0" resultType="com.atguigu.mybatis.bean.Employee">
18 <association property="dept"
19 select="com.atguigu.mybatis.dao.DepartmentMapper.getDeptById"
20 column="d_id">
21 </association>
22 </case>
23 <!--男生 ;如果是男生，把last_name这一列的值赋值给email; -->
24 <case value="1" resultType="com.atguigu.mybatis.bean.Employee">
25 <id column="id" property="id"/>
26 <result column="last_name" property="lastName"/>
27 <result column="email" property="email"/>
28 <result column="gender" property="gender"/>
29 </case>
30 </discriminator>
31 </resultMap>
十七、动态SQL
【1】if 标签的使用：
1 <select id="getEmpsByConditionIf" resultType="com.atguigu.mybatis.bean.Employee">
2 select * from tbl_employee
3 <!-- where 或者给where后面加上1=1，以后的条件都and xxx.
4 mybatis使用where标签来将所有的查询条件包括在内。mybatis就会将where标签中拼装的sql，多出来的and或者or去掉
5 where只会去掉第一个多出来的and或者or。-->
6 <where>
7 <!-- test：判断表达式（OGNL）
8 c:if test从参数中取值进行判断，遇见特殊符号应该去写转义字符：&&：
9 -->
10 <if test="id != null">
11 id=#{id}
12 </if>
13 <if test="lastName!=null && lastName!=''">
14 and last_name like #{lastName}
15 </if>
16 <if test="email!=null and email.trim()!=''">
17 and email=#{email}
18 </if>
19 <!-- ognl会进行字符串与数字的转换判断 "0"==0 -->
20 <if test="gender==0 or gender==1">
21 and gender=#{gender}
22 </if>
23 </where>
24 </select>
【2】choose 标签的使用：
1 <select id="getEmpsByConditionChoose" resultType="com.atguigu.mybatis.bean.Employee">
2 select * from tbl_employee
3 <where>
4 <!-- 如果带了id就用id查，如果带了lastName就用lastName查;只会进入其中一个 -->
5 <choose>
6 <when test="id!=null">
7 id=#{id}
8 </when>
9 <when test="lastName!=null">
10 last_name like #{lastName}
11 </when>
12 <when test="email!=null">
13 email = #{email}
14 </when>
15 <otherwise>
16 gender = 0
17 </otherwise>
18 </choose>
19 </where>
20 </select>
【3】更新表时，set 标签的使用，可以去除多以的逗号。或者使用 trim 标签：
1 <update id="updateEmp">
2 <!-- Set标签的使用 -->
3 update tbl_employee
4 <set>
5 <if test="lastName!=null">
6 last_name=#{lastName},
7 </if>
8 <if test="email!=null">
9 email=#{email},
10 </if>
11 <if test="gender!=null">
12 gender=#{gender}
13 </if>
14 </set>
15 where id=#{id}
16 <!--
17 Trim：更新拼串
18 update tbl_employee
19 <trim prefix="set" suffixOverrides=",">
20 <if test="lastName!=null">
21 last_name=#{lastName},
22 </if>
23 <if test="email!=null">
24 email=#{email},
25 </if>
26 <if test="gender!=null">
27 gender=#{gender},
28 </if>
29 </trim>
30 where id=#{id} -->
31 </update>
【4】foreach 标签的使用：
1 <select id="getEmpsByConditionForeach" resultType="com.atguigu.mybatis.bean.Employee">
2 select * from tbl_employee
3 <!--
4 collection：指定要遍历的集合：
5 list类型的参数会特殊处理封装在map中，map的key就叫list
6 item：将当前遍历出的元素赋值给指定的变量
7 separator:每个元素之间的分隔符
8 open：遍历出所有结果拼接一个开始的字符
9 close:遍历出所有结果拼接一个结束的字符
10 index:索引。遍历list的时候是index就是索引，item就是当前值
11 遍历map的时候index表示的就是map的key，item就是map的值
12
13 #{变量名}就能取出变量的值也就是当前遍历出的元素
14 -->
15 <foreach collection="ids" item="item_id" separator=","
16 open="where id in(" close=")">
17 #{item_id}
18 </foreach>
19 </select>
也可以用于批量存储
1 <!-- 批量保存 -->
2 <!--public void addEmps(@Param("emps")List<Employee> emps); -->
3 <!--MySQL下批量保存：可以foreach遍历 mysql支持values(),(),()语法Oracle不支持此语法-->
4 <insert id="addEmps">
5 insert into tbl_employee(
6 <include refid="insertColumn"></include>
7 )
8 values
9 <foreach collection="emps" item="emp" separator=",">
10 (#{emp.lastName},#{emp.email},#{emp.gender},#{emp.dept.id})
11 </foreach>
12 </insert>
十八、Oracle 中支持的批量插入方法
1 <!-- Oracle数据库批量保存：
2 Oracle不支持values(),(),()
3 Oracle支持的批量方式
4 1、多个insert放在begin - end里面
5 begin
6 insert into employees(employee_id,last_name,email)
7 values(employees_seq.nextval,'test_001','test_001@atguigu.com');
8 insert into employees(employee_id,last_name,email)
9 values(employees_seq.nextval,'test_002','test_002@atguigu.com');
10 end;
11 2、利用中间表：
12 insert into employees(employee_id,last_name,email)
13 select employees_seq.nextval,lastName,email from(
14 select 'test_a_01' lastName,'test_a_e01' email from dual
15 union
16 select 'test_a_02' lastName,'test_a_e02' email from dual
17 union
18 select 'test_a_03' lastName,'test_a_e03' email from dual
19 )
20 -->
21 <insert id="addEmps" databaseId="oracle">
22 <!-- oracle第一种批量方式 -->
23 <!-- <foreach collection="emps" item="emp" open="begin" close="end;">
24 insert into employees(employee_id,last_name,email)
25 values(employees_seq.nextval,#{emp.lastName},#{emp.email});
26 </foreach> -->
27
28 <!-- oracle第二种批量方式 -->
29 insert into employees(
30 <!-- 引用外部定义的sql -->
31 <include refid="insertColumn">
32 <property name="testColomn" value="abc"/>
33 </include>
34 )
35 <foreach collection="emps" item="emp" separator="union"
36 open="select employees_seq.nextval,lastName,email from("
37 close=")">
38 select #{emp.lastName} lastName,#{emp.email} email from dual
39 </foreach>
40 </insert>
十九、常用标签 sql 标签使用（用来抽取公共的部分）：
1 <!--
2 抽取可重用的sql片段。方便后面引用
3 1、sql抽取：经常将要查询的列名，或者插入用的列名抽取出来方便引用
4 2、include来引用已经抽取的sql：
5 3、include还可以自定义一些property，sql标签内部就能使用自定义的属性
6 include-property：取值的正确方式${prop},
7 #{不能使用这种方式}
8 -->
9 <sql id="insertColumn">
10 <if test="_databaseId=='oracle'">
11 employee_id,last_name,email
12 </if>
13 <if test="_databaseId=='mysql'">
14 last_name,email,gender,d_id
15 </if>
16 </sql>
通过 include 标签，引用此标签：
1 <insert id="addEmps">
2 insert into tbl_employee(
3 <include refid="insertColumn"></include>
4 )
5 values
6 <foreach collection="emps" item="emp" separator=",">
7 (#{emp.lastName},#{emp.email},#{emp.gender},#{emp.dept.id})
8 </foreach>
9 </insert>
二十、缓存
一级缓存：（本地缓存）：sqlSession 级别的缓存。一级缓存是一直开启的；SqlSession 级别的一个 Map 与数据库同一次会话期间查询到的数据会放在本地缓存中。以后如果需要获取相同的数据，直接从缓存中拿，没必要再去查询数据库；一级缓存失效情况（没有使用到当前一级缓存的情况，效果就是，还需要再向数据库发出查询）：
【1】sqlSession 不同；
【2】sqlSession相同，查询条件不同。(当前一级缓存中还没有这个数据)；
【3】sqlSession相同，两次查询之间执行了增删改操作(这次增删改可能对当前数据有影响)；
【4】sqlSession相同，手动清除了一级缓存（缓存清空）；
二级缓存：（全局缓存）：基于 namespace 级别的缓存：一个 namespace 对应一个二级缓存：
工作机制：【1】一个会话，查询一条数据，这个数据就会被放在当前会话的一级缓存中；
【2】如果会话关闭；一级缓存中的数据会被保存到二级缓存中；新的会话查询信息，就可以参照二级缓存中的内容；
【3】sqlSession 会话中 EmployeeMapper 存储 Employee 对象的缓存；DepartmentMapper 存储 Department 对象的缓存；不同 namespace 查出的数据会放在自己对应的缓存中（map）；
效果：数据会从二级缓存中获取，查出的数据都会被默认先放在一级缓存中。只有会话提交或者关闭以后，一级缓存中的数据才会转移到二级缓存中。
使用：【1】开启全局二级缓存配置：<setting name="cacheEnabled" value="true"/>
【2】去 mapper.xml 中配置使用二级缓存：<cache></cache>
<cache eviction="FIFO" flushInterval="60000" readOnly="false" size="1024"></cache>
【3】我们的 POJO 需要实现序列化接口；
二十一、缓存有关的设置/属性
【1】cacheEnabled=true：false：关闭缓存（二级缓存关闭）(一级缓存一直可用的)
<setting name="cacheEnabled" value="true"/>
【2】每个 select 标签都有 useCache="true"：false：不使用缓存（一级缓存依然使用，二级缓存不使用）
【3】每个增删改标签的：flushCache="true"：（一级二级都会清除）；
增删改执行完成后就会清除缓存；flushCache="true"：一级缓存就清空了；二级也会被清除；
查询标签默认：flushCache="false"：如果 flushCache=true; 每次查询之后都会清空缓存；缓存是没有被使用的；
【4】sqlSession.clearCache(); 只是清除当前 session 的一级缓存；
【5】localCacheScope：本地缓存作用域：（一级缓存Session）；当前会话的所有数据保存在会话缓存中；STATEMENT：可以禁用一级缓存；
二十二、第三方缓存整合
【1】导入第三方缓存包（ehcache-core-2.6.8.jar）即可；
【2】导入与第三方缓存整合的适配包（mybatis-ehcache-1.0.3.jar）；官方有；
【3】mapper.xml 中使用自定义缓存
<cache type="org.mybatis.caches.ehcache.EhcacheCache"></cache>
【4】ehcache 使用需要 ehcache.xml文件
1 <?xml version="1.0" encoding="UTF-8"?>
2 <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3 xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">
4 <!-- 磁盘保存路径 -->
5 <diskStore path="D:\44\ehcache" />
6
7 <defaultCache
8 maxElementsInMemory="10000"
9 maxElementsOnDisk="10000000"
10 eternal="false"
11 overflowToDisk="true"
12 timeToIdleSeconds="120"
13 timeToLiveSeconds="120"
14 diskExpiryThreadIntervalSeconds="120"
15 memoryStoreEvictionPolicy="LRU">
16 </defaultCache>
17 </ehcache>
18
19 <!--
20 属性说明：
21 l diskStore：指定数据在磁盘中的存储位置。
22 l defaultCache：当借助CacheManager.add("demoCache")创建Cache时，EhCache便会采用<defalutCache/>指定的的管理策略
23
24 以下属性是必须的：
25 l maxElementsInMemory - 在内存中缓存的element的最大数目
26 l maxElementsOnDisk - 在磁盘上缓存的element的最大数目，若是0表示无穷大
27 l eternal - 设定缓存的elements是否永远不过期。如果为true，则缓存的数据始终有效，如果为false那么还要根据timeToIdleSeconds，timeToLiveSeconds判断
28 l overflowToDisk - 设定当内存缓存溢出的时候是否将过期的element缓存到磁盘上
29
30 以下属性是可选的：
31 l timeToIdleSeconds - 当缓存在EhCache中的数据前后两次访问的时间超过timeToIdleSeconds的属性取值时，这些数据便会删除，默认值是0,也就是可闲置时间无穷大
32 l timeToLiveSeconds - 缓存element的有效生命期，默认是0.,也就是element存活时间无穷大
33 diskSpoolBufferSizeMB 这个参数设置DiskStore(磁盘缓存)的缓存区大小.默认是30MB.每个Cache都应该有自己的一个缓冲区.
34 l diskPersistent - 在VM重启的时候是否启用磁盘保存EhCache中的数据，默认是false。
35 l diskExpiryThreadIntervalSeconds - 磁盘缓存的清理线程运行间隔，默认是120秒。每个120s，相应的线程会进行一次EhCache中数据的清理工作
36 l memoryStoreEvictionPolicy - 当内存缓存达到最大，有新的element加入的时候， 移除缓存中element的策略。默认是LRU（最近最少使用），可选的有LFU（最不常使用）和FIFO（先进先出）
37 -->
二十三、Mybatis 使用缓存原理图
二十四、Spring 整合 MyBatis（除jar包外）
整理 application.xml 文件中整合部分代码，具体配置参考此文章：链接
1 <!-- 整合mybatis
2 目的：1、spring管理所有组件。mapper的实现类。
3 service==>Dao @Autowired:自动注入mapper；
4 2、spring用来管理事务，spring声明式事务
5 -->
6 <!--创建出SqlSessionFactory对象 -->
7 <bean id="sqlSessionFactoryBean" class="org.mybatis.spring.SqlSessionFactoryBean">
8 <property name="dataSource" ref="dataSource"></property>
9 <!-- configLocation指定全局配置文件的位置 -->
10 <property name="configLocation" value="classpath:mybatis-config.xml"></property>
11 <!--mapperLocations: 指定mapper文件的位置-->
12 <property name="mapperLocations" value="classpath:mybatis/mapper/*.xml"></property>
13 </bean>
14
15 <!--配置一个可以进行批量执行的sqlSession -->
16 <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
17 <constructor-arg name="sqlSessionFactory" ref="sqlSessionFactoryBean"></constructor-arg>
18 <constructor-arg name="executorType" value="BATCH"></constructor-arg>
19 </bean>
20
21 <!-- 扫描所有的mapper接口的实现，让这些mapper能够自动注入；
22 base-package：指定mapper接口的包名
23 -->
24 <mybatis-spring:scan base-package="com.atguigu.mybatis.dao"/>
25 <!-- <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
26 <property name="basePackage" value="com.atguigu.mybatis.dao"></property>
27 </bean> -->
二十五、了解知识点
【1】typeAliases：别名处理器：可以为Java类型起别名，别名不区分大小写。mybatis-config.xml中配置如下：
1 <!-- 1、typeAlias:为某个java类型起别名
2 type:指定要起别名的类型全类名;默认别名就是类名小写；employee
3 alias:指定新的别名-->
4 <typeAlias type="com.atguigu.mybatis.bean.Employee" alias="emp"/>
EmployeeMapper.xml 中配置 resultType 时就不用使用全类名。
1 <select id="getEmpById" resultType="emp">
2 select * from tbl_employee where id = #{id}
3 </select>
批量取别名：别名都是类名小写。
1 <!-- 2、package:为某个包下的所有类批量起别名
2 name：指定包名（为当前包以及下面所有的后代包的每一个类都起一个默认别名（类名小写），）
3 -->
4 <package name="com.atguigu.mybatis.bean"/>
批量取别名的问题，就是当一类包下有Employee，子包也包含Employee时会出现混乱，此问题可通过@Alias注解解决。
@Alias("emp")
public class Employee {
【2】environments 配置多个环境：default 指定使用某种环境。可以达到快速切换环境。environment：配置一个具体的环境信息；必须有两个标签；id代表当前环境的唯一标识
1 <!-- transactionManager：事务管理器；
2 type：事务管理器的类型;JDBC(JdbcTransactionFactory)|MANAGED(ManagedTransactionFactory)
3 自定义事务管理器：实现TransactionFactory接口.type指定为全类名
4
5 dataSource：数据源;
6 type:数据源类型;UNPOOLED(UnpooledDataSourceFactory)
7 |POOLED(PooledDataSourceFactory)
8 |JNDI(JndiDataSourceFactory)
9 自定义数据源：实现DataSourceFactory接口，type是全类名
10 -->
11 <environments default="dev_mysql">
12 <environment id="dev_mysql">
13 <transactionManager type="JDBC"></transactionManager>
14 <dataSource type="POOLED">
15 <property name="driver" value="${jdbc.driver}" />
16 <property name="url" value="${jdbc.url}" />
17 <property name="username" value="${jdbc.username}" />
18 <property name="password" value="${jdbc.password}" />
19 </dataSource>
20 </environment>
21
22 <environment id="dev_oracle">
23 <transactionManager type="JDBC" />
24 <dataSource type="POOLED">
25 <property name="driver" value="${orcl.driver}" />
26 <property name="url" value="${orcl.url}" />
27 <property name="username" value="${orcl.username}" />
28 <property name="password" value="${orcl.password}" />
29 </dataSource>
30 </environment>
31 </environments>
【3】databaseIdProvider：支持多数据库厂商。mybatis-config.xml中配置如下：
1 <!-- type="DB_VENDOR"：VendorDatabaseIdProvider
2 作用就是得到数据库厂商的标识(驱动getDatabaseProductName())，mybatis就能根据数据库厂商标识来执行不同的sql;
3 MySQL，Oracle，SQL Server,xxxx
4 -->
5 <databaseIdProvider type="DB_VENDOR">
6 <!-- 为不同的数据库厂商起别名 -->
7 <property name="MySQL" value="mysql"/>
8 <property name="Oracle" value="oracle"/>
9 <property name="SQL Server" value="sqlserver"/>
10 </databaseIdProvider>
在EmployeeMapper.xml中通过databaseId来与上面链接。
1 <select id="getEmpById" resultType="com.atguigu.mybatis.bean.Employee"
2 databaseId="mysql">
3 select * from tbl_employee where id = #{id}
4 </select>
【4】trim 标签的使用
1 <select id="getEmpsByConditionTrim" resultType="com.atguigu.mybatis.bean.Employee">
2 select * from tbl_employee
3 <!-- 后面多出的and或者or where标签不能解决
4 prefix="":前缀：trim标签体中是整个字符串拼串 后的结果。
5 prefix给拼串后的整个字符串加一个前缀
6 prefixOverrides="":
7 前缀覆盖： 去掉整个字符串前面多余的字符
8 suffix="":后缀
9 suffix给拼串后的整个字符串加一个后缀
10 suffixOverrides=""
11 后缀覆盖：去掉整个字符串后面多余的字符
12
13 -->
14 <!-- 自定义字符串的截取规则 -->
15 <trim prefix="where" suffixOverrides="and">
16 <if test="id!=null">
17 id=#{id} and
18 </if>
19 <if test="lastName!=null && lastName!=""">
20 last_name like #{lastName} and
21 </if>
22 <if test="email!=null and email.trim()!=""">
23 email=#{email} and
24 </if>
25 <!-- ognl会进行字符串与数字的转换判断 "0"==0 -->
26 <if test="gender==0 or gender==1">
27 gender=#{gender}
28 </if>
29 </trim>
30 </select>
【5】内置参数 _parameter 和 _databaseid 的使用
<!-- 两个内置参数：
不只是方法传递过来的参数可以被用来判断，取值。。。
mybatis默认还有两个内置参数：
_parameter:代表整个参数
单个参数：_parameter就是这个参数
多个参数：参数会被封装为一个map；_parameter就是代表这个map _databaseId:如果配置了databaseIdProvider标签。
_databaseId就是代表当前数据库的别名oracle
--> <!--public List<Employee> getEmpsTestInnerParameter(Employee employee); -->
<select id="getEmpsTestInnerParameter" resultType="com.atguigu.mybatis.bean.Employee">
<!-- bind：可以将OGNL表达式的值绑定到一个变量中，方便后来引用这个变量的值 -->
<bind name="_lastName" value="'%'+lastName+'%'"/>
<if test="_databaseId=='mysql'">
select * from tbl_employee
<if test="_parameter!=null">
where last_name like #{lastName}
</if>
</if>
<if test="_databaseId=='oracle'">
select * from employees
<if test="_parameter!=null">
where last_name like #{_parameter.lastName}
</if>
</if>
</select>
【6】bind 标签的使用
1 <select id="getEmpsTestInnerParameter" resultType="com.atguigu.mybatis.bean.Employee">
2 <!-- bind：可以将OGNL表达式的值绑定到一个变量中，方便后来引用这个变量的值 -->
3 <bind name="_lastName" value="'%'+lastName+'%'"/>
4 <if test="_databaseId=='mysql'">
5 select * from tbl_employee
6 <if test="_parameter!=null">
7 where last_name like #{lastName}
8 </if>
9 </if>
10 </select>