mybatis 缓存机制

mybatis支持一、二级缓存来提高查询效率,能够正确的使用缓存的前提是熟悉mybatis的缓存实现原理;

众所周知,mybatis的sqlSession封装了对数据库的增删改查操作,但是每个SqlSession持有各自的Executor,真正的操作是委托给Executor操作的,而缓存功能也同样是交给了Executor实现;

Executor和缓存

下面看一段Configuration类创建执行器的代码:

public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
    executorType = executorType == null ? defaultExecutorType : executorType;
    executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
    Executor 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装饰
    //cacheEnabled实际上是二级缓存开关,默认也是开启的
    //只是二级缓存需要额外的配置所有并不生效
    if (cacheEnabled) {
      executor = new CachingExecutor(executor);
    }
    executor = (Executor) interceptorChain.pluginAll(executor);
    return executor;
  }

mybatis可选配置的执行器有三种,分别是SimpleExecutor、ReuseExecutor和BatchExecutor,默认是SimpleExecutor;除此之外还有一个重要的执行器是CachingExecutor,根据名称即可推断它与缓存是相关的;看类图:

我们发现BaseExecutor和CachingExecutor实现了Executor接口,BaseExecutor是一个抽象类,它有三个子类(实际上还有一个ClosedExecutor)

一级缓存

mybatis一级缓存是在BaseExecutor中实现的,也相当于一级缓存是默认开启的;Cache对象是在BaseExecutor构造方法中创建的,因此一个Executor对应一个locaCache,下面看一下BaseExecutor中的query方法:

 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++;
      //从一级缓存中取缓存(我们通常的查询中是不需要resultHandler的)
      list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
      if (list != null) {
        //handleLocallyCachedOutputParameters这个只对存储过程有效
        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();
      }
      deferredLoads.clear(); // issue #601
      //如果一级缓存的范围是statement级别,则每次查询都清空一级缓存
      if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
        clearLocalCache(); // issue #482
      }
    }
    return list;
  }

因此,在不考虑二级缓存的情况下,每次查询都从一级缓存中取,如果没有命中缓存,则从数据库查询,并将查询结果加入缓存;这只是一级缓存的存取,接下来还要知道缓存何时失效。

其实我们可以推测一下,如果数据库更新了,但是缓存并没有失效,那么缓存的数据就成了脏数据,所以缓存失效肯定和更新操作有关,但是这个更新就有范围了,是更新操作清除所有缓存(全局)?还是同一个SQLSession的更新操作清除当前SQLSession的缓存呢?

通过文档和源码我们知道LocalCacheScope有两个级别,分别是statement和session;从query方法已经知道statement级别每次查询都清除缓存,这也是一级缓存默认的级别;

那么session级别呢?

下面看BaseExecutor的update方法(SqlSesssion的insert、update、delete操作最后都会执行此方法):

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);
  }

可以看到如果是session级别,在update操作的时候清除缓存;但是有两点要注意:

一、为什么叫做session级别?

同一个SqlSession持有同一个Executor,同一个Executor持有同一个LocalCache,clearLocalCache操作只是清除当前executor的本地缓存,因此session级别的缓存就是对同一个SqlSession生效。

二、缓存失效的时机

可以看到清除缓存是在doUpdate(真正的更新操作)操作之前执行的,也就是说doUpdate执行成功或失败、提交或者回滚 缓存都会失效;

小结

  • MyBatis一级缓存使用没有容量限制的HashMap,比较简陋;
  • statement级别的缓存每一次查询后清除;
  • session级别缓存在同一个SqlSession的insert、update、delete操作之前清除;
  • MyBatis的一级缓存最大是同一个SqlSession,在多个SqlSession环境下就会出现数据修改后缓存无法及时失效的情况产生脏数据;

二级缓存

前面我们知道二级缓存开启后Executor会使用CachingExecutor装饰;那就来看看它的query方法:

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) {
      //是否立即清除缓存,这个是statement标签中flushCache属性控制的,select标签默认false,其它标签默认true;
      flushCacheIfRequired(ms);
      if (ms.isUseCache() && resultHandler == null) {
        //关于存储过程暂不考虑
        //isUseCache()的值是statement标签中useCache配置的,默认为true
        ensureNoOutParams(ms, parameterObject, boundSql);
        @SuppressWarnings("unchecked")
        //从二级缓存获取
        List<E> list = (List<E>) tcm.getObject(cache, key);
        if (list == null) {
          list = delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
          tcm.putObject(cache, key, list); // issue #578. Query must be not synchronized to prevent deadlocks
        }
        return list;
      }
    }
    return delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
  }

这里从查询缓存和加入缓存用的是tcm(TransactionalCacheManager)的getObject和putObject方法,稍稍看一下这个类:

  public class TransactionalCacheManager {
  //维护TransactionalCache 和 Cache 一对一的这样一个映射关系
  private Map<Cache, TransactionalCache> transactionalCaches = new HashMap<Cache, TransactionalCache>();
  //清除缓存
  public void clear(Cache cache) {
    getTransactionalCache(cache).clear();
  }
  //从缓存获取结果
  public Object getObject(Cache cache, CacheKey key) {
    return getTransactionalCache(cache).getObject(key);
  }
  //加入缓存(真正加入还要等commit)
  public void putObject(Cache cache, CacheKey key, Object value) {
    getTransactionalCache(cache).putObject(key, value);
  }
   //省略一部分
   。。。。。。。

  private TransactionalCache getTransactionalCache(Cache cache) {
    TransactionalCache txCache = transactionalCaches.get(cache);
    if (txCache == null) {
      //使用TransactionalCache装饰Cache
      txCache = new TransactionalCache(cache);
      transactionalCaches.put(cache, txCache);
    }
    return txCache;
  }

}

这里我们只需要知道关于缓存的操作最终还是委托给Cache类的,其它的暂不深入,回到CacheExecutor类,Cache对象是从MappedStatement(对应就是select、update等sql标签)中获取的,而Cache也不是在MappedStatement中创建的,但是我们知道mybatis的namespace中关于缓存有如下两个标签:

//表示此namespace要使用二级缓存
<cache/>
属性
type:cache使用的类型,默认是PerpetualCache;
eviction: 缓存策略,常见的有FIFO,LRU;
flushInterval: 自动刷新缓存时间间隔,单位是毫秒。
size: 缓存的对象数量最大值。
readOnly: 是否只读,false时需要实现Serializable接口,默认false。
blocking: 若缓存中找不到对应的key,是否会一直blocking,直到有对应的数据进入缓存。
//引用其它namespace的缓存
<cache-ref namespace="mapper.StudentMapper"/>

可以猜测,Cache的创建在解析namespace标签之后,所以从XmlConfigBuilder(解析配置文件的关键类)一路找到XMLMapperBuilder(根据名称就知道是解析mapper相关的配置也就是namespace标签下的内容):

 //创建缓存对象 
  private void cacheElement(XNode context) throws Exception {
    if (context != null) {
      //获取<cache/>标签配置
      ....
      //创建Cache对象
      builderAssistant.useNewCache(typeClass, evictionClass, flushInterval, size, readWrite, props);
    }
  }

接着看builderAssistant的useNewCache方法:

public Cache useNewCache(Class<? extends Cache> typeClass,
     Class<? extends Cache> evictionClass,
     Long flushInterval,
     Integer size,
     boolean readWrite,
     Properties props) {
   typeClass = valueOrDefault(typeClass, PerpetualCache.class);
   evictionClass = valueOrDefault(evictionClass, LruCache.class);
   //将namespace作为Cache的id
   Cache cache = new CacheBuilder(currentNamespace)
       .implementation(typeClass)
       .addDecorator(evictionClass)
       .clearInterval(flushInterval)
       .size(size)
       .readWrite(readWrite)
       .properties(props)
       .build();
   //将Cache放入Configuration中
   //Configuration中维护一个Map,键是Cache的id也就是namespace
   configuration.addCache(cache);
   currentCache = cache;
   return cache;
 }

这里我们知道解析namespace的cache标签马上会为此namespace创建一个Cache对象;那么cache-ref标签呢?同样是XMLMapperBuilder类:

private void cacheRefElement(XNode context) {
    if (context != null) {
      configuration.addCacheRef(builderAssistant.getCurrentNamespace(), context.getStringAttribute("namespace"));
      CacheRefResolver cacheRefResolver = new CacheRefResolver(builderAssistant, context.getStringAttribute("namespace"));
      try {
          cacheRefResolver.resolveCacheRef();
      } catch (IncompleteElementException e) {
          configuration.addIncompleteCacheRef(cacheRefResolver);
      }
    }
  }

Configuration类有一个map保存的是cache-ref标签声明的引用关系,CacheRefResolver就是去获取引用的namespace的Cache对象,这时如果引用的Cache还没有创建怎么办?

mybatis是将它放在了IncompleteCacheRef的集合中,最后再去重新去处理引用;到这里我们知道了Cache的创建,但是我还记得CacheExecutor中的Cache是从MappedStatement中取的啊!

那是因为XMLStatementBuilder在创建namespace下的MappedStatement时候就将XMLMapperBuilder中创建的Cache注入其中了,因此同一个namespace下的MappedStatement持有的是同一个Cache对象,如果namespace之间是引用关系,那么也是同一个Cache对象;到这里已经弄清楚了MappedStatement中Cache的来历;

再回到CachingExecutor中的清除缓存的方法:

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

ms.isFlushCacheRequired()的值是statement标签中flushCache属性控制的,select标签默认false,其它标签默认true;

这里clear方法并没有清除缓存,而是设置了一个标志位 clearOnCommit = true;顾名思义在提交的时候清除;除此之外,tcm(TransactionalCacheManager)的put和remove操作也只是将动作临时存放在map中,commit 的时候才真正执行:

public void commit() {
    if (clearOnCommit) {
      //清除缓存    
      delegate.clear();
    } else {
      //执行暂存的操作
      for (RemoveEntry entry : entriesToRemoveOnCommit.values()) {
        entry.commit();
      }
    }
    for (AddEntry entry : entriesToAddOnCommit.values()) {
      entry.commit();
    }
    reset();
  }
 //rollback重置,不对缓存操作
 public void rollback() {
    reset();
  }

再简单说一下关于Cache接口:

Cache的设计使用了装饰器模式,基本的装饰链是:

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

具体的过程可以去看CacheBuilder类的build方法;mybatis默认的cache标签type属性是PerpetualCache、eviction是lru,如果要自定义缓存只需要实现Cache接口,并做相应配置即可;

小结

1. 二级缓存的有效范围是namespace,缓存的加载和失效均在事务提交之后生效,使用cache-ref标签可以实现多个namespace共享缓存;

2. 二级缓存可以根据statement标签的useCache和flushCache 细粒度的控制是否需要使用缓存和强制刷新缓存

3. 二级缓存的实现相对于一级缓存有明显增强,但是依然是本地实现,解决了多个SqlSession共享缓存的问题,但是仍然无法应用于分布式环境;

4. 由于是基于namespace的缓存,如果存在多表查询,可能存在数据更新之后此namespace下的缓存还没有失效,也会产生脏数据;

总的来说,如果不熟悉mybatis的缓存机制,最好是使用第三方缓存。

本文分享自微信公众号 - 一个优秀的废人(feiren_java),作者:一个优秀的废人

原文出处及转载信息见文内详细说明,如有侵权,请联系 yunjia_community@tencent.com 删除。

原始发表时间:2019-06-27

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • 聊聊 mybatis 的缓存机制

    mybatis支持一、二级缓存来提高查询效率,能够正确的使用缓存的前提是熟悉mybatis的缓存实现原理;

    一个优秀的废人
  • 为什么我们做分布式使用Redis?

    绝大部分写业务的程序员,在实际开发中使用 Redis 的时候,只会 Set Value 和 Get Value 两个操作,对 Redis 整体缺乏一个认知。这里...

    一个优秀的废人
  • 为什么我们做分布式使用 Redis ?

    绝大部分写业务的程序员,在实际开发中使用 Redis 的时候,只会 Set Value 和 Get Value 两个操作,对 Redis 整体缺乏一个认知。这里...

    一个优秀的废人
  • 聊聊 mybatis 的缓存机制

    mybatis支持一、二级缓存来提高查询效率,能够正确的使用缓存的前提是熟悉mybatis的缓存实现原理;

    一个优秀的废人
  • 浏览器缓存是嘛?

    浏览器的缓存这个东西,我是又爱又恨。爱的是它可以存一些东西在客户端节省资源、提高效率;恨的是你在缓存有时会造成用户那边的信息不更新,你这些修改了,那边收不到。尤...

    web前端教室
  • mybatis 详解(九)------ 一级缓存、二级缓存

      上一章节,我们讲解了通过mybatis的懒加载来提高查询效率,那么除了懒加载,还有什么方法能提高查询效率呢?这就是我们本章讲的缓存。   本篇源码下载链接:...

    IT可乐
  • 什么技能产品经理不会提,但技术人必须懂?

    简介: 缓存是搭建高性能高并发系统的必备手段之一,通常用来解决性能瓶颈,是程序员的必备知识点,也是面试必备考点。

    菜鸟学院
  • [CodeIgniter4]-网页缓存

    尽管 CodeIgniter 已经相当高效了,但是网页中的动态内容、主机的内存 CPU 和数据库读取速度等因素直接影响了网页的加载速度。 依靠网页缓存, 你的网...

    landv
  • 缓存穿透、缓存并发、缓存失效之思路变迁

    来源:https://www.jianshu.com/p/d96906140199

    芋道源码
  • 高并发场景下缓存处理的一些思路

    在实际的开发当中,我们经常需要进行磁盘数据的读取和搜索,因此经常会有出现从数据库读取数据的场景出现。但是当数据访问量次数增大的时候,过多的磁盘读取可能会最终成为...

    好好学java

扫码关注云+社区

领取腾讯云代金券