Mybatis

环境：

• JDK 1.8
• Mysql 5.7
• Maven 3.6.1
• IDEA

文档链接：

https://mybatis.org/mybatis-3/zh/index.html

1、 简介

1.1、 什么是 MyBatis？

• MyBatis 是一款优秀的持久层框架

• 它支持自定义 SQL、存储过程以及高级映射

• MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。

• MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。2013年11月迁移到Github。

任何获得Mybatis:

• maven仓库：

<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<dependency><groupId>org.mybatis</groupId><artifactId>mybatis</artifactId><version>3.4.6</version>
</dependency>

1.2、 持久化

• 持久化是将程序数据在持久状态和瞬时状态间转换的机制。通俗的讲，就是瞬时数据（比如内存中的数据，是不能永久保存的）持久化为持久数据（比如持久化至数据库中，能够长久保存）。
• 持久化的方式： 数据库（jdbc）、IO文件

1.3、 持久层

完成持久化工作的代码块。

1.4、 优点

• 简单易学、灵活
• 解除sql与程序代码的耦合：通过提供DAO层，将业务逻辑和数据访问逻辑分离，使系统的设计更清晰，更易维护，更易单元测试。sql和代码的分离，提高了可维护性。
• 提供映射标签，支持对象与数据库的ORM字段关系映射
• 提供对象关系映射标签，支持对象关系组建维护
• 提供XML标签，支持编写动态sql

2、第一个Mybatis程序

2.1、 搭建环境

数据库：

create DATABASE 'mybatis';USE 'mybatis';CREATE TABLE `users` (`id` int(20) NOT NULL PRIMARY KEY,`name` VARCHAR(30) DEFAULT NULL,`pwd` VARCHAR(30) DEFAULT NULL
)ENGINE=INNODB DEFAULT CHARSET=utf8;INSERT INTO `users` VALUES(1, '小明', '123456'),(2, '小黄', '123456'),(3, '小花', '123456');

新建maven项目：

1. 删除src 将这个工程作为父工程
2. 配置pom.xml文件

<dependencies><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>5.1.47</version></dependency><dependency><groupId>org.mybatis</groupId><artifactId>mybatis</artifactId><version>3.4.6</version></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version></dependency></dependencies>

2.2、 创建模块

1. 新建一个子模块

子模块的pom.xml:

<parent><artifactId>mybatis-demo</artifactId><groupId>com.zzp</groupId><version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion><artifactId>mybatis-01</artifactId>

父工程中多了一个modules

<modules><module>mybatis-01</module>
</modules>

2. 编写MybatisUtils工具类

   public class MybatisUtils {private static  SqlSessionFactory sqlSessionFactory;static{try {//1. 获取SqlSessionFactory对象String resoursePath = "mybatis-config.xml";InputStream resourceAsStream = Resources.getResourceAsStream(resoursePath);sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);} catch (IOException e) {e.printStackTrace();}}// 2. 获取SqlSession对象// SqlSession对象中包含了面向数据库执行sql命令的所有方法public static SqlSession getSqlSession () {return sqlSessionFactory.openSession();}
   }

2.3、 编写代码

1. 编写实体类 pojo

2. 编写dao层

3. 编写xml 由原来的接口实现类变成现在的 xxxmapper.xml文件

   <?xml version="1.0" encoding="UTF-8" ?>
   <!DOCTYPE mapperPUBLIC "-//mybatis.org//DTD Mapper 3.0//EN""http://mybatis.org/dtd/mybatis-3-mapper.dtd">
   <!--namespace  对应的接口-->
   <mapper namespace="com.zzp.dao.UserDao"><!--resultType  返回结果--><select id="getUserList" resultType="com.zzp.pojo.Users">select * from users where id = #{id}</select></mapper>

2.4、编写测试类

注意：

1. 问题1

org.apache.ibatis.binding.BindingException: Type interface com.zzp.dao.UserMapper is not known to the MapperRegistry.

解决办法：

在xml配置文件中注册mapper

<!--每一个Mapper.xml都需要在这里注册-->
<mappers><mapper resource="com/zzp/dao/UserMapper.xml"></mapper></mappers>

2. 问题2

   java.lang.ExceptionInInitializerError

   解决办法：

   没有读取到UserMapper.xml文件,在pom.xml中新增

   <build><resources><resource><directory>src/main/resourses</directory><includes><include>**/*.xml</include><include>**/*.properties</include></includes><filtering>true</filtering></resource><resource><directory>src/main/java</directory><includes><include>**/*.xml</include><include>**/*.properties</include></includes><filtering>true</filtering></resource></resources>
   </build>

3. 问题3

   com.sun.org.apache.xerces.internal.impl.io.MalformedByteSequenceException: 2 字节的 UTF-8 序列的字节 2 无效。

   解决办法：

   在pom.xml文件新增项目编码格式的配置

   <properties><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
   </properties>

2.5、作用域和生命周期

不同作用域和生命周期类别是至关重要的，因为错误的使用会导致非常严重的***并发问题***。

• SqlSessionFactoryBuilder

  这个类可以被实例化、使用和丢弃，一旦创建了 SqlSessionFactory，就不再需要它了。

• SqlSessionFactory

  SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在。最简单的就是使用单例模式或者静态单例模式。

• SqlSession

  每个线程都应该有它自己的 SqlSession 实例。SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域。

3、 CRUD

3.1、namespace

​ namespace中的包名要和Mapper的接口报名一致。

3.2、select、Insert、Update、Delete

选择查询语句：

• id：对应namespace中的方法名
• resultType：sql语句执行返回值
• parameterType:参数类型

注意： 增删改（Insert、Update、Delete）的操作需要提交事务才能完成数据库的修改工作。

4、配置解析

• mybatis-config.xml

• MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息

  configuration（配置）
  properties（属性）
  settings（设置）
  typeAliases（类型别名）
  typeHandlers（类型处理器）
  objectFactory（对象工厂）
  plugins（插件）
  environments（环境配置）
  environment（环境变量）
  transactionManager（事务管理器）
  dataSource（数据源）
  databaseIdProvider（数据库厂商标识）
  mappers（映射器）

4.1、环境配置（environments）

​ MyBatis 可以配置成适应多种环境，这种机制有助于将 SQL 映射应用于多种数据库之中， 现实情况下有多种理由需要这么做。例如，开发、测试和生产环境需要有不同的配置。

​ 不过要记住：尽管可以配置多个环境，但每个 SqlSessionFactory 实例只能选择一种环境。

    <environments default="development"><environment id="development"><transactionManager type="JDBC"/><dataSource type="POOLED"><property name="driver" value="com.mysql.jdbc.Driver"/><property name="url" value="jdbc:mysql://localhost:3306/mybatis?        useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8"/><property name="username" value="root"/><property name="password" value="1q2w3e4r"/></dataSource></environment></environments>

注意一些关键点:

• 默认使用的环境 ID（比如：default=“development”）。
• 每个 environment 元素定义的环境 ID（比如：id=“development”）。
• 事务管理器的配置（比如：type=“JDBC”）。
• 数据源的配置（比如：type=“POOLED”）。

事务管理器

​ 在 MyBatis 中有两种类型的事务管理器:

1. JDBC – 这个配置直接使用了 JDBC 的提交和回滚设施，它依赖从数据源获得的连接来管理事务作用域

2. MANAGED – 基本不用了

 提示： 如果你正在使用 Spring + MyBatis，则没有必要配置事务管理器，因为 Spring 模块会使用自带的管理器来覆盖前面的配置。

数据源（dataSource）

​ dataSource 元素使用标准的 JDBC 数据源接口来配置 JDBC 连接对象的资源。

​ 有三种内建的数据源类型（UNPOOLED、POOLED（常用）、JNDI）。

4.2、属性（properties）

这些属性可以在外部进行配置，并可以进行动态替换。你既可以在典型的 Java 属性文件中配置这些属性，也可以在 properties 元素的子元素中设置。

• 编写一个db.properties文件

  driver=com.mysql.jdbc.Driver
  url=jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=UTF-8
  username=root
  password=1q2w3e4r
  

• 在外部进行属性配置

  <properties resource="db.properties"><property name="password" value="123456"/>
  </properties>

• 设置好的属性可以在整个配置文件中用来替换需要动态配置的属性值

  <dataSource type="POOLED"><property name="driver" value="${driver}"/><property name="url" value="${url}"/><property name="username" value="${username}"/><property name="password" value="${password}"/>
  </dataSource>

  注意：

  ​ 如果一个属性在不只一个地方进行了配置，那么，MyBatis 将按照下面的顺序来加载：

  • 首先读取在 properties 元素体内指定的属性。
  • 然后根据 properties 元素中的 resource 属性读取类路径下属性文件，或根据 url 属性指定的路径读取属性文件，并覆盖之前读取过的同名属性。
  • 最后读取作为方法参数传递的属性，并覆盖之前读取过的同名属性。

  因此，通过方法参数传递的属性具有最高优先级，resource/url 属性中指定的配置文件次之，最低优先级的则是 properties 元素中指定的属性。

4.3、 类型别名（typeAliases）

类型别名可为 Java 类型设置一个缩写名字。它仅用于 XML 配置，意在降低冗余的全限定类名书写。

指定类名：

<typeAliases><typeAlias type="com.zzp.pojo.Users" alias="Users"></typeAlias>
</typeAliases>

指定包： MyBatis 会在包名下面搜索需要的 Java Bean

<typeAliases><package name="com.zzp.pojo"/>
</typeAliases>

注解：

@Alias("hello")
public class Users {

每一个在包 com.zzp.pojo 中的 Java Bean，在没有注解的情况下，会使用 Bean 的首字母小写的非限定类名来作为它的别名。 比如 com.zzp.pojo.Users 的别名为 users；若有注解，则别名为其注解值

4.4、设置（settings）

这是 MyBatis 中极为重要的调整设置，它们会改变 MyBatis 的运行时行为。

设置名	描述	有效值
lazyLoadingEnabled	延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。 特定关联关系中可通过设置 fetchType 属性来覆盖该项的开关状态。	true|false
cacheEnabled	全局性地开启或关闭所有映射器配置文件中已配置的任何缓存。	true|false
logImpl	指定 MyBatis 所用日志的具体实现，未指定时将自动查找。	LOG4J|SLF4J…

4.5、其他配置

• typeHandlers（类型处理器）
• objectFactory（对象工厂)
• plugins（插件）
  • mybatis-generator-core
  • mybatis-plus

4.6、映射器（mappers）

• 方式一

  <mappers><mapper resource="com/zzp/dao/UserMapper.xml"></mapper>
  </mappers>

• 方式二

  使用class文件绑定

  <mappers><mapper class="com.zzp.dao.UserMapper"></mapper>
  </mappers>

• 方式三

  使用包名进行绑定

  <mappers><package name="com.zzp.dao"/>
  </mappers>

注意：

​ 使用方式二和方式三有两个注意点： 1. 接口和Mapper配置文件必须同名； 2.接口和Mapper配置文件必须在同一个包下。

5、结果映射（resultMap）

可以解决数据库字段名和Pojo中属性名称不同的问题。

• 起别名

  <select id="getUserList" resultType="hello">select id, name, pwd as password from mybatis.users
  </select>

• resultMap

  ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了。

6、日志

在Mybatis中具体使用哪一种日志，在setting种配置。

6.1、STDOUT_LOGGING

    <settings><setting name="logImpl" value="STDOUT_LOGGING"/></settings>

6.2、 LOG4J

了解log4j：

• Log4j是Apache的一个开源项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件等
• 我们也可以控制每一条日志的输出格式
• 通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。
• 可以通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。

1. 导入依赖包

   <dependency><groupId>log4j</groupId><artifactId>log4j</artifactId><version>1.2.17</version>
   </dependency>

2. 添加log4j.properties文件

   log4j.rootLogger=DEBUG,console,file#控制台输出的相关设置
   log4j.appender.console = org.apache.log4j.ConsoleAppender
   log4j.appender.console.Target = System.out
   log4j.appender.console.Threshold=DEBUG
   log4j.appender.console.layout = org.apache.log4j.PatternLayout
   log4j.appender.console.layout.ConversionPattern=[%c]-%m%n#文件输出的相关设置
   log4j.appender.file = org.apache.log4j.RollingFileAppender
   log4j.appender.file.File=./log/log.log
   log4j.appender.file.MaxFileSize=10mb
   log4j.appender.file.Threshold=DEBUG
   log4j.appender.file.layout=org.apache.log4j.PatternLayout
   log4j.appender.file.layout.ConversionPattern=[%p][%d{yy-MM-dd}][%c]%m%n#日志输出级别
   log4j.logger.org.mybatis=DEBUG
   log4j.logger.java.sql=DEBUG
   log4j.logger.java.sql.Statement=DEBUG
   log4j.logger.java.sql.ResultSet=DEBUG
   log4j.logger.java.sql.PreparedStatement=DEBUG

3. 配置log4j为日志的实现

   <settings><setting name="logImpl" value="LOG4J"/>
   </settings>

4. 在项目种使用

   • 导包

     import org.apache.log4j.spi.LoggerFactory;

   • new一个日志对象 参数为当前类

     private static Logger logger = Logger.getLogger(UserDaoTest.class);

   • 日志级别

     @Test
     public void test2() {logger.info("info: 111111");logger.debug("debug: 22222");logger.error("error: 33333");
     }

   • 日志文件

     

     生成的日志文件会存放到对应的目录下

     

7、分页

为了前端的显示美化；为了减少数据的处理量

7.1、 sql语句执行

select * from users limit 0, 2;

7.2、 mybatis执行

• 接口

  List<Users> getUserListByLimit (Map<String, Integer> map);

• xml配置

  <select id="getUserListByLimit" resultType="com.zzp.pojo.Users">select * from mybatis.users limit #{startIndex}, #{pageSize}
  </select>

• 测试

  @Test
  public void test3(){SqlSession sqlSession = MybatisUtils.getSqlSession();UserMapper userMapper = sqlSession.getMapper(UserMapper.class);Map<String, Integer> map = new HashMap<String, Integer>();map.put("startIndex", 0);map.put("pageSize", 2);List<Users> userList = userMapper.getUserListByLimit(map);for (Users users : userList) {System.out.println(users);}
  }

7.3、 分页插件 pageHelper

8、使用注解开发

1、 编写接口类

@Select("select id, name, pwd from users where id = #{id}")
Users getUserById(int id);

2、 配置核心配置文件

<mappers><mapper resource="com/zzp/dao/UserMapper.xml"></mapper>
</mappers>

3、 编写测试类

@Test
public void test4(){SqlSession sqlSession = MybatisUtils.getSqlSession();UserMapper userMapper = sqlSession.getMapper(UserMapper.class);Users user = userMapper.getUserById(1);System.out.println(user);
}

注解开发的本质是反射。底层是动态代理。

@Param注解

• 基本类型和String类型的参数， 需要加上这个注解
• 引用类型不需要加
• 如果只有一个基本类型的话，可以不加这个注解，但是建议加上
• sql中引用的变量名称对应的值就是@Param中设定的属性名

#{} 和 ${}的区别：

• ${param}传递的参数会被当成sql语句中的一部分，比如传递表名，字段名

  例子：(传入值为id) order by ${param}

  ​ 则解析成的sql为：order by id

• #{parm}传入的数据都当成一个字符串，会对自动传入的数据加一个双引号

  例子：(传入值为id) select * from table where name = #{param}

  ​ 则解析成的sql为： select * from table where name = “id”

• 为了安全，能用#的地方就用#方式传参，这样可以有效的防止sql注入攻击

9、多对一处理

1、按照查询嵌套处理（子查询）

<resultMap id="StudentTeacher" type="Student"><result property="id" column="id"></result><result property="name" column="name"></result><!--复杂类型的属性 我们需要单独处理 对象 association 集合 collection--><association property="teacher" column="tid" javaType="Teacher" select="getTeacher"/></resultMap><select id="getList" resultMap="StudentTeacher">select * from mybatis.student</select><select id="getTeacher" resultType="Teacher">select * from mybatis.teacher where id = #{id}</select>

2、按照结果嵌套查询（联表查询）

<select id="getList2" resultMap="StudentTeacher2">select s.id as sid, s.name as sname, t.name as tname from mybatis.student s, mybatis.teacher t where s.tid = t.id
</select><resultMap id="StudentTeacher2" type="Student"><result property="id" column="sid"></result><result property="name" column="sname"></result><!--复杂类型的属性 我们需要单独处理 对象 association 集合 collection--><association property="teacher" javaType="Teacher"><result property="name" column="tname"></result></association>
</resultMap>

10、一对多

1、按照结果嵌套查询

<select id="getTeacher" resultMap="StudentTeacher">select t.id tid, t.name tname, s.id sid, s.name sname from mybatis.teacher t, mybatis.student s where s.tid = t.id and t.id = #{id}
</select><resultMap id="StudentTeacher" type="Teacher"><result property="id" column="tid"></result><result property="name" column="tname"></result><!--复杂类型的属性 我们需要单独处理 对象 association 集合 collection--><collection property="students" ofType="Student"><result property="id" column="sid"></result><result property="name" column="sname"></result></collection>
</resultMap>

2、按照查询嵌套查询

<select id="getTeacher2" resultMap="Teacher2">select * from mybatis.teacher where id = #{id}
</select><resultMap id="Teacher2" type="Teacher"><result property="id" column="id"></result><result property="name" column="name"></result><collection property="students" column="id" javaType="ArrayList" ofType="Student" select="getStudentByTid"></collection>
</resultMap><select id="getStudentByTid" resultType="Student">select * from mybatis.student where tid = #{tid}
</select>

整理：

• association： 关联 用于处理多对一的情况 可以理解为一个对象（例如一个学生中的老师）

• collection： 集合 用于处理一对多的情况 可以理解为一个集合 （例如老师中的学生列表）

• javaType ： 是指我们pojo实体类中的属性类型

• ofType ： 指的是映射到List或者Map中的类型，也就是泛型中的约束类型

11、动态Sql

​ 根据不同的条件，生成不同的sql语句。

• if
• choose (when, otherwise)
• trim (where, set)
• foreach

1、 if

<select id="findActiveBlogLike"resultType="Blog">SELECT * FROM BLOG WHERE state = ‘ACTIVE’<if test="title != null">AND title like #{title}</if><if test="author != null and author.name != null">AND author_name like #{author.name}</if>
</select>

​ 这条语句提供了可选的查找文本功能。如果不传入 “title”，那么所有处于 “ACTIVE” 状态的 BLOG 都会返回；如果传入了 “title” 参数，那么就会对 “title” 一列进行模糊查找并返回对应的 BLOG 结果 。

2、choose、when、otherwise

<select id="findActiveBlogLike"resultType="Blog">SELECT * FROM BLOG WHERE state = ‘ACTIVE’<choose><when test="title != null">AND title like #{title}</when><when test="author != null and author.name != null">AND author_name like #{author.name}</when><otherwise>AND featured = 1</otherwise></choose>
</select>

​ 只想从多个条件中选择一个使用。

3、trim、where、set

<select id="findActiveBlogLike"resultType="Blog">SELECT * FROM BLOG<where><if test="state != null">state = #{state}</if><if test="title != null">AND title like #{title}</if><if test="author != null and author.name != null">AND author_name like #{author.name}</if></where>
</select>

​ where 元素只会在子元素返回任何内容的情况下才插入 “WHERE” 子句。而且，若子句的开头为 “AND” 或 “OR”，where 元素也会将它们去除。

<update id="updateAuthorIfNecessary">update Author<set><if test="username != null">username=#{username},</if><if test="password != null">password=#{password},</if><if test="email != null">email=#{email},</if><if test="bio != null">bio=#{bio}</if></set>where id=#{id}
</update>

​ set 元素会动态地在行首插入 SET 关键字，并会删掉额外的逗号（这些逗号是在使用条件语句给列赋值时引入的）。

<trim prefix="SET" suffixOverrides=",">...
</trim><trim prefix="WHERE" prefixOverrides="AND |OR ">...
</trim>

​

4、foreach

<select id="selectPostIn" resultType="domain.blog.Post">SELECT *FROM POST PWHERE ID in<foreach item="item" index="index" collection="list"open="(" separator="," close=")">#{item}</foreach>
</select>

​ foreach 元素的功能非常强大，它允许你指定一个集合，声明可以在元素体内使用的集合项（item）和索引（index）变量。它也允许你指定开头与结尾的字符串以及集合项迭代之间的分隔符。这个元素也不会错误地添加多余的分隔符，看它多智能！

提示: 你可以将任何可迭代对象（如 List、Set 等）、Map 对象或者数组对象作为集合参数传递给 foreach。当使用可迭代对象或者数组时，index 是当前迭代的序号，item 的值是本次迭代获取到的元素。当使用 Map 对象（或者 Map.Entry 对象的集合）时，index 是键，item 是值。

12、Mybatis缓存

• ​ Mybatis包含一个非常强大的查询缓存特性，它可以非常方便的定制和配置缓存。缓存可以极大的提升查询效率。

• ​ Mybatis系统中默认定义了两级缓存：一级缓存和二级缓存

  • 默认情况下，只有一级缓存开启。（SqlSession级别的，也称本地缓存）

  • 二级缓存需要手动开启和配置，它是基于namespace级别的缓存

  • 为了提高拓展性，Mybatis定义了缓存接口Cache，我们可以通过实现Cache接口来自定义二级缓存

12.1、一级缓存

测试一级缓存：

SqlSession sqlSession = MybatisUtils.getSqlSession();
TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);Teacher teacher = mapper.getTeacher2(1);System.out.println(teacher);
System.out.println("------------------------------");Teacher teacher2 = mapper.getTeacher2(1);
System.out.println(teacher2);sqlSession.close();

​

​ 可以看到，只开启了一次连接，第二次直接再缓存中取出来的。

• 缓存失效的原因：
  1. 查询不同的东西
  2. 增删改操作
  3. 查询不同的mapper.xml
  4. 手动清空缓存 sqlSession.clearCache();

12.2 二级缓存

​ 默认情况下，只启用了本地的会话缓存，它仅仅对一个会话中的数据进行缓存。 要启用全局的二级缓存，只需要在你的 SQL 映射文件中添加一行：

<cache/>    

• 映射语句文件中的所有 select 语句的结果将会被缓存。
• 映射语句文件中的所有 insert、update 和 delete 语句会刷新缓存。
• 缓存会使用最近最少使用算法（LRU, Least Recently Used）算法来清除不需要的缓存。
• 缓存不会定时进行刷新（也就是说，没有刷新间隔）。
• 缓存会保存列表或对象（无论查询方法返回哪种）的 1024 个引用。
• 缓存会被视为读/写缓存，这意味着获取到的对象并不是共享的，可以安全地被调用者修改，而不干扰其他调用者或线程所做的潜在修改。

1. 自定义cache配置：

<cacheeviction="FIFO"flushInterval="60000"size="512"readOnly="true"/>

​ 这个更高级的配置创建了一个 FIFO 缓存，每隔 60 秒刷新，最多可以存储结果对象或列表的 512个引用，而且返回的对象被认为是只读的，因此对它们进行修改可能会在不同线程中的调用者产生冲突。

可用的清除策略有：

• LRU – 最近最少使用：移除最长时间不被使用的对象。
• FIFO – 先进先出：按对象进入缓存的顺序来移除它们。
• SOFT – 软引用：基于垃圾回收器状态和软引用规则移除对象。
• WEAK – 弱引用：更积极地基于垃圾收集器状态和弱引用规则移除对象。

2. 使用二级缓存步骤：

• 增加配置，开启全局缓存

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

• 在Mapper中开启二级缓存

<cache/>  

• 测试：

  需要将实体类序列化；

3. 小结

• 只要开启了二级缓存，在一个mapper中就有效
• 所有的数据先放在一级缓存下
• 当会话提交或者关闭的时候，会提交到二级缓存中

13、缓存顺序

14、ehcache

1、导包

<dependency><groupId>org.mybatis.caches</groupId><artifactId>mybatis-ehcache</artifactId><version>1.1.0</version>
</dependency>

2、添加配置文件 ehcache.xml

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"><!-- 磁盘缓存位置 --><diskStore path="./tmpdir/Tmp_ehcache"/><!-- 默认缓存 --><defaultCachemaxEntriesLocalHeap="10000"eternal="false"timeToIdleSeconds="120"timeToLiveSeconds="120"maxEntriesLocalDisk="10000000"diskExpiryThreadIntervalSeconds="120"memoryStoreEvictionPolicy="LRU"><persistence strategy="localTempSwap"/></defaultCache><!-- helloworld缓存 --><cache name="HelloWorldCache"maxElementsInMemory="1000"eternal="false"timeToIdleSeconds="5"timeToLiveSeconds="5"overflowToDisk="false"memoryStoreEvictionPolicy="LRU"/>
</ehcache>

15、Mybatis执行流程

1、 通过Resources加载配置好的mybatis-config.xml配置文件。

String resoursePath = "mybatis-config.xml";
InputStream resourceAsStream = Resources.getResourceAsStream(resoursePath);

2、 创建SqlSessionFactory对象

sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);

​ 通过SqlSessionFactoryBuilder的build方法生成的SqlSessionFactory对象。

public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {try {XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);return build(parser.parse());} catch (Exception e) {throw ExceptionFactory.wrapException("Error building SqlSession.", e);} finally {ErrorContext.instance().reset();try {inputStream.close();} catch (IOException e) {// Intentionally ignore. Prefer previous error.}}}

​ XMLConfigBuilde用来解析XML文件的一个构建者，通过他的parse()方法解析mybatis配置文件。

public Configuration parse() {if (parsed) {throw new BuilderException("Each XMLConfigBuilder can only be used once.");}parsed = true;parseConfiguration(parser.evalNode("/configuration"));return configuration;
}

​ 解析configuration节点下的子节点：

​ 然后我们发现parse()解析完成后，他返回了一个configuration对象，它是用来存放mybatis核心配置文件解析完成后的结果。

public SqlSessionFactory build(Configuration config) {return new DefaultSqlSessionFactory(config);
}

​ 返回了一个build方法，把刚才的返回值configuration作为参数传入这个方法中，并返回了一个DefaultSqlSessionFactory对象，这是SqlSessionFactory的实现类，用来生产defaultSqlSession对象。

3、获取一个SqlSession对象

​ 调用openSession()方法：

// SqlSession对象中包含了面向数据库执行sql命令的所有方法
public static SqlSession getSqlSession () {return sqlSessionFactory.openSession();
}

​ 具体实现：

​ Transaction对象：获取xml中的environment节点，通过这些参数transactionFactory就帮我们产生了transaction。

​ executor执行器，是个接口(一般用SimpleExecutor来执行，实现类)，他是mybatis的核心执行器，相当于jdbc中的statement，发送sql语句并执行。

4、jdk动态代理生成mapper接口的代理对象

​ 通过DefaultSqlSession的getMapper()来生成。

TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);

​ 其实是通过mapperRegistry的对象，它里面是一个knownMappers的HashMap，用于存储配置文件中的mappers标签的每个mapper接口。


​ 通过JDK动态代理，帮mapper接口生成代理实现类

5、执行mapper下的方法
​ 代理对象的业务方法执行其实走的是MapperProxy的invoke方法。

​ 通过判断sql的执行类型，选择对应的方法：

​ 这里以查询为例：

​ DefaultSqlSession中，走executor的query方法

​ 如果开启了二级缓存，走CachingExecutor的query方法，先从二级缓存中获取。

​ 如二级缓存中没有数据，走delegate(BaseExecutor)的query方法 ，也就是一级缓存localCache，如果一级缓存没有数据，则走queryFromDatabase方法查数据库。

​ 从数据库查到数据，放入到一级缓存中

​ 一级缓存底层是个PerpetualCache类型的HashMap。

总结一下

​ mybatis运行时要先通过resources把核心配置文件也就是mybatis.xml文件加载进来，然后通过xmlConfigBulider来解析，解析完成后把结果放入configuration中，并把它作为参数传入到build()方法中，并返回一个defaultSQLSessionFactory。我们再调用openSession()方法，来获取SqlSession，在构建SqlSession的同时还需要transaction和executor用于后续执行操作。

流程图：