Mybatis缓存机制

最新推荐文章于 2024-04-24 09:09:22 发布

Lewis_刘

最新推荐文章于 2024-04-24 09:09:22 发布

阅读量264

点赞数

分类专栏： Mybatis 缓存

本文链接：https://blog.csdn.net/l475128303/article/details/84026296

版权

Mybatis 同时被 2 个专栏收录

3 篇文章 0 订阅

订阅专栏

缓存

2 篇文章 0 订阅

订阅专栏

各种图什么的就不画了，学习交流本篇内容需要一定基础。

MappedStatement （映射器）缓存

cacheEnabled配置如下：

<settings>
  <setting name="cacheEnabled" value="true"/>
 ...
</settings>

这里的cacheEnabled对应Configuration的

public class Configuration {
  protected boolean cacheEnabled = true;
  ...
  }

cacheEnabled默认值为true，意味着默认启用MappedStatement缓存。并且针对不同的mapper.xml文件，每一个mapper.xml可以配置不同的缓存实现类,只需要实现cache接口：

public final class MappedStatement {
	private Cache cache;
}

一个MappedStatement对象对应一个 mapper.xml。

下面以查询为例，分析缓存的应用。
找到DefaultSqlSession中的selectList方法：

 @Override
  public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
    try {
      MappedStatement ms = configuration.getMappedStatement(statement);
      return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
    } catch (Exception e) {
      throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);
    } finally {
      ErrorContext.instance().reset();
    }
  }

可以看到executor接口调用query方法，这里要首先确定executor的具体类型，参看opensession的代码:

private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
    Transaction tx = null;
    try {
      final Environment environment = configuration.getEnvironment();
      final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
      tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
      final Executor executor = configuration.newExecutor(tx, execType);
      return new DefaultSqlSession(configuration, executor, autoCommit);
    } catch (Exception e) {
      closeTransaction(tx); // may have fetched a connection so lets call close()
      throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);
    } finally {
      ErrorContext.instance().reset();
    }
  }

Executor 对象是从configuration的newExecutor方法获取：

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);
    }
    if (cacheEnabled) {
      executor = new CachingExecutor(executor);
    }
    executor = (Executor) interceptorChain.pluginAll(executor);
    return executor;
  }

这里可以看到if (cacheEnabled)判断，所以最终的executor对象是CachingExecutor（ new SimpleExecutor(this, transaction)），执行器这里应用了装饰器模式，CachingExecutor本身又持有一个SimpleExecutor对象。
找到了executor类型，接下来查看CachingExecutor的query方法：

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

这里创建了一个缓存key（CacheKey ），为下一步获取缓存数据做好准备，进入query(ms, parameterObject, rowBounds, resultHandler, key, boundSql)方法：

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

在这里获取到了MappedStatement的Cache 对象，之后有缓存就从缓存中取出查询的数据，缓存具体的操作不做分析，可以自行查看代码，MappedStatement缓存到这里就分析完毕。

本地缓存

紧接着，如果MappedStatement缓存或者MappedStatement里面没有缓存数据，那么执行delegate. query(ms, parameterObject, rowBounds, resultHandler, key, boundSql)方法，进入：

@SuppressWarnings("unchecked")
  @Override
  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();
      if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
        // issue #482
        clearLocalCache();
      }
    }
    return list;
  }

这里首先从 localCache.getObject(key)里面获取结果集如果没有就执行queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql)，进入queryFromDatabase方法：

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

可以看到这里首先put进入占位符，原因：1.是为了解决首次调用这个方法时，localCache里面为空的的问题，便于之后finally里面执行removeObject不出错；2.更重要的是BaseExecutor类里面的DeferredLoad里面的用到了这个占位符，如下。

public boolean canLoad() {
      return localCache.getObject(key) != null && localCache.getObject(key) != EXECUTION_PLACEHOLDER;
    }

之后做查询，然后将结果集放入localCache中，缓存应用的大致源码就是这些。

总结

这里的缓存相对简单，本地缓存默认作用域为session，可通过设置为SESSION或者STATEMENT，当设置为STATEMENT基本相当于关闭本地缓存。可从：

@Override
  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();
      if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
        // issue #482
        clearLocalCache();
      }
    }
    return list;
  }

这里 if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
// issue #482
clearLocalCache();
}，会清除本地缓存。
1.MyBatis的本地缓存相对于MappedStatement 缓存来说，实现了SqlSession之间缓存数据的共享，同时粒度更加的细，能够到Statement 级别，通过Cache接口实现类不同的组合，对Cache的可控性也更强。

2.MyBatis在查询时，不同session查询MappedStatement缓存会出现脏数据

3.布式环境下，由于默认的MyBatis Cache实现都是基于本地的，分布式环境下（session不同）会出现读取到脏数据，需要使用集中式缓存将MyBatis的Cache接口实现，有一定的开发成本，直接使用Redis,Memcached等分布式缓存可能成本更低，安全性也更高。