ToyanのBlog HomeArchivesTagsCategories
Mybatis缓存机制
|WebMybatis
Word count: 5.6k|Reading time: 22 min

一级缓存

一级缓存介绍

在应用运行过程中，我们有可能在一次数据库会话中，执行多次查询条件完全相同的SQL，Mybatis提供了一级缓存的方案优化这部分场景，如果是相同的SQL语句，会优先命中一级缓存，避免直接对数据库进行查询，提高性能，具体执行过程如下图所示

每个SqlSession中持有了Executor，每个Executor中有一个LocalCache。当用户发起查询时，Mybatis根据当前执行的语句生成MappedStatement，在LocalCache进行查询，如果命中缓存的话，直接返回结果给用户，如果缓存没有命中的话，查询数据库，结果写入LocalCache，最后返回结果给用户。具体实现类的类关系图如下图所示。

一级缓存配置

我们来看看如何使用Mybatis一级缓存。开发者只需在Mybatis的配置文件中，添加如下语句，就可以使用一级缓存。共有两个选项，session和statement，默认是session级别，即在一个Mybatis会话中执行的所有语句，都会共享这一个缓存，一种是statement级别，可以理解为缓存只对当前执行的这一个statement有效。

1
<setting name="localCacheScope" value="SESSION">

一级缓存实验

首先创建实例表，创建对应的POJO类和增改的方法

1
2
3
4
5
6
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，代码如下：

1
2
3
4
5
6
7
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

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

1
2
3
4
5
6
7
8
public 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，在sqlSession中查询数据，使一级缓存生效，在sqlSession2中更新数据库，验证一级缓存只在数据库会话内部共享

1
2
3
4
5
6
7
8
9
10
11
public 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的学生的姓名还是凯伦，出现了脏数据，也证明了之前的设想，一级缓存只在数据库会话内部有效

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

那么，一级缓存的工作流程是怎样的呢？我们从源码层面来学习一下

工作流程

一级缓存执行额时序图，如下图所示

源码分析

接下来将对Mybatis查询相关的核心类和一级缓存的源码进行走读。这对后面学习二级缓存也有帮助

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

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

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

在一级缓存的源码分析中，主要学习BaseExecutor的内部实现

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

1
2
3
4
protected abstract int doUpdate(MappedStatement ms, Object parameter) throws SQLException;
protected abstract List<BatchResult> doFlushStatements(boolean isRollback) throws SQLException;
protected abstract <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException;
protected abstract <E> Cursor<E> doQueryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds, BoundSql boundSql) throws SQLException;

在一级缓存的介绍中提到对LocalCache的查询和写入是在Executor内部完成的，在阅读BaseExecutor的代码中发现LocalCache是BaseExecutor内部的一个成员变量，如下代码所示

1
2
3
public abstract class BaseExecutor implements Executor {
 		protected ConcurrentLinkedQueue<BaseExecutor.DeferredLoad> deferredLoads;
    protected PerpetualCache localCache;

**Cache：**Mybatis中的Cache接口，提供了和缓存相关的最基本的操作，如下图所示

有若干个实现类，使用装饰器模式互相组装，提供丰富的操控缓存的能力，部分实现类如下图所示：


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

1
2
3
public class PerpetualCache implements Cache {
    private String id;
    private Map<Object, Object> cache = new HashMap();

为执行和数据库的交互，首先需要初始化SqlSession，通过DefaultSqlSessionFactory开启SqlSession：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
  Transaction tx = null;

  DefaultSqlSession var8;
  try {
    Environment environment = this.configuration.getEnvironment();
    TransactionFactory transactionFactory = this.getTransactionFactoryFromEnvironment(environment);
    tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
    // 重要的两行代码
    Executor executor = this.configuration.newExecutor(tx, execType);
    var8 = new DefaultSqlSession(this.configuration, executor, autoCommit);
  } catch (Exception var12) {
    this.closeTransaction(tx);
    throw ExceptionFactory.wrapException("Error opening session.  Cause: " + var12, var12);
  } finally {
    ErrorContext.instance().reset();
  }

  return var8;
}

在初始化SqlSession时，会使用Configuration类创建一个全新的Executor，作为DefaultSqlSession构造函数的参数，创建Executor代码如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
  executorType = executorType == null ? this.defaultExecutorType : executorType;
  executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
  Object 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);
  }
	// 这里需要注意的是，如果两级缓存开关开启的话，是使用CachingExecutor装饰BaseExecutor的子类
  if (this.cacheEnabled) {
    executor = new CachingExecutor((Executor)executor);
  }

  Executor executor = (Executor)this.interceptorChain.pluginAll(executor);
  return executor;
}

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

1
2
3
4
5
6
7
8
9
10
11
12
13
public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
  List var5;
  try {
    MappedStatement ms = this.configuration.getMappedStatement(statement);
    var5 = this.executor.query(ms, this.wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
  } catch (Exception var9) {
    throw ExceptionFactory.wrapException("Error querying database.  Cause: " + var9, var9);
  } finally {
    ErrorContext.instance().reset();
  }

  return var5;
}

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

1
2
3
4
5
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
  BoundSql boundSql = ms.getBoundSql(parameter);
  CacheKey key = this.createCacheKey(ms, parameter, rowBounds, boundSql);
  return this.query(ms, parameter, rowBounds, resultHandler, key, boundSql);
}

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {
  if (this.closed) {
    throw new ExecutorException("Executor was closed.");
  } else {
    CacheKey cacheKey = new CacheKey();
    cacheKey.update(ms.getId());
    cacheKey.update(rowBounds.getOffset());
    cacheKey.update(rowBounds.getLimit());
    cacheKey.update(boundSql.getSql());
    // 后面是update了sql中带的参数
    List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
    TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry();
    Iterator var8 = parameterMappings.iterator();

    while(var8.hasNext()) {
      ParameterMapping parameterMapping = (ParameterMapping)var8.next();
      if (parameterMapping.getMode() != ParameterMode.OUT) {
        String propertyName = parameterMapping.getProperty();
        Object value;
        if (boundSql.hasAdditionalParameter(propertyName)) {
          value = boundSql.getAdditionalParameter(propertyName);
        } else if (parameterObject == null) {
          value = null;
        } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
          value = parameterObject;
        } else {
          MetaObject metaObject = this.configuration.newMetaObject(parameterObject);
          value = metaObject.getValue(propertyName);
        }
				// 最终需要的生成结果
        cacheKey.update(value);
      }
    }

    if (this.configuration.getEnvironment() != null) {
      cacheKey.update(this.configuration.getEnvironment().getId());
    }

    return cacheKey;
  }
}

在上面的代码中，将MappedStatement的Id、SQL的offset、SQL的limit、SQL本身以及SQL中的参数传入了CacheKey这个类，最终构成CacheKey。以下是这个类的内部结构：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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<Object> updateList;

public CacheKey() {
  this.hashcode = DEFAULT_HASHCODE;
  this.multiplier = DEFAULT_MULTIPLYER;
  this.count = 0;
  this.updateList = new ArrayList();
}

首先是成员变量和构造函数，有一个初始的hashCode和乘数，同时维护了一个内部的updateList。在CacheKey的update方法中，会进行一个hashCode和checkSum的计算，同时把传入的参数添加进updateList中，如下代码所示：

1
2
3
4
5
6
7
8
public void update(Object object) {
  int baseHashCode = object == null ? 1 : ArrayUtil.hashCode(object);
  ++this.count;
  this.checksum += (long)baseHashCode;
  baseHashCode *= this.count;
  this.hashcode = this.multiplier * this.hashcode + baseHashCode;
  this.updateList.add(object);
}

同时重写了CacheKey的equals方法，代码如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public boolean equals(Object object) {
  if (this == object) {
    return true;
  } else if (!(object instanceof CacheKey)) {
    return false;
  } else {
    CacheKey cacheKey = (CacheKey)object;
    if (this.hashcode != cacheKey.hashcode) {
      return false;
    } else if (this.checksum != cacheKey.checksum) {
      return false;
    } else if (this.count != cacheKey.count) {
      return false;
    } else {
      for(int i = 0; i < this.updateList.size(); ++i) {
        Object thisObject = this.updateList.get(i);
        Object thatObject = cacheKey.updateList.get(i);
        if (!ArrayUtil.equals(thisObject, thatObject)) {
          return false;
        }
      }

      return true;
    }
  }
}

除去hashCode、checksum和count的比较外，只要updatelist中的元素一一对应相等，那么就可以认为是CacheKey相等。只要两条SQL的下列五个值相同，即可以认为是相同的SQL

Statement Id + Offset + Limit + Sql + Params

BaseExecutor的query方法继续往下走，代码如下所示：

1
2
3
4
5
6
list = resultHandler == null ? (List)this.localCache.getObject(key) : null;
if (list != null) {
  this.handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
} else {
  list = this.queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
}

如果查不到的话，就从数据库查，在queryFromDataBase中，会对localCache进行写入

在query方法执行的最后，会判断一级缓存级别是否是STATEMENT级别，如果是的话，就清空缓存，这也就是STATEMENT级别的一级缓存无法共享localCache的原因。代码如下所示：

1
2
3
if (this.configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
  this.clearLocalCache();
}

在源码分析的最后，我们确认一下，如果是insert/delete/update方法，缓存就会刷新的原因

SqlSession的insert方法和delete方法，就会统一走update的流程，代码如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public int insert(String statement, Object parameter) {
  return this.update(statement, parameter);
}

public int delete(String statement, Object parameter) {
  return this.update(statement, parameter);
}

public int update(String statement, Object parameter) {
  int var4;
  try {
    this.dirty = true;
    MappedStatement ms = this.configuration.getMappedStatement(statement);
    var4 = this.executor.update(ms, this.wrapCollection(parameter));
  } catch (Exception var8) {
    throw ExceptionFactory.wrapException("Error updating database.  Cause: " + var8, var8);
  } finally {
    ErrorContext.instance().reset();
  }

  return var4;
}

update方法也是委托给了Executor执行。BaseExecutor的执行方法如下所示

1
2
3
4
5
6
7
8
9
public int update(MappedStatement ms, Object parameter) throws SQLException {
  ErrorContext.instance().resource(ms.getResource()).activity("executing an update").object(ms.getId());
  if (this.closed) {
    throw new ExecutorException("Executor was closed.");
  } else {
    this.clearLocalCache();
    return this.doUpdate(ms, parameter);
  }
}

每次执行update前都会清空localCache

至此，一级缓存的工作流程讲解以及源码分析完毕

总结

1、Mybatis一级缓存的生命周期和SqlSession一致

2、Mybatis一级缓存内部设计简单，只是一个没有容量限定的HashMap，在缓存的功能性上有所欠缺

3、Mybatis的一级缓存最大范围是SqlSession内部，有多个SqlSession或者分布式的环境下，数据库写操作会引起脏数据，建议设定缓存级别为Statement

二级缓存

二级缓存介绍

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

二级缓存开启后，同一个namespace下的所有操作语句，都影响着同一个Cache，即二级缓存被多个SqlSession共享，是一个全局的变量

当开启缓存后，数据的查询执行的流程就是 二级缓存 --> 一级缓存 --> 数据库

二级缓存配置

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

1、在Mybatis的配置文件中开启二级缓存

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

2、在Mybatis的映射XML中配置cache或者cache-ref

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

1
<cache/>
  • type：cache使用的类型，默认是PerpetualCache，这在一级缓存中提到过
  • eviction：定义回收的策略，常见的有FIFO、LRU
  • flushInterval：配置一定时间自动刷新缓存，单位是毫秒
  • size：最多缓存对象的个数
  • readOnly：是否只读，若配置可读写，则需要对应的实体类能够序列化
  • blocking：若缓存中找不到对应的key，是否会一直blocking，直到有对应的数据进入缓存

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

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

二级缓存实验

接下来我们通过实验，了解Mybatis二级缓存在使用上的一些特点

在本实验中，id为1的学生名称初始化为点点

实验1

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

1
2
3
4
5
6
7
8
9
10
11
@Test
public 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相同的查询是否会从缓存中获取数据

1
2
3
4
5
6
7
8
9
10
11
12
@Test
public 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下的二级缓存

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@Test
public 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的，多表查询语句所在的namespace无法感应到其他namespace中的语句对多表查询中涉及的表进行的修改，引发脏数据问题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@Test
public 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下的cache没有感应到变化，没有刷新缓存。当StudentMapper中同样的查询再次发起时，从缓存中读取了脏数据

实验5

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

执行结果：

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

四、二级缓存源码分析

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

源码分析

源码分析从CachingExecutor的query方法展开

CachingExecutor的query方法，首先会从MappedStatement中获得在配置初始化时赋予的Cache

1
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

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

1
this.flushCacheIfRequired(ms);

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

1
2
3
4
5
6
7
private void flushCacheIfRequired(MappedStatement ms) {
  Cache cache = ms.getCache();
  if (cache != null && ms.isFlushCacheRequired()) {
    this.tcm.clear(cache);
  }

}

Mybatis的CachingExecutor持有了TransactionalCacheManager，即上述代码中tcm

TransactionalCacheManager中持有了一个Map，代码如下所示：

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

这个Map保存了Cache和用TransactionalCache包装后的Cache的映射关系

TransactionalCache实现了Cache接口，CachingExecutor会默认使用它包装初始生成的Cache，作用是如果事务提交，对缓存的操作才会生效，对缓存的操作才会生效，如果事务回滚或者不提交事务，则不对缓存产生影响

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

1
2
3
4
public void clear() {
  this.clearOnCommit = true;
  this.entriesToAddOnCommit.clear();
}

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

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

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

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

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

1
2
3
4
5
6
7
8
public Object getObject(Object key) {
  Object object = this.delegate.getObject(key);
  if (object == null) {
    this.entriesMissedInCache.add(key);
  }

  return this.clearOnCommit ? null : object;
}

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

1
2
3
4
if (list == null) {
  list = this.delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
  this.tcm.putObject(cache, key, list);
}

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

1
2
3
public void putObject(Object key, Object object) {
  this.entriesToAddOnCommit.put(key, object);
}

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

1
2
3
4
5
6
7
8
9
10
11
public void commit(boolean force) {
  try {
    this.executor.commit(this.isCommitOrRollbackRequired(force));
    this.dirty = false;
  } catch (Exception var6) {
    throw ExceptionFactory.wrapException("Error committing transaction.  Cause: " + var6, var6);
  } finally {
    ErrorContext.instance().reset();
  }

}

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

1
2
3
4
public void commit(boolean required) throws SQLException {
  this.delegate.commit(required);
  this.tcm.commit();
}

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

1
2
3
4
5
6
7
8
public void commit() {
  if (this.clearOnCommit) {
    this.delegate.clear();
  }

  this.flushPendingEntries();
  this.reset();
}

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
private void flushPendingEntries() {
  Iterator var1 = this.entriesToAddOnCommit.entrySet().iterator();

  while(var1.hasNext()) {
    Entry<Object, Object> entry = (Entry)var1.next();
    this.delegate.putObject(entry.getKey(), entry.getValue());
  }

  var1 = this.entriesMissedInCache.iterator();

  while(var1.hasNext()) {
    Object entry = var1.next();
    if (!this.entriesToAddOnCommit.containsKey(entry)) {
      this.delegate.putObject(entry, (Object)null);
    }
  }

}

在flushPendingEntries中，将待提交的Map进行循环处理，委托给包装的Cache类，进行putObject的操作

后续的查询操作会重复执行这套流程。如果是insert|update|delete的话，会统一进入CachingExecutor的update方法，其中调用了这个函数。代码如下所示：

1
2
3
4
5
6
7
private void flushCacheIfRequired(MappedStatement ms) {
  Cache cache = ms.getCache();
  if (cache != null && ms.isFlushCacheRequired()) {
    this.tcm.clear(cache);
  }

}

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

总结

  1. Mybatis的二级缓存相对于一级缓存来说，实现了SqlSession之间缓存数据的共享，同时粒度更加的细，能够到namespace级别，通过Cache接口实现不同的组合，对Cache的可控性也更强
  2. Mybatis在多表查询中，极大可能出现脏数据，有设计上的缺陷，安全使用二级缓存的条件比较苛刻
  3. 在分布式环境下，由于默认的Mybatis Cache实现都是基于本地的，分布式环境下必然出现读取到脏数据，需要使用集中式缓存将Mybatis的Cache接口实现，有一定的开发成本，直接使用Redis、Memcached等分布式存储可能成本更低，安全性也更高
Author: Toyan
Link: https://toyan.top/mybatis-cache/
Copyright Notice: All articles in this blog are licensed under CC BY-NC-SA 4.0 unless stating additionally.
Mybatis
支付宝打赏
微信打赏