公众号搜索“码路印记”，点关注不迷路！
了解过Mybatis的同学，大概都知道Mybatis有一级缓存和二级缓存；但是我们使用Mybatis时一般使用默认的配置，对缓存的原理知之甚少。之前介绍Executor的文章中提到了Mybatis缓存相关的内容，但是比较琐碎，不成体系。
今天通过这篇文章对Mybatis的缓存机制做下详细解读，对一级缓存、二级缓存的执行流程、工作原理有个全面的认识，方便开发过程中合理使用。
还是先通过一个“全景图”对Mybatis的缓存机制有个整体了解，然后结合整体流程，对每个环节逐个剖析。如图所示，Mybatis一级缓存是在BaseExecutor中实现，并且一级缓存仅在SqlSession生命周期内有效；二级缓存是在CachingExecutor实现，二级缓存是在namespace维度且全局共享。
若一二级缓存同时开启，当执行查询时：Mybatis先查询二级缓存；如果二级缓存未命中，则继续查询一级缓存；若一级缓存未命中，则查询数据库并更新一二级缓存。默认情况下，一级缓存是开启的，而且没有办法关闭；二级缓存默认关闭。大体了解Mybatis缓存机制后，我们逐个了解一下一二级缓存分别是怎么实现的。
一级缓存
先来看下比较简单的一级缓存。Mybatis一级缓存在BaseExecutor中实现，使用Cache接口实现类PerpetualCache作为缓存存储的容器，通过源码可知其内部就是一个HashMap。这就跟我们平时自己做K-V存储或者使用Redis做缓存的思路类似。那么，我们自然而然的需要弄清楚以下几个问题：
- Mybatis是如何写缓存、何时写缓存？
- Mybatis如何读缓存、何时读缓存？
- Mybatis何时使缓存失效，缓存失效采用了什么策略？
- Cache接口及实现类提供了哪些接口方法，Mybatis是如何使用它们的？
- 一级缓存是应用内的本地缓存，在分布式场景下会不会导致脏读等不一致问题？该如何解决？
呃，好像问题挺多的！前面三个是缓存的使用问题，第四个是源码层面的，最后一个是结合一级缓存特点如何使用的问题。带着这几个问题，我们进入正题。
Cache接口及PerpetualCache
Cache接口位于org.apache.ibatis.cache包下，是Mybatis实现缓存的核心接口，Mybatis一级、二级缓存的都依赖于它，通过下面的类图简单了解一下继承关系，以体现Cache的重要地位：
一级缓存仅用到了PerpetualCache，所以这个阶段我们先通过源码认识Cache接口及PerpetualCache实现。先看下Cache接口的注释：
/**
* SPI for cache providers.
* One instance of cache will be created for each namespace.
* The cache implementation must have a constructor that receives the cache id as an String parameter.
* MyBatis will pass the namespace as id to the constructor.
*
* <pre>
* public MyCache(final String id) {
* if (id == null) {
* throw new IllegalArgumentException("Cache instances require an ID");
* }
* this.id = id;
* initialize();
* }
* </pre>
*
* @author Clinton Begin
*/
作者Clinton Begin说，Cache接口定义了Mybatis cache体系的SPI，任何一个cache实例都是为namespace创建的，并且通过示例要求每个Cache接口实现类应该通过构造方法接收namespace作为cache的id作为唯一标识。这也就是说，每个Cache实例都是有唯一标识的（id）。再来看下Cache的接口定义：
public interface Cache {
/**
* 获取缓存的唯一标识
* @return The identifier of this cache
*/
String getId();
/**
* 向缓存中添加内容，这里的key使用了CacheKey这个类
*
* @param key Can be any object but usually it is a {@link CacheKey}
* @param value The result of a select.
*/
void putObject(Object key, Object value);
/**
* 根据key从缓存中查询
* @param key The key
* @return The object stored in the cache.
*/
Object getObject(Object key);
/**
* 从缓存中移除key对应的内容
*
* @param key The key
* @return Not used
*/
Object removeObject(Object key);
/**
* Clears this cache instance，清空缓存
*/
void clear();
}
Cache接口很少，它提供了对缓存添加、查询、删除、清空的基本操作方法，其中添加、查询、删除都需要使用类型为CacheKey的key来操作。CacheKey是Mybatis用来生成缓存索引的工具类，通过一定的规则来确保散列的鲁棒性。再看PerpetualCache，刚才也提到，它使用HashMap作为缓存的存储容器，再结合Cache接口定义的方法我们自然就可以知道它是对HashMap元素的操作了，节省篇幅，代码就不再贴了。
缓存管理
一级缓存管理涉及PerpetualCache创建、查询缓存、添加缓存、清空缓存几个过程，除了缓存创建外，其他几个过程都是由Executor的update/query/commit/rollback等方法执行时触发。
缓存创建
PerpetualCache的初始化工作在BaseExecutor构造方法中完成，并指定id为LocalCache，所以一级缓存也叫本地缓存。初始化代码如下所示：
protected BaseExecutor(Configuration configuration, Transaction transaction) {
this.transaction = transaction;
this.deferredLoads = new ConcurrentLinkedQueue<>();
// 缓存初始化
this.localCache = new PerpetualCache("LocalCache");
this.localOutputParameterCache = new PerpetualCache("LocalOutputParameterCache");
this.closed = false;
this.configuration = configuration;
this.wrapper = this;
}
缓存查询与添加
缓存的目的是为了提高查询效率，所以查询缓存必然是在BaseExecutor#query触发。如果查询过程中命中缓存，可直接把缓存内容返回；如果未命中，则需要从数据库中查询，然后再把数据库查询结果添加到缓存中，以保证下次的查询效率。查询过程中的缓存管理流程如下图所示：
以上流程分别涉及了BaseExecutor#query()、BaseExecutor#queryFromDatabase两个方法，大家可以对照流程图及代码过一下：
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
if (closed) {
throw new ExecutorException("Executor was closed.");
}
if (queryStack == 0 && ms.isFlushCacheRequired()) {
clearLocalCache();
}
List<E> list;
try {
queryStack++;
// 检查是否命中缓存，如果命中则取出结果
list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
if (list != null) {
handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
} else {
//未命中时，调用方法查询数据库
list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
}
} finally {
queryStack--;
}
if (queryStack == 0) {
for (DeferredLoad deferredLoad : deferredLoads) {
deferredLoad.load();
}
// issue #601
deferredLoads.clear();
// 如果本地缓存（一级缓存）的作用范围是STATEMENT，则清空缓存
if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
// issue #482
clearLocalCache();
}
}
return list;
}
private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
List<E> list;
//通过占位符预占缓存
localCache.putObject(key, EXECUTION_PLACEHOLDER);
try {
// 查询数据库
list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
} finally {
// 移除占位符
localCache.removeObject(key);
}
// 把数据库查询结果添加到缓存中
localCache.putObject(key, list);
if (ms.getStatementType() == StatementType.CALLABLE) {
localOutputParameterCache.putObject(key, parameter);
}
return list;
}
清空缓存
当数据源发生改变时，为了保证数据一致性，清空缓存中的失效数据，从而保证再次查询时从数据库加载最新数据。所以，引起数据源变更的操作即为清空缓存的时机。
从BaseExecutor的接口来看，update、commit、rollback等方法都会导致数据源的变更，通过源码来看，这些方法内部确实调用了clearLocalCache方法来清空缓存。代码如下所示：
public int update(MappedStatement ms, Object parameter) throws SQLException {
ErrorContext.instance().resource(ms.getResource()).activity("executing an update").object(ms.getId());
if (closed) {
throw new ExecutorException("Executor was closed.");
}
clearLocalCache();
return doUpdate(ms, parameter);
}
public void commit(boolean required) throws SQLException {
if (closed) {
throw new ExecutorException("Cannot commit, transaction is already closed");
}
clearLocalCache();
flushStatements();
if (required) {
transaction.commit();
}
}
public void rollback(boolean required) throws SQLException {
if (!closed) {
try {
clearLocalCache();
flushStatements(true);
} finally {
if (required) {
transaction.rollback();
}
}
}
}
public void clearLocalCache() {
if (!closed) {
localCache.clear();
localOutputParameterCache.clear();
}
}
这里需要注意的是：在update方法中，如果本地缓存（一级缓存）的作用范围是STATEMENT，则也会调用方法clearLocalCache来清空缓存。
一级缓存总结
生命周期
在之前的文章中我们已经了解到，Executor被SqlSession持有，而一级缓存LocalCache只是BaseExecutor的一个字段。所以，当SqlSession的生命周期结束时，一级缓存也会被回收。也就是说，一级缓存仅能作用于同一个SqlSession的声明周期，不同SqlSession间不可共享。它们之间的关系如下图所示：
分布式系统如何避免数据不一致
既然一级缓存仅可在SqlSession内部共享，那么如果同时存在多个SqlSession或者分布式的环境下，update、commit等引起缓存失效的方法无法对其他SqlSession起作用，必然会带来脏读问题。这个问题可以通过更改一级缓存的作用范围（localCacheScope）为STATEMENT进行避免。
缓存读写时机与原理
一级缓存由PerpetualCache实现，其内部通过HashMap完成对缓存的读写操作，所以本质上讲，一级缓存其实是通过HashMap实现的，Map中的key是由MappedStatement生成CacheKey，来确保查询的唯一性。
一级缓存是为了提高查询效率，在执行query操作前会先查询缓存：若命中缓存，则直接把缓存内容作为结果返回，不再查询数据库；若未命中缓存，则执行数据库查询，然后把查询结果加入缓存内，最终返回结果。
二级缓存
一级缓存生命周期仅限于SqlSession，然而实际使用时我们创建多个SqlSession对象，但是多个SqlSession之间无法共享缓存内容。为了解决这个问题，我们可以使用二级缓存。二级缓存由CachingExecutor实现，作用在一级缓存之前。开启二级缓存后，Executor的查询流程变为：二级缓存->一级缓存->数据库。
启用二级缓存
启用二级缓存，需要依次完成以下几个配置：
- 在Mybatis配置文件中配置cacheEnabled 设置（settings）：全局性地开启或关闭所有映射器配置文件中已配置的任何缓存，默认值为true。
<setting name="cacheEnabled" value="true"/>
- 在mapper配置文件中增加节点。
<!--默认情况下，这一行就可以-->
<cache/>
这样会使用默认的缓存策略，cache节点有如下几个属性可以设置：
- eviction：清除策略。支持LRU（最近最少使用，默认）、FIFO（先进先出）、SOFT、WEAK。
- flushInterval：刷新间隔。可以被设置为任意的正整数，设置的值应该是一个以毫秒为单位的合理时间量。 默认情况是不设置，也就是没有刷新间隔，缓存仅仅会在调用语句时刷新。
- size：缓存数量，默认值是 1024。可以被设置为任意正整数，要注意欲缓存对象的大小和运行环境中可用的内存资源。
- readOnly（只读）属性可以被设置为 true 或 false。只读的缓存会给所有调用者返回缓存对象的相同实例。 因此这些对象不能被修改。这就提供了可观的性能提升。而可读写的缓存会（通过序列化）返回缓存对象的拷贝。 速度上会慢一些，但是更安全，因此默认值是 false。
默认情况下（如上配置）起到的效果如下：
- 映射语句文件中的所有 select 语句的结果将会被缓存。
- 映射语句文件中的所有 insert、update 和 delete 语句会刷新缓存。
- 缓存会使用最近最少使用算法（LRU, Least Recently Used）算法来清除不需要的缓存。
- 缓存不会定时进行刷新（也就是说，没有刷新间隔）。
- 缓存会保存列表或对象（无论查询方法返回哪种）的 1024 个引用。
- 缓存会被视为读/写缓存，这意味着获取到的对象并不是共享的，可以安全地被调用者修改，而不干扰其他调用者或线程所做的潜在修改。
二级缓存初始化
二级缓存初始化是在mapper对应的xml文件解析时执行的，可以按照以下链路查询解析流程，其中cacheElement方法读取了并为配置信息赋值为默认值，然后调用MapperBuilderAssistant#useNewCache初始化二级缓存对象。
- org.apache.ibatis.session.SqlSessionFactoryBuilder#build(java.io.InputStream, java.lang.String, java.util.Properties)
- org.apache.ibatis.builder.xml.XMLConfigBuilder#parse
- org.apache.ibatis.builder.xml.XMLConfigBuilder#parseConfiguration
- org.apache.ibatis.builder.xml.XMLConfigBuilder#mapperElement
- org.apache.ibatis.builder.xml.XMLMapperBuilder#parse
- org.apache.ibatis.builder.xml.XMLMapperBuilder#configurationElement
- org.apache.ibatis.builder.xml.XMLMapperBuilder#cacheElement
- org.apache.ibatis.builder.MapperBuilderAssistant#useNewCache
cacheElement方法读取配置并初始化配置信息，若未配置属性会采用默认值。
private void cacheElement(XNode context) {
if (context != null) {
// 读取缓存类型，默认为PERPETUAL
String type = context.getStringAttribute("type", "PERPETUAL");
Class<? extends Cache> typeClass = typeAliasRegistry.resolveAlias(type);
// 读取数据淘汰策略并获取其类型，默认为LRU，默认大小1024
String eviction = context.getStringAttribute("eviction", "LRU");
Class<? extends Cache> evictionClass = typeAliasRegistry.resolveAlias(eviction);
// 刷新间隔，默认为空，即不会刷新。
Long flushInterval = context.getLongAttribute("flushInterval");
// 缓存数量：默认为空，会使用LRU的默认大小1024
Integer size = context.getIntAttribute("size");
boolean readWrite = !context.getBooleanAttribute("readOnly", false);
boolean blocking = context.getBooleanAttribute("blocking", false);
Properties props = context.getChildrenAsProperties();
// 初始化缓存对象
builderAssistant.useNewCache(typeClass, evictionClass, flushInterval, size, readWrite, blocking, props);
}
}
useNewCache方法：依次创建缓存对象PerpetualCache，添加数据淘汰策略（装饰器），设置刷新间隔，设置缓存大小……，这一系列操作采用装饰器模式进行装配，最终得到的是一个层层嵌套的Cache对象。
public Cache useNewCache(Class<? extends Cache> typeClass,
Class<? extends Cache> evictionClass,
Long flushInterval,
Integer size,
boolean readWrite,
boolean blocking,
Properties props) {
Cache cache = new CacheBuilder(currentNamespace)
.implementation(valueOrDefault(typeClass, PerpetualCache.class))
.addDecorator(valueOrDefault(evictionClass, LruCache.class))
.clearInterval(flushInterval)
.size(size)
.readWrite(readWrite)
.blocking(blocking)
.properties(props)
.build();
configuration.addCache(cache);
currentCache = cache;
return cache;
}
Cache初始化时，使用currentNamespace（即：mapper文件的namespace）作为Cache的id，最终把该缓存对象存储在全局缓存Configuration中，以此实现了跨Session共享。
缓存使用
如前文所述，二级缓存在CachingExecutor中生效。查看org.apache.ibatis.executor.CachingExecutor#query方法可知，其执行流程如下：
- 根据MappedStatement、parameterObject等信息生成CacheKey；
- 获取MappedStatement中缓存的Cache对象；
- 通过TransactionalCacheManager尝试获取缓存数据：若缓存命中，则直接返回；若缓存未命中，则执行后续查询并把结果缓存在TransactionalCacheManager中。
query方法完成了缓存的查询与添加操作，具体过程可查看如下代码。
@Override
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
throws SQLException {
Cache cache = ms.getCache();
if (cache != null) {
flushCacheIfRequired(ms);
if (ms.isUseCache() && resultHandler == null) {
ensureNoOutParams(ms, boundSql);
@SuppressWarnings("unchecked")
List<E> list = (List<E>) tcm.getObject(cache, key);
if (list == null) {
list = delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
tcm.putObject(cache, key, list); // issue #578 and #116
}
return list;
}
}
return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}
缓存失效
为了避免脏读，当CachingExecutor执行update、commit、rollback等操作时，会执行缓存的删除或清空重置操作。
update源码：
@Override
public int update(MappedStatement ms, Object parameterObject) throws SQLException {
flushCacheIfRequired(ms);
return delegate.update(ms, parameterObject);
}
private void flushCacheIfRequired(MappedStatement ms) {
Cache cache = ms.getCache();
if (cache != null && ms.isFlushCacheRequired()) {
tcm.clear(cache);
}
}
commit源码：
//org.apache.ibatis.executor.CachingExecutor#commit
@Override
public void commit(boolean required) throws SQLException {
delegate.commit(required);
tcm.commit();
}
//org.apache.ibatis.executor.CachingExecutor#rollback
@Override
public void rollback(boolean required) throws SQLException {
try {
delegate.rollback(required);
} finally {
if (required) {
tcm.rollback();
}
}
}
//org.apache.ibatis.cache.TransactionalCacheManager#commit
public void commit() {
for (TransactionalCache txCache : transactionalCaches.values()) {
txCache.commit();
}
}
//org.apache.ibatis.cache.decorators.TransactionalCache#commit
public void commit() {
if (clearOnCommit) {
delegate.clear();
}
flushPendingEntries();
reset();
}
private void reset() {
clearOnCommit = false;
entriesToAddOnCommit.clear();
entriesMissedInCache.clear();
}
二级缓存总结
MyBatis的二级缓存相对于一级缓存来说，实现了SqlSession之间缓存数据的共享，同时粒度更加的细，能够到namespace级别，通过Cache接口实现类不同的组合，对Cache的可控性也更强。
在分布式环境下，由于默认的MyBatis Cache实现都是基于本地的，分布式环境下必然会出现读取到脏数据，需要使用集中式缓存将MyBatis的Cache接口实现，有一定的开发成本，直接使用Redis、Memcached等分布式缓存可能成本更低，安全性也更高。
全文总结
本文简单梳理了mybatis的缓存机制，主要在于了解其运行原理，虽然在实际工作中不会使用，但是某些参数或特性可能会影响我们应用的运行效果，了解其原理重点在于避坑。另外，其缓存原理也可以为我们实际开发工作提供一些好的思路。
公众号搜索“码路印记”，点关注不迷路！
