mybatis.configuration.cache-enabled=true

// SqlSessionUtils.class
// 通過工廠對象(單例，存在容器中)，開啟會話，獲得會話對象，executorType是執(zhí)行器枚舉類(SIMPLE, REUSE, BATCH)，一般是SIMPLE
session = sessionFactory.openSession(executorType);

// DefaultSqlSessionFactory.class
private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
  Transaction tx = null;
  try {
    final Environment environment = configuration.getEnvironment();
    final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
    tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
    // 通過configuration(Mybatis配置，單例)創(chuàng)建執(zhí)行器
    final Executor executor = configuration.newExecutor(tx, execType);
    return new DefaultSqlSession(configuration, executor, autoCommit);
  } catch (Exception e) {
    closeTransaction(tx); // may have fetched a connection so lets call close()
    throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);
  } finally {
    ErrorContext.instance().reset();
  }
}

// Configuration.class
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 {
    // 創(chuàng)建了一個簡易執(zhí)行器
    executor = new SimpleExecutor(this, transaction);
  }
  // 如果開啟了緩存，即 mybatis.configuration.cache-enabled=true
  if (cacheEnabled) {
    // 創(chuàng)建了緩存執(zhí)行器，并且把簡易執(zhí)行器作為其 delegate，通過構(gòu)造方法放入
    executor = new CachingExecutor(executor);
  }
  executor = (Executor) interceptorChain.pluginAll(executor);
  return executor;
}

// CachingExecutor.class
@Override
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
    throws SQLException {
  // mappedStatement 就是我們寫的mapper接口里的某個方法的所有信息，注意其描述的是一個方法，而不是一整個mapper接口的所有方法
  // 當(dāng)然，它同樣也包含某些mapper層次的設(shè)置，如對應(yīng)的xml文件位置等，此處的Cache同樣是mapper層次的設(shè)置
  Cache cache = ms.getCache();
  // 有Cache才會真正的去找二級緩存，否則直接就讓委托的執(zhí)行器去查詢數(shù)據(jù)了。
  // 注意此處的Cache并不是緩存本身，而是mapper里的緩存配置
  if (cache != null) {
    // ....
      List<E> list = (List<E>) tcm.getObject(cache, key);
    // ....
      return list;
    }
  }
  return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}

// MapperBuilderAssistant.class
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;
}

// CachingExecutor.class query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
if (cache != null) {
  // 是否清緩存，即如果Cache配置里含有flushCache=“true” 則進(jìn)行 tcm.clear();
  flushCacheIfRequired(ms);
  if (ms.isUseCache() && resultHandler == null) {
    ensureNoOutParams(ms, boundSql);
    @SuppressWarnings("unchecked")
    // tcm 是一個成員變量，是通過new TransactionalCacheManager()賦值的，此處為查詢
    List<E> list = (List<E>) tcm.getObject(cache, key);
    if (list == null) {
      list = delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
      // 通過 tcm 進(jìn)行結(jié)果的存儲
      tcm.putObject(cache, key, list); // issue #578 and #116
    }
    return list;
  }
}

public class TransactionalCacheManager {
	private final Map<Cache, TransactionalCache> transactionalCaches = new HashMap<>();
	public Object getObject(Cache cache, CacheKey key) {
	    // 先把緩存設(shè)置作為key，查詢出一個TransactionalCache
    	return getTransactionalCache(cache).getObject(key);
  	}
  	private TransactionalCache getTransactionalCache(Cache cache) {
  	    // 作為第一次查詢，不難發(fā)現(xiàn)，所謂的value居然也是依托緩存設(shè)置來構(gòu)造的
    	return transactionalCaches.computeIfAbsent(cache, TransactionalCache::new);
    }
  	// ....
}
public class TransactionalCache implements Cache {
    private final Cache delegate;
    private boolean clearOnCommit;
    // 臨時待加緩存，查詢數(shù)據(jù)庫返回的結(jié)果，首先會放在這里，等本次事務(wù)提交后，才會加入到真正的二級緩存中，即調(diào)用套娃對象，層層深入，最終存入HashMap
    // 在事務(wù)提交前，其他會話甚至本會話自己都無法看見該緩存,更無法使用該緩存
    private final Map<Object, Object> entriesToAddOnCommit;
    // 查二級緩存沒查到時，會把key值存在這個miss的集合中
    private final Set<Object> entriesMissedInCache;
    public TransactionalCache(Cache delegate) {
    	this.delegate = delegate;
    	this.clearOnCommit = false;
    	this.entriesToAddOnCommit = new HashMap<>();
    	this.entriesMissedInCache = new HashSet<>();
    }
	public Object getObject(Object key) {
		// issue #116
		// 觀察后，可以知道，這里的delegate其實(shí)就是我們說的mapper緩存設(shè)置
		// 由此可見，緩存設(shè)置中也能包含緩存的值，并且以完整sql為鍵，sql結(jié)果為值以map存儲
		Object object = delegate.getObject(key);
		if (object == null) {
			entriesMissedInCache.add(key);
		}
		// issue #146
		if (clearOnCommit) {
			return null;
		} else {
			return object;
		}
	}
}