欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

Mybatis 缓存 源码分析

程序员文章站 2022-06-27 20:55:54
文章目录1. 结论2. Show code2.1 SimpleExecutor2.2 CacheExecutor3 细说1. 结论老规矩,先说结论。给各位大兄弟来点总结。mybatis有两级缓存,分别是:SqlSession级别Mapper级别想必大家都对这个结论不陌生,但是有许多人其实并不明白具体原因。所以今天就和各位大兄弟一起来探讨一下具体代码。2. Show code这个缓存就得从创建执行器开始,org.apache.ibatis.session.Configuration#new...

1. 结论

老规矩,先说结论。给各位大兄弟来点总结。

mybatis有两级缓存,分别是:

  • SqlSession级别
  • Mapper级别

想必大家都对这个结论不陌生,但是有许多人其实并不明白具体原因。所以今天就和各位大兄弟一起来探讨一下具体代码。

2. Show code

这个缓存就得从创建执行器开始,org.apache.ibatis.session.Configuration#newExecutor(org.apache.ibatis.transaction.Transaction, org.apache.ibatis.session.ExecutorType),创建执行器是从创建SqlSession开始的, 这个看过上一篇文章的大兄弟应有了解,就不一一说啦。先上代码。

  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);
    }
    if (cacheEnabled) { // 是否开启二级缓存,这个属性是从配置文件中解析出来的。二级缓存默认是true.
      executor = new CachingExecutor(executor);
    }
    executor = (Executor) interceptorChain.pluginAll(executor);
    return executor;
  }

这段代码,我们可以看出,如果在配置文件中,没有开启二级缓存,则会直接创建一个Executor, 如果开启了二级缓存,则会把创建的执行器进行包装。 那我们就从没有开启二级缓存查看。(为什么要直接分析SimpleExecutor先不说,卖个关子)

2.1 SimpleExecutor

直接点进SimpleExecutor,发现没啥东西,直接点进父类构造函数。(BaseExecutor有三个默认实现,分别是:BatchExecutorReuseExecutorSimpleExecutor。所以小伙伴不要纠结为什么选择SimpleExecutor了)代码如下。

  protected BaseExecutor(Configuration configuration, Transaction transaction) {
    this.transaction = transaction;
    this.deferredLoads = new ConcurrentLinkedQueue<DeferredLoad>();
    this.localCache = new PerpetualCache("LocalCache");
    this.localOutputParameterCache = new PerpetualCache("LocalOutputParameterCache");
    this.closed = false;
    this.configuration = configuration;
    this.wrapper = this;
  }

点进父类的构造函数,我们大概也看出来了,在父类的构造函数中,的确存在名字叫localCache。 那不行,我们只看到了Cahce,得找到使用的地方。缓存一般都是用来缓存查询内容的,那我们就去找select,query方法咯。

  private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    List<E> list;
    // 用来延迟加载,表示当前key已经被缓存
    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;
  }

从一个query方法中,点到最后。我们不用关注其中细节,在最终query方法中,的确是放入缓存中。我们看一下localCache的具体类型。代码如下。

public class PerpetualCache implements Cache {

  private final String id;

  private Map<Object, Object> cache = new HashMap<Object, Object>();

  public PerpetualCache(String id) {
    this.id = id;
  }
}

很简单,就是一个id 和 一个map。 ,这也就是说明了,mybatis是用map来缓存数据的。

我们看到现在,算是明白了,mybatis中的一级缓存是自动开启的,不需要什么配置文件,也只是用map来缓存的。

2.2 CacheExecutor

从上面代码看,CacheExecutor是对SimpleExecutor进行了包装。那就进代码看看。

  public CachingExecutor(Executor delegate) {
    this.delegate = delegate;
    // 进行包装, 从实现类字面理解,就是延迟加载
    delegate.setExecutorWrapper(this);
  }

我们不关注这么多, 我们就一个目的,搞清楚这个cache。 老规矩,查缓存从select或query方法找起来。

  public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
      throws SQLException {
    // 从mappedStatement中获取缓存。
    Cache cache = ms.getCache();
    if (cache != null) {
      flushCacheIfRequired(ms);
      if (ms.isUseCache() && resultHandler == null) {
        ensureNoOutParams(ms, boundSql);
        @SuppressWarnings("unchecked")
       	// 把cache和key传递进去,查看是否有缓存数据
        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);
  }

我们基本看出来,这个ms.getCache()是至关重要的,因为在代码中,接下来的操作都和这个cache有关系。 那么唯一的一件事就是搞清楚这个cache是从哪来的。我们就从MappedStatement的方方法开始看,这个cache是如何生成的。

public final class MappedStatement {
  ....
  public Builder cache(Cache cache) {
    mappedStatement.cache = cache;
    return this;
  }
  ...
}

我们不难看出来,这个Cache通过传递进来,然后直接赋值给了MappedStatement的变量。 那么我们就点击一下这个方法,看被哪调用。

org.apache.ibatis.builder.MapperBuilderAssistant#addMappedStatement(...){
  MappedStatement.Builder statementBuilder = new MappedStatement.Builder(configuration, id, sqlSource, sqlCommandType)
       	...
        .useCache(valueOrDefault(useCache, isSelect))
    		// 传入cache
        .cache(currentCache);
}

我们发现被这个方法,这个方法有点熟悉,就是我们前一篇文章讲到的,在解析mapper,构建MappedStatement的方法。这个传入的currentCache不是当期方法的,是当前类的,那我们就要看当那类是怎么构建出来的。我们直接看这个方法被哪调用,然后顺藤摸瓜,找到创建的地方。

public void parseStatementNode() {
    String id = context.getStringAttribute("id");
    String databaseId = context.getStringAttribute("databaseId");

   	...
    // 通过使用builderAssistant添加mapper. 我们要接着看builderAssistant是如何构建的
    builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType,
        fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass,
        resultSetTypeEnum, flushCache, useCache, resultOrdered, 
        keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets);
  }

note: 看到这些代码并不陌生,我们现在反着推断了。 有的小伙伴肯定好奇,我是如何找到这些方法的, 如何你有这个疑问,就需要看一下前一篇mybatis的文章啦!!

因为builderAssistant是类成员变量,那我们接着看parseStatementNode()方法被哪调用,然后找到构建builderAssistant的地方

 private void buildStatementFromContext(List<XNode> list, String requiredDatabaseId) {
    for (XNode context : list) {
      final XMLStatementBuilder statementParser = new XMLStatementBuilder(configuration, builderAssistant, context, requiredDatabaseId);
      try {
        statementParser.parseStatementNode();
      } catch (IncompleteElementException e) {
        configuration.addIncompleteStatement(statementParser);
      }
    }
  }

到这仍发现builderAssistant是传递过来的,那我们就接着往上翻代码。找到当前类是如何构建的。

一直往上翻,有很多代码,道理相同,我们最后找到了如下代码。

private void configurationElement(XNode context) {
    try {
      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"));
      // 构建cache
      cacheElement(context.evalNode("cache"));
      parameterMapElement(context.evalNodes("/mapper/parameterMap"));
      resultMapElements(context.evalNodes("/mapper/resultMap"));
      sqlElement(context.evalNodes("/mapper/sql"));
      // 解析mappedStatement
      buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
    } catch (Exception e) {
      ...
    }
  }

这个熟悉的感觉。 我们看大了给builderAssistant设置namespace。并且有关于cache的代码,这个时候就不要点走啦,得进去看看了,因为已经到了我们关心的点。点进cacheElement(context.evalNode("cache"));一探究竟。

  public Cache useNewCache(Class<? extends Cache> typeClass,
      Class<? extends Cache> evictionClass,
      Long flushInterval,
      Integer size,
      boolean readWrite,
      boolean blocking,
      Properties props) {
    Cache cache = new CacheBuilder(currentNamespace)
        .implementation(valueOrDefault(typeClass, PerpetualCache.class))
        .addDecorator(valueOrDefault(evictionClass, LruCache.class))
        .clearInterval(flushInterval)
        .size(size)
        .readWrite(readWrite)
        .blocking(blocking)
        .properties(props)
        .build();
    configuration.addCache(cache);
    currentCache = cache;
    return cache;
  }

发现最终调用了org.apache.ibatis.builder.MapperBuilderAssistant#useNewCache的方法,我们也如愿看到了cache的产生,并且是以namespace为单位的。

自此,我们搞清楚了一条大概的逻辑。

3 细说

现在大体逻辑是搞懂了,但是代码可能各位大兄弟看着有些糊涂,建议在电脑自己看看,加深一下印象。 毕竟看别人千遍,不如自己来实现一遍。

本文地址:https://blog.csdn.net/shiyan719902675/article/details/107138565