Mybatis源码剖析 -- 二级缓存

一、思考一个问题

假设 Mybatis 一级缓存和二级缓存同时开启，那么到底是生效一级缓存还是二级缓存呢？

• 答案：二级缓存是构建在⼀级缓存之上的，在收到查询请求时，MyBatis 首先会查询二级缓存，若二级缓存未能命中，再去查询⼀级缓存，⼀级缓存没有，再查询数据库。
• 所以实际上是这样的：二级缓存 -> 一级缓存 -> 数据库
• 与一级缓存不同，二级缓存和具体的命名空间（namespace）绑定，⼀个 Mapper 中有⼀个 Cache，相同 Mapper 中的 MappedStatement 共用⼀个 Cache，⼀级缓存则是和 SqlSession 绑定。

二、启用二级缓存

1. 在 sqlMapConfig.xml 中开启全局二级缓存配置
   注意官方文档中的这句解释，自己意会：全局性的开启或关闭所有映射器配置文件中已配置的任何缓存，默认：true

   <!--开启全局的二级缓存配置-->
   <settings>
       <setting name="CacheEnabled" value="true"/>
   </settings>
   

2. 在需要使用二级缓存的 Mapper 配置文件中配置标签 <cache></cache>
3. 在具体 CURD 标签上配置 useCache=true
   注意：这个配置默认就是 true

   <select id="findById" resultMap="userMap"  useCache="true">
      select * from user where id = #{id}
   </select>
   

三、cache 标签解析

1. 根据之前的 mybatis 源码剖析，xml 的解析工作主要交XMLConfigBuilder.parse()方法来实现，最终通过mapperElement(root.evalNode("mappers"));获取到 Mapper 配置文件，那么 cache 标签也应该在这里被解析

   private void mapperElement(XNode parent) throws Exception {
       if (parent != null) {
           // 遍历子节点
           for (XNode child : parent.getChildren()) {
               // 如果是 package 标签，则扫描该包
               if ("package".equals(child.getName())) {
                   // 获取 <package> 节点中的 name 属性
                   String mapperPackage = child.getStringAttribute("name");
                   // 从指定包中查找 mapper 接口，并根据 mapper 接口解析映射配置
                   configuration.addMappers(mapperPackage);
               // 如果是 mapper 标签，
               } else {
                   // 获得 resource、url、class 属性
                   String resource = child.getStringAttribute("resource");
                   String url = child.getStringAttribute("url");
                   String mapperClass = child.getStringAttribute("class");
   
                   // resource 不为空，且其他两者为空，则从指定路径中加载配置
                   if (resource != null && url == null && mapperClass == null) {
                       ErrorContext.instance().resource(resource);
                       // 获得 resource 的 InputStream 对象
                       InputStream inputStream = Resources.getResourceAsStream(resource);
                       // 创建 XMLMapperBuilder 对象
                       XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
                       // 执行解析
                       mapperParser.parse();
                       // url 不为空，且其他两者为空，则通过 url 加载配置
                   } else if (resource == null && url != null && mapperClass == null) {
                       ErrorContext.instance().resource(url);
                       // 获得 url 的 InputStream 对象
                       InputStream inputStream = Resources.getUrlAsStream(url);
                       // 创建 XMLMapperBuilder 对象
                       XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());
                       // 执行解析
                       mapperParser.parse();
                       // mapperClass 不为空，且其他两者为空，则通过 mapperClass 解析映射配置
                   } else if (resource == null && url == null && mapperClass != null) {
                       // 获得 Mapper 接口
                       Class<?> mapperInterface = Resources.classForName(mapperClass);
                       // 添加到 configuration 中
                       configuration.addMapper(mapperInterface);
                       // 以上条件不满足，则抛出异常
                   } else {
                       throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");
                   }
               }
           }
       }
   }
   

2. 其中mapperParser.parse();方法就是解析配置文件的

   public void parse() {
       // 判断当前 Mapper 是否已经加载过
       if (!configuration.isResourceLoaded(resource)) {
           // 解析 `<mapper />` 节点
           configurationElement(parser.evalNode("/mapper"));
           // 标记该 Mapper 已经加载过
           configuration.addLoadedResource(resource);
           // 绑定 Mapper
           bindMapperForNamespace();
       }
   
       // 解析待定的 <resultMap /> 节点
       parsePendingResultMaps();
       // 解析待定的 <cache-ref /> 节点
       parsePendingCacheRefs();
       // 解析待定的 SQL 语句的节点
       parsePendingStatements();
   }
   

3. 解析 <mapper /> 节点

   // 解析 `<mapper />` 节点
   private void configurationElement(XNode context) {
       try {
           // 获得 namespace 属性
           String namespace = context.getStringAttribute("namespace");
           if (namespace == null || namespace.equals("")) {
               throw new BuilderException("Mapper's namespace cannot be empty");
           }
           // 设置 namespace 属性
           builderAssistant.setCurrentNamespace(namespace);
           // 解析 <cache-ref /> 节点
           cacheRefElement(context.evalNode("cache-ref"));
           // 解析 <cache /> 节点
           cacheElement(context.evalNode("cache"));
           // 已废弃！老式风格的参数映射。内联参数是首选,这个元素可能在将来被移除，这里不会记录。
           parameterMapElement(context.evalNodes("/mapper/parameterMap"));
           // 解析 <resultMap /> 节点们
           resultMapElements(context.evalNodes("/mapper/resultMap"));
           // 解析 <sql /> 节点们
           sqlElement(context.evalNodes("/mapper/sql"));
           // 解析 <select /> <insert /> <update /> <delete /> 节点们
           // 这里会将生成的Cache包装到对应的MappedStatement
           buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
       } catch (Exception e) {
           throw new BuilderException("Error parsing Mapper XML. The XML location is '" + resource + "'. Cause: " + e, e);
       }
   }
   

4. 解析 <cache /> 节点

   // 解析 <cache /> 标签，获取 cache 标签的各个属性
   private void cacheElement(XNode context) throws Exception {
       if (context != null) {
           //解析<cache/>标签的type属性，这里我们可以自定义cache的实现类，比如redisCache，如果没有自定义，这里使用和一级缓存相同的PERPETUAL
           String type = context.getStringAttribute("type", "PERPETUAL");
           Class<? extends Cache> typeClass = typeAliasRegistry.resolveAlias(type);
           // 获得负责过期的 Cache 实现类
           String eviction = context.getStringAttribute("eviction", "LRU");
           Class<? extends Cache> evictionClass = typeAliasRegistry.resolveAlias(eviction);
           // 清空缓存的频率。0 代表不清空
           Long flushInterval = context.getLongAttribute("flushInterval");
           // 缓存容器大小
           Integer size = context.getIntAttribute("size");
           // 是否序列化
           boolean readWrite = !context.getBooleanAttribute("readOnly", false);
           // 是否阻塞
           boolean blocking = context.getBooleanAttribute("blocking", false);
           // 获得 Properties 属性
           Properties props = context.getChildrenAsProperties();
           // 创建 Cache 对象
           builderAssistant.useNewCache(typeClass, evictionClass, flushInterval, size, readWrite, blocking, props);
       }
   }
   

5. 创建 cache 对象

   /**
    * 创建 Cache 对象
    *
    * @param typeClass 负责存储的 Cache 实现类
    * @param evictionClass 负责过期的 Cache 实现类
    * @param flushInterval 清空缓存的频率。0 代表不清空
    * @param size 缓存容器大小
    * @param readWrite 是否序列化
    * @param blocking 是否阻塞
    * @param props Properties 对象
    * @return Cache 对象
    */
   public Cache useNewCache(Class<? extends Cache> typeClass,
                            Class<? extends Cache> evictionClass,
                            Long flushInterval,
                            Integer size,
                            boolean readWrite,
                            boolean blocking,
                            Properties props) {
   
       // 1.生成Cache对象
       Cache cache = new CacheBuilder(currentNamespace)
               //这里如果我们定义了<cache/>中的type，就使用自定义的Cache,否则使用和一级缓存相同的PerpetualCache
               .implementation(valueOrDefault(typeClass, PerpetualCache.class))
               .addDecorator(valueOrDefault(evictionClass, LruCache.class))
               .clearInterval(flushInterval)
               .size(size)
               .readWrite(readWrite)
               .blocking(blocking)
               .properties(props)
               .build();
       // 2.添加到Configuration中
       configuration.addCache(cache);
       // 3.并将cache赋值给MapperBuilderAssistant.currentCache
       currentCache = cache;
       return cache;
   }
   

6. 将生成的 Cache 包装到对应的 MappedStatement

   // 解析 <select /> <insert /> <update /> <delete /> 节点们
   private void buildStatementFromContext(List<XNode> list) {
       if (configuration.getDatabaseId() != null) {
           buildStatementFromContext(list, configuration.getDatabaseId());
       }
       buildStatementFromContext(list, null);
       // 上面两块代码，可以简写成 buildStatementFromContext(list, configuration.getDatabaseId());
   }
   

   private void buildStatementFromContext(List<XNode> list, String requiredDatabaseId) {
       //遍历 <select /> <insert /> <update /> <delete /> 节点们
       for (XNode context : list) {
           // 创建 XMLStatementBuilder 对象，执行解析
           final XMLStatementBuilder statementParser = new XMLStatementBuilder(configuration, builderAssistant, context, requiredDatabaseId);
           try {
   
               // 每一条执行语句转换成一个MappedStatement
               statementParser.parseStatementNode();
           } catch (IncompleteElementException e) {
               // 解析失败，添加到 configuration 中
               configuration.addIncompleteStatement(statementParser);
           }
       }
   }
   

   /**
    * 执行解析
    */
   public void parseStatementNode() {
       // 获得 id 属性，编号。
       String id = context.getStringAttribute("id");
       // 获得 databaseId ， 判断 databaseId 是否匹配
       String databaseId = context.getStringAttribute("databaseId");
       if (!databaseIdMatchesCurrent(id, databaseId, this.requiredDatabaseId)) {
           return;
       }
   
       // 获得各种属性
       Integer fetchSize = context.getIntAttribute("fetchSize");
       Integer timeout = context.getIntAttribute("timeout");
       String parameterMap = context.getStringAttribute("parameterMap");
       String parameterType = context.getStringAttribute("parameterType");
       Class<?> parameterTypeClass = resolveClass(parameterType);
       String resultMap = context.getStringAttribute("resultMap");
       String resultType = context.getStringAttribute("resultType");
       String lang = context.getStringAttribute("lang");
   
       // 获得 lang 对应的 LanguageDriver 对象
       LanguageDriver langDriver = getLanguageDriver(lang);
   
       // 获得 resultType 对应的类
       Class<?> resultTypeClass = resolveClass(resultType);
       // 获得 resultSet 对应的枚举值
       String resultSetType = context.getStringAttribute("resultSetType");
       ResultSetType resultSetTypeEnum = resolveResultSetType(resultSetType);
       // 获得 statementType 对应的枚举值
       StatementType statementType = StatementType.valueOf(context.getStringAttribute("statementType", StatementType.PREPARED.toString()));
   
       // 获得 SQL 对应的 SqlCommandType 枚举值
       String nodeName = context.getNode().getNodeName();
       SqlCommandType sqlCommandType = SqlCommandType.valueOf(nodeName.toUpperCase(Locale.ENGLISH));
       // 获得各种属性
       boolean isSelect = sqlCommandType == SqlCommandType.SELECT;
       boolean flushCache = context.getBooleanAttribute("flushCache", !isSelect);
       boolean useCache = context.getBooleanAttribute("useCache", isSelect);
       boolean resultOrdered = context.getBooleanAttribute("resultOrdered", false);
   
       // Include Fragments before parsing
       // 创建 XMLIncludeTransformer 对象，并替换 <include /> 标签相关的内容
       XMLIncludeTransformer includeParser = new XMLIncludeTransformer(configuration, builderAssistant);
       includeParser.applyIncludes(context.getNode());
   
       // Parse selectKey after includes and remove them.
       // 解析 <selectKey /> 标签
       processSelectKeyNodes(id, parameterTypeClass, langDriver);
   
       // Parse the SQL (pre: <selectKey> and <include> were parsed and removed)
       // 创建 SqlSource 对象
       SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass);
       // 获得 KeyGenerator 对象
       String resultSets = context.getStringAttribute("resultSets");
       String keyProperty = context.getStringAttribute("keyProperty");
       String keyColumn = context.getStringAttribute("keyColumn");
       KeyGenerator keyGenerator;
       // 优先，从 configuration 中获得 KeyGenerator 对象。如果存在，意味着是 <selectKey /> 标签配置的
       String keyStatementId = id + SelectKeyGenerator.SELECT_KEY_SUFFIX;
       keyStatementId = builderAssistant.applyCurrentNamespace(keyStatementId, true);
       if (configuration.hasKeyGenerator(keyStatementId)) {
           keyGenerator = configuration.getKeyGenerator(keyStatementId);
       // 其次，根据标签属性的情况，判断是否使用对应的 Jdbc3KeyGenerator 或者 NoKeyGenerator 对象
       } else {
           keyGenerator = context.getBooleanAttribute("useGeneratedKeys", // 优先，基于 useGeneratedKeys 属性判断
                   configuration.isUseGeneratedKeys() && SqlCommandType.INSERT.equals(sqlCommandType)) // 其次，基于全局的 useGeneratedKeys 配置 + 是否为插入语句类型
                   ? Jdbc3KeyGenerator.INSTANCE : NoKeyGenerator.INSTANCE;
       }
   
       // 创建 MappedStatement 对象
       builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType,
               fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass,
               resultSetTypeEnum, flushCache, useCache, resultOrdered,
               keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets);
   }
   

   // 构建 MappedStatement 对象
   public MappedStatement addMappedStatement(
           String id,
           SqlSource sqlSource,
           StatementType statementType,
           SqlCommandType sqlCommandType,
           Integer fetchSize,
           Integer timeout,
           String parameterMap,
           Class<?> parameterType,
           String resultMap,
           Class<?> resultType,
           ResultSetType resultSetType,
           boolean flushCache,
           boolean useCache,
           boolean resultOrdered,
           KeyGenerator keyGenerator,
           String keyProperty,
           String keyColumn,
           String databaseId,
           LanguageDriver lang,
           String resultSets) {
   
       // 如果只想的 Cache 未解析，抛出 IncompleteElementException 异常
       if (unresolvedCacheRef) {
           throw new IncompleteElementException("Cache-ref not yet resolved");
       }
   
       // 获得 id 编号，格式为 `${namespace}.${id}`
       id = applyCurrentNamespace(id, false);
       boolean isSelect = sqlCommandType == SqlCommandType.SELECT;
   
       // 创建 MappedStatement.Builder 对象
       MappedStatement.Builder statementBuilder = new MappedStatement.Builder(configuration, id, sqlSource, sqlCommandType)
               .resource(resource)
               .fetchSize(fetchSize)
               .timeout(timeout)
               .statementType(statementType)
               .keyGenerator(keyGenerator)
               .keyProperty(keyProperty)
               .keyColumn(keyColumn)
               .databaseId(databaseId)
               .lang(lang)
               .resultOrdered(resultOrdered)
               .resultSets(resultSets)
               .resultMaps(getStatementResultMaps(resultMap, resultType, id)) // 获得 ResultMap 集合
               .resultSetType(resultSetType)
               .flushCacheRequired(valueOrDefault(flushCache, !isSelect))
               .useCache(valueOrDefault(useCache, isSelect))
               .cache(currentCache); // 在这里将之前生成的Cache封装到MappedStatement
   
       // 获得 ParameterMap ，并设置到 MappedStatement.Builder 中
       ParameterMap statementParameterMap = getStatementParameterMap(parameterMap, parameterType, id);
       if (statementParameterMap != null) {
           statementBuilder.parameterMap(statementParameterMap);
       }
   
       // 创建 MappedStatement 对象
       MappedStatement statement = statementBuilder.build();
       // 添加到 configuration 中
       configuration.addMappedStatement(statement);
       return statement;
   }
   

四、执行流程

1. 先走到selectList()中去

   @Override
   public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
       try {
           // 获得 MappedStatement 对象
           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();
       }
   }
   

2. 点进executor.query实现类CachingExecutor缓存装饰类
   只要是 sqlMapConfig.xml 中开启全局的二级缓存配置，就会走这个实现类

   @Override
   public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
       // 获得 BoundSql 对象
       BoundSql boundSql = ms.getBoundSql(parameterObject);
       // 创建 CacheKey 对象
       CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);
       // 查询
       return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
   }
   

3. 创建 CacheKey，继续 query

   @Override
   public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
           throws SQLException {
   
       // 从 MappedStatement 中获取 Cache，注意这里的 Cache 是从MappedStatement中获取的
       // 也就是我们上面解析Mapper中<cache/>标签中创建的，它保存在Configration中
       // 我们在初始化解析xml时分析过每一个MappedStatement都有一个Cache对象，就是这里
       Cache cache = ms.getCache();
   
       // 如果配置文件中没有配置 <cache>，则 cache 为空
       if (cache != null) {
           //如果需要刷新缓存的话就刷新：flushCache="true"
           flushCacheIfRequired(ms);
           if (ms.isUseCache() && resultHandler == null) {
               // 暂时忽略，存储过程相关
               ensureNoOutParams(ms, boundSql);
               @SuppressWarnings("unchecked")
               // 从二级缓存中，获取结果
               List<E> list = (List<E>) tcm.getObject(cache, key);
               if (list == null) {
                   // 如果没有值，则执行查询，这个查询实际也是先走一级缓存查询，一级缓存也没有的话，则进行DB查询
                   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);
   }
   

4. 第一次查询，二级缓存肯定为空，所以最终会走到delegate.query中去，这个其实就是 BaseExecutor 的一个具体实现

   @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());
       // 已经关闭，则抛出 ExecutorException 异常
       if (closed) {
           throw new ExecutorException("Executor was closed.");
       }
       // 清空本地缓存，如果 queryStack 为零，并且要求清空本地缓存。
       if (queryStack == 0 && ms.isFlushCacheRequired()) {
           clearLocalCache();
       }
       List<E> list;
       try {
           // queryStack + 1
           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 - 1
           queryStack--;
       }
       if (queryStack == 0) {
           // 执行延迟加载
           for (DeferredLoad deferredLoad : deferredLoads) {
               deferredLoad.load();
           }
           // issue #601
           // 清空 deferredLoads
           deferredLoads.clear();
           // 如果缓存级别是 LocalCacheScope.STATEMENT ，则进行清理
           if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
               // issue #482
               clearLocalCache();
           }
       }
       return list;
   }
   

5. 先查询二级缓存再查询一级缓存，最后查询数据库，执行的queryFromDatabase

   // 从数据库中读取操作
   private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
       List<E> list;
       // 在缓存中，添加占位对象。此处的占位符，和延迟加载有关，可见 `DeferredLoad#canLoad()` 方法
       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;
   }
   

6. 查询结果添加到缓存localCache.putObject，这个其实就是一级缓存
7. 使用 TransactionalCacheManager 的tcm.putObject方法
   TransactionalCacheManager 内部维护了 Cache 实例与 TransactionalCache 实例间的映射关系，该类也仅负责维护两者的映射关系，真正做事的还是 TransactionalCache，TransactionalCache 是⼀种缓存装饰器，可以为 Cache 实例增加事务功能，先来看 TransactionalCache 这个类中的这三个成员变量

   public class TransactionalCache implements Cache {
   
       /**
        * 委托的 Cache 对象。
        *
        * 实际上，就是二级缓存 Cache 对象。
        */
       private final Cache delegate;
   
       /**
        *  在事务被提交前，所有从数据库中查询的结果将缓存在此集合中
        */
       private final Map<Object, Object> entriesToAddOnCommit;
   
       /**
        *   在事务被提交前，当缓存未命中时，CacheKey 将会被存储在此集合中
        */
       private final Set<Object> entriesMissedInCache;
   }
   

8. 二级缓存存放的时候，先存进这个名叫 entriesToAddOnCommit 的 map 集合中，但是获取二级缓存的时候，却是直接从 Cache 对象中去获取

   @Override
   public void putObject(Object key, Object object) {
       // 将键值对存入到 entriesToAddOnCommit 这个Map中中，而非真实的缓存对象 delegate 中
       entriesToAddOnCommit.put(key, object);
   }
   
   @Override
   public Object getObject(Object key) {
       // 查询的时候是直接从delegate中去查询的，也就是从真正的缓存对象中查询
       Object object = delegate.getObject(key);
       // 如果不存在，则添加到 entriesMissedInCache 中
       if (object == null) {
           // 缓存未命中，则将 key 存入到 entriesMissedInCache 中
           entriesMissedInCache.add(key);
       }
       // issue #146
       // 如果 clearOnCommit 为 true ，表示处于持续清空状态，则返回 null
       if (clearOnCommit) {
           return null;
       // 返回 value
       } else {
           return object;
       }
   }
   

9. 再看 commit 方法，秒懂，要想真正使二级缓存生效，就得让 commit 方法被执行，也就是业务代码中得执行 sqlsession.commit

   public void commit() {
       // 如果 clearOnCommit 为 true ，则清空 delegate 缓存
       if (clearOnCommit) {
           delegate.clear();
       }
       // 将 entriesToAddOnCommit、entriesMissedInCache 刷入 delegate(cache) 中
       flushPendingEntries();
       // 重置
       reset();
   }
   

10. 结论：存储二级缓存对象的时候是放到了 TransactionalCache.entriesToAddOnCommit这个 map 中，但是每次查询的时候是直接从TransactionalCache.delegate中去查询的，所以这个二级缓存查询数据库后，设置缓存值是没有立刻生效的，主要是因为直接存到 delegate 会导致脏数据问题

五、生效机制

抛出结论：只有在执行sqlsession.commit或者sqlsession.close之后，二级缓存才会生效

1. 入口肯定就是sqlSession.commit();，点进去

   @Override
   public void commit(boolean force) {
       try {
           // 提交事务
           executor.commit(isCommitOrRollbackRequired(force));
           // 标记 dirty 为 false
           dirty = false;
       } catch (Exception e) {
           throw ExceptionFactory.wrapException("Error committing transaction.  Cause: " + e, e);
       } finally {
           ErrorContext.instance().reset();
       }
   }
   

2. executor.commit走进 CachingExecutor 实现

   @Override
   public void commit(boolean required) throws SQLException {
       // 执行 delegate 对应的方法
       delegate.commit(required);
       // 提交 TransactionalCacheManager
       tcm.commit();
   }
   

3. 点进tcm.commit();

   /**
    * 提交所有 TransactionalCache
    */
   public void commit() {
       for (TransactionalCache txCache : transactionalCaches.values()) {
           txCache.commit();
       }
   }
   

4. 最终txCache.commit();调用了 TransactionalCache 中的 commit

   public void commit() {
       // 如果 clearOnCommit 为 true ，则清空 delegate 缓存
       if (clearOnCommit) {
           delegate.clear();
       }
       // 将 entriesToAddOnCommit、entriesMissedInCache 刷入 delegate(cache) 中
       flushPendingEntries();
       // 重置
       reset();
   }
   

六、刷新机制

结论：进行增删改操作时，就会清空二级缓存

1. 先看一下update入口

   @Override
   public int update(MappedStatement ms, Object parameterObject) throws SQLException {
       // 如果需要清空缓存，则进行清空
       flushCacheIfRequired(ms);
       // 执行 delegate 对应的方法
       return delegate.update(ms, parameterObject);
   }
   

2. 点进 flushCacheIfRequired

   /**
    * 如果需要清空缓存，则进行清空
    *
    * @param ms MappedStatement 对象
    */
   private void flushCacheIfRequired(MappedStatement ms) {
       Cache cache = ms.getCache();
       if (cache != null && ms.isFlushCacheRequired()) { // 是否需要清空缓存
           tcm.clear(cache);
       }
   }
   

3. tcm.clear就是 TransactionalCache 中的 clear

   @Override
   public void clear() {
       // 标记 clearOnCommit 为 true
       clearOnCommit = true;
       // 清空 entriesToAddOnCommit
       entriesToAddOnCommit.clear();
   }