首先从配置文件说起，有个cacheEnabled的配置项，当设置为true时（默认就是true），Session就会用一个CachingExecutor来包装我们的Executor实例：
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) {
executor = new CachingExecutor(executor);
}
executor = (Executor) interceptorChain.pluginAll(executor);
return executor;
}
这是一个装饰者模式，在大部分情况下是直接转发调用的，在update方法和query方法中分别根据mapper中statement的配置来对缓存进行读取和刷新
@Override
public int update(MappedStatement ms, Object parameterObject) throws SQLException {
flushCacheIfRequired(ms);
return delegate.update(ms, parameterObject);
}
@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);
}
其中flushCacheIfRequired和ms.isUseCache都是在Mapper文件中配置的，用于刷新缓存和使用缓存
以上所说的缓存都是二级缓存，所谓二级缓存就是可以在查询结束后还能操作的全局缓存。
相比于全局缓存，那么就有局部缓存，也叫一级缓存，在mybatis中用LocalCache表示
Mybatis的局部缓存有两种作用域可以配置： SESSION和STATEMENT，会话作用域和语句作用域；本地缓存一直是开着的，在执行器内部会存放一个PerpetualCache类型的成员变量localCache来作为查询缓存，一个PerpetualCache类型的localOutputParameterCache成员来缓存存储过程的输出参数。如果是statement级别的缓存，那么在这个statement执行完成后就会清空缓存。如果执行更新操作会立即清空本地缓存。
@Override
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
if (closed) {
throw new ExecutorException("Executor was closed.");
}
if (queryStack == 0 && ms.isFlushCacheRequired()) {
clearLocalCache();
}
List<E> list;
try {
queryStack++;
list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
if (list != null) {
handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
} else {
list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
}
} finally {
queryStack--;
}
if (queryStack == 0) {
for (DeferredLoad deferredLoad : deferredLoads) {
deferredLoad.load();
}
// issue #601
deferredLoads.clear();
if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
// issue #482
// 如果是statement级别的缓存，那么在这个statement执行完成后就会清空缓存
clearLocalCache();
}
}
return list;
}
// 清空缓存
@Override
public void clearLocalCache() {
if (!closed) {
localCache.clear();
localOutputParameterCache.clear();
}
}
private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
List<E> list;
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;
}
@Override
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);
}
我们可以看到，本地缓存使用的是PerpetualCache，它实现了Cache接口，那么二级缓存用的是什么呢：
事实上，这又是一个装饰者模式，Cache接口的唯一真正实现是PerpetualCache，其他的实现类都是对它的包装，比如LoggingCache：
public class LoggingCache implements Cache {
private Log log;
private Cache delegate;
protected int requests = 0; // 访问数量
protected int hits = 0; // 命中数量
public LoggingCache(Cache delegate) {
this.delegate = delegate;
this.log = LogFactory.getLog(getId());
}
... omitted ...
@Override
public Object getObject(Object key) {
requests++;
final Object value = delegate.getObject(key);
if (value != null) {
hits++;
}
if (log.isDebugEnabled()) {
log.debug("Cache Hit Ratio [" + getId() + "]: " + getHitRatio()); // 记录缓存命中率
}
return value;
}
@Override
public Object removeObject(Object key) {
return delegate.removeObject(key);
}
// 缓存命中率
private double getHitRatio() {
return (double) hits / (double) requests;
}
}
LoggingCache是对Cache对象的一个包装，然后记录缓存命中率。
当然还有负责淘汰的包装器，比如 LruCache（默认的淘汰包装器）：
public class LruCache implements Cache {
private final Cache delegate;
private Map<Object, Object> keyMap;
private Object eldestKey;
public LruCache(Cache delegate) {
this.delegate = delegate;
setSize(1024);
}
// 设置缓存大小，分配缓存存储空间，LinkedHashMap，移除最近最少使用的key的时候讲key交给eldestKey
public void setSize(final int size) {
keyMap = new LinkedHashMap<Object, Object>(size, .75F, true) {
private static final long serialVersionUID = 4267176411845948333L;
@Override
protected boolean removeEldestEntry(Map.Entry<Object, Object> eldest) {
boolean tooBig = size() > size;
if (tooBig) {
eldestKey = eldest.getKey();
}
return tooBig;
}
};
}
@Override
public void putObject(Object key, Object value) {
delegate.putObject(key, value);
cycleKeyList(key);
}
@Override
public Object getObject(Object key) {
keyMap.get(key); //touch一下，更新时间
return delegate.getObject(key);
}
@Override
public void clear() {
delegate.clear();
keyMap.clear();
}
@Override
public ReadWriteLock getReadWriteLock() {
return null;
}
// 移除 eldestKey
private void cycleKeyList(Object key) {
keyMap.put(key, key);
if (eldestKey != null) {
delegate.removeObject(eldestKey);
eldestKey = null;
}
}
}
同样，这个缓存和淘汰缓存的实现都是可以在Mapper文件中指定的，可以自己写Cache实现类，然后配置在Mapper文件中
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);
}
}
但是这些跟executor好像都没有什么关系，我们的CachingExecutor中是使用tcm成员对象来对缓存进行管理的，这个tcm实际上是TransactionalCacheManager的一个示例，TransactionalCacheManager类是对缓存的事务包装，细想，如果一个事务失败了，那个这个缓存该怎么搞呢，之前写了的缓存该怎么回滚？
在TransactionalCacheManager中是使用TransactionalCache来实现这一点的，他也是对Cache的一层包装，不过在putObject方法中，它并没有直接调用被包装cache对象的putObject，而是将键值对保存到自己的私有成员entriesToAddOnCommit中，待被调用commit方法时，才会将这些键值对通过调用被包装对象cache的putObject刷入真正的缓存：
private Map<Object, Object> entriesToAddOnCommit; //内部的键值对
public void putObject(Object key, Object object) {
entriesToAddOnCommit.put(key, object); //put到内部的键值对
}
public void commit() {
if (clearOnCommit) {
delegate.clear();
}
flushPendingEntries();
reset();
}
public void rollback() {
unlockMissedEntries();
reset();
}
private void flushPendingEntries() { // 将内部的键值对刷入到 真正的cache中
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);
}
}
}
TransactionalCacheManager将Cache包装成TransactionalCache
private TransactionalCache getTransactionalCache(Cache cache) {
TransactionalCache txCache = transactionalCaches.get(cache);
if (txCache == null) {
txCache = new TransactionalCache(cache);
transactionalCaches.put(cache, txCache);
}
return txCache;
}
之后，来看看缓存key的计算，cacheKey是在BaseExecutor.createCacheKey方法中计算的：
public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {
if (closed) {
throw new ExecutorException("Executor was closed.");
}
CacheKey cacheKey = new CacheKey();
cacheKey.update(ms.getId()); // statementId
cacheKey.update(rowBounds.getOffset()); // offset
cacheKey.update(rowBounds.getLimit()); // limit
cacheKey.update(boundSql.getSql()); // sql语句
List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry();
// mimic DefaultParameterHandler logic
for (ParameterMapping parameterMapping : parameterMappings) {
if (parameterMapping.getMode() != ParameterMode.OUT) {
Object value;
String propertyName = parameterMapping.getProperty();
if (boundSql.hasAdditionalParameter(propertyName)) {
value = boundSql.getAdditionalParameter(propertyName);
} else if (parameterObject == null) {
value = null;
} else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
value = parameterObject;
} else {
MetaObject metaObject = configuration.newMetaObject(parameterObject);
value = metaObject.getValue(propertyName);
}
cacheKey.update(value); // 参数
}
}
if (configuration.getEnvironment() != null) {
// issue #176
cacheKey.update(configuration.getEnvironment().getId()); //数据库
}
return cacheKey;
}
cacheKey的计算是根据statementId, 分页情况，查询参数和数据库链接作为条件来计算的，CacheKey会根据这些条件来区分每一个CacheKey：
public class CacheKey implements Cloneable, Serializable {
// hashCode扩展因子
private static final int DEFAULT_MULTIPLYER = 37;
// hashcode初始值
private static final int DEFAULT_HASHCODE = 17;
private int multiplier;
private int hashcode;
private long checksum;
private int count;
private List<Object> updateList;
public CacheKey() {
this.hashcode = DEFAULT_HASHCODE;
this.multiplier = DEFAULT_MULTIPLYER;
this.count = 0;
this.updateList = new ArrayList<Object>();
}
public CacheKey(Object[] objects) {
this();
updateAll(objects);
}
public int getUpdateCount() {
return updateList.size();
}
public void update(Object object) {
if (object != null && object.getClass().isArray()) {
int length = Array.getLength(object);
for (int i = 0; i < length; i++) {
Object element = Array.get(object, i);
doUpdate(element);
}
} else {
doUpdate(object);
}
}
// 计算hashCode和校验和
private void doUpdate(Object object) {
int baseHashCode = object == null ? 1 : object.hashCode();
count++;
checksum += baseHashCode;
baseHashCode *= count;
hashcode = multiplier * hashcode + baseHashCode;
updateList.add(object);
}
public void updateAll(Object[] objects) {
for (Object o : objects) {
update(o);
}
}
// IMPORTANT
@Override
public boolean equals(Object object) {
if (this == object) {
return true;
}
if (!(object instanceof CacheKey)) {
return false;
}
final CacheKey cacheKey = (CacheKey) object;
// hash值不同，肯定不是同一个Cache
if (hashcode != cacheKey.hashcode) {
return false;
}
// 校验和不同，也不是相同的Cache
if (checksum != cacheKey.checksum) {
return false;
}
//参数数量不同
if (count != cacheKey.count) {
return false;
}
// 最后再依次比较各个条件，为了速度
for (int i = 0; i < updateList.size(); i++) {
Object thisObject = updateList.get(i);
Object thatObject = cacheKey.updateList.get(i);
if (thisObject == null) {
if (thatObject != null) {
return false;
}
} else {
if (!thisObject.equals(thatObject)) {
return false;
}
}
}
return true;
}
// 根据条件产生cahceKey的字符串，效率较慢，给自定义缓存使用
@Override
public String toString() {
StringBuilder returnValue = new StringBuilder().append(hashcode).append(':').append(checksum);
for (Object object : updateList) {
returnValue.append(':').append(object);
}
return returnValue.toString();
}
}
最后，附上一张缓存工作的时序图，TransactionCachingManager是二级缓存，LocalCache是一级缓存
