【01-02】Mybatis的配置文件与基于XML的使用

1、引入日志

• 在这里我们引入SLF4J的日志门面，使用logback的具体日志实现；
• 引入相关依赖：

		<!--日志的依赖--><dependency><groupId>org.slf4j</groupId><artifactId>slf4j-api</artifactId><version>1.7.30</version></dependency><dependency><groupId>ch.qos.logback</groupId><artifactId>logback-classic</artifactId><version>1.2.3</version></dependency>

• 添加logback的配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<configuration scan="true"><!--追加器：日志以哪种方式输出，name：自定义追加器的名称，class：追加器实现类的全限定名（不同实现类输出的方式不同，下面是以控制台方式输出）--><appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender"><encoder><!--设置日志输出格式--><pattern>%d{YYYY-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} ---> %msg%n</pattern><charset>UTF-8</charset></encoder></appender><!--设置全局日志级别--><root level="INFO"><!--设置当前日志级别输出到哪个追加器上--><appender-ref ref="CONSOLE" /></root><!--设置某个包或者某个类的局部日志级别--><logger name="org.example.mapper" level="debug" /><logger name="org.apache.ibatis.transaction" level="debug" /></configuration>

• 测试结果：
  

2、全局配置文件

在mybatis的项目中，有一个mybatis-config.xml的配置文件，这个配置文件是mybatis的全局配置文件，用来进行相关的全局配置。

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "https://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration><properties resource="db.properties"></properties><settings> </settings><typeAliases> </typeAliases><environments></environments><mappers></mappers>
</configuration>

1、propertis（属性）

  <!--配置外部属性资源文件，通过 ${} 来进行引用--><properties resource="db.properties"><!--也可以在内部自定义属性--><property name="driver" value="com.mysql.cj.jdbc.Driver"/><property name="url" value="jdbc:mysql://localhost:3306/trs-db?useUnicode=true&amp;characterEncoding=utf8&amp;tinyInt1isBit=false&amp;useSSL=false&amp;serverTimezone=GMT%2B8&amp;allowMultiQueries=true&amp;zeroDateTimeBehavior=convertToNull"/><property name="username" value="root"/><property name="password" value="rootxq"/></properties>

2、setting（设置）

 	<settings><!--	设置默认执行器：SIMPLE(普通执行器)、REUSE(可重复使用执行器，会重用预处理语句)、BATCH(批量执行器，不仅重用预处理语句，而且可以批量更新)--><setting name="defaultExecutorType" value="SIMPLE"/><!--    开启驼峰命名自动映射--><setting name="mapUnderscoreToCamelCase" value="true"/><!--	在懒加载下，哪些方法会触发立即加载，默认：equals、toString、hashCode--><!--<setting name="lazyLoadTriggerMethods" value=""/>--><!--    开启全局的延迟加载：true 所有的嵌套查询都是懒加载，false 所有嵌套查询都会被立即加载--><setting name="lazyLoadingEnabled" value="true"/><!--    设置加载的数据是否按需加载--><setting name="aggressiveLazyLoading" value="false"/><!--    开启二级缓存--><setting name="cacheEnabled" value="true"/></settings>

3、typeAliases（类型别名）

	<!--设置类的别名，可以降低冗余的全局限定名的书写--><typeAliases><!--1、可以设置包下所有类的别名：会使用类名作为别名（是忽略大小写的）--><!--<package name="org.example.pojo"/>--><!--2、可以自定义设置某个类的别名--><typeAlias type="org.example.pojo.Emp" alias="emp"/><typeAlias type="org.example.pojo.Dept" alias="dept"/></typeAliases>

4、environments（环境配置）

 <!--配置数据源连接信息--><!--可以配置多个数据源（environment），例如：测试环境、生产环境各配置一个数据源，default：设置默认使用哪个数据源--><environments default="development"><environment id="development"><!--事务管理器：type 设置事务管理类型（1）JDBC：使用JDBC的事务管理方式（2）MANAGED：不运用事务 --><transactionManager type="JDBC"/><!--数据源：type 设置数据源类型（1）UNPOOLED：不使用连接池（2）POOLED：使用Mybatis的连接池--><dataSource type="POOLED"><property name="driver" value="${db.driver}"/><property name="url" value="${db.url}"/><property name="username" value="${db.username}"/><property name="password" value="${db.password}"/></dataSource></environment></environments>

5、mappers（映射器）

 <!--映射器：有4种配置方式--><mappers><!--1、设置MapperXML的方式，适用于根据statementId进行操作--><mapper resource="mapper/DeptMapper.xml"/><mapper resource="mapper/EmpMapper.xml"/><!--2、设置Mapper接口的方式，适用于接口绑定的方式--><!--<mapper class="org.example.mapper.EmpMapper"/>--><!--<mapper class="org.example.mapper.DeptMapper"/>--><!--3、使用磁盘的绝对路径（基本不用）--><!--4、根据包路径设置该包下的所有Mapper接口，适用于接口绑定和注解的方式（应用最多的方式）--><!--<package name="org.example.mapper"/>--></mappers>

3、SQL映射文件

• MyBatis 的真正强大之处在于它的语句映射。由于它的异常强大，映射器的XML 文件就显得相对简单。MyBatis 致力于减少使用成本，让用户能更专注于 SQL 代码。
• 映射文件中极其重要的几大标签：
  • select：映射查询语句
  • insert：映射插入语句
  • update：映射更新语句
  • delete：映射删除语句
  • sql：定义可重用的sql语句；
  • cache：设置当前命名空间下的缓存配置；
  • cache-ref：引用其他命名空间下的缓存配置；
  • resultMap：描述如何从数据库的结果集中加载对象；
• 每个顶级元素标签中可以添加很多个属性，下面介绍相关属性的作用
  • （1）id：设置当前命名空间中各个映射标签的唯一标识符（同一个命名空间中的id不允许重复，对应mapper接口中的方法名称）；
  • （2）paramType：设置SQL的参数类型（mybatis会根据接口方法的参数自动读取参数的类型，所以不强制要求设置）；
  • （3）statementType：设置当前的Statement类型（默认为PREPARED）:
    • STATEMENT：代表JDBC的Statement，不支持参数预解析;
    • PREPARED：代表JDBC的PreparedStatement，支持参数预解析;
    • CALLABLE：代表JDBC的CallableStatement，支持存储过程调用;
  • （4）useGeneratedKeys：启用主键生成策略，设置是否获取插入后的自增长主键的值，默认是false，设置为true时，才会获取自增长主键的值；
  • （5）keyProperty：设置将获取到的自增长主键值映射到实体类的哪个属性上；
  • （6）keyColumn：如果存在组合主键的情况，指定获取哪个主键的字段名;
• 例如：

	<insert id="insertEmp" useGeneratedKeys="true" keyProperty="eId" ><!--如果数据库不支持列值自增长的话，可以使用下面的方法：selectKey：可以在增删改操作之前或者之后执行相关属性：order：设置执行时机（BEFORE表示之前，AFTER表示之后）keyProperty：设置将当前查询结果放到哪个POJO的属性上resultType：设置返回值的类型--><selectKey order="BEFORE" keyProperty="eId" resultType="int">SELECT MAX(eid)+1 FROM emp</selectKey>INSERT INTO emp (eid,e_name,e_mail,salary,did) values (#{eId},#{eName},#{eMail},#{salary},#{did})</insert>

4、基于XML的详细使用

• POJO实体类

  public class Emp{private Integer eId;private String eName;private String eMail;private Double salary;private Integer did;
  }public class Dept{private Integer did;private String dName;
  }
  

1、参数的获取方式

• #{} ==> sql = “SELECT * FROM emp WHERE eid = ?”
  • a、会经过JDBC中的PreparedStatement对象进行预编译处理，会根据不同的数据类型来编译成对应数据库所对应的数据类型;
    例如：String id = “100010”，#{id} ==> sql = "SELECT * FROM emp WHERE eid = ‘100010’;
    例如：Integer id = 100010，#{id} ==> sql = "SELECT * FROM emp WHERE eid = 100010;
  • b、能够有效的防止SQL注入;
• ${} ==> sql = “SELECT * FROM emp WHERE eid =” + id;
  • a、不会进行预编译，会直接将获取到的的参数直接拼接在sql中;
  • b、存在SQL注入的风险；
  • 特殊用法：
    （1）调试时可以临时使用，这样可以直接将携带参数的完整sql语句打印在控制台；
    （2）需要动态拼接的时候，可以使用${}，但是要在保证数据的安全性的前提下操作;

2、参数的传递方式

• 单个参数的传递：

  • （1）参数类型是普通数据类型时：使用#{参数名称}来获取参数，即：#{id}；

      public interface EmpMapper {Emp selectEmpById(Integer id);
    }
    

      <select id="selectEmpById"  resultMap="empResultSet">select * from emp where eid = #{id}</select>
    

  • （2）参数类型是javaBean时：使用#{属性名}来获取参数，emp.eId ==> #{eId}, emp.eName ==> #{eName}

      public interface EmpMapper {Emp selectEmpInfo(Emp emp);}
    

     <select id="selectEmpInfo" resultType="org.example.pojo.Emp">select * from emp where eid = #{eId} and e_name = #{eName}</select>
    

  • （3）参数类型是数组或者list集合时：mybatis会自动封装成map

    • 数组：{key:array,value:array}，获取方式：#{arg0.下标} 或者 #{array.下标}
    • 集合：{key:list,value:list}，获取方式：#{arg0.下标} 或者 #{list.下标}
    • 如果方法中使用了@Param()注解来指定别名，则获取方式为：#{别名.下标}

      public interface EmpMapper {List<Emp> selectEmpByNames(List<String> names);}
    

    <select id="selectEmpByNames" resultType="org.example.pojo.Emp">select * from emp where e_name in (#{arg0.0}, #{list.1}, #{arg0.2})
    </select>
    

  • （4）参数类型是map集合时：与javaBean的参数传递情况一样；

     public interface EmpMapper {Emp selectEmpByMap(Map<String,Object> paramMap);
    }Map<String, Object> paramMap = new HashMap<>();paramMap .put("id",1);paramMap .put("ename","lq");
    

     <select id="selectEmpByMap" resultType="org.example.pojo.Emp">select * from emp where eid = #{id} and e_name = #{ename}</select>
    

• 多个参数的传递

  • mybatis会对参数按顺序进行封装，将参数封装成map集合；

     public interface EmpMapper {Emp selectEmpByIdAndName( Integer id, String ename);
    }
    

    • id ==> {key : arg0，value : id的值} 或者 {key : param1，value : id的值}
    • ename ==> {key : arg1，value : ename的值} 或者 {key : param2，value : ename的值}
    • 可以使用#{key}来获取对应的值，

    <select id="selectEmpByIdAndName" resultType="org.example.pojo.Emp">select * from emp where eid = #{arg0} and e_name = #{param2}
    </select>
    

  • 可以给每个参数设置别名，使其具有参数意义：
    • 语法：使用注解：@Param("参数别名")

    public interface EmpMapper {Emp selectEmpByIdAndName( @Param("id")Integer id, @Param("ename")String ename);
    }
    

    • id ==> #{id} 或者 #{param1}
    • ename ==> #{ename} 或者 #{param2}
    • 可以使用#{参数别名}来获取对应的值

     <select id="selectEmpByIdAndName" resultType="org.example.pojo.Emp">select * from emp where eid = #{id} and e_name = #{ename}</select>
    

  • 如果是参数类型既有普通数据类型又有javaBean时：

    public interface EmpMapper {Emp selectEmpInfoByDid(Integer did,@Param("emp") Emp emp);
    }
    

    • id ==> #{param1} 或者 @Param(“did”)
    • emp.eName ==> #{param2.eName} 或者 emp.eName
    • 注意：多个参数时，获取JavaBean中的属性时，使用#{参数别名.属性名}；

     <select id="selectEmpInfoByDid" resultType="org.example.pojo.Emp">select * from emp where did = #{param1} and e_name = #{emp.eName}</select>
    

3、处理返回结果

• 返回类型设置：
  • 如果返回单行数据，可是使用Java基础数据类型或者POJO或者Map接收；
  • 如果返回多行数据，可以使用List< POJO>或者List< Map >接收，需要在resultType中指定List中的泛型类型;
• 当返回结果是集合的时候，返回值的类型依然写的是集合中具体的类型

   <select id="selectAllEmp" resultType="org.example.pojo.Emp">select * from emp</select>
  

• 在查询时可以设置返回值的类型为map，当mybatis查询完成之后会把列的名称作为key，列的值作为value，转换到map中；

  <select id="selectEmpByEmpReturnMap" resultType="map">select * from emp where empno = #{empno}
  </select>
  

4、自定义结果集

• 如果数据库表的字段与POJO的属性名不一致时，除了可使用'AS'来设置别名，还可以使用resultMap来设置自定义结果集，注意：resultType与resultMap二者只能使用其一。
• 相关属性：
  • id：唯一标识，需要与select标签中的resultMap进行关联；
  • type：需要映射的Pojo类型；
  • autoMapping：是否自动映射，默认为false，只要字段名与属性名遵循映射规则就可以自动映射；
  • extends：如果同一命名空间内，如果有多个resultMap有重复的映射，可以声明父resultMap，将公共的映射提取出来，可以减少子resultMap的映射冗余；

   <resultMap id="empResultSet" type="org.example.pojo.Emp"><!--<id>：用来指定主键字段的映射关系<result>：用来指定普通字段的映射关系column：需要映射的数据库表中字段的名称property：需要映射的POJO中的属性名称--><id column="eid" property="eId"/><result column="e_name" property="eName"/><result column="e_mail" property="eMail"/><result column="salary" property="salary"/><result column="did" property="did"/></resultMap><select id="selectEmp" resultMap="empResultSet">select * from emp where did = #{dept_id}</select>
  

5、高级结果映射

1、联合查询

public class EmpDeptDto extends Emp{private Dept dept;public Dept getDept() {return dept;}public void setDept(Dept dept) {this.dept = dept;}@Overridepublic String toString() {return super.toString() + "EmpDeptDto{" +"dept=" + dept +'}';}
}

1、多对一映射

• 查询所有员工的信息以及对应的部门（多员工同属一个部门）

<resultMap id="empAndDeptMap" extends="empResultSet" type="org.example.pojo.EmpDeptDto"><!--普通方式：对象属性名.属性--><!--<result property="dept.dName" column="d_name"/>--><!--<result property="dept.did" column="did"/>--><!--association方式：会强行使我们的结果映射为多对一property：指定的“一”javaType：“一“的类型（自定义映射的时候才需要指定，与resultType二者使用其一）resultMap：调用已经存在的映射关系（重用resultMap）columnPrefix： 如果出现两张表的字段有重复时，则需要使用as来起别名，可以给字段加上前缀，在映射的时候，可以使用columnPrefix自动将前缀去掉，这样就能映射成功--><association property="dept" columnPrefix="dept_" javaType="org.example.pojo.Dept" resultMap="org.example.mapper.DeptMapper.baseDeptMap"><!--<id property="did" column="did"/>--><!--<result property="dName" column="d_name"/>--></association></resultMap><select id="selectEmpAndDept" resultMap="empAndDeptMap">SELECTe.*,d.did AS dept_did,d.d_name AS dept_d_nameFROMemp AS eLEFT JOIN dept AS d ON e.did = d.did</select>

2、一对多映射

• 查询部门信息以及所属的员工信息（一个部门包含多个员工）

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN""https://mybatis.org/dtd/mybatis-3-mapper.dtd"><mapper namespace="org.example.mapper.DeptMapper"><resultMap id="baseDeptMap" type="org.example.pojo.Dept"><id column="did" property="did"/><result column="d_name" property="dName"/></resultMap><!--一对多映射关系property：指定的“多”ofType：“多”的类型（自定义映射的时候才需要指定，与resultType二者使用其一）resultMap：调用已经存在的映射关系（重用resultMap）无论是association还是collection，都需要查询主键值--><resultMap id="deptAndEmpMap" extends="baseDeptMap" type="org.example.pojo.DeptEmpDto"><collection property="emps" ofType="org.example.pojo.Emp" resultMap="org.example.mapper.EmpMapper.empResultSet"><!--也可以自定义映射关系--><!--<id column="eid" property="eId"/>--><!--<result column="e_name" property="eName"/>--><!--<result column="e_mail" property="eMail"/>--><!--<result column="salary" property="salary"/>--><!--<result column="did" property="did"/>--></collection></resultMap><select id="getDeptAndEmp" resultMap="deptAndEmpMap">SELECTd.*,e.*FROM dept d LEFT JOIN emp eON d.did = e.did</select>
</mapper>

2、嵌套查询

<!--嵌套查询：分步查询select：查询关联对象的sql语句column：需要传递的参数值的字段fetchType：懒加载（延迟查询）：嵌套查询的对象用到的时候才回去查询数据--><resultMap id="queryDeptAndEmpMap" type="org.example.pojo.DeptEmpDto" extends="baseDeptMap"><collection property="emps" fetchType="lazy" select="org.example.mapper.EmpMapper.selectEmp" column="did"/></resultMap><select id="queryDeptAndEmp" resultMap="queryDeptAndEmpMap">select * from dept</select>

3、延迟查询

• 当我们在进行表关联的时候，有可能在查询结果的时候不需要关联对象的属性值，那么此时可以通过延迟加载来实现功能。在全局配置文件中添加如下属性：

	<!‐‐ 开启延迟加载，所有分步查询都是懒加载 （默认是立即加载）‐‐><setting name="lazyLoadingEnabled" value="true"/><!‐‐当开启式， 使用pojo中任意属性都会加载延迟查询 ,默认是false<setting name="aggressiveLazyLoading" value="false"/>‐‐><!‐‐设置对象的哪些方法调用会加载延迟查询 默认：equals,clone,hashCode,toString‐‐><setting name="lazyLoadTriggerMethods" value=""/>

• 如果设置了全局加载，但是希望在某一个sql语句查询的时候不使用延时策略，可以添加fetchType下属性;

 <association property="dept" column="dept_id" fetchType="eager" resultMap="org.example.mapper.DeptMapper.baseDeptMap"></association>

6、动态SQL

动态 SQL 是 MyBatis 的强大特性之一。如果你使用过 JDBC 或其它类似的框架，你应该能理解根据不同条件拼接 SQL 语句有多痛苦，例如拼接时要确保不能忘记添加必要的空格，还要注意去掉列表最后一个列名的逗号。利用动态 SQL，可以彻底摆脱这种痛苦。

如果出现SQL语句中因特殊字符报错的话，可以使用转义字符或者<![CDATA[]]>来解决

1、动态SQL之if

• 语法：< if test="条件表达式 可以是OGNL表达式">< /if>
• 作用：完成简单的条件判断，加载动态条件
• 问题：如果无法确定第一个条件是否成立，导致无法确定是否拼接 and或者or 的拼接
  • （1）可以设置 1=1 避免报错
  • （2）可以使用< where>标签，它会自动拼接或者删除and或者or
  • （3）可以使用< trim>标签

  	 <select id="queryEmps" resultType="org.example.pojo.Emp">select * from emp where 1=1<if test="salary != null and salary != ''">AND salary <![CDATA[<=]]> #{salary}</if><if test="eName != null and salary != ''">AND e_name = #{eName}</if><if test="eId != null and salary != ''">AND eid = #{eId}</if>	       </select>
  

2、动态SQL之where

• 语法：< where>< /where>
• 作用：如果存在条件则自动拼接where关键字，也可以动态的删除条件语句中的and或者or

   	<select id="queryEmps" resultType="org.example.pojo.Emp">select * from emp <where><if test="salary != null and salary != ''">AND salary <![CDATA[<=]]> #{salary}</if><if test="eName != null and salary != ''">AND e_name = #{eName}</if><if test="eId != null and salary != ''">AND eid = #{eId}</if></where></select>
  

3、动态SQL之trim

• 语法：< trim prefix="" prefixOverrides="" suffix="" suffixOverrides="">< /trim>
• 作用：它的功能比较灵活、广泛，可以在条件判断完的SQL语句前后添加或者去掉指定的字符
• 相关属性：
  • prefix：前缀，需要添加的前缀
  • prefixOverrides：需要去掉的前缀，例如：and|or
  • suffix：后缀，需要添加的后缀
  • suffixOverrides：需要去掉的后缀，例如：,

 	<select id="queryEmps" resultType="org.example.pojo.Emp">select * from emp <trim prefix="where" prefixOverrides="and|or" suffix="" suffixOverrides=""><if test="salary != null and salary != ''">AND salary <![CDATA[<=]]> #{salary}</if><if test="eName != null and salary != ''">AND e_name = #{eName}</if><if test="eId != null and salary != ''">AND eid = #{eId}</if></trim></select>

4、动态SQL之choose、when、otherwise

• 作用：它有着类似于if、elseif、else的作用。

  	<select id="queryEmps2" resultMap="empResultSet">select * from emp<where><choose><when test="eName == 'lv'">eid = 1</when><when test="eName == 'zlq'">eid = 2</when><otherwise>eid = 3</otherwise></choose></where></select>
  

5、动态SQL之set

• 作用：主要用于解决修改操作中SET关键字以及SQL语句中可能多出的逗号问题

  	<update id="updateEmp">update emp<set><if test="eName != null and eName != ''">e_name = #{eName},</if><if test="eMail != null and eMail != ''">e_mail = #{eMail},</if><if test="salary != null and salary != ''">salary = #{salary},</if><if test="did != null and did != ''">did = #{did},</if></set>where eid = #{eId}</update>
  

6、动态SQL之foreach

• 作用：循环遍历集合或者数组
• 相关属性：
  • collection：指定需要遍历的集合名称
  • item：每次遍历的集合元素
  • index：遍历时的下标
  • separator：分隔符
  • open：循环开始时添加的字符
  • close：循环结束时添加的字符

  	<select id="queryEmpByNames" resultMap="empResultSet">select * from empwhere e_name in<foreach collection="names" item="name" index="i" separator="," open="(" close=")">#{name}</foreach></select>
  

7、动态SQL之sql片段

• 作用：提取重复冗余的sql语句，使其可以被共用
• 相关属性：
  • id：唯一标识，使用< include refid=“sql片段的Id” />标签来引用

   	<sql id="querySQL">select * from emp</sql><select id="selectEmpByMap" resultType="org.example.pojo.Emp"><include refid="querySQL"/>where eid = #{id} and e_name = #{ename}</select>
  

8、常用的OGNL表达式

• （1）e1 or e2：逻辑或
• （2）e1 and e2：逻辑与
• （3）e1 != e2 或者 e1 neq e2：判断两个对象是否不相等
• （4）e1 == e2 或者 e1 eq e2：判断两个对象是否相等
• （5）e1 > e2 或者 e1 gt e2：判断e1是否大于e2
• （6）e1 >= e2 或者 e1 gte e2：判断e1是否大于等于e2
• （7）e1 < e2 或者 e1 lt e2：判断e1是否小于e2
• （8）e1 <= e2 或者 e1 lte e2：判断e1是否小于等于e2
• （9）e1 instanceof e2：判断e1是否是e2的实例
• （10）e1.method(e2)：调用e1对象的method方法，并将e2作为参数传递给method方
• （11）e1 in e2：判断e1是否在e2中
• （12）e1 not in e2：判断e1是否不在e2中（13）e1 like e2：判断e1是否和e2匹配
• （13）e1 not like e2：判断e1是否和e2不匹配
• （14）e1 between e2 and e3：判断e1是否在e2和e3之间
• （15）e1 not between e2 and e3：判断e1是否不在e2和e3之间
• （16）e1 is null：判断e1是否为null
• （17）e1 is not null：判断e1是否不为null
• （18）!e1：逻辑非
• （19）e1+e2,e1-e2,e1*e2,e1/e2：加减乘除

7、缓存

• MyBatis 内置了一个强大的事务性查询缓存机制，它可以非常方便地配置和定制。
• 在进行配置的时候还会分为一级缓存和二级缓存：
  • 一级缓存：线程级别的缓存，是本地缓存，sqlSession级别的缓存；
  • 二级缓存：全局范围的缓存，不仅局限于当前会话；

1、一级缓存

• 特性：
  • 1、默认开启，也可以关闭一级缓存，localCacheScope=STATENENT
  • 2、作用域默认是基于sqlSession的，就是一次数据库操作会话
  • 3、缓存默认的实现类是：PerpetualCache，使用map进行存储，key ==> hashcode + sqlid + sql + hashcode + environment的id
  • 4、查询完就会进行数据的缓存
• 失效情况：
  • 1、不同的sqlSession会使一级缓存失效
  • 2、同一个sqlSession，但是查询语句不同，也会使一级缓存失效
  • 3、同一个sqlSession，查询语句相同，但在中间过程中执行了增删改操作，也会使一级缓存失效
  • 4、同一个sqlSession，查询语句相同，执行手动清除缓存，会使一级缓存失效
• 例如：
  

2、二级缓存

• 特性：
  • 1、默认开启，但没有实现
  • 2、作用域，是全局范围的，存储到Java进程当中的，如果线程过多，会出现OOM
  • 3、缓存默认的实现类也是PerpetualCache，使用map进行存储，但是，使用map存储的是二级缓存根据不同的mapper命名空间多包了一层的map。即：key：mapper的命名空间，value：Map<k,PerpetualCache.map>；
  • 4、提交事务时或者sqlSession关闭的时候进行数据缓存
• 实现：
  • 1、在全局配置文件中开启二级缓存，< setting name="cacheEnabled" value="true"/>
  • 2、在需要用到二级缓存的mapper映射文件中加入，< cache>< /cache>，它是基于Mapper映射文件来实现存储的.
• 查询顺序：
  • 先从二级缓存中获取，再从一级缓存中获取，如果都没有，则查询数据库
• 失效情况：
  • 1、同一个命名空间下进行增删改操作，会使二级缓存失效
  • 2、如果不想增删改操作后缓存被清空，则可以给对应的增删改sql设置flushCache="false"，但是设置要慎重，因为会造成数据脏读问题。
  • 3、让查询到的数据不缓存到二级缓存中：设置useCache=“false” 即：<select id="getDeptById" useCache="false">
  • 4、如果希望其他mapper映射文件的命名空间执行了增删改也清空另外的命名空间的缓存，可以在某个命名空间下使用：< cache-ref namespace=""/>
• 例如
  
  
  

8、分页插件

• Mybatis通过提供插件机制，让我们可以根据自己的需要去增强Mybatis的功能。Mybatis的插件可以在不修改原来代码的情况下，通过拦截的方式，改变四大核心对象的行为，例如：处理参数、处理SQL、处理结果等等；
• Mybatis的分页默认是基于内存分页的（查出所有，再截取），在数据量大的情况下效率较低，不过使用mybatis插件可以改变该行为，只需要拦截StatementHandler类的prepare方法，改变要执行的SQL语句为分页语句即可；

1、应用过程

1、添加依赖

 	<!--mybatis分页插件依赖--><dependency><groupId>com.github.pagehelper</groupId><artifactId>pagehelper</artifactId><version>5.1.11</version></dependency>

2、插件注册

• 在mybatis-config.xml配置文件中进行注册：

 	<plugins><!--注册分页插件--><plugin interceptor="com.github.pagehelper.PageInterceptor"><!--设置当前数据库的方言（默认会自动检查当前数据库环境实用的数据库）--><property name="helperDialect" value="mysql"/><!--自动合理化设置分页参数--><property name="reasonable" value="true"/><!--支持通过Mapper接口的参数来传递分页参数，默认值为false,分页参数名称为：pageNum、pageSize--><property name="supportMethodsArguments" value="true"/></plugin></plugins>

3、调用

	<select id="queryEmpList" resultType="org.example.pojo.Emp">select * from emp</select>

 @Testpublic void testMybatis9(){EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);PageHelper.startPage(1,2);List<Emp> emps = mapper.queryEmpList();System.out.println(emps);//PageInfo对象中包含了很多分页相关的属性，例如，当前页，总页数，总记录数，是否有上/下一页等等PageInfo<Emp> pageInfo = new PageInfo<>(emps);pageInfo.getList().forEach(System.out::println);System.out.println(pageInfo.getTotal());System.out.println(Arrays.toString(pageInfo.getNavigatepageNums()));}

2、代理和拦截的实现

• 四大对象什么时候被代理
  • Executor 是openSession()的时候创建的；
  • StatementHandler 是SimpleExecutor.doQuery()创建的，里面包含了处理参数的ParameterHandler 和 处理结果集的ResultSetHandler 的创建，创建之后即调用InterceptorChain.pluginAll()，返回层层代理后的对象。
  • 代理是由Plugin 类创建。在我们重写的plugin() 方法里面可以直接调用returnPlugin.wrap(target, this);返回代理对象。
  • 因为代理类是Plugin，所以最后调用的是Plugin 的invoke()方法。它先调用了定义的拦截器的intercept()方法。可以通过invocation.proceed()调用到被代理对象被拦截的方法。
    
• 调用流程时序图