mybatis 源码刨析扩展之 二级缓存
目录
- 一、复习一下二级缓存内容
-
- 1、启动二级缓存
-
- 1）开启全局二级缓存配置
- 2）在需要使用二级缓存的 Mapper 配置文件中配置标签
- 3）在具体 CURD 标签上配置 useCache=true
- 二、源码刨析
-
- 1、配置初始化，标签 的解析
-
- 1）XMLConfigBuilder
- 2）我们来看看解析 Mapper.xml
- 3）看看是如何构建 Cache 对象的
- 4）buildStatementFromContext(context.evalNodes("select|insert|update|delete")); 将 Cache 包装到 MappedStatement
- 2、调用查询语句时，源码分析
- 3、事务相关缓存处理，源码分析
-
- 1）TransactionalCacheManager
- 2）TransactionalCache
- 3）SqlSession
- 4、更新操作，二级缓存的刷新，源码分析
- 三、总结
一、复习一下二级缓存内容
二级缓存构建在一级缓存之上，在收到查询请求时，MyBatis 首先会查询二级缓存，若二级缓存未命
中，再去查询一级缓存，一级缓存没有，再查询数据库。
二级缓存 -----> 一级缓存 -----> 数据库。
与一级缓存不同，二级缓存和具体的命名空间绑定，一个 Mapper 中有一个 Cache，相同 Mapper 中的 MappedStatement 共用一个 Cache，一级缓存则是和 SqlSession 绑定。
如果要继续了解详情请看 mybatis 缓存 。
1、启动二级缓存
分为三步走：
1）开启全局二级缓存配置
<settings>
<setting name="cacheEnabled" value="true"/>
settings>
2）在需要使用二级缓存的 Mapper 配置文件中配置标签
<cache>cache>
3）在具体 CURD 标签上配置 useCache=true
<select id="findById" resultType="com.demo.pojo.User" useCache="true">
select * from user where id = #{id}
select>
二、源码刨析
1、配置初始化，标签 的解析
根据之前的 mybatis 源码剖析，xml 的解析工作主要交给 XMLConfigBuilder.parse() 方法来实现。
1）XMLConfigBuilder
// parse()
public Configuration parse() {
if (parsed) {
throw new BuilderException("Each XMLConfigBuilder can only be used once.");
}
parsed = true;
// 在这里
parseConfiguration(parser.evalNode("/configuration"));
return configuration;
}
// parseConfiguration()
// 既然是在 xml 中添加的，那么我们就直接看关于 mappers 标签的解析
private void parseConfiguration(XNode root) {
try {
// issue #117 read properties first
propertiesElement(root.evalNode("properties"));
Properties settings = settingsAsProperties(root.evalNode("settings"));
loadCustomVfs(settings);
loadCustomLogImpl(settings);
typeAliasesElement(root.evalNode("typeAliases"));
pluginElement(root.evalNode("plugins"));
objectFactoryElement(root.evalNode("objectFactory"));
objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
reflectorFactoryElement(root.evalNode("reflectorFactory"));
settingsElement(settings);
// read it after objectFactory and objectWrapperFactory issue #631
environmentsElement(root.evalNode("environments"));
databaseIdProviderElement(root.evalNode("databaseIdProvider"));
typeHandlerElement(root.evalNode("typeHandlers"));
// 就是这里
mapperElement(root.evalNode("mappers"));
} catch (Exception e) {
throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: "
+ e, e);
}
}
// mapperElement()
private void mapperElement(XNode parent) throws Exception {
if (parent != null) {
for (XNode child : parent.getChildren()) {
if ("package".equals(child.getName())) {
String mapperPackage = child.getStringAttribute("name");
configuration.addMappers(mapperPackage);
} else {
String resource = child.getStringAttribute("resource");
String url = child.getStringAttribute("url");
String mapperClass = child.getStringAttribute("class");
// 按照我们本例的配置，则直接走该 if 判断。
if (resource != null && url == null && mapperClass == null) {
ErrorContext.instance().resource(resource);
InputStream inputStream = Resources.getResourceAsStream(resource);
XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream,
configuration, resource, configuration.getSqlFragments());
// 生成 XMLMapperBuilder，并执行其 parse 方法。
mapperParser.parse();
} else if (resource == null && url != null && mapperClass == null) {
ErrorContext.instance().resource(url);
InputStream inputStream = Resources.getUrlAsStream(url);
XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream,
configuration, url, configuration.getSqlFragments());
mapperParser.parse();
} else if (resource == null && url == null && mapperClass != null) {
Class<?> mapperInterface = Resources.classForName(mapperClass);
configuration.addMapper(mapperInterface);
} else {
throw new BuilderException("A mapper element may only specify a url,"
+ " resource or class, but not more than one.");
}
}
}
}
}
2）我们来看看解析 Mapper.xml
XMLMapperBuilder
// parse()
public void parse() {
if (!configuration.isResourceLoaded(resource)) {
configurationElement(parser.evalNode("/mapper"));
configuration.addLoadedResource(resource);
bindMapperForNamespace();
}
parsePendingResultMaps();
parsePendingCacheRefs();
parsePendingStatements();
}
// configurationElement()
private void configurationElement(XNode context) {
try {
String namespace = context.getStringAttribute("namespace");
if (namespace == null || namespace.isEmpty()) {
throw new BuilderException("Mapper's namespace cannot be empty");
}
builderAssistant.setCurrentNamespace(namespace);
cacheRefElement(context.evalNode("cache-ref"));
// 最终在这里看到了关于 cache 属性的处理
cacheElement(context.evalNode("cache"));
parameterMapElement(context.evalNodes("/mapper/parameterMap"));
resultMapElements(context.evalNodes("/mapper/resultMap"));
sqlElement(context.evalNodes("/mapper/sql"));
// 这里会将生成的 Cache 包装到对应的 MappedStatement
buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
} catch (Exception e) {
throw new BuilderException("Error parsing Mapper XML. The XML location is '"
+ resource + "'. Cause: " + e, e);
}
}
// cacheElement()
private void cacheElement(XNode context) {
if (context != null) {
// 解析 3）看看是如何构建 Cache 对象的
public Cache useNewCache(Class<? extends Cache> typeClass,
Class<? extends Cache> evictionClass, Long flushInterval,
Integer size, boolean readWrite, boolean blocking,
Properties props) {
// 1、生成 Cache 对象
Cache cache = new CacheBuilder(currentNamespace)
// 这里如果我们定义了 我们看到一个 Mapper.xml 只会解析一次标签，也就是只创建一次 Cache 对象，放进 configuration 中， 并将 cache 赋值给 MapperBuilderAssistant.currentCache。
4）buildStatementFromContext(context.evalNodes(“select|insert|update|delete”)); 将 Cache 包装到 MappedStatement
XMLMapperBuilder
// buildStatementFromContext()
private void buildStatementFromContext(List<XNode> list) {
if (configuration.getDatabaseId() != null) {
buildStatementFromContext(list, configuration.getDatabaseId());
}
buildStatementFromContext(list, null);
}
// buildStatementFromContext()
private void buildStatementFromContext(List<XNode> list, String requiredDatabaseId) {
for (XNode context : list) {
final XMLStatementBuilder statementParser = new XMLStatementBuilder(
configuration, builderAssistant, context, requiredDatabaseId);
try {
// 每一条执行语句转换成一个 MappedStatement
statementParser.parseStatementNode();
} catch (IncompleteElementException e) {
configuration.addIncompleteStatement(statementParser);
}
}
}
XMLStatementBuilder#parseStatementNode
public void parseStatementNode() {
String id = context.getStringAttribute("id");
String databaseId = context.getStringAttribute("databaseId");
if (!databaseIdMatchesCurrent(id, databaseId, this.requiredDatabaseId)) {
return;
}
String nodeName = context.getNode().getNodeName();
SqlCommandType sqlCommandType = SqlCommandType.valueOf(nodeName
.toUpperCase(Locale.ENGLISH));
boolean isSelect = sqlCommandType == SqlCommandType.SELECT;
boolean flushCache = context.getBooleanAttribute("flushCache", !isSelect);
boolean useCache = context.getBooleanAttribute("useCache", isSelect);
boolean resultOrdered = context.getBooleanAttribute("resultOrdered", false);
// Include Fragments before parsing
XMLIncludeTransformer includeParser = new XMLIncludeTransformer(configuration,
builderAssistant);
includeParser.applyIncludes(context.getNode());
String parameterType = context.getStringAttribute("parameterType");
Class<?> parameterTypeClass = resolveClass(parameterType);
String lang = context.getStringAttribute("lang");
LanguageDriver langDriver = getLanguageDriver(lang);
// Parse selectKey after includes and remove them.
processSelectKeyNodes(id, parameterTypeClass, langDriver);
// Parse the SQL (pre: and were parsed and removed)
KeyGenerator keyGenerator;
String keyStatementId = id + SelectKeyGenerator.SELECT_KEY_SUFFIX;
keyStatementId = builderAssistant.applyCurrentNamespace(keyStatementId, true);
if (configuration.hasKeyGenerator(keyStatementId)) {
keyGenerator = configuration.getKeyGenerator(keyStatementId);
} else {
keyGenerator = context.getBooleanAttribute("useGeneratedKeys",
configuration.isUseGeneratedKeys() &&
SqlCommandType.INSERT.equals(sqlCommandType))
? Jdbc3KeyGenerator.INSTANCE : NoKeyGenerator.INSTANCE;
}
SqlSource sqlSource = langDriver.createSqlSource(configuration, context,
parameterTypeClass);
StatementType statementType = StatementType.valueOf(context
.getStringAttribute("statementType", StatementType.PREPARED.toString()));
Integer fetchSize = context.getIntAttribute("fetchSize");
Integer timeout = context.getIntAttribute("timeout");
String parameterMap = context.getStringAttribute("parameterMap");
String resultType = context.getStringAttribute("resultType");
Class<?> resultTypeClass = resolveClass(resultType);
String resultMap = context.getStringAttribute("resultMap");
String resultSetType = context.getStringAttribute("resultSetType");
ResultSetType resultSetTypeEnum = resolveResultSetType(resultSetType);
if (resultSetTypeEnum == null) {
resultSetTypeEnum = configuration.getDefaultResultSetType();
}
String keyProperty = context.getStringAttribute("keyProperty");
String keyColumn = context.getStringAttribute("keyColumn");
String resultSets = context.getStringAttribute("resultSets");
// 创建 MappedStatement 对象
builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType,
fetchSize, timeout, parameterMap, parameterTypeClass, resultMap,
resultTypeClass,resultSetTypeEnum, flushCache, useCache, resultOrdered,
keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets);
}
MapperBuilderAssistant#addMappedStatement
public MappedStatement addMappedStatement(String id, SqlSource sqlSource,
StatementType statementType, SqlCommandType sqlCommandType, Integer fetchSize,
Integer timeout, String parameterMap, Class<?> parameterType, String resultMap,
Class<?> resultType, ResultSetType resultSetType, boolean flushCache,
boolean useCache, boolean resultOrdered, KeyGenerator keyGenerator,
String keyProperty, String keyColumn, String databaseId, LanguageDriver lang,
String resultSets) {
if (unresolvedCacheRef) {
throw new IncompleteElementException("Cache-ref not yet resolved");
}
id = applyCurrentNamespace(id, false);
boolean isSelect = sqlCommandType == SqlCommandType.SELECT;
// 创建 MappedStatement 对象
MappedStatement.Builder statementBuilder = new MappedStatement.Builder(configuration,
id, sqlSource, sqlCommandType)
.resource(resource).fetchSize(fetchSize).timeout(timeout)
.statementType(statementType).keyGenerator(keyGenerator)
.keyProperty(keyProperty).keyColumn(keyColumn).databaseId(databaseId)
.lang(lang).resultOrdered(resultOrdered).resultSets(resultSets)
.resultMaps(getStatementResultMaps(resultMap, resultType, id))
.resultSetType(resultSetType)
.flushCacheRequired(valueOrDefault(flushCache, !isSelect))
.useCache(valueOrDefault(useCache, isSelect))
.cache(currentCache);// 在这里将之前生成的 Cache 封装到 MappedStatement
ParameterMap statementParameterMap = getStatementParameterMap(parameterMap,
parameterType, id);
if (statementParameterMap != null) {
statementBuilder.parameterMap(statementParameterMap);
}
MappedStatement statement = statementBuilder.build();
configuration.addMappedStatement(statement);
return statement;
}
我们看到将 Mapper 中创建的 Cache 对象，加入到了每个 MappedStatement 对象中，也就是同一个 Mapper 中所有的 MappedStatement 对象都拥有同样的 Cache 对象。
有关于配置初始化时，标签的解析就到这了。
2、调用查询语句时，源码分析
CachingExecutor#query
@Override
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds,
ResultHandler resultHandler) throws SQLException {
BoundSql boundSql = ms.getBoundSql(parameterObject);
// 创建 CacheKey
CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);
return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}
@Override
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds,
ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
throws SQLException {
// 从 MappedStatement 中获取 Cache，注意这里的 Cache 是从 MappedStatement 中获取的。
// 也就是我们上面解析 Mapper 中 ，则 cache 为空。
if (cache != null) {
// 如果需要刷新缓存的话就刷新：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) {
// 如果没有值，则执行查询，这个查询实际也是先走一级缓存查询，
// 一级缓存也没有的话，则进行 DB 查询。
list = delegate.query(ms, parameterObject, rowBounds, resultHandler,
key, boundSql);
// 缓存查询结果
tcm.putObject(cache, key, list); // issue #578 and #116
}
return list;
}
}
return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}
如果设置了 flushCache=“true”，则每次查询都会刷新缓存。
<select id="findbyId" resultType="com.demo.pojo.user" useCache="true" flushCache="true">
select * from t_demo
select>
如上，注意二级缓存是从 MappedStatement 中获取的。
由于 MappedStatement 存在于全局配置中，可以多个 CachingExecutor 获取到，这样就会出现线程安全问题。
除此之外，若不加以控制，多个事务共用一个缓存实例，会导致脏读问题。
至于脏读问题，需要借助其他类来处理，也就是上面代码中 tcm 变量对应的类型。
下面分析一下。
3、事务相关缓存处理，源码分析
1）TransactionalCacheManager
/**
* 事务缓存管理器
*/
public class TransactionalCacheManager {
// Cache 与 TransactionalCache 的映射关系表
private final Map<Cache, TransactionalCache> transactionalCaches = new HashMap<>();
public void clear(Cache cache) {
// 获取 TransactionalCache 对象，并调用该对象的 clear 方法，下同。
getTransactionalCache(cache).clear();
}
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);
}
public void commit() {
for (TransactionalCache txCache : transactionalCaches.values()) {
txCache.commit();
}
}
public void rollback() {
for (TransactionalCache txCache : transactionalCaches.values()) {
txCache.rollback();
}
}
private TransactionalCache getTransactionalCache(Cache cache) {
// 从映射表中获取 TransactionalCache
// TransactionalCache 也是一种装饰类，为 Cache 增加事务功能
// 创建一个新的 TransactionalCache，并将真正的Cache对象存进去
return transactionalCaches.computeIfAbsent(cache, TransactionalCache::new);
}
}
TransactionalCacheManager 内部维护了 Cache 实例与 TransactionalCache 实例间的映射关系，该类也仅负责维护两者的映射关系，真正做事的还是 TransactionalCache。
2）TransactionalCache
TransactionalCache 是一种缓存装饰器，可以为 Cache 实例增加事务功能。
我在之前提到的脏读问题正是由该类进行处理的。下面分析一下该类的逻辑。
public class TransactionalCache implements Cache {
private static final Log log = LogFactory.getLog(TransactionalCache.class);
// 真正的缓存对象，和上面的 Map 中的 Cache 是同一个。
private final Cache delegate;
private boolean clearOnCommit;
// 在事务被提交前，所有从数据库中查询的结果将缓存在此集合中。
private final Map<Object, Object> entriesToAddOnCommit;
// 在事务被提交前，当缓存未命中时，CacheKey 将会被存储在此集合中。
private final Set<Object> entriesMissedInCache;
public TransactionalCache(Cache delegate) {
this.delegate = delegate;
this.clearOnCommit = false;
this.entriesToAddOnCommit = new HashMap<>();
this.entriesMissedInCache = new HashSet<>();
}
@Override
public String getId() {
return delegate.getId();
}
@Override
public int getSize() {
return delegate.getSize();
}
@Override
public Object getObject(Object key) {
// issue #116
// 查询的时候是直接从 delegate 中去查询的，也就是从真正的缓存对象中查询。
Object object = delegate.getObject(key);
if (object == null) {
// 缓存未命中，则将 key 存入到 entriesMissedInCache 中。
entriesMissedInCache.add(key);
}
// issue #146
if (clearOnCommit) {
return null;
} else {
return object;
}
}
@Override
public void putObject(Object key, Object object) {
// 将键值对存入到 entriesToAddOnCommit 这个 Map 中，而非真实的缓存对象 delegate 中。
entriesToAddOnCommit.put(key, object);
}
@Override
public Object removeObject(Object key) {
return null;
}
@Override
public void clear() {
clearOnCommit = true;
// 清空 entriesToAddOnCommit，但不清空 delegate 缓存。
entriesToAddOnCommit.clear();
}
public void commit() {
// 根据 clearOnCommit 的值决定是否清空 delegate。
if (clearOnCommit) {
delegate.clear();
}
// 刷新未缓存的结果到 delegate 缓存中。
flushPendingEntries();
// 重置 entriesToAddOnCommit 和 entriesMissedInCache
reset();
}
public void rollback() {
unlockMissedEntries();
reset();
}
private void reset() {
clearOnCommit = false;
// 清空集合
entriesToAddOnCommit.clear();
entriesMissedInCache.clear();
}
private void flushPendingEntries() {
for (Map.Entry<Object, Object> entry : entriesToAddOnCommit.entrySet()) {
// 将 entriesToAddOnCommit 中的内容转存到 delegate 中。
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 {
// 调用 removeObject 进行解锁
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);
}
}
}
}
存储二级缓存对象的时候是放到了 TransactionalCache.entriesToAddOnCommit 这个 map 中，但是每次查询的时候是直接从 TransactionalCache.delegate 中去查询的，所以这个二级缓存查询数据库后，设置缓存值是没有立刻生效的，主要是因为直接存到 delegate 会导致脏数据问题。
3）SqlSession
为何只有 SqlSession 提交或关闭之后？
那我们来看下 SqlSession.commit() 方法做了什么。
// DefaultSqlSession.commit
@Override
public void commit(boolean force) {
try {
// 主要是这句
executor.commit(isCommitOrRollbackRequired(force));
dirty = false;
} catch (Exception e) {
throw ExceptionFactory.wrapException("Error committing transaction. Cause: "
+ e, e);
} finally {
ErrorContext.instance().reset();
}
}
// CachingExecutor.commit
@Override
public void commit(boolean required) throws SQLException {
delegate.commit(required);
// 在这里
tcm.commit();
}
// TransactionalCacheManager.commit()
public void commit() {
for (TransactionalCache txCache : transactionalCaches.values()) {
// 在这里
txCache.commit();
}
}
// TransactionalCache.commit()
public void commit() {
if (clearOnCommit) {
delegate.clear();
}
// 这一句
flushPendingEntries();
reset();
}
// TransactionalCache.flushPendingEntries()
private void flushPendingEntries() {
for (Map.Entry<Object, Object> entry : entriesToAddOnCommit.entrySet()) {
// 在这里真正的将 entriesToAddOnCommit 的对象逐个添加到 delegate 中，
// 只有这时，二级缓存才真正的生效.
delegate.putObject(entry.getKey(), entry.getValue());
}
for (Object entry : entriesMissedInCache) {
if (!entriesToAddOnCommit.containsKey(entry)) {
delegate.putObject(entry, null);
}
}
}
4、更新操作，二级缓存的刷新，源码分析
我们来看看 SqlSession 的更新操作。
// DefaultSqlSession.update()
@Override
public int update(String statement, Object parameter) {
try {
dirty = true;
MappedStatement ms = configuration.getMappedStatement(statement);
return executor.update(ms, wrapCollection(parameter));
} catch (Exception e) {
throw ExceptionFactory.wrapException("Error updating database. Cause: " + e, e);
} finally {
ErrorContext.instance().reset();
}
}
// CachingExecutor.update()
@Override
public int update(MappedStatement ms, Object parameterObject) throws SQLException {
flushCacheIfRequired(ms);
return delegate.update(ms, parameterObject);
}
// CachingExecutor.flushCacheIfRequired()
private void flushCacheIfRequired(MappedStatement ms) {
// 获取 MappedStatement 对应的 Cache，进行清空。
Cache cache = ms.getCache();
// SQL 需设置 flushCache="true" 才会执行清空。
if (cache != null && ms.isFlushCacheRequired()) {
tcm.clear(cache);
}
}
MyBatis 二级缓存只适用于不常进行增、删、改的数据，比如国家行政区省市区街道数据。
一但数据变更，MyBatis 会清空缓存。因此二级缓存不适用于经常进行更新的数据。
三、总结
在二级缓存的设计上，MyBatis 大量地运用了装饰者模式，如 CachingExecutor，以及各种 Cache 接口的装饰器。
- 二级缓存实现了 Sqlsession 之间的缓存数据共享，属于 namespace 级别；
- 二级缓存具有丰富的缓存策略；
- 二级缓存可由多个装饰器，与基础缓存组合而成；
- 二级缓存工作由一个缓存装饰执行器 CachingExecutor 和一个事务型预缓存 TransactionalCache 完成。
文章内容输出来源：拉勾教育Java高薪训练营；