MyBatis|缓存机制


1. MyBatis缓存

1.1 缓存介绍

就是将用户经常查询的数据的结果的一个保存,保存到一个内存中(缓存就是内存中的一个对象),用户在查询的时候就不用到数据库文件中查询(磁盘),从而减少与数据库的交付次数提高了响应速度,解决了并发系统的西能问题。

1.2 MyBatis缓存分类

MyBatis提供了一级缓存和二级缓存

  • 一级缓存:也称为本地缓存,用于保存用户在一次会话过程中查询的结果,用户一次会话中只能使用一个sqlSession,一级缓存是自动开启的,不允许关闭。
  • 二级缓存:也称为全局缓存,是mapper级别的缓存,是针对一个表的查结果的存储,可以共享给所有针对这张表的查询的用户。也就是说对于mapper级别的缓存不同的sqlsession是可以共享的。

1.3 什么是会话

会话就是一次完整的交流,再一次交流过程中包含多次请求响应,而发送的请求都是同一个用户,SqlSession就是用户与数据库进行一次会话过程中使用的接口。

2. MyBatis一级缓存

2.1 一级缓存介绍

在应用运行过程中,在一次数据库会话中,执行多次查询条件完全相同的SQL,会优先命中一级缓存,避免直接对数据库中直接查询。



每个SqlSession中都持有Excutor,每个Excutor中有一个LocalCache。当用户发起询问时,MyBatis根据当前执行的语句生成MappedStatement,在Local Cache进行查询,如果缓存命中的话,直接返回结果给用户,如果缓存没有命中的话,查询数据库,结果写入Local Cache,最后返回结果给用户。


2.2 源码分析

SqlSession: 对外提供了用户和数据库之间交互需要的所有方法,隐藏了底层的细节。默认实现类是DefaultSqlSession。
Executor: SqlSession向用户提供操作数据库的方法,但和数据库操作有关的职责都会委托给Executor。Executor有两个实现类,和一级缓存关联的是BaseExecutor。
BaseExecutor: BaseExecutor是一个实现了Executor接口的抽象类,定义若干抽象方法,在执行的时候,把具体的操作委托给子类进行执行。
PerpetualCache:对Cache接口最基本实现,内部持有HashMap,对一级缓存的操作实则是对HashMap的操作。

SqlSession初始化时会创建Executor的实例,Mybatis默认使用的是SimpleExecutor,初始化代码如下所示:

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);
    }
   //如果启用二级缓存,使用CahingExecutor装饰类
    if (cacheEnabled) {
      executor = new CachingExecutor(executor);
    }
    executor = (Executor) interceptorChain.pluginAll(executor);
    return executor;
  }

SqlSession在提交的时候会清空本地缓存,因为commit操作一般对应插入、更新或者删除操作,清空缓存防止读取脏数据。

  @Override
  public void commit(boolean required) throws SQLException {
    if (closed) {
      throw new ExecutorException("Cannot commit, transaction is already closed");
    }
    clearLocalCache();
    flushStatements();
    if (required) {
      transaction.commit();
    }
  }

SqlSession的insert方法和delete方法,都会统一走update的流程。

@Override
public int insert(String statement, Object parameter) {
    return update(statement, parameter);
  }
   @Override
  public int delete(String statement) {
    return update(statement, null);
}

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

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

2.3 一级缓存失效的原因

  • 同一个用户使用不同的SqlSession对象导致无法看到一级缓存工作。
              DeptDao dao1 =   session.getMapper(DeptDao.class);
              Dept dept1 = dao1.findByDeptNo(10);
              System.out.println("第一次查询的部门对象地址 "+dept1);
              
              //新建一个SqlSession
              SqlSession session2 =  factory.openSession();
              DeptDao dao2 =   session2.getMapper(DeptDao.class);
              Dept dept2 = dao2.findByDeptNo(10);
              System.out.println("第二次查询的部门对象地址 "+dept2);
  • 在一个SqlSession中使用条件查询不同一级缓存也会失效。
              DeptDao dao1 =   session.getMapper(DeptDao.class);
              Dept dept1 = dao1.findByDeptNo(10);
              System.out.println("第一次查询的部门对象地址 "+dept1);
              
             
              DeptDao dao2 =   session.getMapper(DeptDao.class);
              Dept dept2 = dao2.findByDeptNo(20);
              System.out.println("第二次查询的部门对象地址 "+dept2);
  • 在一个SqlSession使用相同条件,但是,此时在查询之间进行数据修改操作会导致一级缓存失效。
 DeptDao dao1 =   session.getMapper(DeptDao.class);
              Dept dept1 = dao1.findByDeptNo(10);
              System.out.println("第一次查询的部门对象地址 "+dept1);
              
              //执行数据库修改
              Dept dept = new Dept(40, "测试部门", "深圳");
              dao1.deptAdd(dept);
             
              DeptDao dao2 =   session.getMapper(DeptDao.class);
              Dept dept2 = dao2.findByDeptNo(10);
              System.out.println("第二次查询的部门对象地址 "+dept2);
              
              session.commit();
  • 在一个SqlSession使用相同查询条件此时手动刷新缓存时导致一级缓存失败。
              DeptDao dao1 =   session.getMapper(DeptDao.class);
              Dept dept1 = dao1.findByDeptNo(10);
              System.out.println("第一次查询的部门对象地址 "+dept1);
              
              //手动刷新用户一级缓存,导致用户一级缓存原有的内容消失掉
              session.clearCache();
              
              DeptDao dao2 =   session.getMapper(DeptDao.class);
              Dept dept2 = dao2.findByDeptNo(10);
              System.out.println("第二次查询的部门对象地址 "+dept2);

2.4 注意

  • MyBatis一级缓存的生命周期和SqlSession一致。
  • MyBatis一级缓存内部设计简单,只是一个没有容量限定的HashMap,在缓存的功能性上有所欠缺。
  • MyBatis的一级缓存最大范围是SqlSession内部,有多个SqlSession或者分布式的环境下,数据库写操作会引起脏数据。
  • mybatis和spring整合后进行mapper代理开发,不支持一级缓存。

3. 二级缓存

3.1 二级缓存介绍

开启二级缓存后,会使用CachingExecutor装饰Executor,进入一级缓存的查询流程前,先在CachingExecutor进行二级缓存的查询,具体的工作流程如下所示。



二级缓存开启后,同一个namespace下的所有操作语句,都影响着同一个Cache,即二级缓存被多个SqlSession共享,是一个全局的变量。
当开启缓存后,数据的查询执行的流程就是 二级缓存 -> 一级缓存 -> 数据库。

3.2 二级缓存配置

  1. 需要在MyBatis核心配置文件,通过settings标签开发二级缓存。
    <setting name="cacheEnabled" value="true"/>
  2. 在对应的Mapper文件中添加cache标签
  3. cache标签属性
  • type:cache使用的类型,默认是PerpetualCache,这在一级缓存中提到过。
  • eviction: 定义回收的策略,常见的有FIFO,LRU。
  • flushInterval: 配置一定时间自动刷新缓存,单位是毫秒。
  • size: 最多缓存对象的个数。
  • readOnly: 是否只读,若配置可读写,则需要对应的实体类能够序列化。
  • blocking: 若缓存中找不到对应的key,是否会一直blocking,直到有对应的数据进入缓存。
  1. cache-ref代表引用别的命名空间的Cache配置,两个命名空间的操作使用的是同一个Cache。
    <cache-ref namespace="mapper.StudentMapper"/>

3.3 二级缓存源码分析

MyBatis在为SqlSession对象创建Excutor对象时候,会给Executor对象加上一个装饰者:CachingExecutor,这时SqlSession使用CachingExecutor对象来完成操作请求。CachingExecutor对于查询请求,会先判断该查询请求在二级缓存中是否有缓存,如果有则直接返回缓存结果;如果没有再交给真正的Executor对象来完成查询操作,之后CachingExecutor会将真正Executor返回的查询结果放置到缓存中,然后再返回给用户。



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

以下是具体这些Cache实现类的介绍,他们的组合为Cache赋予了不同的能力。

  • SynchronizedCache: 同步Cache,实现比较简单,直接使用synchronized修饰方法。
  • LoggingCache: 日志功能,装饰类,用于记录缓存的命中率,如果开启了DEBUG模式,则会输出命中率日志。
  • SerializedCache: 序列化功能,将值序列化后存到缓存中。该功能用于缓存返回一份实例的Copy,用于保存线程安全。
  • LruCache: 采用了Lru算法的Cache实现,移除最近最少使用的key/value。
  • PerpetualCache: 作为为最基础的缓存类,底层实现比较简单,直接使用了HashMap。

可以为每条Mapper语句设置是否要刷新缓存,可以指定select语句是否使用缓存,如下所示:

<select ... flushCache="false" useCache="true"/>
<insert ... flushCache="true"/>
<update ... flushCache="true"/>
<delete ... flushCache="true"/>

判断是否刷新缓存
flushCacheIfRequired(ms);
在默认的设置的select语句是不会刷新缓存的,insert/update/delte会刷新缓存。

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

CachingExecutor的查询语句:

public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
  throws SQLException {
//从MappedStatement中获得在配置初始化时赋予的Cache
Cache cache = ms.getCache();
if (cache != null) {
   //获取Mapper语句的flushCache配置 判断是否刷新缓存
  flushCacheIfRequired(ms);
//ensureNoOutParams主要是用来处理存储过程的
  if (ms.isUseCache() && resultHandler == null) {
    ensureNoOutParams(ms, parameterObject, boundSql);
    //从TransactionalCacheManager获取缓存的列表
    //在getObject方法中,会把获取值的职责一路传递,最终到PerpetualCache。
    List<E> list = (List<E>) tcm.getObject(cache, key);
   //如果缓存中没有找到则调用实际的Executor执行查询语句,查询到数据,则调用tcm.putObject方法,往缓存中放入值
    //tcm的put方法也不是直接操作缓存,只是在把这次的数据和key放入待提交的Map中
    if (list == null) {
      list = delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
      tcm.putObject(cache, key, list); // issue #578 and #116
    }
    return list;
  }
}
return delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}

3.4 二级缓存失效的原因

  • flushCache属性在查询中作用针对二级缓存导致失效
 //会话过程中第一次发送请求,从数据库中得到结果
            //得到结果之后,mybatis自动将这个查询结果放入到当前用户的一级缓存
            DeptDao dao =  session.getMapper(DeptDao.class);
            Dept dept = dao.findByDeptNo(10);
            System.out.println("第一次查询得到部门对象 = "+dept);
            session.close();//触发MyBatis框架从当前一级缓存中将Dept对象保存到二级缓存
            
            SqlSession session2 =factory.openSession();
            DeptDao dao2 =  session2.getMapper(DeptDao.class);
            Dept dept2 = dao2.findByDeptNo(10);
            System.out.println("第二次查询得到部门对象 = "+dept2);
  • flushCache属性在查询中作用针对一级缓存导致失效
//会话过程中第一次发送请求,从数据库中得到结果
            //得到结果之后,mybatis自动将这个查询结果放入到当前用户的一级缓存
            DeptDao dao =  session.getMapper(DeptDao.class);
            Dept dept = dao.findByDeptNo(10);
            System.out.println("第一次查询得到部门对象 = "+dept);
        
            DeptDao dao2 =  session.getMapper(DeptDao.class);
            Dept dept2 = dao2.findByDeptNo(10);
            System.out.println("第二次查询得到部门对象 = "+dept2);
  • flushCache属性在更新中作用导致两次查询结果完全一样
    //会话过程中第一次发送请求,从数据库中得到结果
            //得到结果之后,mybatis自动将这个查询结果放入到当前用户的一级缓存
            DeptDao dao =  session.getMapper(DeptDao.class);
            Dept dept = dao.findByDeptNo(10);
            System.out.println("第一次查询得到部门对象 = "+dept.getDname());
            
            Dept dept3 = new Dept(10,"部门20","北京");
            dao.updateDept(dept3);
            session.commit();
            session.close();
          
            SqlSession session2 = factory.openSession();            
            DeptDao dao2 =  session2.getMapper(DeptDao.class);
            Dept dept2 = dao2.findByDeptNo(10);
            System.out.println("第二次查询得到部门对象 = "+dept2.getDname());
           

3.5 总结

  • MyBatis的二级缓存相对于一级缓存来说,实现了SqlSession之间缓存数据的共享,同时粒度更加的细,能够到namespace级别,通过Cache接口实现类不同的组合,对Cache的可控性也更强。
  • MyBatis在多表查询时,极大可能会出现脏数据,有设计上的缺陷,安全使用二级缓存的条件比较苛刻。
  • 在分布式环境下,由于默认的MyBatis Cache实现都是基于本地的,分布式环境下必然会出现读取到脏数据,需要使用集中式缓存将MyBatis的Cache接口实现,有一定的开发成本,直接使用Redis,Memcached等分布式缓存可能成本更低,安全性也更高。

本文参考美团技术https://tech.meituan.com/mybatis_cache.html

推荐阅读更多精彩内容