Mybatis CachingExecutor二级缓存使用示例详解

mybatis.configuration.cache-enabled=true

// SqlSessionUtils.class
// 通过工厂对象(单例，存在容器中)，开启会话，获得会话对象，executorType是执行器枚举类(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配置，单例)创建执行器
    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 {
    // 创建了一个简易执行器
    executor = new SimpleExecutor(this, transaction);
  }
  // 如果开启了缓存，即 mybatis.configuration.cache-enabled=true
  if (cacheEnabled) {
    // 创建了缓存执行器，并且把简易执行器作为其 delegate，通过构造方法放入
    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接口的所有方法
  // 当然，它同样也包含某些mapper层次的设置，如对应的xml文件位置等，此处的Cache同样是mapper层次的设置
  Cache cache = ms.getCache();
  // 有Cache才会真正的去找二级缓存，否则直接就让委托的执行器去查询数据了。
  // 注意此处的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” 则进行 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 进行结果的存储
      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) {
	    // 先把缓存设置作为key，查询出一个TransactionalCache
    	return getTransactionalCache(cache).getObject(key);
  	}
  	private TransactionalCache getTransactionalCache(Cache cache) {
  	    // 作为第一次查询，不难发现，所谓的value居然也是依托缓存设置来构造的
    	return transactionalCaches.computeIfAbsent(cache, TransactionalCache::new);
    }
  	// ....
}
public class TransactionalCache implements Cache {
    private final Cache delegate;
    private boolean clearOnCommit;
    // 临时待加缓存，查询数据库返回的结果，首先会放在这里，等本次事务提交后，才会加入到真正的二级缓存中，即调用套娃对象，层层深入，最终存入HashMap
    // 在事务提交前，其他会话甚至本会话自己都无法看见该缓存,更无法使用该缓存
    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其实就是我们说的mapper缓存设置
		// 由此可见，缓存设置中也能包含缓存的值，并且以完整sql为键，sql结果为值以map存储
		Object object = delegate.getObject(key);
		if (object == null) {
			entriesMissedInCache.add(key);
		}
		// issue #146
		if (clearOnCommit) {
			return null;
		} else {
			return object;
		}
	}
}