Mybatis版本 3.4.6

配置

config配置

<configuration>
    <properties resource="db.properties"></properties>
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
        <!--一级缓存默认打开，下面这一行关闭了一级缓存-->
        <!--<setting name="localCacheScope" value="STATEMENT"/>-->
        <!--二级缓存默认打开，除非配置了下面的setting-->
        <setting name="cacheEnabled" value="false"/>
    </settings>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="personMapper.xml"/>
    </mappers>
</configuration>

一级二级缓存都是默认有效的，除非使用上述配置显式关闭。若想使用二级缓存，还必须在mapper.xml中配置<cache />，否则也无法使用二级缓存。

一级缓存

我们知道，Mybatis真正运行SQL的操作都委托给了BaseExecutor.java类，每次新open一个SqlSession，都会新建一个BaseExecutor，而一级缓存实际是BaseExecutor的一个实例变量，所以一级缓存是SqlSession独有的，不同的SqlSession不能共享；
请看下面查询操作：

//代码-1 BaseExecutor的query方法
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
      ......
      list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
      if (list != null) {
        handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
      } else {
        //若localCache中没有，则从数据库中查询并放入localCache中
        list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
      }
  
    if (queryStack == 0) {
      ......
      //若配置中配了<setting name="localCacheScope" value="STATEMENT"/>，则这句话就会生效，那么localCache就会被清空。
      //效果就是关闭了一级缓存，每次查询都会查到数据库中。
      if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
        clearLocalCache(); 
      }
    }
    return list;
  }

笔者觉得上述关闭一级缓存的方式并不优雅，因为总是要先把结果放入localCache中，如要关闭一级缓存，再清空。

一级缓存分成Session 和 Statement两种，Statement实际上就是没有一级缓存。

由于一级缓存是SqlSession级别的，这样就可能引发一个问题，SqlSession1修改了数据库，SqlSession2却感知不到这一变化，读到一级缓存中的脏数据。

二级缓存

二级缓存相关的类是CacheingExecutor.java，它的实例变量private final TransactionalCacheManager tcm = new TransactionalCacheManager()实际上就管理着二级缓存，其查询方法如下：

 public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
      throws SQLException {
    //这里的cache就是二级缓存
    Cache cache = ms.getCache(); 
    if (cache != null) {
      flushCacheIfRequired(ms);
      if (ms.isUseCache() && resultHandler == null) {
        ensureNoOutParams(ms, boundSql);
        @SuppressWarnings("unchecked")
        //先查二级缓存
        List<E> list = (List<E>) tcm.getObject(cache, key);
        if (list == null) {
          //二级缓存中没有，就通过BaseExecutor查询；BaseExecutor中会查询一级缓存
          list = delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
          tcm.putObject(cache, key, list); // A
        }
        return list;
      }
    }
    return delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
  }

Mybatis中的二级缓存是通过TransactionalCacheManager(tcm)维护的, 真正的二级缓存是TransactionalCache。

public class TransactionalCache implements Cache {
  //存储我们查询到的数据的地方
  private final Cache delegate;
  private boolean clearOnCommit;

  //查询的数据会先暂时放在这里，等commit()后，才能移到上面的delegate里
  private final Map<Object, Object> entriesToAddOnCommit;
  private final Set<Object> entriesMissedInCache;

  public TransactionalCache(Cache delegate) {
    this.delegate = delegate;
    this.clearOnCommit = false;
    this.entriesToAddOnCommit = new HashMap<Object, Object>();
    this.entriesMissedInCache = new HashSet<Object>();
  }

  @Override
  public String getId() {
    return delegate.getId();
  }

  @Override
  public int getSize() {
    return delegate.getSize();
  }

  @Override
  public Object getObject(Object key) {
    // issue #116
    Object object = delegate.getObject(key);
    if (object == null) {
      entriesMissedInCache.add(key);
    }
    // issue #146
    if (clearOnCommit) {
      return null;
    } else {
      return object;
    }
  }

  @Override
  public ReadWriteLock getReadWriteLock() {
    return null;
  }

  @Override
  public void putObject(Object key, Object object) {
    //这里可以发现，代码A并没有把查询结果真正放入到缓存里，只是放在了entriesToAddOnCommit这个临时的地方
    entriesToAddOnCommit.put(key, object);
  }

  @Override
  public Object removeObject(Object key) {
    return null;
  }

  @Override
  public void clear() {
    clearOnCommit = true;
    entriesToAddOnCommit.clear();
  }

  //调用该方法，查询结果才会放入二级缓存
  public void commit() {
    if (clearOnCommit) {
      delegate.clear();
    }
    //把临时保存的数据保存到缓存中
    flushPendingEntries();
    reset();
  }

  public void rollback() {
    unlockMissedEntries();
    reset();
  }

  private void reset() {
    clearOnCommit = false;
    entriesToAddOnCommit.clear();
    entriesMissedInCache.clear();
  }

  //一次commit，可以将一个事务中多次查询的结果一次性放入缓存
  private void flushPendingEntries() {
    for (Map.Entry<Object, Object> entry : entriesToAddOnCommit.entrySet()) {
      delegate.putObject(entry.getKey(), entry.getValue());
    }
    for (Object entry : entriesMissedInCache) {
      if (!entriesToAddOnCommit.containsKey(entry)) {
        delegate.putObject(entry, null);
      }
    }
  }

  private void unlockMissedEntries() {
    for (Object entry : entriesMissedInCache) {
      try {
        delegate.removeObject(entry);
      } catch (Exception e) {
        log.warn("Unexpected exception while notifiying a rollback to the cache adapter."
            + "Consider upgrading your cache adapter to the latest version.  Cause: " + e);
      }
    }
  }
}

缓存的初始化

从上文可知，缓存是与Executor关联在一起，使用不同的Executor执行sql，就会使用不同的缓存。下面看一下Executor的初始化：
Configuration.java

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) { //可以通过setting配置为false；默认为true；
      executor = new CachingExecutor(executor); //二级缓存
    }
    executor = (Executor) interceptorChain.pluginAll(executor);
    return executor;
  }

二级缓存的初始化

二级缓存是通过解析mapper.xml中的<cache />或<cache-ref />进行初始化的，若没有这两个中的任意一个配置，是无法使用二级缓存的。
XMLMapperBuilder.java

private void cacheElement(XNode context) throws Exception {
    if (context != null) {
      String type = context.getStringAttribute("type", "PERPETUAL");
      Class<? extends Cache> typeClass = typeAliasRegistry.resolveAlias(type);
      String eviction = context.getStringAttribute("eviction", "LRU");
      Class<? extends Cache> evictionClass = typeAliasRegistry.resolveAlias(eviction);
      Long flushInterval = context.getLongAttribute("flushInterval");
      Integer size = context.getIntAttribute("size");
      boolean readWrite = !context.getBooleanAttribute("readOnly", false);
      boolean blocking = context.getBooleanAttribute("blocking", false);
      Properties props = context.getChildrenAsProperties();
      builderAssistant.useNewCache(typeClass, evictionClass, flushInterval, size, readWrite, blocking, props);
    }
  }

上面的attribute实际上就是cache标签的属性，这里实例化了各种Cache，并进行了装饰，装饰后，默认情况下如下图所示；然后将该cache的引用赋值给MappedStatement实例，MappedStatement实例代表了一个sql，这样就把mapper.xml的sql语句与cache联系到了一起。当该sql查询出结果后，放入该cache中并交给TransactionalCacheManager管理。

Cache.png

本文参考了这里