Mybatis源码剖析 -- 二级缓存

一、思考一个问题

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

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

二、启用二级缓存

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

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

   
      select * from user where id = #{id}
   
   

三、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())) {
                   // 获取  节点中的 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)) {
           // 解析 `` 节点
           configurationElement(parser.evalNode("/mapper"));
           // 标记该 Mapper 已经加载过
           configuration.addLoadedResource(resource);
           // 绑定 Mapper
           bindMapperForNamespace();
       }
   
       // 解析待定的  节点
       parsePendingResultMaps();
       // 解析待定的  节点
       parsePendingCacheRefs();
       // 解析待定的 SQL 语句的节点
       parsePendingStatements();
   }
   

3. 解析 节点

   // 解析 `` 节点
   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);
           // 解析  节点
           cacheRefElement(context.evalNode("cache-ref"));
           // 解析  节点
           cacheElement(context.evalNode("cache"));
           // 已废弃！老式风格的参数映射。内联参数是首选,这个元素可能在将来被移除，这里不会记录。
           parameterMapElement(context.evalNodes("/mapper/parameterMap"));
           // 解析  节点们
           resultMapElements(context.evalNodes("/mapper/resultMap"));
           // 解析  节点们
           sqlElement(context.evalNodes("/mapper/sql"));
           // 解析     节点们
           // 这里会将生成的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);
       }
   }
     
     
   解析  节点 
   // 解析  标签，获取 cache 标签的各个属性
   private void cacheElement(XNode context) throws Exception {
       if (context != null) {
           //解析标签的type属性，这里我们可以自定义cache的实现类，比如redisCache，如果没有自定义，这里使用和一级缓存相同的PERPETUAL
           String type = context.getStringAttribute("type", "PERPETUAL");
           Class typeClass = typeAliasRegistry.resolveAlias(type);
           // 获得负责过期的 Cache 实现类
           String eviction = context.getStringAttribute("eviction", "LRU");
           Class 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);
       }
   }
    
    
     
   创建 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 typeClass,
                            Class evictionClass,
                            Long flushInterval,
                            Integer size,
                            boolean readWrite,
                            boolean blocking,
                            Properties props) {
   
       // 1.生成Cache对象
       Cache cache = new CacheBuilder(currentNamespace)
               //这里如果我们定义了中的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;
   }
    
    
     
   将生成的 Cache 包装到对应的 MappedStatement 
   // 解析     节点们
   private void buildStatementFromContext(List list) {
       if (configuration.getDatabaseId() != null) {
           buildStatementFromContext(list, configuration.getDatabaseId());
       }
       buildStatementFromContext(list, null);
       // 上面两块代码，可以简写成 buildStatementFromContext(list, configuration.getDatabaseId());
   }
   

   private void buildStatementFromContext(List list, String requiredDatabaseId) {
       //遍历     节点们
       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 对象，并替换  标签相关的内容
       XMLIncludeTransformer includeParser = new XMLIncludeTransformer(configuration, builderAssistant);
       includeParser.applyIncludes(context.getNode());
   
       // Parse selectKey after includes and remove them.
       // 解析  标签
       processSelectKeyNodes(id, parameterTypeClass, langDriver);
   
       // Parse the SQL (pre:  and  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 对象。如果存在，意味着是  标签配置的
       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;
   }
     
     
    
   四、执行流程
    
    
    
     
   先走到selectList()中去 
   @Override
   public  List 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();
       }
   }
    
    
     
   点进executor.query实现类CachingExecutor缓存装饰类
    只要是 sqlMapConfig.xml 中开启全局的二级缓存配置，就会走这个实现类 
   @Override
   public  List 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);
   }
    
    
     
   创建 CacheKey，继续 query 
   @Override
   public  List query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
           throws SQLException {
   
       // 从 MappedStatement 中获取 Cache，注意这里的 Cache 是从MappedStatement中获取的
       // 也就是我们上面解析Mapper中标签中创建的，它保存在Configration中
       // 我们在初始化解析xml时分析过每一个MappedStatement都有一个Cache对象，就是这里
       Cache cache = ms.getCache();
   
       // 如果配置文件中没有配置 ，则 cache 为空
       if (cache != null) {
           //如果需要刷新缓存的话就刷新：flushCache="true"
           flushCacheIfRequired(ms);
           if (ms.isUseCache() && resultHandler == null) {
               // 暂时忽略，存储过程相关
               ensureNoOutParams(ms, boundSql);
               @SuppressWarnings("unchecked")
               // 从二级缓存中，获取结果
               List list = (List) 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);
   }
    
    
     
   第一次查询，二级缓存肯定为空，所以最终会走到delegate.query中去，这个其实就是 BaseExecutor 的一个具体实现 
   @Override
   public  List 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 list;
       try {
           // queryStack + 1
           queryStack++;
           // 从一级缓存中，获取查询结果
           list = resultHandler == null ? (List) 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;
   }
    
    
     
   先查询二级缓存再查询一级缓存，最后查询数据库，执行的queryFromDatabase 
   // 从数据库中读取操作
   private  List queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
       List 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;
   }
    
    
     
   查询结果添加到缓存localCache.putObject，这个其实就是一级缓存
    
     
   使用 TransactionalCacheManager 的tcm.putObject方法
    TransactionalCacheManager 内部维护了 Cache 实例与 TransactionalCache 实例间的映射关系，该类也仅负责维护两者的映射关系，真正做事的还是 TransactionalCache，TransactionalCache 是⼀种缓存装饰器，可以为 Cache 实例增加事务功能，先来看 TransactionalCache 这个类中的这三个成员变量 
   public class TransactionalCache implements Cache {
   
       /**
        * 委托的 Cache 对象。
        *
        * 实际上，就是二级缓存 Cache 对象。
        */
       private final Cache delegate;
   
       /**
        *  在事务被提交前，所有从数据库中查询的结果将缓存在此集合中
        */
       private final Map entriesToAddOnCommit;
   
       /**
        *   在事务被提交前，当缓存未命中时，CacheKey 将会被存储在此集合中
        */
       private final Set