MyBaits的二级缓存机制及其实现原理详解

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

<select id="queryUserBySchoolName" resultType="User" flushCache="false">
  SELECT * FROM `user` WHERE schoolName = #{schoolName}
</select>

// 查询操作的结果缓存
protected PerpetualCache localCache;
// Callable查询的输出参数缓存
protected PerpetualCache localOutputParameterCache;

/**
 * 查询数据库中的数据
 * @param ms 映射语句
 * @param parameter 参数对象
 * @param rowBounds 翻页限制条件
 * @param resultHandler 结果处理器
 * @param key 缓存的键
 * @param boundSql 查询语句
 * @param <E> 结果类型
 * @return 结果列表
 * @throws SQLException
 */
@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) {
      // 本地缓存中有结果，则对于CALLABLE语句还需要绑定到IN/INOUT参数上
      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();
    // 如果本地缓存的作用域为STATEMENT，则立刻清除本地缓存
    if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
      clearLocalCache();
    }
  }
  return list;
}

/**
 * 更新数据库数据，INSERT/UPDATE/DELETE三种操作都会调用该方法
 * @param ms 映射语句
 * @param parameter 参数对象
 * @return 数据库操作结果
 * @throws SQLException
 */
@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);
}

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

<cache type="PERPETUAL"
       eviction="FIFO"
       flushInterval="60000"
       size="512"
       readOnly="true"
       blocking="true">
    <!--可以加入property节点，将用来直接修改Cache实现类及装饰器类的属性-->
</cache>

<cache-ref namespace="com.github.yeecode.mybatisdemo.dao.UserMapper"/>

<select id="queryUserBySchoolName" resultType="User" flushCache="false" useCache="true">
  SELECT * FROM `user` WHERE schoolName = #{schoolName}
</select>

/**
 * 创建一个执行器
 * @param transaction 事务
 * @param executorType 数据库操作类型
 * @return 执行器
 */
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);
  }
  // 根据配置文件中settings节点cacheEnabled配置项确定是否启用缓存
  if (cacheEnabled) { // 如果配置启用缓存
    // 使用CachingExecutor装饰实际执行器
    executor = new CachingExecutor(executor);
  }
  // 为执行器增加拦截器（插件），以启用各个拦截器的功能
  executor = (Executor) interceptorChain.pluginAll(executor);
  return executor;
}

// 被装饰的执行器
private final Executor delegate;
// 事务缓存管理器
private final TransactionalCacheManager tcm = new TransactionalCacheManager();

/**
 * 查询数据库中的数据
 * @param ms 映射语句
 * @param parameterObject 参数对象
 * @param rowBounds 翻页限制条件
 * @param resultHandler 结果处理器
 * @param key 缓存的键
 * @param boundSql 查询语句
 * @param <E> 结果类型
 * @return 结果列表
 * @throws SQLException
 */
@Override
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
    throws SQLException {
  // 获取MappedStatement对应的缓存，可能的结果有：该命名空间的缓存、共享的其他命名空间的缓存、无缓存
  Cache cache = ms.getCache();
  // 如果映射文件未设置<cache>或<cache-ref>则，此处cache变量为null
  if (cache != null) { // 存在缓存
    // 根据要求判断语句执行前是否要清除二级缓存，如果需要，清除二级缓存
    flushCacheIfRequired(ms);
    if (ms.isUseCache() && resultHandler == null) { // 该语句使用缓存且没有输出结果处理器
      // 二级缓存不支持含有输出参数的CALLABLE语句，故在这里进行判断
      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);
}

/**
 * 根据要求判断语句执行前是否要清除二级缓存，如果需要，清除二级缓存
 * 注意：默认情况下，非SELECT语句的isFlushCacheRequired方法会返回true
 * @param ms MappedStatement
 */
private void flushCacheIfRequired(MappedStatement ms) {
  // 获取MappedStatement对应的缓存
  Cache cache = ms.getCache();
  if (cache != null && ms.isFlushCacheRequired()) { // 存在缓存且该操作语句要求执行前清除缓存
    // 清除事务中的缓存
    tcm.clear(cache);
  }
}