mybatis源码解读：cache包（缓存机制）

港控/mmm° 2022-12-28 01:39 206阅读 0赞

欢迎关注本人公众号：

![20201220181453606.png][]

1.缓存机制

在进行源码阅读时，通常可以以包为单位进行，因为包本身就是具有一定结构、功能的类的集合，但是，也总会有一些功能相对复杂，会横跨多个包。因此以功能为主线一次阅读多个包中的源码是必要的，能帮助我们理清功能实现。

mybatis基于cache包中提供的缓存实现了两级缓存机制。

1.一级缓存

mybatis的一级缓存又叫本地缓存，与它相关的配置项有2个。

1.在配置文件XML的setting节点,可选项有session与statement，分别对应了一次会话和一条语句，一级缓存的默认范围是session。

> <setting name="cache" value="SESSION">

2.是在映射文件mapper.xml中的数据库操作节点内增加flushCache属性，默认值为false。可以设置为ture或false;当设置为true时，mybatis会在改数据库操作执行前清空一，二级缓存。

> <select id = "selectById" resultType="User"  flushCache="true">
> 
> </select>

一级缓存功能是由BaseExecutor类实现。BaseExecutor类作为实际执行器的基类，为所有实际执行器提供一些通用的基本功能，在这里增加缓存也就意味着每个实际执行器都具有着一级缓存。

>     public abstract class BaseExecutor implements Executor {
>     
>       private static final Log log = LogFactory.getLog(BaseExecutor.class);
>     
>       protected Transaction transaction;
>       protected Executor wrapper;
>     
>       protected ConcurrentLinkedQueue<DeferredLoad> deferredLoads;
>       // 查询操作的结果缓存
>       protected PerpetualCache localCache;
>       // Callable查询的输出参数缓存
>       protected PerpetualCache localOutputParameterCache;
>       protected Configuration configuration;
>     
>       protected int queryStack;
>       private boolean closed;
> 
>     /**
>      * 更新数据库数据，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);
>     }
>     
>     @Override
>     public List<BatchResult> flushStatements() throws SQLException {
>       return flushStatements(false);
>     }
>     
>     public List<BatchResult> flushStatements(boolean isRollBack) throws SQLException {
>       if (closed) {
>         throw new ExecutorException("Executor was closed.");
>       }
>       return doFlushStatements(isRollBack);
>     }
>     
>     /**
>      * 执行查询操作
>      * @param ms 映射语句对象
>      * @param parameter 参数对象
>      * @param rowBounds 翻页限制
>      * @param resultHandler 结果处理器
>      * @param <E> 输出结果类型
>      * @return 查询结果
>      * @throws SQLException
>      */
>     @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);
>     }
>     
>     /**
>      * 查询数据库中的数据
>      * @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;
>     }
> 
> \}

因为localCache和localOutputParameterCache都是Executor的属性，而Executor归属sqlSession，因此第一级缓存的最大作用范围便是sqlSession,即一次会话。而insert,update,delete方法都对应了Executor的update方法，会引发一级缓存的更新。可见一级缓存就是BaseExcecutor中的两个PrepetualCache类型的属性（localCache和localOutputParameterCache），其作用范围有限，不支持各种装饰器的修饰，因此不能进行容量配置，清理策略设置及阻塞设置等。

2.二级缓存

二级缓存的作用范围是一个命名空间（即一个mapper.xml映射文件）,而且可以实现多个命名空间共享一个缓存，因此比一级缓存作用范围更广，更为灵活。

有关二级缓存的4个配置：

1.在配置文件中的setting配置语句来启用和关闭二级缓存，默认值为true即默认开启二级缓存

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

2.在mapper.xml映射文件中，可以使用cache标签来开启配置本命名空间的缓存，或者使用cache-ref标签来开启。如果两项都不配置则表示命名空间没有缓存。注意：该配置只有在第一项配置中选择启用二级缓存时才有效。

> <cache  type="PERPETUA"> </cache> 或 <cache-ref namespace="com.UserMapper" />

3.第三个配置项为数据库操作节点内的userCache属性，可以配置使用二级缓存。注意只有当第一、二项都配置了才有效，而对应select语句默认值为true，对于insert，update，delete等语句则没有意义。

> <select id="selectById" resultType = "com.User" useCache = "true>
> 
> </select>

4.第四个配置项为数据库操作节点的flushCache属性项， 该配置属性与一级缓存共用，表示是否要在该语句执行前清除一、二级缓存。

二级缓存原理：

二级缓存功能由CacheingExecutor类实现，它是一个装饰器类， 能通过装饰实际执行器为它们增加二级缓存功能。mybatis会根据配置文件中的二级缓存开关配置用CacheingExecutor类装饰实际执行器。

在Configuration类中的newExecutor方法中实现用CacheingExecutor类装饰实际执行器。

>     /**
>      * 主要内容分为以下几个部分：
>      * 1、大量的配置项，和与`<configuration>`标签中的配置对应
>      * 2、创建类型别名注册机，并向内注册了大量的类型别名
>      * 3、创建了大量Map，包括存储映射语句的Map，存储缓存的Map等，这些Map使用的是一种不允许覆盖的严格Map
>      * 4、给出了大量的处理器的创建方法，包括参数处理器、语句处理器、结果处理器、执行器。
>      *    注意这里并没有真正创建，只是给出了方法。
>      */
>     
>     public class Configuration {
>     
>       // <environment>节点的信息
>       protected Environment environment;
> 
>     /**
>      * 创建一个执行器
>      * @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;
>     }
> 
> \}

在数据库操作中， 可以将多条语句封装为一个事务，而在我们没有显式地声明事务时，数据库会为每条语句开启一个事务。于是，事务不仅可以表示封装在一起的多条语句，也可以用来指一条普通的语句。tcm是事务缓存管理器，既然一条语句也是一个事务，那事务缓存管理器可以应用在有事务的场景， 也可以应用在无事务的场景。

>     public class CachingExecutor implements Executor {
>     
>       // 被装饰的执行器
>       private final Executor delegate;
>       // 事务缓存管理器
>       private final TransactionalCacheManager tcm = new TransactionalCacheManager();
>     
>       public CachingExecutor(Executor delegate) {
>         this.delegate = delegate;
>         delegate.setExecutorWrapper(this);
>       }
> 
>     /**
>      * 查询数据库中的数据
>      * @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);
>       }
>     }
> 
> \}

其中flushCacheIfRequired方法是用来判断并清理二级缓存的，而update方法（对应insert,update, delete数据库操作）也会调用flushCacheIfRequired方法，而对于这些语句isFlushCacheRequired方法都是返回true,所以总是导致二级缓存的清除。

3.二级缓存机制

mybatis存在两级缓存，其中一级缓存是由BaseExecutor通过两个PerpetualCache类型属性提供的，而二级缓存是由CachingExecutor装饰器类提供的。

那么在数据库查询操作中是先访问一级缓存还是二级缓存呢？

实际上CachingExecutor作为装饰器会先运行，然后才调用实际执行器，这时BaseExecutor中的方法才会执行。所以数据库查询操作中，mybatis会先访问二级缓存再访问一级缓存。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTIyMDQ3Mg_size_16_color_FFFFFF_t_70][]

[20201220181453606.png]: /images/20221120/bef70481293f43019034181d780b99a0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTIyMDQ3Mg_size_16_color_FFFFFF_t_70]: /images/20221120/91e47e1c0f6044fbacec52ac20082ac3.png