缓存的使用前面已经说过，在同时开启一级缓存和二级缓存的情况下，会先查询二级缓存，再查询一级缓存，最后查询数据库，并且在操作过程中，只有一次sqlSession查询，commit或者close之后，查询结果才会放入二级缓存，这点前面在mybatis的使用的时候也说过，接下来看下源码具体分析下。

标签解析

还是看加载配置解析配置的代码：

  1. // 还是看解析mappers标签的部分
  2. private void mapperElement(XNode parent) throws Exception {
  3.     if (parent != null) {
  4.         for (XNode child : parent.getChildren()) {
  5.             if ("package".equals(child.getName())) {
  6.                 String mapperPackage = child.getStringAttribute("name");
  7.                 configuration.addMappers(mapperPackage);
  8.             } else {
  9.                 String resource = child.getStringAttribute("resource");
  10.                 String url = child.getStringAttribute("url");
  11.                 String mapperClass = child.getStringAttribute("class");
  12.                 if (resource != null && url == null && mapperClass == null) {
  13.                     ErrorContext.instance().resource(resource);
  14.                     InputStream inputStream = Resources.getResourceAsStream(resource);
  15.                     XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
  16.                     mapperParser.parse();
  17.                 } else if (resource == null && url != null && mapperClass == null) {
  18.                     ErrorContext.instance().resource(url);
  19.                     InputStream inputStream = Resources.getUrlAsStream(url);
  20.                     XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());
  21.                     mapperParser.parse();
  22.                 } else if (resource == null && url == null && mapperClass != null) {
  23.                     Class<?> mapperInterface = Resources.classForName(mapperClass);
  24.                     configuration.addMapper(mapperInterface);
  25.                 } else {
  26.                     throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");
  27.                 }
  28.             }
  29.         }
  30.     }
  31. }
  33. // 看parse方法
  34. public void parse() {
  35.     if (!configuration.isResourceLoaded(resource)) {
  36.         configurationElement(parser.evalNode("/mapper"));
  37.         configuration.addLoadedResource(resource);
  38.         bindMapperForNamespace();
  39.     }
  41.     parsePendingResultMaps();
  42.     parsePendingCacheRefs();
  43.     parsePendingStatements();
  44. }
  46. // 看configurationElement
  47. private void configurationElement(XNode context) {
  48.     try {
  49.         String namespace = context.getStringAttribute("namespace");
  50.         if (namespace == null || namespace.isEmpty()) {
  51.             throw new BuilderException("Mapper's namespace cannot be empty");
  52.         }
  53.         builderAssistant.setCurrentNamespace(namespace);
  54.         cacheRefElement(context.evalNode("cache-ref"));
  55.         cacheElement(context.evalNode("cache"));
  56.         parameterMapElement(context.evalNodes("/mapper/parameterMap"));
  57.         resultMapElements(context.evalNodes("/mapper/resultMap"));
  58.         sqlElement(context.evalNodes("/mapper/sql"));
  59.         buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
  60.     } catch (Exception e) {
  61.         throw new BuilderException("Error parsing Mapper XML. The XML location is '" + resource + "'. Cause: " + e, e);
  62.     }
  63. }
  65. // 关键在于解析cache部分
  66. private void cacheElement(XNode context) {
  67.     if (context != null) {
  68.         // 设置默认的缓存处理类，默认是 PerpetualCache，也可以自定义缓存实现类
  69.         String type = context.getStringAttribute("type", "PERPETUAL");
  70.         Class<? extends Cache> typeClass = typeAliasRegistry.resolveAlias(type);
  71.         // 负责过期的Cache实现类
  72.         String eviction = context.getStringAttribute("eviction", "LRU");
  73.         Class<? extends Cache> evictionClass = typeAliasRegistry.resolveAlias(eviction);
  74.         // 清空缓存的频率 0表示不清空
  75.         Long flushInterval = context.getLongAttribute("flushInterval");
  76.         // 缓存大小
  77.         Integer size = context.getIntAttribute("size");
  78.         // 是否序列化
  79.         boolean readWrite = !context.getBooleanAttribute("readOnly", false);
  80.         // 是否阻塞
  81.         boolean blocking = context.getBooleanAttribute("blocking", false);
  82.         Properties props = context.getChildrenAsProperties();
  83.         builderAssistant.useNewCache(typeClass, evictionClass, flushInterval, size, readWrite, blocking, props);
  84.     }
  85. }
  87. // 创建Cache对象
  88. public Cache useNewCache(Class<? extends Cache> typeClass,
  89.                          Class<? extends Cache> evictionClass,
  90.                          Long flushInterval,
  91.                          Integer size,
  92.                          boolean readWrite,
  93.                          boolean blocking,
  94.                          Properties props) {
  95.     // 根据配置的参数创建Cache对象
  96.     Cache cache = new CacheBuilder(currentNamespace)
  97.         .implementation(valueOrDefault(typeClass, PerpetualCache.class))
  98.         .addDecorator(valueOrDefault(evictionClass, LruCache.class))
  99.         .clearInterval(flushInterval)
  100.         .size(size)
  101.         .readWrite(readWrite)
  102.         .blocking(blocking)
  103.         .properties(props)
  104.         .build();
  105.     // 将Cache对象添加到configuration对象中去
  106.     configuration.addCache(cache);
  107.     // 将当前 MapperBuilderAssistant 的cache设置，这里有大用
  108.     currentCache = cache;
  109.     return cache;
  110. }
  112. // 在 configurationElement中，我们解析玩Cache标签之后，看看最后 buildStatementFromContext 方法，证实一个Mapper一个Cache，准确说
  113. // 一个namespace一个cache
  114. // 下面这个类解析了每一个MappedStatement的参数
  115. public void parseStatementNode() {
  116.     String id = context.getStringAttribute("id");
  117.     String databaseId = context.getStringAttribute("databaseId");
  119.     if (!databaseIdMatchesCurrent(id, databaseId, this.requiredDatabaseId)) {
  120.         return;
  121.     }
  123.     String nodeName = context.getNode().getNodeName();
  124.     SqlCommandType sqlCommandType = SqlCommandType.valueOf(nodeName.toUpperCase(Locale.ENGLISH));
  125.     boolean isSelect = sqlCommandType == SqlCommandType.SELECT;
  126.     boolean flushCache = context.getBooleanAttribute("flushCache", !isSelect);
  127.     boolean useCache = context.getBooleanAttribute("useCache", isSelect);
  128.     boolean resultOrdered = context.getBooleanAttribute("resultOrdered", false);
  130.     // Include Fragments before parsing
  131.     XMLIncludeTransformer includeParser = new XMLIncludeTransformer(configuration, builderAssistant);
  132.     includeParser.applyIncludes(context.getNode());
  134.     String parameterType = context.getStringAttribute("parameterType");
  135.     Class<?> parameterTypeClass = resolveClass(parameterType);
  137.     String lang = context.getStringAttribute("lang");
  138.     LanguageDriver langDriver = getLanguageDriver(lang);
  140.     // Parse selectKey after includes and remove them.
  141.     processSelectKeyNodes(id, parameterTypeClass, langDriver);
  143.     // Parse the SQL (pre: <selectKey> and <include> were parsed and removed)
  144.     KeyGenerator keyGenerator;
  145.     String keyStatementId = id + SelectKeyGenerator.SELECT_KEY_SUFFIX;
  146.     keyStatementId = builderAssistant.applyCurrentNamespace(keyStatementId, true);
  147.     if (configuration.hasKeyGenerator(keyStatementId)) {
  148.         keyGenerator = configuration.getKeyGenerator(keyStatementId);
  149.     } else {
  150.         keyGenerator = context.getBooleanAttribute("useGeneratedKeys",
  151.                                                    configuration.isUseGeneratedKeys() && SqlCommandType.INSERT.equals(sqlCommandType))
  152.             ? Jdbc3KeyGenerator.INSTANCE : NoKeyGenerator.INSTANCE;
  153.     }
  155.     SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass);
  156.     StatementType statementType = StatementType.valueOf(context.getStringAttribute("statementType", StatementType.PREPARED.toString()));
  157.     Integer fetchSize = context.getIntAttribute("fetchSize");
  158.     Integer timeout = context.getIntAttribute("timeout");
  159.     String parameterMap = context.getStringAttribute("parameterMap");
  160.     String resultType = context.getStringAttribute("resultType");
  161.     Class<?> resultTypeClass = resolveClass(resultType);
  162.     String resultMap = context.getStringAttribute("resultMap");
  163.     String resultSetType = context.getStringAttribute("resultSetType");
  164.     ResultSetType resultSetTypeEnum = resolveResultSetType(resultSetType);
  165.     if (resultSetTypeEnum == null) {
  166.         resultSetTypeEnum = configuration.getDefaultResultSetType();
  167.     }
  168.     String keyProperty = context.getStringAttribute("keyProperty");
  169.     String keyColumn = context.getStringAttribute("keyColumn");
  170.     String resultSets = context.getStringAttribute("resultSets");
  172.     builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType,
  173.                                         fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass,
  174.                                         resultSetTypeEnum, flushCache, useCache, resultOrdered,
  175.                                         keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets);
  176. }
  177. // 下面方法是我们要关注的点
  178. public MappedStatement addMappedStatement(
  179.     String id,
  180.     SqlSource sqlSource,
  181.     StatementType statementType,
  182.     SqlCommandType sqlCommandType,
  183.     Integer fetchSize,
  184.     Integer timeout,
  185.     String parameterMap,
  186.     Class<?> parameterType,
  187.     String resultMap,
  188.     Class<?> resultType,
  189.     ResultSetType resultSetType,
  190.     boolean flushCache,
  191.     boolean useCache,
  192.     boolean resultOrdered,
  193.     KeyGenerator keyGenerator,
  194.     String keyProperty,
  195.     String keyColumn,
  196.     String databaseId,
  197.     LanguageDriver lang,
  198.     String resultSets) {
  200.     if (unresolvedCacheRef) {
  201.         throw new IncompleteElementException("Cache-ref not yet resolved");
  202.     }
  204.     id = applyCurrentNamespace(id, false);
  205.     boolean isSelect = sqlCommandType == SqlCommandType.SELECT;
  206.     // 创建MapperStatement
  207.     MappedStatement.Builder statementBuilder = new MappedStatement.Builder(configuration, id, sqlSource, sqlCommandType)
  208.         .resource(resource)
  209.         .fetchSize(fetchSize)
  210.         .timeout(timeout)
  211.         .statementType(statementType)
  212.         .keyGenerator(keyGenerator)
  213.         .keyProperty(keyProperty)
  214.         .keyColumn(keyColumn)
  215.         .databaseId(databaseId)
  216.         .lang(lang)
  217.         .resultOrdered(resultOrdered)
  218.         .resultSets(resultSets)
  219.         .resultMaps(getStatementResultMaps(resultMap, resultType, id))
  220.         .resultSetType(resultSetType)
  221.         .flushCacheRequired(valueOrDefault(flushCache, !isSelect))
  222.         .useCache(valueOrDefault(useCache, isSelect))
  223.         .cache(currentCache);
  225.     ParameterMap statementParameterMap = getStatementParameterMap(parameterMap, parameterType, id);
  226.     if (statementParameterMap != null) {
  227.         statementBuilder.parameterMap(statementParameterMap);
  228.     }
  230.     MappedStatement statement = statementBuilder.build();
  231.     configuration.addMappedStatement(statement);
  232.     return statement;
  233. }
  235. // 在创建 MappedStatement 的时候，使用了 MapperBuilderAssistant的currentCache属性，那就证实了一个namespace一个cache

Cache标签的解析说明了一个namespace虽然有多个MappedStatement，但是它们都使用的是一个缓存，接下来继续深入执行流程。

二级缓存执行流程

这段源码的查看就可以清楚为什么必须要前一个sqlSession执行commit或者close操作之后，一级缓存的内容才可以刷新到二级缓存中去。

  1. // 执行方法 Executor.selectList 来进行查看，这个时候查询的时候就要找 CacheExecutor，如下
  2. @Override
  3. public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
  4.     throws SQLException {
  5.     // 上面cache标签的解析来说，每一个MappedStatement中都有一个Cache对象
  6.     Cache cache = ms.getCache();
  7.     if (cache != null) {
  8.         // 判断是否清除缓存，根据设置的标签 flushCache 来判断
  9.         flushCacheIfRequired(ms);
  10.         // 判断是否使用缓存， useCache 标签
  11.         if (ms.isUseCache() && resultHandler == null) {
  12.             ensureNoOutParams(ms, boundSql);
  13.             // TransactionalCacheManager 对象中查询二级缓存，这个下面有战士
  14.             @SuppressWarnings("unchecked")
  15.             List<E> list = (List<E>) tcm.getObject(cache, key);
  16.             if (list == null) {
  17.                 // 查询一级缓存，这里执行的就是 BaseExecutor 
  18.                 list = delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
  19.                 // 保存数据到map中
  20.                 tcm.putObject(cache, key, list); // issue #578 and #116
  21.             }
  22.             return list;
  23.         }
  24.     }
  25.     return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
  26. }
  28. // 一级缓存中查询，没有查询数据库，也是上面的 delegate.query
  29. @Override
  30. public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
  31.     ......
  32.         // 前面的不用看，直接看查询缓存和查询数据库的操作
  33.         try {
  34.             queryStack++;
  35.             // 查询一级缓存
  36.             list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
  37.             if (list != null) {
  38.                 handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
  39.             } else {
  40.                 // 查询数据库
  41.                 list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
  42.             }
  43.         } finally {
  44.             queryStack--;
  45.         }
  46.     ......
  47.         return list;
  48. }
  50. // 查询数据库
  51. private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
  52.     List<E> list;
  53.     localCache.putObject(key, EXECUTION_PLACEHOLDER);
  54.     try {
  55.         // 查询数据库，简历连接执行sql
  56.         list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
  57.     } finally {
  58.         localCache.removeObject(key);
  59.     }
  60.     // 结果存入一级缓存
  61.     localCache.putObject(key, list);
  62.     if (ms.getStatementType() == StatementType.CALLABLE) {
  63.         localOutputParameterCache.putObject(key, parameter);
  64.     }
  65.     return list;
  66. }
  68. // 结果查询完成之后就要返回到我们的query方法，接下来执行 tcm.putObject(cache, key, list);
  69. // 目标类是 TransactionalCacheManager
  70. private final Map<Cache, TransactionalCache> transactionalCaches = new HashMap<>();
  71. public void putObject(Cache cache, CacheKey key, Object value) {
  72.     // 根据二级缓存的 cache对象来从 transactionalCaches 中获取 TransactionalCache
  73.     getTransactionalCache(cache).putObject(key, value);
  74. }
  76. // 接下来就要看 TransactionalCache 的put方法 以及 get方法了，因为get方法也是从 TransactionalCache对象中获取
  77. private final Cache delegate;
  79. private final Map<Object, Object> entriesToAddOnCommit;
  80. @Override
  81. public void putObject(Object key, Object object) {
  82.     // 可以看到 put的时候是放在 entriesToAddOnCommit中
  83.     entriesToAddOnCommit.put(key, object);
  84. }
  86. @Override
  87. public Object getObject(Object key) {
  88.     // issue #116
  89.     // 从Cache获取的时候取的是 Cache 对象 delegate中的
  90.     Object object = delegate.getObject(key);
  91.     if (object == null) {
  92.         entriesMissedInCache.add(key);
  93.     }
  94.     // issue #146
  95.     if (clearOnCommit) {
  96.         return null;
  97.     } else {
  98.         return object;
  99.     }
  100. }

到这里就知道为什么查询的时候在没有 commit 和 close 的时候无法命中缓存。

二级缓存生效时机

上面说了只有 sqlSession 执行 commit 或 close 缓存才会生效，看看执行操作干了什么？

  1. // 层层向下找，找到 CachingExecutor 的commit
  2. @Override
  3. public void commit(boolean required) throws SQLException {
  4.     // 一级缓存的commit
  5.     delegate.commit(required);
  6.     tcm.commit();
  7. }
  8. // 下面的操作就是将保存在 delegate 中的缓存数据保存到 entriesToAddOnCommit 中
  9. public void commit() {
  10.     for (TransactionalCache txCache : transactionalCaches.values()) {
  11.         txCache.commit();
  12.     }
  13. }
  14. public void commit() {
  15.     if (clearOnCommit) {
  16.         delegate.clear();
  17.     }
  18.     flushPendingEntries();
  19.     reset();
  20. }
  21. private void flushPendingEntries() {
  22.     for (Map.Entry<Object, Object> entry : entriesToAddOnCommit.entrySet()) {
  23.         delegate.putObject(entry.getKey(), entry.getValue());
  24.     }
  25.     for (Object entry : entriesMissedInCache) {
  26.         if (!entriesToAddOnCommit.containsKey(entry)) {
  27.             delegate.putObject(entry, null);
  28.         }
  29.     }
  30. }
  32. // 上面是 commit 流程，下面看close
  33. @Override
  34. public void close(boolean forceRollback) {
  35.     try {
  36.         // issues #499, #524 and #573
  37.         if (forceRollback) {
  38.             tcm.rollback();
  39.         } else {
  40.             // close也会执行 TransactionalCacheManager 的commit 方法
  41.             tcm.commit();
  42.         }
  43.     } finally {
  44.         delegate.close(forceRollback);
  45.     }
  46. }

综上所述，只有commit或者close之后二级缓存才会生效，原因就是一级缓存查询之后并没有保存到二级缓存，而是保存到了同一个对象TransactionalCache下的Cache对象中，而不是保存二级缓存Map对象 entriesToAddOnCommit 中。

二级缓存的刷新

其实二级缓存的刷新也叫二级缓存的清空，也就是在执行update方法的时候会进行清空，这里的update包括了增删改操作

  1. @Override
  2. public int update(String statement, Object parameter) {
  3.     try {
  4.         dirty = true;
  5.         MappedStatement ms = configuration.getMappedStatement(statement);
  6.         return executor.update(ms, wrapCollection(parameter));
  7.     } catch (Exception e) {
  8.         throw ExceptionFactory.wrapException("Error updating database.  Cause: " + e, e);
  9.     } finally {
  10.         ErrorContext.instance().reset();
  11.     }
  12. }
  14. @Override
  15. public int update(MappedStatement ms, Object parameterObject) throws SQLException {
  16.     flushCacheIfRequired(ms);
  17.     return delegate.update(ms, parameterObject);
  18. }
  20. // 清空二级缓存
  21. private void flushCacheIfRequired(MappedStatement ms) {
  22.     Cache cache = ms.getCache();
  23.     if (cache != null && ms.isFlushCacheRequired()) {
  24.         tcm.clear(cache);
  25.     }
  26. }

综上，基本就是二级缓存的所有流程了，包括了执行、刷新、生效。
二级缓存的设计使用了大量的装饰者模式：

  • 二级缓存是基于namespace级别的，实现了sqlSession之间的缓存共享
  • 二级缓存的工作是由一个缓存执行器CachingExecutor和一个事务型预缓存 TransactionalCache 完成