了解过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接口的注释： ~~~java /** * 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的接口定义： ~~~java 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`，所以一级缓存也叫本地缓存。初始化代码如下所示： ~~~java 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两个方法，大家可以对照流程图及代码过一下： ~~~java 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方法来清空缓存。代码如下所示： ~~~java 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。 ~~~xml <setting name="cacheEnabled" value="true"/> 复制代码 ~~~ * 在mapper配置文件中增加节点。 ~~~xml <!--默认情况下，这一行就可以--> <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方法读取配置并初始化配置信息，若未配置属性会采用默认值。 ~~~java 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对象。 ~~~java 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方法完成了缓存的查询与添加操作，具体过程可查看如下代码。 ~~~java @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源码： ~~~java @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源码： ~~~java //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的缓存机制，主要在于了解其运行原理，虽然在实际工作中不会使用，但是某些参数或特性可能会影响我们应用的运行效果，了解其原理重点在于避坑。另外，其缓存原理也可以为我们实际开发工作提供一些好的思路。 作者：码路印记 链接：https://juejin.cn/post/6908703314867650567 来源：掘金 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。