干货分享|精讲 MyBatis 缓存机制（下）

Posted 2021-04-16 程序之心

每天给你诚意满满的干货

作者：凯伦

原文：

https://tech.meituan.com/mybatis_cache.html

目录

本文按照以下顺序展开。

• 二级缓存介绍及相关配置。

• 二级缓存源码分析。

• 二级缓存总结。

• 全文总结。

  
  

二级缓存

二级缓存介绍

在上文中提到的一级缓存中，其最大的共享范围就是一个SqlSession内部，如果多个SqlSession之间需要共享缓存，则需要使用到二级缓存。开启二级缓存后，会使用CachingExecutor装饰Executor，进入一级缓存的查询流程前，先在CachingExecutor进行二级缓存的查询，具体的工作流程如下所示。

二级缓存开启后，同一个namespace下的所有操作语句，都影响着同一个Cache，即二级缓存被多个SqlSession共享，是一个全局的变量。
当开启缓存后，数据的查询执行的流程就是 二级缓存 -> 一级缓存 -> 数据库。

二级缓存配置

要正确的使用二级缓存，需完成如下配置的。

1.在MyBatis的配置文件中开启二级缓存。 

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

2.在MyBatis的映射XML中配置cache或者 cache-ref 。

cache标签用于声明这个namespace使用二级缓存，并且可以自定义配置。

<cache/>

• type：cache使用的类型，默认是PerpetualCache，这在一级缓存中提到过。

• eviction： 定义回收的策略，常见的有FIFO，LRU。

• flushInterval： 配置一定时间自动刷新缓存，单位是毫秒。

• size： 最多缓存对象的个数。

• readOnly： 是否只读，若配置可读写，则需要对应的实体类能够序列化。

• blocking： 若缓存中找不到对应的key，是否会一直blocking，直到有对应的数据进入缓存。

cache-ref代表引用别的命名空间的Cache配置，两个命名空间的操作使用的是同一个Cache。

<cache-ref namespace="mapper.StudentMapper"/>

二级缓存实验

接下来我们通过实验，了解MyBatis二级缓存在使用上的一些特点。
在本实验中，id为1的学生名称初始化为点点。

实验1

测试二级缓存效果，不提交事务，sqlSession1查询完数据后，sqlSession2相同的查询是否会从缓存中获取数据。

@Testpublic void testCacheWithoutCommitOrClose() 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("studentMapper2读取数据: " + studentMapper2.getStudentById(1));
}

执行结果：

我们可以看到，当sqlsession没有调用commit()方法时，二级缓存并没有起到作用。

实验2

测试二级缓存效果，当提交事务时，sqlSession1查询完数据后，sqlSession2相同的查询是否会从缓存中获取数据。

@Testpublic void testCacheWithCommitOrClose() 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));
      sqlSession1.commit();
      System.out.println("studentMapper2读取数据: " + studentMapper2.getStudentById(1));
}

从图上可知，sqlsession2的查询，使用了缓存，缓存的命中率是0.5。

实验3

测试update操作是否会刷新该namespace下的二级缓存。

@Testpublic void testCacheWithUpdate() throws Exception {
      SqlSession sqlSession1 = factory.openSession(true); 
      SqlSession sqlSession2 = factory.openSession(true); 
      SqlSession sqlSession3 = factory.openSession(true); 

      StudentMapper studentMapper = sqlSession1.getMapper(StudentMapper.class);
      StudentMapper studentMapper2 = sqlSession2.getMapper(StudentMapper.class);
      StudentMapper studentMapper3 = sqlSession3.getMapper(StudentMapper.class);

      System.out.println("studentMapper读取数据: " + studentMapper.getStudentById(1));
      sqlSession1.commit();
      System.out.println("studentMapper2读取数据: " + studentMapper2.getStudentById(1));

      studentMapper3.updateStudentName("方方",1);
      sqlSession3.commit();
      System.out.println("studentMapper2读取数据: " + studentMapper2.getStudentById(1));
}

我们可以看到，在sqlSession3更新数据库，并提交事务后，sqlsession2的StudentMapper namespace下的查询走了数据库，没有走Cache。

实验4

验证MyBatis的二级缓存不适应用于映射文件中存在多表查询的情况。
通常我们会为每个单表创建单独的映射文件，由于MyBatis的二级缓存是基于namespace的，多表查询语句所在的namspace无法感应到其他namespace中的语句对多表查询中涉及的表进行的修改，引发脏数据问题。

@Testpublic void testCacheWithDiffererntNamespace() throws Exception {
      SqlSession sqlSession1 = factory.openSession(true); 
      SqlSession sqlSession2 = factory.openSession(true); 
      SqlSession sqlSession3 = factory.openSession(true); 

      StudentMapper studentMapper = sqlSession1.getMapper(StudentMapper.class);
      StudentMapper studentMapper2 = sqlSession2.getMapper(StudentMapper.class);
      ClassMapper classMapper = sqlSession3.getMapper(ClassMapper.class);

      System.out.println("studentMapper读取数据: " + studentMapper.getStudentByIdWithClassInfo(1));
      sqlSession1.close();
      System.out.println("studentMapper2读取数据: " + studentMapper2.getStudentByIdWithClassInfo(1));

      classMapper.updateClassName("特色一班",1);
      sqlSession3.commit();
      System.out.println("studentMapper2读取数据: " + studentMapper2.getStudentByIdWithClassInfo(1));
}

执行结果：

在这个实验中，我们引入了两张新的表，一张class，一张classroom。class中保存了班级的id和班级名，classroom中保存了班级id和学生id。我们在StudentMapper中增加了一个查询方法getStudentByIdWithClassInfo，用于查询学生所在的班级，涉及到多表查询。在ClassMapper中添加了updateClassName，根据班级id更新班级名的操作。

当sqlsession1的studentmapper查询数据后，二级缓存生效。保存在StudentMapper的namespace下的cache中。当sqlSession3的classMapper的updateClassName方法对class表进行更新时，updateClassName不属于StudentMapper的namespace，所以StudentMapper下的cache没有感应到变化，没有刷新缓存。当StudentMapper中同样的查询再次发起时，从缓存中读取了脏数据。

实验5

为了解决实验4的问题呢，可以使用Cache ref，让ClassMapper引用StudenMapper命名空间，这样两个映射文件对应的Sql操作都使用的是同一块缓存了。

执行结果：

不过这样做的后果是，缓存的粒度变粗了，多个Mapper namespace下的所有操作都会对缓存使用造成影响。

二级缓存源码分析

MyBatis二级缓存的工作流程和前文提到的一级缓存类似，只是在一级缓存处理前，用CachingExecutor装饰了BaseExecutor的子类，在委托具体职责给delegate之前，实现了二级缓存的查询和写入功能，具体类关系图如下图所示。

源码分析

源码分析从CachingExecutor的query方法展开，源代码走读过程中涉及到的知识点较多，不能一一详细讲解，读者朋友可以自行查询相关资料来学习。
CachingExecutor的query方法，首先会从MappedStatement中获得在配置初始化时赋予的Cache。

Cache cache = ms.getCache();

本质上是装饰器模式的使用，具体的装饰链是

SynchronizedCache -> LoggingCache -> SerializedCache -> LruCache -> PerpetualCache。

以下是具体这些Cache实现类的介绍，他们的组合为Cache赋予了不同的能力。

• SynchronizedCache： 同步Cache，实现比较简单，直接使用synchronized修饰方法。

• LoggingCache： 日志功能，装饰类，用于记录缓存的命中率，如果开启了DEBUG模式，则会输出命中率日志。

• SerializedCache： 序列化功能，将值序列化后存到缓存中。该功能用于缓存返回一份实例的Copy，用于保存线程安全。

• LruCache： 采用了Lru算法的Cache实现，移除最近最少使用的key/value。

• PerpetualCache： 作为为最基础的缓存类，底层实现比较简单，直接使用了HashMap。

  
  

然后是判断是否需要刷新缓存，代码如下所示：

flushCacheIfRequired(ms);

在默认的设置中SELECT语句不会刷新缓存，insert/update/delte会刷新缓存。进入该方法。代码如下所示：

private void flushCacheIfRequired(MappedStatement ms) {
  Cache cache = ms.getCache();    
   if (cache != null && ms.isFlushCacheRequired()) {      
    tcm.clear(cache);
   }}

MyBatis的CachingExecutor持有了TransactionalCacheManager，即上述代码中的tcm。
TransactionalCacheManager中持有了一个Map，代码如下所示：

private Map<Cache, TransactionalCache> transactionalCaches = new HashMap<Cache, TransactionalCache>();

这个Map保存了Cache和用TransactionalCache包装后的Cache的映射关系。
TransactionalCache实现了Cache接口，CachingExecutor会默认使用他包装初始生成的Cache，作用是如果事务提交，对缓存的操作才会生效，如果事务回滚或者不提交事务，则不对缓存产生影响。

在TransactionalCache的clear，有以下两句。清空了需要在提交时加入缓存的列表，同时设定提交时清空缓存，代码如下所示：

@Overridepublic void clear() {
    clearOnCommit = true;
    entriesToAddOnCommit.clear();}

CachingExecutor继续往下走，ensureNoOutParams主要是用来处理存储过程的，暂时不用考虑。

if (ms.isUseCache() && resultHandler == null) {
    ensureNoOutParams(ms, parameterObject, boundSql);

之后会尝试从tcm中获取缓存的列表。

List<E> list = (List<E>) tcm.getObject(cache, key);

在getObject方法中，会把获取值的职责一路传递，最终到PerpetualCache。如果没有查到，会把key加入Miss集合，这个主要是为了统计命中率。

Object object = delegate.getObject(key);if (object == null) {
    entriesMissedInCache.add(key);
}

CachingExecutor继续往下走，如果查询到数据，则调用tcm.putObject方法，往缓存中放入值。

if (list == null) {
    list = delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
    tcm.putObject(cache, key, list); // issue #578 and #116
}

tcm的put方法也不是直接操作缓存，只是在把这次的数据和key放入待提交的Map中。

@Overridepublic void putObject(Object key, Object object) {
    entriesToAddOnCommit.put(key, object);}

从以上的代码分析中，我们可以明白，如果不调用commit方法的话，由于TranscationalCache的作用，并不会对二级缓存造成直接的影响。因此我们看看Sqlsession的commit方法中做了什么。代码如下所示：

@Overridepublic void commit(boolean force) {   
   try {
     executor.commit(isCommitOrRollbackRequired(force));

因为我们使用了CachingExecutor，首先会进入CachingExecutor实现的commit方法。

@Overridepublic void commit(boolean required) throws SQLException {
    delegate.commit(required);
    tcm.commit();}

会把具体commit的职责委托给包装的Executor。主要是看下tcm.commit()，tcm最终又会调用到TrancationalCache。

public void commit() {    if (clearOnCommit) {
      delegate.clear();
    }
    flushPendingEntries();
    reset();}

看到这里的clearOnCommit就想起刚才TrancationalCache的clear方法设置的标志位，真正的清理Cache是放到这里来进行的。具体清理的职责委托给了包装的Cache类。之后进入flushPendingEntries方法。代码如下所示：

private void flushPendingEntries() {   
    for (Map.Entry<Object, Object> entry : entriesToAddOnCommit.entrySet()) {
     delegate.putObject(entry.getKey(), entry.getValue());
    }
    ................}

在flushPendingEntries中，将待提交的Map进行循环处理，委托给包装的Cache类，进行putObject的操作。
后续的查询操作会重复执行这套流程。如果是insert|update|delete的话，会统一进入CachingExecutor的update方法，其中调用了这个函数，代码如下所示：

private void flushCacheIfRequired(MappedStatement ms)

在二级缓存执行流程后就会进入一级缓存的执行流程，因此不再赘述。

总结

1. MyBatis的二级缓存相对于一级缓存来说，实现了SqlSession之间缓存数据的共享，同时粒度更加的细，能够到namespace级别，通过Cache接口实现类不同的组合，对Cache的可控性也更强。

2. MyBatis在多表查询时，极大可能会出现脏数据，有设计上的缺陷，安全使用二级缓存的条件比较苛刻。

3. 在分布式环境下，由于默认的MyBatis Cache实现都是基于本地的，分布式环境下必然会出现读取到脏数据，需要使用集中式缓存将MyBatis的Cache接口实现，有一定的开发成本，直接使用Redis,Memcached等分布式缓存可能成本更低，安全性也更高。

全文总结

本文对介绍了MyBatis一二级缓存的基本概念，并从应用及源码的角度对MyBatis的缓存机制进行了分析。最后对MyBatis缓存机制做了一定的总结，个人建议MyBatis缓存特性在生产环境中进行关闭，单纯作为一个ORM框架使用可能更为合适。

推荐阅读：