了解过Mybatis的同学,大概都知道Mybatis有一级缓存和二级缓存;但是我们使用Mybatis时一般使用默认的配置,对缓存的原理知之甚少。之前介绍Executor的文章中提到了Mybatis缓存相关的内容,但是比较琐碎,不成体系。 今天通过这篇文章对Mybatis的缓存机制做下详细解读,对一级缓存、二级缓存的执行流程、工作原理有个全面的认识,方便开发过程中合理使用。 ![image.png](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/76827989df754f16804d217e0ee00191~tplv-k3u1fbpfcp-zoom-1.image) 还是先通过一个“全景图”对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的重要地位: ![image.png](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/285015ab9d3e41468c802e5782dcd901~tplv-k3u1fbpfcp-zoom-1.image) 一级缓存仅用到了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触发。如果查询过程中命中缓存,可直接把缓存内容返回;如果未命中,则需要从数据库中查询,然后再把数据库查询结果添加到缓存中,以保证下次的查询效率。查询过程中的缓存管理流程如下图所示: ![image.png](data:image/svg+xml;utf8,) 以上流程分别涉及了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间不可共享。它们之间的关系如下图所示: ![image.png](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/f616507473e441699b4f0d04e4403c8e~tplv-k3u1fbpfcp-zoom-1.image) #### 分布式系统如何避免数据不一致 既然一级缓存仅可在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 来源:掘金 著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。