当前位置: 首页>编程语言>正文

java 清楚mybatis缓存 mybatis缓存问题

        查询缓存的使用,主要是为了提高查询访问速度。将用户对同一数据的重复查询过程简化,不再每次均从数据库查询获取结果数据,从而提高访问速度。

MyBatis 的查询缓存机制,根据缓存区的作用域(生命周期)可划分为两种:一级查询 缓存与二级查询缓存。

一、查询缓存

1.一级查询缓存

MyBatis 一级查询缓存是基于 org.apache.ibatis.cache.impl.PerpetualCache 类的 HashMap 本地缓存,其作用域是 SqlSession。在同一个 SqlSession 中两次执行相同的 sql 查询语句,第一次执行完毕后,会将查询结果写入到缓存中,第二次会从缓存中直接获取数据,而不再到 数据库中进行查询,从而提高查询效率。

当一个 SqlSession 结束后,该 SqlSession 中的一级查询缓存也就不存在了。myBatis 默认 一级查询缓存是开启状态,且不能关闭。 具体执行过程如下图所示:

java 清楚mybatis缓存 mybatis缓存问题,java 清楚mybatis缓存 mybatis缓存问题_二级缓存,第1张

每个SqlSession中持有了Executor,每个Executor中有一个LocalCache。当用户发起查询时,MyBatis根据当前执行的语句生成MappedStatement,在Local Cache进行查询,如果缓存命中的话,直接返回结果给用户,如果缓存没有命中的话,查询数据库,结果写入Local Cache,最后返回结果给用户。具体实现类的类关系图如下图所示:

java 清楚mybatis缓存 mybatis缓存问题,java 清楚mybatis缓存 mybatis缓存问题_java 清楚mybatis缓存_02,第2张

1.1 从缓存读取数据的依据是 Sql 的 id

一级缓存缓存的是相同 Sql 映射 id 的查询结果,而非相同 Sql 语句的查询结果。因为MyBatis 内部对于查询缓存,无论是一级查询缓存还是二级查询缓存,其底层均使用一个HashMap 实现:key 为 Sql 的 id 相关内容,value 为从数据库中查询出的结果。

1.2 增删改对一级查询缓存的影响

增、删、改操作,无论是否进行提交 sqlSession.commit(),均会清空一级查询缓存,使查询再次从 DB 中 select。

1.3 一级缓存配置

开发者只需在MyBatis的配置文件中,添加如下语句,就可以使用一级缓存。共有两个选项,SESSION或者STATEMENT,默认是SESSION级别,即在一个MyBatis会话中执行的所有语句,都会共享这一个缓存。一种是STATEMENT级别,可以理解为缓存只对当前执行的这一个Statement有效。

<setting name="localCacheScope" value="SESSION"/>

2.内置二级查询缓存

MyBatis 查询缓存的作用域是根据映射文件 mapper 的 namespace 划分的,相同namespace 的 mapper 查询数据存放在同一个缓存区域。不同 namespace 下的数据互不干扰。

无论是一级缓存还是二级缓存,都是按照 namespace 进行分别存放的。 但一、二级缓存的不同之处在于,SqlSession 一旦关闭,则 SqlSession 中的数据将不存在,即一级缓存就不覆存在。而二级缓存的生命周期会与整个应用同步,与 SqlSession 是否 关闭无关。

使用二级缓存的目的,不是共享数据,因为 MyBatis 从缓存中读取数据的依据是 SQL 的 id,而非查询出的对象。所以,二级缓存中的数据不是为了在多个查询之间共享(所有查询中只要查询结果中存在该对象的,就直接从缓存中读取,这是对数据的共享,Hibernate 中的缓存就是为了共享,但 MyBaits 的不是),而是为了延长该查询结果的保存时间,提高系统性能。

MyBatis 内置的二级缓存为 org.apache.ibatis.cache.impl.PerpetualCache。

在上文中提到的一级缓存中,其最大的共享范围就是一个SqlSession内部,如果多个SqlSession之间需要共享缓存,则需要使用到二级缓存。开启二级缓存后,会使用CachingExecutor装饰Executor,进入一级缓存的查询流程前,先在CachingExecutor进行二级缓存的查询,具体的工作流程如下所示。

java 清楚mybatis缓存 mybatis缓存问题,java 清楚mybatis缓存 mybatis缓存问题_查询缓存_03,第3张

二级缓存开启后,同一个namespace下的所有操作语句,都影响着同一个Cache,即二级缓存被多个SqlSession共享,是一个全局的变量。

当开启缓存后,数据的查询执行的流程就是 二级缓存 -> 一级缓存 -> 数据库。

2.1 二级缓存用法

(1) 实体序列化

要求查询结果所涉及到的实体类要实现 java.io.Serializable 接口。若该实体类存在父类, 或其具有域属性,则父类与域属性类也要实现序列化接口。

(2) mapper 映射中添加<cache/>标签

在 mapper 映射文件的<mapper/>标签中添加<cache/>子标签。

(3) 二级缓存的配置

为<cache/>标签添加一些相关属性设置,可以对二级缓存的运行性能进行控制。当然, 若不指定设置,则均保持默认值。

java 清楚mybatis缓存 mybatis缓存问题,java 清楚mybatis缓存 mybatis缓存问题_java 清楚mybatis缓存_04,第4张

  • eviction:逐出策略。当二级缓存中的对象达到最大值时,就需要通过逐出策略将缓存 中的对象移出缓存。默认为 LRU。常用的策略有:
  • FIFO:First In First Out,先进先出
  • LRU:Least Recently Used,未被使用时间最长的
  • flushInterval:刷新缓存的时间间隔,单位毫秒。这里的刷新缓存即清空缓存。一般不指 定,即当执行增删改时刷新缓存。
  • readOnly:设置缓存中数据是否只读。只读的缓存会给所有调用者返回缓存对象的相同 实例,因此这些对象不能被修改,这提供了很重要的性能优势。但读写的缓存会返回缓 存对象的拷贝。这会慢一些,但是安全,因此默认是 false。
  • size:二级缓存中可以存放的最多对象个数。默认为 1024 个。

2.2 二级缓存效果

对于映射文件中的同一个查询,肯定是同一个 namespace 中的查询(因为就是同一个查询)。在一次查询后,将 SqlSession 关闭,再进行一次相同查询,发现并没有到 DB 中进行select 查询。说明二级查询缓存是存在的。

Cache Hit Ratio 表示缓存命中率。开启二级缓存后,每执行一次查询,系统都会计算一次二级缓存的命中率。第一次查询也是先从缓存中查询,只不过缓存中一定是没有的。所以会再从 DB 中查询。由于二级缓存中不存在该数据,所以命中率为 0。但第二次查询是从二级缓存中读取的,所以这一次的命中率为 1/2 = 0.5。当然,若有第三次查询的话,则命中率会是 1/3 = 0.66。

2.3 增删改对二级查询缓存的影响

(1) 默认对缓存的刷新

增删改操作,无论是否进行提交 sqlSession.commit(),均会清空一级、二级查询缓存, 使查询再次从 DB 中 select。

(2) 设置增删改操作不刷新二级缓存

若要使某个增、删或改操作不清空二级缓存,则需要在其<insert/>或<delete/>或<update/> 中添加属性 flushCache=”false”,默认为 true。

java 清楚mybatis缓存 mybatis缓存问题,java 清楚mybatis缓存 mybatis缓存问题_缓存_05,第5张

2.4 二级缓存的关闭

二级缓存默认为开启状态。若要将其关闭,则需要进行相关设置。 根据关闭的范围大小,可以分为全局关闭与局部关闭。

(1) 全局关闭

所谓全局关闭是指,整个应用的二级缓存全部关闭,所有查询均不使用二级缓存。全局开关设置在主配置文件的全局设置<settings/>中,该属性为 cacheEnabled,设置为 false,则关闭;设置为 true,则开启,默认值为 true。即二级缓存默认是开启的。

java 清楚mybatis缓存 mybatis缓存问题,java 清楚mybatis缓存 mybatis缓存问题_查询缓存_06,第6张

(2) 局部关闭

所谓局部关闭是指,整个应用的二级缓存是开启的,但只是针对于某个<select/>查询, 不使用二级缓存。此时可以单独只关闭该<select/>标签的二级缓存。

在该要关闭二级缓存的<select/>标签中,将其属性 useCache 设置为 false,即可关闭该 查询的二级缓存。该属性默认为 true,即每个<select/>查询的二级缓存默认是开启的。

java 清楚mybatis缓存 mybatis缓存问题,java 清楚mybatis缓存 mybatis缓存问题_二级缓存_07,第7张

2.5 二级缓存的使用原则

(1) 只能在一个命名空间下使用二级缓存

由于二级缓存中的数据是基于 namespace 的,即不同 namespace 中的数据互不干扰。 在多个 namespace 中若均存在对同一个表的操作,那么这多个 namespace 中的数据可能就会出现不一致现象。

(2) 在单表上使用二级缓存

如果一个表与其它表有关联关系,那么就非常有可能存在多个 namespace 对同一数据 的操作。而不同 namespace 中的数据互不干扰,所以有可能出现这多个 namespace 中的数 据不一致现象。

(3) 查询多于修改时使用二级缓存

在查询操作远远多于增删改操作的情况下可以使用二级缓存。因为任何增删改操作都将刷新二级缓存,对二级缓存的频繁刷新将降低系统性能。

3.ehcache 二级查询缓存

Mybatis 的特长是 SQL 操作,缓存数据管理不是其特长,为了提高缓存的性能,MyBatis允许使用第三方缓存产品。ehCache 就是其中的一种。

注意,使用 ehcache 二级缓存,实体类无需实现序列化接口。

1.导入 Jar 包

这里需要两个 Jar 包:一个为 ehcache 的核心 Jar 包,一个是 myBatis 与 ehcache 整合的插件 Jar 包。它们可以从 https://github.com/mybatis/ehcache-cache/releases 下载。 解压该文件,获取到它们。其中 lib 下的是 ehcache 的核心 Jar 包。

2 添加 ehcache.xml

解压 EHCache 的核心 Jar 包 ehcache-core-2.6.8.jar,将其中的一个配置文件ehcache-failsafe.xml 直接放到项目的 src 目录下,并更名为 ehcache.xml。

(1) <diskStore/>标签

指定一个文件目录,当内存空间不够,需要将二级缓存中数据写到硬盘上时,会写到这个指定目录中。其值一般为 java.io.tmpdir,表示当前系统的默认文件临时目录。

当前系统的默认文件临时目录,可以通过 System.property()方法查看:

java 清楚mybatis缓存 mybatis缓存问题,java 清楚mybatis缓存 mybatis缓存问题_二级缓存_08,第8张

(2) <defaultCache/>标签

java 清楚mybatis缓存 mybatis缓存问题,java 清楚mybatis缓存 mybatis缓存问题_缓存_09,第9张

设定缓存的默认属性数据:

• maxElementsInMemory:指定该内存缓存区可以存放缓存对象的最多个数。
• eternal:设定缓存对象是否不会过期。若设为true,表示对象永远不会过期,此时会忽略 timeToIdleSeconds 与 timeToLiveSeconds 属性。默认值为 false。
• timeToIdleSeconds:设定允许对象处于空闲状态的最长时间,以秒为单位。当对象自从最近一次被访问后,若处于空闲状态的时间超过了timeToIdleSeconds设定的值,这个对象就会过期。当对象过期,EHCache 就会将它从缓存中清除。 设置值为 0,则对象可以无 限期地处于空闲状态。
• timeToLiveSeconds:设定对象允许存在于缓存中的最长时间,以秒为单位。当对象 自从被存放到缓存后,若处于缓存中的时间超过了 timeToLiveSeconds 设定的值,这个对象 就会过期。当对象过期,EHCache 就会将它从缓存中清除。设置值为 0,则对象可以无限期 地存在于缓存中。注意,只有 timeToLiveSeconds≥ timeToIdleSeconds,才有意义。
• overflowToDisk:设定为 true,表示当缓存对象达到了 maxElementsInMemory 界限, 会将溢出的对象写到<diskStore>元素指定的硬盘目录缓存中。
• maxElementsOnDisk:指定硬盘缓存区可以存放缓存对象的最多个数。
• diskPersistent:指定当程序结束时,硬盘缓存区中的缓存对象是否做持久化。
• diskExpiryThreadIntervalSeconds:指定硬盘中缓存对象的失效时间间隔。
• memoryStoreEvictionPolicy:如果内存缓存区超过限制,选择移向硬盘缓存区中的 对象时使用的策略。支持三种策略:
• FIFO:First In First Out,先进先出
• LFU:Less Frequently Used,最少使用
• LRU:Least Recently Used,最近最少使用

3 启用 ehcache 缓存机制

在映射文件的 mapper 中的<cache/>中通过 type 指定缓存机制为 Ehcache 缓存。默认为 MyBatis 内置的二级缓存 org.apache.ibatis.cache.impl.PerpetualCache。

java 清楚mybatis缓存 mybatis缓存问题,java 清楚mybatis缓存 mybatis缓存问题_查询缓存_10,第10张

4 ehcache 在不同 mapper 中的个性化设置

在 ehcache.xml 中设置的属性值,会对该项目中所有使用 ehcache 缓存机制的缓存区域起作用。一个项目中可以有多个 mapper,不同的 mapper 有不同的缓存区域。对于不同缓存区域也可进行专门针对于当前区域的个性化设置,可通过指定不同 mapper 的<cache>属性 值来设置。 <cache>属性值的优先级高于 ehcache.xml 中的属性值。

java 清楚mybatis缓存 mybatis缓存问题,java 清楚mybatis缓存 mybatis缓存问题_查询缓存_11,第11张

二、一级和二级缓存实现原理

1.一级缓存工作流程&源码分析

工作流程

一级缓存执行的时序图,如下图所示:

java 清楚mybatis缓存 mybatis缓存问题,java 清楚mybatis缓存 mybatis缓存问题_查询缓存_12,第12张

源码分析

SqlSession: 对外提供了用户和数据库之间交互需要的所有方法,隐藏了底层的细节。默认实现类是DefaultSqlSession

java 清楚mybatis缓存 mybatis缓存问题,java 清楚mybatis缓存 mybatis缓存问题_java 清楚mybatis缓存_13,第13张

ExecutorSqlSession向用户提供操作数据库的方法,但和数据库操作有关的职责都会委托给Executor。

java 清楚mybatis缓存 mybatis缓存问题,java 清楚mybatis缓存 mybatis缓存问题_缓存_14,第14张

如下图所示,Executor有若干个实现类,为Executor赋予了不同的能力。

java 清楚mybatis缓存 mybatis缓存问题,java 清楚mybatis缓存 mybatis缓存问题_查询缓存_15,第15张

在一级缓存的源码分析中,主要学习BaseExecutor的内部实现。

BaseExecutorBaseExecutor是一个实现了Executor接口的抽象类,定义若干抽象方法,在执行的时候,把具体的操作委托给子类进行执行。

// BaseExecutor.java
protected abstract int doUpdate(MappedStatement ms, Object parameter) throws SQLException;
protected abstract List<BatchResult> doFlushStatements(boolean isRollback) throws SQLException;
protected abstract <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException;
protected abstract <E> Cursor<E> doQueryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds, BoundSql boundSql) throws SQLException;

在一级缓存的介绍中提到对Local Cache的查询和写入是在Executor内部完成的。在阅读BaseExecutor的代码后发现Local CacheBaseExecutor内部的一个成员变量,如下代码所示:

public abstract class BaseExecutor implements Executor {
protected ConcurrentLinkedQueue<DeferredLoad> deferredLoads;
protected PerpetualCache localCache;

Cache: MyBatis中的Cache接口,提供了和缓存相关的最基本的操作,如下图所示:

java 清楚mybatis缓存 mybatis缓存问题,java 清楚mybatis缓存 mybatis缓存问题_二级缓存_16,第16张

有若干个实现类,使用装饰器模式互相组装,提供丰富的操控缓存的能力,部分实现类如下图所示:

java 清楚mybatis缓存 mybatis缓存问题,java 清楚mybatis缓存 mybatis缓存问题_二级缓存_17,第17张

BaseExecutor成员变量之一的PerpetualCache,是对Cache接口最基本的实现,其实现非常简单,内部持有HashMap,对一级缓存的操作实则是对HashMap的操作。如下代码所示:

public class PerpetualCache implements Cache {
  private String id;
  private Map<Object, Object> cache = new HashMap<Object, Object>();

为执行和数据库的交互,首先需要初始化SqlSession,通过DefaultSqlSessionFactory开启SqlSession

// DefaultSqlSessionFactory.java
private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
    ............
    final Executor executor = configuration.newExecutor(tx, execType);     
    return new DefaultSqlSession(configuration, executor, autoCommit);
}

在初始化SqlSesion时,会使用Configuration类创建一个全新的Executor,作为DefaultSqlSession构造函数的参数,创建Executor代码如下所示:

// Configuration.java
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装饰BaseExecutor的子类
    if (cacheEnabled) {
      executor = new CachingExecutor(executor);                      
    }
    executor = (Executor) interceptorChain.pluginAll(executor);
    return executor;
}

SqlSession创建完毕后,根据Statment的不同类型,会进入SqlSession的不同方法中,如果是Select语句的话,最后会执行到SqlSessionselectList,代码如下所示:

@Override
public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
      MappedStatement ms = configuration.getMappedStatement(statement);
      return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
}

SqlSession把具体的查询职责委托给了Executor。如果只开启了一级缓存的话,首先会进入BaseExecutorquery方法。代码如下所示:

// BaseExecutor.java
@Override
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
    BoundSql boundSql = ms.getBoundSql(parameter);
    CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
    return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
}

在上述代码中,会先根据传入的参数生成CacheKey,进入该方法查看CacheKey是如何生成的,代码如下所示:

// BaseExecutor.java的createCacheKey方法
CacheKey cacheKey = new CacheKey();
cacheKey.update(ms.getId());
cacheKey.update(rowBounds.getOffset());
cacheKey.update(rowBounds.getLimit());
cacheKey.update(boundSql.getSql());
//后面是update了sql中带的参数
cacheKey.update(value);

在上述的代码中,将MappedStatement的Id、SQL的offset、SQL的limit、SQL本身以及SQL中的参数传入了CacheKey这个类,最终构成CacheKey。CacheKey.java的内部结构:

private static final int DEFAULT_MULTIPLYER = 37;
private static final int DEFAULT_HASHCODE = 17;

private int multiplier;
private int hashcode;
private long checksum;
private int count;
private List<Object> updateList;

public CacheKey() {
    this.hashcode = DEFAULT_HASHCODE;
    this.multiplier = DEFAULT_MULTIPLYER;
    this.count = 0;
    this.updateList = new ArrayList<Object>();
}

首先是成员变量和构造函数,有一个初始的hachcode和乘数,同时维护了一个内部的updatelist。在CacheKeyupdate方法中,会进行一个hashcodechecksum的计算,同时把传入的参数添加进updatelist中。如下代码所示:

public void update(Object object) {
    int baseHashCode = object == null ? 1 : ArrayUtil.hashCode(object); 
    count++;
    checksum += baseHashCode;
    baseHashCode *= count;
    hashcode = multiplier * hashcode + baseHashCode;
    
    updateList.add(object);
}

同时重写了CacheKeyequals方法,代码如下所示:

@Override
public boolean equals(Object object) {
    .............
    for (int i = 0; i < updateList.size(); i++) {
      Object thisObject = updateList.get(i);
      Object thatObject = cacheKey.updateList.get(i);
      if (!ArrayUtil.equals(thisObject, thatObject)) {
        return false;
      }
    }
    return true;
}

除去hashcode、checksum和count的比较外,只要updatelist中的元素一一对应相等,那么就可以认为是CacheKey相等。只要两条SQL的下列五个值相同,即可以认为是相同的SQL。

Statement Id + Offset + Limmit + Sql + Params

BaseExecutor的query方法继续往下走,代码如下所示:

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

如果查不到的话,就从数据库查,在queryFromDatabase中,会对localcache进行写入。在query方法执行的最后,会判断一级缓存级别是否是STATEMENT级别,如果是的话,就清空缓存,这也就是STATEMENT级别的一级缓存无法共享localCache的原因。代码如下所示:

if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
        clearLocalCache();
}

如果是insert/delete/update方法,缓存就会刷新的原因。SqlSessioninsert方法和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);
}

每次执行update前都会清空localCache

总结

  1. MyBatis一级缓存的生命周期和SqlSession一致。
  2. MyBatis一级缓存内部设计简单,只是一个没有容量限定的HashMap,在缓存的功能性上有所欠缺。
  3. MyBatis的一级缓存最大范围是SqlSession内部,有多个SqlSession或者分布式的环境下,数据库写操作会引起脏数据,建议设定缓存级别为Statement。

2.二级缓存源码分析

MyBatis二级缓存的工作流程和前文提到的一级缓存类似,只是在一级缓存处理前,用CachingExecutor装饰了BaseExecutor的子类,在委托具体职责给delegate之前,实现了二级缓存的查询和写入功能,具体类关系图如下图所示:

java 清楚mybatis缓存 mybatis缓存问题,java 清楚mybatis缓存 mybatis缓存问题_查询缓存_18,第18张

源码分析

源码分析从CachingExecutorquery方法展开,CachingExecutorquery方法,首先会从MappedStatement中获得在配置初始化时赋予的Cache。      Cache cache = ms.getCache();

本质上是装饰器模式的使用,具体的装饰链是:

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

java 清楚mybatis缓存 mybatis缓存问题,java 清楚mybatis缓存 mybatis缓存问题_缓存_19,第19张

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

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

然后是判断是否需要刷新缓存,代码如下所示:

flushCacheIfRequired(ms);

在默认的设置中SELECT语句不会刷新缓存,insert/update/delte会刷新缓存。进入该方法。代码如下所示:

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

MyBatis的CachingExecutor持有了TransactionalCacheManager,即上述代码中的tcm。

TransactionalCacheManager中持有了一个Map,代码如下所示:

private Map<Cache, TransactionalCache> transactionalCaches = new HashMap<Cache, TransactionalCache>();

这个Map保存了Cache和用TransactionalCache包装后的Cache的映射关系。

TransactionalCache实现了Cache接口,CachingExecutor会默认使用他包装初始生成的Cache,作用是如果事务提交,对缓存的操作才会生效,如果事务回滚或者不提交事务,则不对缓存产生影响。

在TransactionalCache.java的clear方法中,有以下两句。清空了需要在提交时加入缓存的列表,同时设定提交时清空缓存,代码如下所示:

@Override
public void clear() {
	clearOnCommit = true;
	entriesToAddOnCommit.clear();
}

CachingExecutor继续往下走,ensureNoOutParams主要是用来处理存储过程的,暂时不用考虑。

if (ms.isUseCache() && resultHandler == null) {
	ensureNoOutParams(ms, parameterObject, boundSql);

之后会尝试从tcm中获取缓存的列表。

List<E> list = (List<E>) tcm.getObject(cache, key);

在getObject方法中,会把获取值的职责一路传递,最终到PerpetualCache.java。如果没有查到,会把key加入Miss集合,这个主要是为了统计命中率。

Object object = delegate.getObject(key);
if (object == null) {
	entriesMissedInCache.add(key);
}

CachingExecutor继续往下走,如果查询到数据,则调用tcm.putObject方法,往缓存中放入值。

if (list == null) {
	list = delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
	tcm.putObject(cache, key, list); // issue #578 and #116
}

tcm的put方法也不是直接操作缓存,只是在把这次的数据和key放入待提交的Map中。

@Override
public void putObject(Object key, Object object) {
    entriesToAddOnCommit.put(key, object);
}

从以上的代码分析中知道,如果不调用commit方法的话,由于TranscationalCache的作用,并不会对二级缓存造成直接的影响。因此我们看看Sqlsessioncommit方法中做了什么。代码如下所示:

@Override
public void commit(boolean force) {
    try {
      executor.commit(isCommitOrRollbackRequired(force));

因为我们使用了CachingExecutor,首先会进入CachingExecutor实现的commit方法。

@Override
public void commit(boolean required) throws SQLException {
    delegate.commit(required);
    tcm.commit();
}

会把具体commit的职责委托给包装的Executor。主要是看下tcm.commit(),tcm最终又会调用到TrancationalCache

public void commit() {
    if (clearOnCommit) {
      delegate.clear();
    }
    flushPendingEntries();
    reset();
}

看到这里的clearOnCommit就想起刚才TrancationalCacheclear方法设置的标志位,真正的清理Cache是放到这里来进行的。具体清理的职责委托给了包装的Cache类。之后进入flushPendingEntries方法。代码如下所示:

private void flushPendingEntries() {
    for (Map.Entry<Object, Object> entry : entriesToAddOnCommit.entrySet()) {
      delegate.putObject(entry.getKey(), entry.getValue());
    }
    ................
}

flushPendingEntries中,将待提交的Map进行循环处理,委托给包装的Cache类,进行putObject的操作。

后续的查询操作会重复执行这套流程。如果是insert|update|delete的话,会统一进入CachingExecutorupdate方法,其中调用了这个函数,代码如下所示:

private void flushCacheIfRequired(MappedStatement ms)

在二级缓存执行流程后就会进入一级缓存的执行流程,因此不再赘述。

总结

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


https://www.xamrdz.com/lan/5vg1963597.html

相关文章: