一文详解mybatis二级缓存执行流程
作者：LixBox
本文主要详细介绍了mybatis二级缓存执行流程,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考价值,感兴趣的朋友们下面随着小编来一起学习吧
mybatis二级缓存的执行流程
1.二级缓存的生成
在mybatis启动时会加载并解析配置文件，其中就会解析二级缓存的可选项配置，由此是否生成二级缓存，下面这段代码就是解析xxxMapper.xml文件中的子标签来生成二级缓存
//XMLmapperBuilder
private void configurationElement(XNode context) {
try {
// 获取<mapper>标签的namespace值，也就是命名空间
String namespace = context.getStringAttribute("namespace");
// 命名空间不能为空
if (namespace == null || namespace.isEmpty()) {
throw new BuilderException("Mapper's namespace cannot be empty");
}
// MapperBuilderAssistant:构建MappedStatement对象的构建助手，设置当前的命名空间为namespace的值
builderAssistant.setCurrentNamespace(namespace);
......
// 解析<cache>子标签,这里生成二级缓存
cacheElement(context.evalNode("cache"));
......
} catch (Exception e) {
throw new BuilderException("Error parsing Mapper XML. The XML location is '" + resource + "'. Cause: " + e, e);
}
}
默认的二级缓存对象是PerpetuateCache,并把缓存封装进MapperStatement，所以一个MapperStatement对应一个二级缓存，一个MapperStatement就是存储一个xxxMapper.xml文件中的信息
//XMLmapperBuilder
private void cacheElement(XNode context) {
if (context != null) {
// 解析<cache>标签type属性的值，在这可以自定义type的值，比如redisCache,如果没有指定默认就是PERPETUAL
String type = context.getStringAttribute("type", "PERPETUAL");
Class<? extends Cache> typeClass = typeAliasRegistry.resolveAlias(type);
// 获取负责过期的eviction对象，默认策略为LRU
String eviction = context.getStringAttribute("eviction", "LRU");
Class<? extends Cache> evictionClass = typeAliasRegistry.resolveAlias(eviction);
// 清空缓存的频率 0代表不清空
Long flushInterval = context.getLongAttribute("flushInterval");
// 缓存容器的大小
Integer size = context.getIntAttribute("size");
// 是否只读
boolean readWrite = !context.getBooleanAttribute("readOnly", false);
// 是否阻塞
boolean blocking = context.getBooleanAttribute("blocking", false);
// 获得Properties属性
Properties props = context.getChildrenAsProperties();
//builderAssistant是MapperBuilderAssistant，作用就是解耦建立MapperStatement，因为
//MapperStatement对象创建复杂，所以用这个类来解耦创建
builderAssistant.useNewCache(typeClass, evictionClass, flushInterval, size, readWrite, blocking, props);
}
}
PerpetualCache内部的缓存其实就是个HashMap
public class PerpetualCache implements Cache {
private final String id;
private final Map<Object, Object> cache = new HashMap<>();
2.二级缓存的使用
在执行查询时，会先走二级缓存，若二级缓存没有才走下一步查询，并把查询结果存到二级缓存中，但此时只是存到tcm（TransactionalCacheManager）中的一个map中
//CachingExecutor
@Override
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
throws SQLException {
// 获取二级缓存，是从MapperStatement里面获取的
Cache cache = ms.getCache();
if (cache != null) {
// 刷新tcm的缓存 （存在缓存且flushCache为true时）
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执行
list = delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
// 将查询结果 要存到二级缓存中（注意：此处只是存到map集合中，没有真正存到二级缓存中）
tcm.putObject(cache, key, list); // issue #578 and #116
}
return list;
}
}
// 如果没有开启二级缓存或开启了没查到二级缓存则委托给BaseExecutor执行下一步查询
return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}
TransactionalCacheManager顾名思义事务缓存管理器，只在一次事务中进行缓存管理，当事务commit后tcm就不存在了。在一次事务commit前可以进行多次数据库操作，例如进行2次查询。
public class TransactionalCacheManager {
// Cache 与 TransactionalCache 的映射关系表
private final Map<Cache, TransactionalCache> transactionalCaches = new HashMap<>();
public Object getObject(Cache cache, CacheKey key) {
// 直接从TransactionalCache中获取缓存
return getTransactionalCache(cache).getObject(key);
}
public void putObject(Cache cache, CacheKey key, Object value) {
// 直接存入TransactionalCache的缓存中
getTransactionalCache(cache).putObject(key, value);
}
private TransactionalCache getTransactionalCache(Cache cache) {
// 从映射表中获取 TransactionalCache，下面代码等同于
// transactionalCaches.computeIfAbsent(cache, TransactionalCache::new);
return MapUtil.computeIfAbsent(transactionalCaches, cache, TransactionalCache::new);
}
上面提到查询时先走二级缓存，二级缓存查询从这开始，从这里查一下二级缓存是否存在，不存在再走其他查询结果，以下的delegate就是MapperStatement的二级缓存对象
public class TransactionalCache implements Cache {
/* 二级缓存 Cache 对象。
*/
private final Cache delegate;
/**
* 提交时，清空 {@link #delegate}
*
* 初始时，该值为 false
* 清理后{@link #clear()} 时，该值为 true ，表示持续处于清空状态
*/
private boolean clearOnCommit;
/**
* // 在事务被提交前，所有从数据库中查询的结果将缓存在此集合中
*/
private final Map<Object, Object> entriesToAddOnCommit;
/**
* 在事务被提交前，当缓存未命中时，CacheKey 将会被存储在此集合中
*/
private final Set<Object> entriesMissedInCache;
public Object getObject(Object key) {
// issue #116
// 查询的时候是直接从delegate（就是MapperSatement的二级缓存对象）中去查询的
Object object = delegate.getObject(key);
// 如果不存在，则添加到 entriesMissedInCache 中
if (object == null) {
// 缓存未命中，则将 key 存入到 entriesMissedInCache 中
entriesMissedInCache.add(key);
}
// issue #146
// 如果 clearOnCommit 为 true ，表示处于持续清空状态，则返回 null
if (clearOnCommit) {
return null;
} else {
// 返回 value
return object;
}
}
不存在二级缓存，走其他查询后，把查询结果放进二级缓存中，但这里其实并没放进二级缓存，而是放到了entriesToAddOnCommit中，毕竟一次事务之后tcm才不存在，所以在事务commit后，再放进真正二级缓存
//TransactionalCache
public void putObject(Object key, Object object) {
// 将键值对存入到 entriesToAddOnCommit 这个Map中中，而非真实的缓存对象 delegate 中
entriesToAddOnCommit.put(key, object);
}
当一次事务commit后，会把查询结果真正放到二级缓存中
public void commit() {
// 如果 clearOnCommit 为 true ，则清空 delegate 缓存
if (clearOnCommit) {
delegate.clear();
}
// 将 entriesToAddOnCommit、entriesMissedInCache 刷入 delegate(cache) 中
flushPendingEntries();
// 重置
reset();
}
private void flushPendingEntries() {
// 将 entriesToAddOnCommit 中的内容转存到 delegate 中
for (Map.Entry<Object, Object> entry : entriesToAddOnCommit.entrySet()) {
// 在这里真正的将entriesToAddOnCommit的对象逐个添加到delegate中，只有这时，二级缓存才真正的生效
delegate.putObject(entry.getKey(), entry.getValue());
}
// 将 entriesMissedInCache 刷入 delegate 中
for (Object entry : entriesMissedInCache) {
if (!entriesToAddOnCommit.containsKey(entry)) {
delegate.putObject(entry, null);
}
}
}
到此这篇关于一文详解mybatis二级缓存执行流程的文章就介绍到这了,更多相关mybatis二级缓存执行内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！