MyBatis 重点知识归纳

一、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中配置如下：

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

五、mapper 映射配置

---

 将写好的 SQL映射文件（EmployeeMapper.xml）一定注册到全局配置文件（mybatis-config.xml）中 

<!-- mappers：将sql映射注册到全局配置中 -->
<mappers>
    <!-- 
        mapper:注册一个sql映射 
            注册配置文件
            resource：引用类路径下的sql映射文件
                mybatis/mapper/EmployeeMapper.xml
            url：引用网路路径或者磁盘路径下的sql映射文件
                file:///var/mappers/AuthorMapper.xml
                
            注册接口
            class：引用（注册）接口，
                1、有sql映射文件，映射文件名必须和接口同名，并且放在与接口同一目录下；
                2、没有sql映射文件，所有的sql都是利用注解写在接口上;
                推荐：
                    比较重要的，复杂的Dao接口我们来写sql映射文件
                    不重要，简单的Dao接口为了开发快速可以使用注解；
    -->
    <!-- <mapper resource="mybatis/mapper/EmployeeMapper.xml"/> -->
    <!-- <mapper class="com.atguigu.mybatis.dao.EmployeeMapperAnnotation"/> -->
    
    <!-- 批量注册： -->
    <package name="com.atguigu.mybatis.dao"/>
</mappers>

六、Mysql 获取自增主键的值

---

  Mybatis 允许增删改直接定义以下类型返回值 Integer、Long（表示成功的个数）、Boolean、void； 

<!--mysql支持自增主键，自增主键值的获取，mybatis也是利用statement.getGenreatedKeys()；
    useGeneratedKeys="true"；使用自增主键获取主键值策略
    keyProperty；指定对应的主键属性，也就是mybatis获取到主键值以后，将这个值封装给javaBean的哪个属性
-->
<insert id="addEmp" parameterType="com.atguigu.mybatis.bean.Employee"
    useGeneratedKeys="true" keyProperty="id" databaseId="mysql">
    insert into tbl_employee(last_name,email,gender) 
    values(#{lastName},#{email},#{gender})
</insert>

七、Oracle 不支持自增

---

  Oracle 使用序列来模拟自增；获取非自增主键的值，每次插入的数据的主键是从序列中拿到的值；如何获取到这个值。

<insert id="addEmp" databaseId="oracle" parameterType="com.atguigu.mybatis.bean.Employee">
    <!-- 
    keyProperty:查出的主键值封装给javaBean的哪个属性
    order="BEFORE":当前sql在插入sql之前运行
           AFTER：当前sql在插入sql之后运行
    resultType:查出的数据的返回值类型
    
    BEFORE运行顺序：
        先运行selectKey查询id的sql；查出id值封装给javaBean的id属性
        在运行插入的sql；就可以取出id属性对应的值
     -->
    <selectKey keyProperty="id" order="BEFORE" resultType="Integer">
        <!-- 编写查询主键的sql语句 -->
        select EMPLOYEES_SEQ.nextval from dual 
    </selectKey>
    
    <!-- 插入时的主键是从序列中拿到的 -->
    insert into employees(EMPLOYEE_ID,LAST_NAME,EMAIL) 
    values(#{id},#{lastName},#{email<!-- ,jdbcType=NULL -->}) 
</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）数据传输对象；

Page{
    int index;
    int size;
}

九、 #{} 和 ${} 区别

---

  都可以获取 Map 中的值或者 pojo 对象属性的值

select * from tbl_employee where id=${id} and last_name=#{lastName}
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；

@MapKey("lastName")
public Map<String, Employee> getEmpByLastNameLikeReturnMap(String lastName);

 EmployeeMapper.xml 中

 <!--public Map<Integer, Employee> getEmpByLastNameLikeReturnMap(String lastName);  -->
 <select id="getEmpByLastNameLikeReturnMap" resultType="com.atguigu.mybatis.bean.Employee">
     select * from tbl_employee where last_name like #{lastName}
 </select>

十二、常用标签

---

【1】resultMap 标签使用（常用）

<resultMap type="com.atguigu.mybatis.bean.Employee" id="MySimpleEmp">
  <!--指定主键列的封装规则
  id定义主键会底层有优化；
  column：指定哪一列
  property：指定对应的javaBean属性
  -->
  <id column="id" property="id"/>
  <!-- 定义普通列封装规则 -->
  <result column="last_name" property="lastName"/>
  <!-- 其他不指定的列会自动封装：我们只要写resultMap就把全部的映射规则都写上。 -->
  <result column="email" property="email"/>
  <result column="gender" property="gender"/>
</resultMap>

<!-- resultMap:自定义结果集映射规则；  -->
<!-- public Employee getEmpById(Integer id); -->
<select id="getEmpById"  resultMap="MySimpleEmp">
    select * from tbl_employee where id=#{id}
</select>

【2】查询 Employee 的同时查询员工对应的部门，Employee===Department 一个员工有与之对应的部门信息；

<!-- 使用association定义关联的单个对象的封装规则；-->
<resultMap type="com.atguigu.mybatis.bean.Employee" id="MyDifEmp2">
    <id column="id" property="id"/>
    <result column="last_name" property="lastName"/>
    <result column="gender" property="gender"/>

    <!--  association可以指定联合的javaBean对象
    property="dept"：指定哪个属性是联合的对象
    javaType:指定这个属性对象的类型[不能省略]
    -->
    <association property="dept" javaType="com.atguigu.mybatis.bean.Department">
        <id column="did" property="id"/>
        <result column="dept_name" property="departmentName"/>
    </association>
</resultMap>  

<!--  public Employee getEmpAndDept(Integer id);-->
<select id="getEmpAndDept" resultMap="MyDifEmp">
    SELECT e.id id,e.last_name last_name,e.gender gender,e.d_id d_id,
    d.id did,d.dept_name dept_name FROM tbl_employee e,tbl_dept d
    WHERE e.d_id=d.id AND e.id=#{id}
</select>

  也可以通过对象.属性获取

<!--联合查询：级联属性封装结果集-->
<resultMap type="com.atguigu.mybatis.bean.Employee" id="MyDifEmp">
    <id column="id" property="id"/>
    <result column="last_name" property="lastName"/>
    <result column="gender" property="gender"/>
    <result column="did" property="dept.id"/>
    <result column="dept_name" property="dept.departmentName"/>
</resultMap>

【3】使用 association 进行分步查询，涉及到两个 mapper。EmployeeMapper.xml 文件如下：

<!-- 使用association进行分步查询：
    1、先按照员工id查询员工信息
    2、根据查询员工信息中的d_id值去部门表查出部门信息
    3、部门设置到员工中；
 -->
 
 <!--  id  last_name  email   gender    d_id   -->
 <resultMap type="com.atguigu.mybatis.bean.Employee" id="MyEmpByStep">
    <id column="id" property="id"/>
    <result column="last_name" property="lastName"/>
    <result column="email" property="email"/>
    <result column="gender" property="gender"/>
    <!-- association定义关联对象的封装规则
        select:表明当前属性是调用select指定的方法查出的结果
        column:指定将哪一列的值传给这个方法
        
        流程：使用select指定的方法（传入column指定的这列参数的值）查出对象，并封装给property指定的属性
     -->
    <association property="dept" 
        select="com.atguigu.mybatis.dao.DepartmentMapper.getDeptById"
        column="d_id">
    </association>
 </resultMap>
 <!--  public Employee getEmpByIdStep(Integer id);-->
 <select id="getEmpByIdStep" resultMap="MyEmpByStep">
    select * from tbl_employee where id=#{id}
 </select>

  DepatermentMapper.xml 文件

<mapper namespace="com.atguigu.mybatis.dao.DepartmentMapper">
    <!--public Department getDeptById(Integer id);  -->
    <select id="getDeptById" resultType="com.atguigu.mybatis.bean.Department">
        select id,dept_name departmentName from tbl_dept where id=#{id}
    </select>
</mapper>

十三、 可以使用延迟加载（懒加载）

---

(按需加载) Employee 中的 Dept 对象：不开启懒加载时，我们每次查询 Employee 对象的时候，都将全部信息查询出来。开启后部门信息在我们使用的时候再去查询；开启懒加载只需要在分段查询的基础之上加上两个配置：mybatis-config.xml中添加如下：

<settings>
    <!--显示的指定每个我们需要更改的配置的值，即使他是默认的。防止版本更新带来的问题  -->
    <setting name="lazyLoadingEnabled" value="true"/>
    <setting name="aggressiveLazyLoading" value="false"/>
</settings>

十四、关联查询

---

  查询部门的时候将部门对应的所有员工信息也查询出来：DepartmentMapper.xml 内容如下：

<!--嵌套结果集的方式，使用collection标签定义关联的集合类型的属性封装规则  -->
<resultMap type="com.atguigu.mybatis.bean.Department" id="MyDept">
    <id column="did" property="id"/>
    <result column="dept_name" property="departmentName"/>
    <!-- 
        collection定义关联集合类型的属性的封装规则 
        ofType:指定集合里面元素的类型
    -->
    <collection property="emps" ofType="com.atguigu.mybatis.bean.Employee">
        <!-- 定义这个集合中元素的封装规则 -->
        <id column="eid" property="id"/>
        <result column="last_name" property="lastName"/>
        <result column="email" property="email"/>
        <result column="gender" property="gender"/>
    </collection>
</resultMap>
<!-- public Department getDeptByIdPlus(Integer id); -->
<select id="getDeptByIdPlus" resultMap="MyDept">
    SELECT d.id did,d.dept_name dept_name,
            e.id eid,e.last_name last_name,e.email email,e.gender gender
    FROM tbl_dept d
    LEFT JOIN tbl_employee e
    ON d.id=e.d_id
    WHERE d.id=#{id}
</select>

十五、collection：分段查询

---

 与单个对象分段查询一致：

    <!-- collection：分段查询 -->
<resultMap type="com.atguigu.mybatis.bean.Department" id="MyDeptStep">
    <id column="id" property="id"/>
    <id column="dept_name" property="departmentName"/>
    <collection property="emps" 
        select="com.atguigu.mybatis.dao.EmployeeMapperPlus.getEmpsByDeptId"
        column="{deptId=id}" fetchType="lazy"><!--也可以传递多个条件，通过key=value键值对-->
    </collection>
</resultMap>
<!-- public Department getDeptByIdStep(Integer id); -->
<select id="getDeptByIdStep" resultMap="MyDeptStep">
    select id,dept_name from tbl_dept where id=#{id}
</select>

  EmployeeMapper.xml 中被关联内容：

<select id="getEmpsByDeptId" resultType="com.atguigu.mybatis.bean.Employee">
    select * from tbl_employee where d_id=#{deptId}
</select>

十六、鉴别器

---

  通过对返回值的判断，取相应的值：

<!-- <discriminator javaType=""></discriminator>
    鉴别器：mybatis可以使用discriminator判断某列的值，然后根据某列的值改变封装行为
    封装Employee：
        如果查出的是女生：就把部门信息查询出来，否则不查询；
        如果是男生，把last_name这一列的值赋值给email;
 -->
 <resultMap type="com.atguigu.mybatis.bean.Employee" id="MyEmpDis">
    <id column="id" property="id"/>
    <result column="last_name" property="lastName"/>
    <result column="email" property="email"/>
    <result column="gender" property="gender"/>
    <!--
        column：指定判定的列名
        javaType：列值对应的java类型  -->
    <discriminator javaType="string" column="gender">
        <!--女生  resultType:指定封装的结果类型；不能缺少。/resultMap-->
        <case value="0" resultType="com.atguigu.mybatis.bean.Employee">
            <association property="dept" 
                select="com.atguigu.mybatis.dao.DepartmentMapper.getDeptById"
                column="d_id">
            </association>
        </case>
        <!--男生 ;如果是男生，把last_name这一列的值赋值给email; -->
        <case value="1" resultType="com.atguigu.mybatis.bean.Employee">
            <id column="id" property="id"/>
            <result column="last_name" property="lastName"/>
            <result column="email" property="email"/>
            <result column="gender" property="gender"/>
        </case>
    </discriminator>
 </resultMap>

十七、动态SQL

---

【1】if 标签的使用：

<select id="getEmpsByConditionIf" resultType="com.atguigu.mybatis.bean.Employee">
    select * from tbl_employee
    <!-- where 或者给where后面加上1=1，以后的条件都and xxx. 
        mybatis使用where标签来将所有的查询条件包括在内。mybatis就会将where标签中拼装的sql，多出来的and或者or去掉
        where只会去掉第一个多出来的and或者or。-->
    <where>                        
        <!-- test：判断表达式（OGNL）
        c:if  test从参数中取值进行判断，遇见特殊符号应该去写转义字符：&&：
        -->
        <if test="id != null">
            id=#{id}
        </if>
        <if test="lastName!=null && lastName!=''">
            and last_name like #{lastName}
        </if>
        <if test="email!=null and email.trim()!=''">
            and email=#{email}
        </if> 
        <!-- ognl会进行字符串与数字的转换判断  "0"==0 -->
        <if test="gender==0 or gender==1">
            and gender=#{gender}
        </if>
    </where>
 </select>

【2】choose 标签的使用：

<select id="getEmpsByConditionChoose" resultType="com.atguigu.mybatis.bean.Employee">
    select * from tbl_employee 
    <where>
        <!-- 如果带了id就用id查，如果带了lastName就用lastName查;只会进入其中一个 -->
        <choose>
            <when test="id!=null">
                id=#{id}
            </when>
            <when test="lastName!=null">
                last_name like #{lastName}
            </when>
            <when test="email!=null">
                email = #{email}
            </when>
            <otherwise>
                gender = 0
            </otherwise>
        </choose>
    </where>
 </select>

【3】更新表时，set 标签的使用，可以去除多以的逗号。或者使用 trim 标签：

<update id="updateEmp">
    <!-- Set标签的使用 -->
    update tbl_employee 
    <set>
        <if test="lastName!=null">
            last_name=#{lastName},
        </if>
        <if test="email!=null">
            email=#{email},
        </if>
        <if test="gender!=null">
            gender=#{gender}
        </if>
    </set>
    where id=#{id} 
    <!--         
    Trim：更新拼串
    update tbl_employee 
        <trim prefix="set" suffixOverrides=",">
        <if test="lastName!=null">
            last_name=#{lastName},
        </if>
        <if test="email!=null">
            email=#{email},
        </if>
        <if test="gender!=null">
            gender=#{gender},
        </if>
        </trim>
    where id=#{id}  -->
 </update>

【4】foreach 标签的使用：

<select id="getEmpsByConditionForeach" resultType="com.atguigu.mybatis.bean.Employee">
    select * from tbl_employee
    <!--
        collection：指定要遍历的集合：
            list类型的参数会特殊处理封装在map中，map的key就叫list
        item：将当前遍历出的元素赋值给指定的变量
        separator:每个元素之间的分隔符
        open：遍历出所有结果拼接一个开始的字符
        close:遍历出所有结果拼接一个结束的字符
        index:索引。遍历list的时候是index就是索引，item就是当前值
                      遍历map的时候index表示的就是map的key，item就是map的值
        
        #{变量名}就能取出变量的值也就是当前遍历出的元素
      -->
    <foreach collection="ids" item="item_id" separator=","
        open="where id in(" close=")">
        #{item_id}
    </foreach>
 </select>

  也可以用于批量存储

<!-- 批量保存 -->
<!--public void addEmps(@Param("emps")List<Employee> emps);  -->
<!--MySQL下批量保存：可以foreach遍历   mysql支持values(),(),()语法Oracle不支持此语法-->
<insert id="addEmps">
    insert into tbl_employee(
        <include refid="insertColumn"></include>
    ) 
    values
    <foreach collection="emps" item="emp" separator=",">
        (#{emp.lastName},#{emp.email},#{emp.gender},#{emp.dept.id})
    </foreach>
</insert>

十八、Oracle 中支持的批量插入方法

---

<!-- Oracle数据库批量保存： 
    Oracle不支持values(),(),()
    Oracle支持的批量方式
    1、多个insert放在begin - end里面
        begin
            insert into employees(employee_id,last_name,email) 
            values(employees_seq.nextval,'test_001','test_001@atguigu.com');
            insert into employees(employee_id,last_name,email) 
            values(employees_seq.nextval,'test_002','test_002@atguigu.com');
        end;
    2、利用中间表：
        insert into employees(employee_id,last_name,email)
               select employees_seq.nextval,lastName,email from(
                  select 'test_a_01' lastName,'test_a_e01' email from dual
                  union
                  select 'test_a_02' lastName,'test_a_e02' email from dual
                  union
                  select 'test_a_03' lastName,'test_a_e03' email from dual
           )    
     -->
 <insert id="addEmps" databaseId="oracle">
     <!-- oracle第一种批量方式 -->
     <!-- <foreach collection="emps" item="emp" open="begin" close="end;">
         insert into employees(employee_id,last_name,email) 
            values(employees_seq.nextval,#{emp.lastName},#{emp.email});
          </foreach> -->
     
     <!-- oracle第二种批量方式  -->
     insert into employees(
         <!-- 引用外部定义的sql -->
         <include refid="insertColumn">
             <property name="testColomn" value="abc"/>
         </include>
     )
             <foreach collection="emps" item="emp" separator="union"
                 open="select employees_seq.nextval,lastName,email from("
                 close=")">
                 select #{emp.lastName} lastName,#{emp.email} email from dual
             </foreach>
 </insert>

十九、常用标签 sql 标签使用（用来抽取公共的部分）：

<!-- 
抽取可重用的sql片段。方便后面引用 
1、sql抽取：经常将要查询的列名，或者插入用的列名抽取出来方便引用
2、include来引用已经抽取的sql：
3、include还可以自定义一些property，sql标签内部就能使用自定义的属性
        include-property：取值的正确方式${prop},
        #{不能使用这种方式}
-->
<sql id="insertColumn">
    <if test="_databaseId=='oracle'">
        employee_id,last_name,email
    </if>
    <if test="_databaseId=='mysql'">
        last_name,email,gender,d_id
    </if>
</sql>

  通过 include 标签，引用此标签：

<insert id="addEmps">
    insert into tbl_employee(
        <include refid="insertColumn"></include>
    ) 
    values
    <foreach collection="emps" item="emp" separator=",">
        (#{emp.lastName},#{emp.email},#{emp.gender},#{emp.dept.id})
    </foreach>
 </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文件

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">
 <!-- 磁盘保存路径 -->
 <diskStore path="D:\44\ehcache" />
 
 <defaultCache 
   maxElementsInMemory="10000" 
   maxElementsOnDisk="10000000"
   eternal="false" 
   overflowToDisk="true" 
   timeToIdleSeconds="120"
   timeToLiveSeconds="120" 
   diskExpiryThreadIntervalSeconds="120"
   memoryStoreEvictionPolicy="LRU">
 </defaultCache>
</ehcache>
 
<!-- 
属性说明：
l diskStore：指定数据在磁盘中的存储位置。
l defaultCache：当借助CacheManager.add("demoCache")创建Cache时，EhCache便会采用<defalutCache/>指定的的管理策略
 
以下属性是必须的：
l maxElementsInMemory - 在内存中缓存的element的最大数目 
l maxElementsOnDisk - 在磁盘上缓存的element的最大数目，若是0表示无穷大
l eternal - 设定缓存的elements是否永远不过期。如果为true，则缓存的数据始终有效，如果为false那么还要根据timeToIdleSeconds，timeToLiveSeconds判断
l overflowToDisk - 设定当内存缓存溢出的时候是否将过期的element缓存到磁盘上
 
以下属性是可选的：
l timeToIdleSeconds - 当缓存在EhCache中的数据前后两次访问的时间超过timeToIdleSeconds的属性取值时，这些数据便会删除，默认值是0,也就是可闲置时间无穷大
l timeToLiveSeconds - 缓存element的有效生命期，默认是0.,也就是element存活时间无穷大
 diskSpoolBufferSizeMB 这个参数设置DiskStore(磁盘缓存)的缓存区大小.默认是30MB.每个Cache都应该有自己的一个缓冲区.
l diskPersistent - 在VM重启的时候是否启用磁盘保存EhCache中的数据，默认是false。
l diskExpiryThreadIntervalSeconds - 磁盘缓存的清理线程运行间隔，默认是120秒。每个120s，相应的线程会进行一次EhCache中数据的清理工作
l memoryStoreEvictionPolicy - 当内存缓存达到最大，有新的element加入的时候， 移除缓存中element的策略。默认是LRU（最近最少使用），可选的有LFU（最不常使用）和FIFO（先进先出）
 -->

二十三、Mybatis 使用缓存原理图

---

​

二十四、Spring 整合 MyBatis（除jar包外）

---

整理 application.xml 文件中整合部分代码，具体配置参考此文章：链接

<!-- 整合mybatis 
    目的：1、spring管理所有组件。mapper的实现类。
            service==>Dao   @Autowired:自动注入mapper；
        2、spring用来管理事务，spring声明式事务
-->
<!--创建出SqlSessionFactory对象  -->
<bean id="sqlSessionFactoryBean" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource"></property>
    <!-- configLocation指定全局配置文件的位置 -->
    <property name="configLocation" value="classpath:mybatis-config.xml"></property>
    <!--mapperLocations: 指定mapper文件的位置-->
    <property name="mapperLocations" value="classpath:mybatis/mapper/*.xml"></property>
</bean>

<!--配置一个可以进行批量执行的sqlSession  -->
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
    <constructor-arg name="sqlSessionFactory" ref="sqlSessionFactoryBean"></constructor-arg>
    <constructor-arg name="executorType" value="BATCH"></constructor-arg>
</bean>

<!-- 扫描所有的mapper接口的实现，让这些mapper能够自动注入；
base-package：指定mapper接口的包名
 -->
<mybatis-spring:scan base-package="com.atguigu.mybatis.dao"/>
<!-- <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="basePackage" value="com.atguigu.mybatis.dao"></property>
</bean> -->

二十五、了解知识点

---

【1】typeAliases：别名处理器：可以为Java类型起别名，别名不区分大小写。mybatis-config.xml中配置如下：

<!-- 1、typeAlias:为某个java类型起别名
    type:指定要起别名的类型全类名;默认别名就是类名小写；employee
    alias:指定新的别名-->
<typeAlias type="com.atguigu.mybatis.bean.Employee" alias="emp"/> 

  EmployeeMapper.xml 中配置 resultType 时就不用使用全类名。

<select id="getEmpById" resultType="emp">
    select * from tbl_employee where id = #{id}
</select>

  批量取别名：别名都是类名小写。

<!-- 2、package:为某个包下的所有类批量起别名 
    name：指定包名（为当前包以及下面所有的后代包的每一个类都起一个默认别名（类名小写），）
-->
<package name="com.atguigu.mybatis.bean"/>

  批量取别名的问题，就是当一类包下有Employee，子包也包含Employee时会出现混乱，此问题可通过@Alias注解解决。

@Alias("emp")
public class Employee {

【2】environments 配置多个环境：default 指定使用某种环境。可以达到快速切换环境。environment：配置一个具体的环境信息；必须有两个标签；id代表当前环境的唯一标识

<!-- transactionManager：事务管理器；
            type：事务管理器的类型;JDBC(JdbcTransactionFactory)|MANAGED(ManagedTransactionFactory)
                自定义事务管理器：实现TransactionFactory接口.type指定为全类名
        
        dataSource：数据源;
            type:数据源类型;UNPOOLED(UnpooledDataSourceFactory)
                        |POOLED(PooledDataSourceFactory)
                        |JNDI(JndiDataSourceFactory)
            自定义数据源：实现DataSourceFactory接口，type是全类名
-->
<environments default="dev_mysql">
    <environment id="dev_mysql">
        <transactionManager type="JDBC"></transactionManager>
        <dataSource type="POOLED">
            <property name="driver" value="${jdbc.driver}" />
            <property name="url" value="${jdbc.url}" />
            <property name="username" value="${jdbc.username}" />
            <property name="password" value="${jdbc.password}" />
        </dataSource>
    </environment>

    <environment id="dev_oracle">
        <transactionManager type="JDBC" />
        <dataSource type="POOLED">
            <property name="driver" value="${orcl.driver}" />
            <property name="url" value="${orcl.url}" />
            <property name="username" value="${orcl.username}" />
            <property name="password" value="${orcl.password}" />
        </dataSource>
    </environment>
</environments>

【3】databaseIdProvider：支持多数据库厂商。mybatis-config.xml中配置如下：

<!-- type="DB_VENDOR"：VendorDatabaseIdProvider
    作用就是得到数据库厂商的标识(驱动getDatabaseProductName())，mybatis就能根据数据库厂商标识来执行不同的sql;
    MySQL，Oracle，SQL Server,xxxx
-->
<databaseIdProvider type="DB_VENDOR">
    <!-- 为不同的数据库厂商起别名 -->
    <property name="MySQL" value="mysql"/>
    <property name="Oracle" value="oracle"/>
    <property name="SQL Server" value="sqlserver"/>
</databaseIdProvider>

  在EmployeeMapper.xml中通过databaseId来与上面链接。

<select id="getEmpById" resultType="com.atguigu.mybatis.bean.Employee"
    databaseId="mysql">
    select * from tbl_employee where id = #{id}
</select>

【4】trim 标签的使用

<select id="getEmpsByConditionTrim" resultType="com.atguigu.mybatis.bean.Employee">
    select * from tbl_employee
    <!-- 后面多出的and或者or where标签不能解决 
    prefix="":前缀：trim标签体中是整个字符串拼串 后的结果。
            prefix给拼串后的整个字符串加一个前缀 
    prefixOverrides="":
            前缀覆盖： 去掉整个字符串前面多余的字符
    suffix="":后缀
            suffix给拼串后的整个字符串加一个后缀 
    suffixOverrides=""
            后缀覆盖：去掉整个字符串后面多余的字符
            
    -->
    <!-- 自定义字符串的截取规则 -->
    <trim prefix="where" suffixOverrides="and">
        <if test="id!=null">
            id=#{id} and
        </if>
        <if test="lastName!=null && lastName!=""">
            last_name like #{lastName} and
        </if>
        <if test="email!=null and email.trim()!=""">
            email=#{email} and
        </if> 
        <!-- ognl会进行字符串与数字的转换判断  "0"==0 -->
        <if test="gender==0 or gender==1">
            gender=#{gender}
        </if>
     </trim>
 </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 标签的使用

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