Mybatis 源码学习(七) 缓存的刷新

谁践踏了优雅 2022-05-21 07:58 334阅读 0赞

之前学习了mybatis的一级缓存和二级缓存。

那么当数据库数据有跟新的时候，缓存是如何被刷新的呢？

找到update的实现源码：

public int update(String statement, Object parameter) {
        try {
          dirty = true;
          MappedStatement ms = configuration.getMappedStatement(statement);
          return executor.update(ms, wrapCollection(parameter));
        } catch (Exception e) {
          throw ExceptionFactory.wrapException("Error updating database.  Cause: " + e, e);
        } finally {
          ErrorContext.instance().reset();
        }
      }

看来是在executor中清理的。

public class CachingExecutor implements Executor {
      
    public int update(MappedStatement ms, Object parameterObject) throws SQLException {
        flushCacheIfRequired(ms); //这里清空了二级缓存
        return delegate.update(ms, parameterObject);
      }
     
     private void flushCacheIfRequired(MappedStatement ms) {
        Cache cache = ms.getCache();
        if (cache != null && ms.isFlushCacheRequired()) {
          dirty = true; // issue #524. Disable using cached data for this session
          tcm.clear(cache);
        }
      }
    }

public abstract class BaseExecutor implements Executor {
      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);
      }
    }

public void clearLocalCache() {
        if (!closed) {
          localCache.clear();
          localOutputParameterCache.clear();
        }
      }

一级缓存比较简单清晰，同一个sqlSession执行查询的时候缓存，再执行相同查的时候使用缓存，当执行修改操作的时候，直接刷新整个sqlSession的缓存（在Executer上的localCache）。

![70][]

二级缓存的更新一直让我有点困惑，缓存是在MappedStatement上的，怎么能在修改的时候把其他的查询缓存清除呢，他们是在不同的MappedStatement上的啊？

先看查询的时候是怎么放到缓存的

@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, parameterObject, 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);
      }
    
      public void putObject(Cache cache, CacheKey key, Object value) {
        getTransactionalCache(cache).putObject(key, value);
      }
      private TransactionalCache getTransactionalCache(Cache cache) {
        TransactionalCache txCache = transactionalCaches.get(cache);
        if (txCache == null) {
          txCache = new TransactionalCache(cache);
          transactionalCaches.put(cache, txCache);
        }
        return txCache;
      }

从以上的三个方法可以看到，是通过TransactionalCacheManager来放入缓存的。在放入mappedStatement的缓存同时，还被存入了executror下的tcm属性的transactionalCaches对象内容。这是有点绕。如下图所看到的，通过层层代理，最终看到id是mapper的名字。这样其他的SqlSession在查询的时候先查缓存中是否已经存在。刷新的时候也是按照mapper来刷新的。大功告成！

![70 1][]

[70]: /images/20220521/dc9ba2abf8de4287bfd563a56946f461.png
[70 1]: /images/20220521/1dcde893c29941eba724a99484284a36.png