mybatis两级缓存原理剖析

https://blog.csdn.net/zhurhyme/article/details/81064108

对于mybatis的缓存认识一直有一个误区，所以今天写一篇文章帮自己订正一下。mybatis的缓存分一级缓存与二级缓存。下面分别对这两种缓存进行详细解说。
mybatis 的调用链

首先我们需要大致的了解一下mybatis的调用链，然后才能更好的理解mybatis的缓存。
主要的api罗列如下：

public interface SqlSessionFactory {    
  SqlSession openSession();
}

public class DefaultSqlSessionFactory implements SqlSessionFactory {

@Override
  public SqlSession openSession() {
    return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
  }

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

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);
        }
        if (cacheEnabled) {// 二级缓存开关
          executor = new CachingExecutor(executor);
        }
        executor = (Executor) interceptorChain.pluginAll(executor); //mybatis的插件机制
        return executor;
      }

1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47

上面的代码大致描述了，我们为了获取一个sqlSession实例的过程。下面的方法为SqlSession的实现类DefaultSqlSession中的一个查询方法.

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

1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11

从该方法我们可知SqlSession的方法实现全部委托给了Executor实例。Executor接口的类图:

这里写图片描述
mybatis 一级缓存

上面的executor.query如何执行呢？public abstract class BaseExecutor 中的方法给了我们答案.

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

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

1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42

请注意localCache是什么呢？在BaseExecutor的构造器有这么一句代码： this.localCache = new PerpetualCache(“LocalCache”); 即locaCache为缓存，即mybatis的一级缓存。

localCache生命周期是与SqlSession的生命周期是一样；不同的sqlSession会生成不同的localCache.这就是mybatis的一级缓存，它是与sqlSession息息相关，只能单个sqlSession实例独享。并且默认是开启的，没有开关可以关闭它。但是它的使用非常有局限。所以mybatis才需要在二级缓存，即突破SqlSession范围的缓存。mybatis的二级缓存与我们通常认知的缓存没有区别。
mybatis 的二级缓存

mybatis的二级缓存即通过CachingExecutor来实现。

CachingExecutor 中的query方法代码如下：

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

1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19

即当cache不为null时，则从tcm中获取，如果获取不到则再从delegate中获取。
现在关键是tcm.getObject(cache, key);
private final TransactionalCacheManager tcm = new TransactionalCacheManager();

TransactionalCacheManager的部分源代码

public class TransactionalCacheManager {

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

public Object getObject(Cache cache, CacheKey key) {
        return getTransactionalCache(cache).getObject(key);
      }

private TransactionalCache getTransactionalCache(Cache cache) {
    /*
    关键代码,它的作用从transactionalCaches 中获取TransactionalCache ,如果没有，则将cache作为参数，重新new一个,这段代码涉及jdk8的新语法及以及新特性，
    不太容易懂,如果有小朋友看不懂，我建议你好好学习一下jdk8
    */  
        return transactionalCaches.computeIfAbsent(cache, TransactionalCache::new);
      }

}

1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18

TransactionalCache 部分源码

public TransactionalCache(Cache delegate) {
        this.delegate = delegate;
        this.clearOnCommit = false;
        this.entriesToAddOnCommit = new HashMap<>();
        this.entriesMissedInCache = new HashSet<>();
      }

@Override
      public Object getObject(Object key) {
        // issue #116
        Object object = delegate.getObject(key);
        if (object == null) {
          entriesMissedInCache.add(key);
        }
        // issue #146
        if (clearOnCommit) {
          return null;
        } else {
          return object;
        }
      }

1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21

峰回路转

Cache cache = ms.getCache(); //这句是重点

1

即只要MappedStatement ms 自己有cache,则直接使用，这个就是mybatis的二级缓存。关于开启mybatis的二级缓存，则需要在config中配置cacheEnabled 为ture,它的默认值即为true。
另外需要在mapper中配置

<cache />

1

这样就可以最简单的方式使用mybatis的二级缓存了。至于如何扩展mybatis的二级缓存，不在本文之列。
mybatis 二级缓存絮叨

至此mybatis 的二级缓存好像已经说明白了。但是还想在此絮叨一下，原因是为了更好的理解什么是缓存。mybatis的二级缓存cache它是跟在MappedStatement上的。我们设置 cache标签，是以mapper为单位的。即这个mapper文件内的statement 共用这个cache标签。cache它与sqlSession没有任何关系，即不同的sqlSession执行同一个statement就可以共用同一个cache实例了。

那么是否有更大的cache使用范围呢？答案是有的，举个栗子。 部门表被cache；人员表被cache,从上面我们可知，这是两个不同的cache实例。在人员mapper中如何出人员与部门的联合查询，则当部门更新时，会出现局部的数据不一致。如何解决这个问题呢？一种答案是去掉缓存；另一种就是mybatis给我们提供的

<cache-ref >

1

标签，它可以使多个mapper使用同一个cache实例，从而达到缓存数据的一致性（关于缓存数据的一致性，性能，缓存数据范围，在此不讨论）。
---------------------
作者：zhurhyme
来源：CSDN
原文：https://blog.csdn.net/zhurhyme/article/details/81064108
版权声明：本文为博主原创文章，转载请附上博文链接！