一步步学习Mybatis的缓存特性

本文来自 凯伦 在 GitChat 上精彩分享「零基础搭建你的个人博客」，「阅读原文」看看大家与作者做了哪些交流。

前言

基于个人的兴趣，开了这场 chat，主题是 Mybatis 一级和二级缓存的应用及源码分析。希望在本场 chat 结束后，能够帮助读者朋友明白以下三点。

1. Mybatis 是什么。

2. Mybatis 一级和二级缓存如何配置使用。

3. Mybatis 一级和二级缓存的工作流程及源码分析。

本次分析中涉及到的代码和数据库表均放在 Github 上，地址: mybatis-cache-demo。

1. Mybatis的基础概念

本章节会对 Mybatis 进行大体的介绍，分为官方定义和核心组件介绍。首先是 Mybatis 官方定义，如下所示。

MyBatis 是支持定制化 SQL、存储过程以及高级映射的优秀的持久层框架。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以对配置和原生 Map 使用简单的 XML 或注解，将接口和 Java 的 POJOs （Plain Old Java Objects，普通的 Java 对象）映射成数据库中的记录。

其次是 Mybatis 的几个核心概念。

1. SqlSession : 代表和数据库的一次会话，向用户提供了操作数据库的方法。

2. MappedStatement: 代表要发往数据库执行的指令，可以理解为是Sql的抽象表示。

3. Executor: 具体用来和数据库交互的执行器，接受 MappedStatement 作为参数。

4. 映射接口: 在接口中会要执行的Sql用一个方法来表示，具体的 Sql 写在映射文件中。

5. 映射文件: 可以理解为是 Mybatis 编写 Sql 的地方，通常来说每一张单表都会对应着一个映射文件，在该文件中会定义 Sql 语句入参和出参的形式。

下图就是一个针对 Student 表操作的接口文件 StudentMapper，在StudentMapper 中，我们可以若干方法，这个方法背后就是代表着要执行的 Sql 的意义。

通常也可以把涉及多表查询的方法定义在 StudentMapper 中，如果查询的主体仍然是 Student 表的信息。也可以将涉及多表查询的语句单独抽出一个独立的接口文件。在定义完接口文件后，我们会开发一个 Sql 映射文件，主要由mapper 元素和 select | insert | update | delete 元素构成，如下图所示。

mapper元素代表这个文件是一个映射文件，使用namespace和具体的映射接口绑定起来，namespace的值就是这个接口的全限定类名。

select | insert | update | delete代表的是 Sql 语句，映射接口中定义的每一个方法也会和映射文件中的语句通过 id 的方式绑定起来，方法名就是语句的id，同时会定义语句的入参和出参，用于完成和 Java 对象之间的转换。

在 Mybatis 初始化的时候，每一个语句都会使用对应的 MappedStatement 代表，使用 namespace+ 语句本身的id来代表这个语句。如下代码所示，使用 mapper.StudentMapper.getStudentById 代表其对应的 Sql。

SELECT id,name,age FROM student WHERE id = #{id}

在 Mybatis 执行时，会进入对应接口的方法，通过类名加上方法名的组合生成 id，找到需要的 MappedStatement，交给执行器使用。至此，Mybatis 的基础概念介绍完毕。

2. 一级缓存

2.1 一级缓存介绍

在系统代码的运行中，我们可能会在一个数据库会话中，执行多次查询条件完全相同的 Sql，鉴于日常应用的大部分场景都是读多写少，这重复的查询会带来一定的网络开销，同时 select 查询的量比较大的话，对数据库的性能是有比较大的影响的。

如果是 Mysql 数据库的话，在服务端和 Jdbc 端都开启预编译支持的话，可以在本地 JVM 端缓存 Statement，可以在 Mysql 服务端直接执行 Sql，省去编译 Sql 的步骤，但也无法避免和数据库之间的重复交互。关于 Jdbc 和 Mysql 预编译缓存的事情，可以看我的这篇博客 JDBC 和 Mysql 那些事。

Mybatis 提供了一级缓存的方案来优化在数据库会话间重复查询的问题。实现的方式是每一个 SqlSession 中都持有了自己的缓存，一种是 SESSION 级别，即在一个 Mybatis 会话中执行的所有语句，都会共享这一个缓存。一种是 STATEMENT 级别，可以理解为缓存只对当前执行的这一个 statement 有效。如果用一张图来代表一级查询的查询过程的话，可以用下图表示。每一个 SqlSession 中持有了自己的 Executor，每一个 Executor 中有一个 Local Cache。当用户发起查询时，Mybatis 会根据当前执行的 MappedStatement 生成一个 key，去 Local Cache 中查询，如果缓存命中的话，返回。如果缓存没有命中的话，则写入 Local Cache，最后返回结果给用户。

2.2 一级缓存配置

上文介绍了一级缓存的实现方式，解决了什么问题。在这个章节，我们学习如何使用 Mybatis 的一级缓存。只需要在 Mybatis 的配置文件中，添加如下语句，就可以使用一级缓存。共有两个选项，SESSION 或者 STATEMENT，默认是 SESSION 级别。

 name="localCacheScope" value="SESSION"/>

2.3 一级缓存实验

配置完毕后，通过实验的方式了解 Mybatis 一级缓存的效果。每一个单元测试后都请恢复被修改的数据。首先是创建了一个示例表 student，为其创建了对应的 POJO 类和增改的方法，具体可以在 entity 包和 Mapper 包中查看。

CREATE TABLE `student` (  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,  `name` varchar(200) COLLATE utf8_bin DEFAULT NULL,  `age` tinyint(3) unsigned DEFAULT NULL,  PRIMARY KEY (`id`)) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8 COLLATE=utf8_bin;

在以下实验中，id为1的学生名称是凯伦。

实验1

开启一级缓存，范围为会话级别，调用三次getStudentById，代码如下所示:

public void getStudentById() throws Exception {        SqlSession sqlSession = factory.openSession(true); // 自动提交事务        StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);        System.out.println(studentMapper.getStudentById(1));        System.out.println(studentMapper.getStudentById(1));        System.out.println(studentMapper.getStudentById(1));    }




    

执行结果:我们可以看到，只有第一次真正查询了数据库,后续的查询使用了一级缓存。

实验2

在这次的试验中，我们增加了对数据库的修改操作，验证在一次数据库会话中，对数据库发生了修改操作，一级缓存是否会失效。

@Testpublic void addStudent() throws Exception {        SqlSession sqlSession = factory.openSession(true); // 自动提交事务        StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);        System.out.println(studentMapper.getStudentById(1));        System.out.println("增加了" + studentMapper.addStudent(buildStudent()) + "个学生");        System.out.println(studentMapper.getStudentById(1));        sqlSession.close();}

执行结果:

我们可以看到，在修改操作后执行的相同查询，查询了数据库，一级缓存失效。

实验3

开启两个 SqlSession，在 sqlSession1 中查询数据，使一级缓存生效，在 sqlSession2 中更新数据库，验证一级缓存只在数据库会话内部共享。

@Testpublic void testLocalCacheScope() throws Exception {        SqlSession sqlSession1 = factory.openSession(true);         SqlSession sqlSession2 = factory.openSession(true);        StudentMapper studentMapper = sqlSession1.getMapper(StudentMapper.class);       StudentMapper studentMapper2 = sqlSession2.getMapper(StudentMapper.class);        System.out.println("studentMapper读取数据: " + studentMapper.getStudentById(1));        System.out.println("studentMapper读取数据: " + studentMapper.getStudentById(1));        System.out.println("studentMapper2更新了" + studentMapper2.updateStudentName("小岑",1) + "个学生的数据");        System.out.println("studentMapper读取数据: " + studentMapper.getStudentById(1));        System.out.println("studentMapper2读取数据: " + studentMapper2.getStudentById(1));}

我们可以看到，sqlSession2 更新了 id 为 1 的学生的姓名，从凯伦改为了小岑，但 session1 之后的查询中，id 为 1 的学生的名字还是凯伦，出现了脏数据，也证明了我们之前就得到的结论，一级缓存只存在于只在数据库会话内部共享。

3. 一级缓存工作流程&源码分析

这一章节主要从一级缓存的工作流程和源码层面对一级缓存进行学习。

3.1 工作流程

根据一级缓存的工作流程，我们绘制出一级缓存执行的时序图，如下图所示。

主要步骤如下:

1. 对于某个 Select Statement，根据该 Statement 生成 key。

2. 判断在 Local Cache 中，该 key 是否用对应的数据存在。

3. 如果命中，则跳过查询数据库，继续往下走。

4. 如果没命中：

去数据库中查询数据，得到查询结果；

将 key 和查询到的结果作为 key 和 value，放入 Local Cache 中。

将查询结果返回；

5. 判断缓存级别是否为 STATEMENT 级别，如果是的话，清空本地缓存。

3.2 源码分析

了解具体的工作流程后，我们队 Mybatis 查询相关的核心类和一级缓存的源码进行走读。这对于之后学习二级缓存时也有帮助。

SqlSession: 对外提供了用户和数据库之间交互需要的所有方法，隐藏了底层的细节。它的一个默认实现类是 DefaultSqlSession。

Executor: SqlSession 向用户提供操作数据库的方法，但和数据库操作有关的职责都会委托给 Executor。

如下图所示，Executor 有若干个实现类，为 Executor 赋予了不同的能力，大家可以根据类名，自行私下学习每个类的基本作用。

在一级缓存章节，我们主要学习 BaseExecutor。

BaseExecutor: BaseExecutor 是一个实现了 Executor 接口的抽象类，定义若干抽象方法，在执行的时候，把具体的操作委托给子类进行执行。

protected abstract int doUpdate(MappedStatement ms, Object parameter) throws SQLException;protected abstract List doFlushStatements(boolean isRollback) throws SQLException;protected abstract  List doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException;protected abstract  Cursor doQueryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds, BoundSql boundSql) throws SQLException;

在一级缓存的介绍中，我们提到对 Local Cache 的查询和写入是在 Executor 内部完成的。在阅读 BaseExecutor 的代码后，我们也发现 Local Cache 就是它内部的一个成员变量，如下代码所示。

public abstract class BaseExecutor implements Executor {protected ConcurrentLinkedQueue deferredLoads;protected PerpetualCache localCache;

Cache: Mybatis中的Cache接口，提供了和缓存相关的最基本的操作，有若干个实现类，使用装饰器模式互相组装，提供丰富的操控缓存的能力。

BaseExecutor 成员变量之一的 PerpetualCache，就是对 Cache 接口最基本的实现，其实现非常的简内部持有了 hashmap，对一级缓存的操作其实就是对这个 hashmap 的操作。如下代码所示。

public class PerpetualCache implements Cache {  private String id;  private Map

在阅读相关核心类代码后，从源代码层面对一级缓存工作中涉及到的相关代码，出于篇幅的考虑，对源码做适当删减，读者朋友可以结合本文，后续进行更详细的学习。

为了执行和数据库的交互，首先会通过 DefaultSqlSessionFactory 开启一个 SqlSession，在创建 SqlSession 的过程中，会通过 Configuration 类创建一个全新的 Executor，作为 DefaultSqlSession 构造函数的参数，代码如下所示。

private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {      ............    final Executor executor = configuration.newExecutor(tx, execType);         return new DefaultSqlSession(configuration, executor, autoCommit);}

如果用户不进行制定的话，Configuration 在创建 Executor 时，默认创建的类型就是 SimpleExecutor,它是一个简单的执行类，只是单纯执行Sql。以下是具体用来创建的代码。

public Executor newExecutor(Transaction transaction, ExecutorType executorType) {    executorType = executorType == null ? defaultExecutorType : executorType;    executorType = executorType == null ? ExecutorType.SIMPLE : executorType;    Executor executor;    if (ExecutorType.BATCH == executorType) {      executor = new BatchExecutor(this, transaction);    } else if (ExecutorType.REUSE == executorType) {      executor = new ReuseExecutor(this, transaction);    } else {      executor = new SimpleExecutor(this, transaction);    }    // 尤其可以注意这里，如果二级缓存开关开启的话，是使用CahingExecutor装饰BaseExecutor的子类    if (cacheEnabled) {      executor = new CachingExecutor(executor);                          }    executor = (Executor) interceptorChain.pluginAll(executor);    return executor;}




    

在 SqlSession 创建完毕后，根据 Statment 的不同类型，会进入 SqlSession 的不同方法中，如果是 Select 语句的话，最后会执行到 SqlSession 的 selectList，代码如下所示。

@Overridepublic  List selectList(String statement, Object parameter, RowBounds rowBounds) {      MappedStatement ms = configuration.getMappedStatement(statement);      return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);}

在上文的代码中，SqlSession 把具体的查询职责委托给了 Executor。如果只开启了一级缓存的话，首先会进入 BaseExecutor 的 query 方法。代码如下所示。

@Overridepublic  List query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {    BoundSql boundSql = ms.getBoundSql(parameter);    CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);    return query(ms, parameter, rowBounds, resultHandler, key, boundSql);}

在上述代码中，会先根据传入的参数生成 CacheKey，进入该方法查看 CacheKey 是如何生成的，代码如下所示。

CacheKey cacheKey = new CacheKey();cacheKey.update(ms.getId());cacheKey.update(rowBounds.getOffset());cacheKey.update(rowBounds.getLimit());cacheKey.update(boundSql.getSql());//后面是update了sql中带的参数cacheKey.update(value);

在上述的代码中，我们可以看到它将 MappedStatement 的 Id、sql 的offset、Sql的limit、Sql 本身以及 Sql 中的参数传入了 CacheKey 这个类，最终生成了CacheKey。我们看一下这个类的结构。

private static final int DEFAULT_MULTIPLYER = 37;private static final int DEFAULT_HASHCODE = 17;private int multiplier;private int hashcode;private long checksum;private int count;private List