Mybatis缓存
⼀级缓存
mybatis 为我们提供了一级缓存和二级缓存，可以通过下图来理解：
可以看到
一级缓存是SqlSession级别的缓存。
在操作数据库时需要构造sqlSession对象，底层实际上是在对象中有一个数据结构（HashMap）用于存储缓存数据。 不同的sqlSession之间的缓存数据区域（HashMap）是互相不影响的。
二级缓存是mapper级别的缓存，多个SqlSession去操作同一个Mapper的sql语句，多个SqlSession可以共用二级缓存，二级缓存是跨SqlSession的。
具体我们来看一段代码
在⼀个sqlSession中，对User表根据id进⾏两次查询，查看他们发出sql语句的情况
InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
User user = sqlSession.selectOne("com.lagou.mapper.IUserMapper.findById",1);
System.out.println(user);
User user2 = sqlSession.selectOne("com.lagou.mapper.IUserMapper.findById",1);
System.out.println(user2);
System.out.println(user==user2);
// 5.释放资源
sqlSession.close();
在这段代码中我们查询两次id是1的对象，通过debug查询是否进行了2次sql语句查询
可以看到值发出了一次Sql 然后进行了两次查询，两次查询的结果也是相同的，内存地址也是相同的。
然后再进行两次查询，然后中间穿插一次修改操作
InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
User user = sqlSession.selectOne("com.lagou.mapper.IUserMapper.findById",1);
System.out.println(user);
User user3 = new User();
user3.setId(1);
user3.setUsername("jack111");
//更新
sqlSession.update("com.lagou.mapper.IUserMapper.updateById",user3);
User user2 = sqlSession.selectOne("com.lagou.mapper.IUserMapper.findById",1);
System.out.println(user2);
System.out.println(user==user2);
// 5.释放资源
sqlSession.close();
再来debug可以看到，两次查询操作结果一致，更新操作会将缓存清除，然后重新缓存进去。
通过以上操作可以确认，一级缓存是默认开启的，更新操作是可以让缓存失效；
1、第⼀次发起查询⽤户id为1的⽤户信息，先去找缓存中是否有id为1的⽤户信息，如果没有，从 数据 库查询⽤户信息。得到⽤户信息，将⽤户信息存储到⼀级缓存中。 2、 如果中间sqlSession去执⾏commit操作（执⾏插⼊、更新、删除），则会清空SqlSession中的 ⼀ 级缓存，这样做的⽬的为了让缓存中存储的是最新的信息，避免脏读。 3、 第⼆次发起查询⽤户id为1的⽤户信息，先去找缓存中是否有id为1的⽤户信息，缓存中有，直 接从 缓存中获取⽤户信息
既然一级缓存是sqlSession级别的，那么关闭一个sqlSession查询完成后，另一个SqlSession再来查询是此时缓存中数据是不存在的；
我们可以验证一下
InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
User user = sqlSession.selectOne("com.lagou.mapper.IUserMapper.findById",1);
System.out.println(user);
User user3 = new User();
user3.setId(1);
user3.setUsername("jack111");
sqlSession.update("com.lagou.mapper.IUserMapper.updateById",user3);
User user2 = sqlSession.selectOne("com.lagou.mapper.IUserMapper.findById",1);
System.out.println(user2);
System.out.println(user==user2);
// 5.释放资源
sqlSession.close();
//在此查询
System.out.println(" ---------------- ");
SqlSession sqlSession2 = sqlSessionFactory.openSession();
User user5 = sqlSession2.selectOne("com.lagou.mapper.IUserMapper.findById",1);
System.out.println(user5);
sqlSession2.close();
}
可以看到不同SqlSession关闭之后一级缓存是失效的；
一级缓存到底存储在哪儿。
我们来深入研究一下，既然一级缓存是默认开启的，而且还是sqlSession级别的，那么我们可以从sqlSession作为入口；
在sqlSession接口中我们发现了 clearCache()方法
/**
* Clears local session cache
*/
void clearCache();
然后在默认的实现类里可以看到 这么一段代码，意思大概是清除本地缓存
然后我们点击此方法 在Executor执行器中可以看到下面两个方法
CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql);
void clearLocalCache();
创建缓存key 和清除本地缓存接口
可以看到有这么两个实现类
分别点进去可以看到
在base类中可以看到
@Override
public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {
if (closed) {
throw new ExecutorException("Executor was closed.");
}
// 创建 CacheKey 对象
CacheKey cacheKey = new CacheKey();
// 设置 id、offset、limit、sql 到 CacheKey 对象中
cacheKey.update(ms.getId());
cacheKey.update(rowBounds.getOffset());
cacheKey.update(rowBounds.getLimit());
cacheKey.update(boundSql.getSql());
// 设置 ParameterMapping 数组的元素对应的每个 value 到 CacheKey 对象中
List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry();
// mimic DefaultParameterHandler logic 这块逻辑，和 DefaultParameterHandler 获取 value 是一致的。
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);
}
}
// 设置 Environment.id 到 CacheKey 对象中
if (configuration.getEnvironment() != null) {
// issue #176
cacheKey.update(configuration.getEnvironment().getId());
}
return cacheKey;
}
可以看到缓存key的构成是由sql,MappedStatement的id编号，以及分页的两个参数，再加上sql的参数 构成的key；
然后在缓存管理器CachingExecutor类中
瞬间可以明白 这个类是针对缓存对外提供操作方法，也是实现与Executor接口，然后通过Excutor的方法区清除和添加以及查询本地缓存；
在 CachingExecutor接口中有一个query查询方法
@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/>标签中创建的，它保存在Configration中
// 我们在初始化解析xml时分析过每一个MappedStatement都有一个Cache对象，就是这里
Cache cache = ms.getCache();
// 如果配置文件中没有配置 <cache>，则 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);
}
先不管二级缓存 上面If表示是二级缓存 ，可以看到先是从二级缓存查 然后没查到再去以及缓存查；
Cache cache = ms.getCache();应该是获取二级缓存开关
直接看这么一段 代码 delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql); 这是一级缓存代码
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());
// 已经关闭，则抛出 ExecutorException 异常
if (closed) {
throw new ExecutorException("Executor was closed.");
}
// 清空本地缓存，如果 queryStack 为零，并且要求清空本地缓存。
if (queryStack == 0 && ms.isFlushCacheRequired()) {
clearLocalCache();
}
List<E> list;
try {
// queryStack + 1
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 - 1
queryStack--;
}
if (queryStack == 0) {
// 执行延迟加载
for (DeferredLoad deferredLoad : deferredLoads) {
deferredLoad.load();
}
// issue #601
// 清空 deferredLoads
deferredLoads.clear();
// 如果缓存级别是 LocalCacheScope.STATEMENT ，则进行清理
if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
// issue #482
clearLocalCache();
}
}
return list;
}
可以看到 list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;这么一段话 从缓存中查询，如果没查到 下面代码从db进行查询；
@Override
public Object getObject(Object key) {
return cache.get(key);
}
可以看到 以及缓存是个map 容器
private Map<Object, Object> cache = new HashMap<>();
从此分析可以看到在查询的时候回先从缓存进行查询 ，没有查询然后从db查然后再queryFromDatabase方法中进行缓存存储。
// 从数据库中读取操作
private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
List<E> list;
// 在缓存中，添加占位对象。此处的占位符，和延迟加载有关，可见 `DeferredLoad#canLoad()` 方法
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;
}
可以看到 添加缓存 localCache.putObject(key, list);到map中以及缓存中；
既然查询和添加缓存都找到了，那么缓存失效呢？
我们再来查看一级缓存失效地方
@Override
public int update(MappedStatement ms, Object parameterObject) throws SQLException {
// 如果需要清空缓存，则进行清空
flushCacheIfRequired(ms);
// 执行 delegate 对应的方法
return delegate.update(ms, parameterObject);
}
可以看到是否需要清除 ，这里是二级缓存清除 先不看
private void flushCacheIfRequired(MappedStatement ms) {
Cache cache = ms.getCache();
if (cache != null && ms.isFlushCacheRequired()) { // 是否需要清空缓存
tcm.clear(cache);
}
}
下面update方法清除本地缓存
clearLocalCache()
可以总结一下
一级缓存是SqlSession级别的 一级缓存默认开启 一级缓存在底层update方法也就是删除 新增 更新 时候会清除一级缓存； 一级缓存在查询的时候会先从缓存中查询，没查到去查db，然后再放入本地一级缓存； 一级缓存之前会先从二级缓存查，没查到再去一级查，一级没查到再去db查；
二级缓存
为什么要用二级缓存？
因为一级缓存的是SqlSession级别的，每一次的连接查询结束关闭时候，其他SqlSession再同样的查询，当前SqlSession缓存中是不存在的，需要重新去查询db；
为了让所有的SqlSession同样的查询去共享缓存，多个SqlSession公用一个Mapper，所以用mapper级别表示二级缓存。
先看一段代码
开启二级缓存
<!--开启全局的二级缓存配置-->
<settings>
<setting name="cacheEnabled" value="true"/>
</settings>
UserMapper.xml中开启缓存
<!--开启⼆级缓存-->
<cache></cache>
InputStream inputStream = Resources.getResourceAsStream("sqlMapConfig.xml");
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession sqlSession1 = factory.openSession();
SqlSession sqlSession2 = factory.openSession();
SqlSession sqlSession3 = factory.openSession();
User user1 = sqlSession1.selectOne("com.lagou.mapper.IUserMapper.findById", 1);
User user3 = sqlSession3.selectOne("com.lagou.mapper.IUserMapper.findById", 1);
System.out.println(user1);
System.out.println(user3);
System.out.println(user3==user1);
System.out.println("-------------------");
User user = new User();
user.setId(1);
user.setUsername("jack1111");
// 增删改会清空二级缓存
sqlSession1.update("com.lagou.mapper.IUserMapper.updateById",user);
User user2 = sqlSession2.selectOne("com.lagou.mapper.IUserMapper.findById", 1);
System.out.println(user2);
执行结果可以看到，多个sqlSession去查询同一个相同数剧sql查询只发送了一次sql。第二次直接从缓存中返回数据。
并且两个数据的内存地址是不一样的，数据是相同的`。
当数据发生修改时候，二级缓存会清空，下次查询会从新从db查询；
其他属性
useCache和flushCache
mybatis中还可以配置userCache和flushCache等配置项，userCache是⽤来设置是否禁⽤⼆级缓 存的，在statement中设置useCache=false可以禁⽤当前select语句的⼆级缓存，即每次查询都会发出 sql去查询，默认情况是true,即该sql使⽤⼆级缓存
<select id="selectUserByUserId" useCache="false"
resultType="com.pojo.User" parameterType="int">
select * from user where id=#{id}
</select>
flushCache=true表示刷新缓存，这样可以避免数据库脏 读。
一级缓存什么时候放入二级缓存？
二级缓存示例图
Xml里面开启了二级缓存，然后每个mapper里面需要配置
cash标签这样二级缓存才生效。
既然配置xml ，我们先来看一下xml这儿MyBatis解析二级缓存标签
首选从build来开始
然后到了build方法
首先来看parse方法
private void parseConfiguration(XNode root) {
try {
//issue #117 read properties first
// 解析 <properties /> 标签
propertiesElement(root.evalNode("properties"));
// 解析 <settings /> 标签
Properties settings = settingsAsProperties(root.evalNode("settings"));
// 加载自定义的 VFS 实现类
loadCustomVfs(settings);
// 解析 <typeAliases /> 标签
typeAliasesElement(root.evalNode("typeAliases"));
// 解析 <plugins /> 标签
pluginElement(root.evalNode("plugins"));
// 解析 <objectFactory /> 标签
objectFactoryElement(root.evalNode("objectFactory"));
// 解析 <objectWrapperFactory /> 标签
objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
// 解析 <reflectorFactory /> 标签
reflectorFactoryElement(root.evalNode("reflectorFactory"));
// 赋值 <settings /> 到 Configuration 属性
settingsElement(settings);
// read it after objectFactory and objectWrapperFactory issue #631
// 解析 <environments /> 标签
environmentsElement(root.evalNode("environments"));
// 解析 <databaseIdProvider /> 标签
databaseIdProviderElement(root.evalNode("databaseIdProvider"));
// 解析 <typeHandlers /> 标签
typeHandlerElement(root.evalNode("typeHandlers"));
// 解析 <mappers /> 标签
mapperElement(root.evalNode("mappers"));
} catch (Exception e) {
throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
}
}
我们来看 Properties settings = settingsAsProperties(root.evalNode("settings"));这段代码
用来解析我们``xml文件里的setting标签，次标签里配置开启二级缓存标签
然后 settingsElement(settings);这段代码，用来解析setting xml配置
可以看到
然后可以看到
二级缓存默认其实是开启的，不需要配置，但还是手动的去配置xml然后声明开启
然后再往下可以看到 下面代码，在解析sqlMapConfig.xml里面的mappers标签
mapperElement(root.evalNode("mappers"));
完整代码
private void mapperElement(XNode parent) throws Exception {
if (parent != null) {
// 遍历子节点
for (XNode child : parent.getChildren()) {
// 如果是 package 标签，则扫描该包
if ("package".equals(child.getName())) {
// 获取 <package> 节点中的 name 属性
String mapperPackage = child.getStringAttribute("name");
// 从指定包中查找 mapper 接口，并根据 mapper 接口解析映射配置
configuration.addMappers(mapperPackage);
// 如果是 mapper 标签，
} else {
// 获得 resource、url、class 属性
String resource = child.getStringAttribute("resource");
String url = child.getStringAttribute("url");
String mapperClass = child.getStringAttribute("class");
// resource 不为空，且其他两者为空，则从指定路径中加载配置
if (resource != null && url == null && mapperClass == null) {
ErrorContext.instance().resource(resource);
// 获得 resource 的 InputStream 对象
InputStream inputStream = Resources.getResourceAsStream(resource);
// 创建 XMLMapperBuilder 对象
XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
// 执行解析
mapperParser.parse();
// url 不为空，且其他两者为空，则通过 url 加载配置
} else if (resource == null && url != null && mapperClass == null) {
ErrorContext.instance().resource(url);
// 获得 url 的 InputStream 对象
InputStream inputStream = Resources.getUrlAsStream(url);
// 创建 XMLMapperBuilder 对象
XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());
// 执行解析
mapperParser.parse();
// mapperClass 不为空，且其他两者为空，则通过 mapperClass 解析映射配置
} else if (resource == null && url == null && mapperClass != null) {
// 获得 Mapper 接口
Class<?> mapperInterface = Resources.classForName(mapperClass);
// 添加到 configuration 中
configuration.addMapper(mapperInterface);
// 以上条件不满足，则抛出异常
} else {
throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");
}
}
}
}
}
这儿我用的package 标签 可以看到第一个if里面的代码,将指定包下的 如果是mapps标签就走else里面代码，去解析xml
public void addMappers(String packageName, Class<?> superType) {
// 扫描指定包下的指定类
ResolverUtil<Class<?>> resolverUtil = new ResolverUtil<>();
resolverUtil.find(new ResolverUtil.IsA(superType), packageName);
Set<Class<? extends Class<?>>> mapperSet = resolverUtil.getClasses();
// 遍历，添加到 knownMappers 中
for (Class<?> mapperClass : mapperSet) {
addMapper(mapperClass);
}
}
如果是mappers的话解析xml
parse方法
分别取解析我们每个mapper里面的每个sql 以及映射等
// 解析 `<mapper />` 节点
private void configurationElement(XNode context) {
try {
// 获得 namespace 属性
String namespace = context.getStringAttribute("namespace");
if (namespace == null || namespace.equals("")) {
throw new BuilderException("Mapper's namespace cannot be empty");
}
// 设置 namespace 属性
builderAssistant.setCurrentNamespace(namespace);
// 解析 <cache-ref /> 节点
cacheRefElement(context.evalNode("cache-ref"));
// 解析 <cache /> 节点
cacheElement(context.evalNode("cache"));
// 已废弃！老式风格的参数映射。内联参数是首选,这个元素可能在将来被移除，这里不会记录。
parameterMapElement(context.evalNodes("/mapper/parameterMap"));
// 解析 <resultMap /> 节点们
resultMapElements(context.evalNodes("/mapper/resultMap"));
// 解析 <sql /> 节点们
sqlElement(context.evalNodes("/mapper/sql"));
// 解析 <select /> <insert /> <update /> <delete /> 节点们
// 这里会将生成的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);
}
}
其中可以看到buildStatementFromContext是解析我们各种crud的xml
里面可以看到
parseStatementNode解析sql
public void parseStatementNode() {
// 获得 id 属性，编号。
String id = context.getStringAttribute("id");
// 获得 databaseId ， 判断 databaseId 是否匹配
String databaseId = context.getStringAttribute("databaseId");
if (!databaseIdMatchesCurrent(id, databaseId, this.requiredDatabaseId)) {
return;
}
// 获得各种属性
Integer fetchSize = context.getIntAttribute("fetchSize");
Integer timeout = context.getIntAttribute("timeout");
String parameterMap = context.getStringAttribute("parameterMap");
String parameterType = context.getStringAttribute("parameterType");
Class<?> parameterTypeClass = resolveClass(parameterType);
String resultMap = context.getStringAttribute("resultMap");
String resultType = context.getStringAttribute("resultType");
String lang = context.getStringAttribute("lang");
// 获得 lang 对应的 LanguageDriver 对象
LanguageDriver langDriver = getLanguageDriver(lang);
// 获得 resultType 对应的类
Class<?> resultTypeClass = resolveClass(resultType);
// 获得 resultSet 对应的枚举值
String resultSetType = context.getStringAttribute("resultSetType");
ResultSetType resultSetTypeEnum = resolveResultSetType(resultSetType);
// 获得 statementType 对应的枚举值
StatementType statementType = StatementType.valueOf(context.getStringAttribute("statementType", StatementType.PREPARED.toString()));
// 获得 SQL 对应的 SqlCommandType 枚举值
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 对象，并替换 <include /> 标签相关的内容
XMLIncludeTransformer includeParser = new XMLIncludeTransformer(configuration, builderAssistant);
includeParser.applyIncludes(context.getNode());
// Parse selectKey after includes and remove them.
// 解析 <selectKey /> 标签
processSelectKeyNodes(id, parameterTypeClass, langDriver);
// Parse the SQL (pre: <selectKey> and <include> were parsed and removed)
// 创建 SqlSource 对象
SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass);
// 获得 KeyGenerator 对象
String resultSets = context.getStringAttribute("resultSets");
String keyProperty = context.getStringAttribute("keyProperty");
String keyColumn = context.getStringAttribute("keyColumn");
KeyGenerator keyGenerator;
// 优先，从 configuration 中获得 KeyGenerator 对象。如果存在，意味着是 <selectKey /> 标签配置的
String keyStatementId = id + SelectKeyGenerator.SELECT_KEY_SUFFIX;
keyStatementId = builderAssistant.applyCurrentNamespace(keyStatementId, true);
if (configuration.hasKeyGenerator(keyStatementId)) {
keyGenerator = configuration.getKeyGenerator(keyStatementId);
// 其次，根据标签属性的情况，判断是否使用对应的 Jdbc3KeyGenerator 或者 NoKeyGenerator 对象
} else {
keyGenerator = context.getBooleanAttribute("useGeneratedKeys", // 优先，基于 useGeneratedKeys 属性判断
configuration.isUseGeneratedKeys() && SqlCommandType.INSERT.equals(sqlCommandType)) // 其次，基于全局的 useGeneratedKeys 配置 + 是否为插入语句类型
? Jdbc3KeyGenerator.INSTANCE : NoKeyGenerator.INSTANCE;
}
// 创建 MappedStatement 对象
builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType,
fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass,
resultSetTypeEnum, flushCache, useCache, resultOrdered,
keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets);
}
具体可以看到几个参数返回类型。实例化成字节码对象
Class<?> resultTypeClass = resolveClass(resultType);
入参,这儿可以对应到我们自定义MyBatis框架中的入参对象和返回对象。
String parameterType = context.getStringAttribute("parameterType");
Class<?> parameterTypeClass = resolveClass(parameterType);
再往下可以看到将解析到的信息存到MappedStatement对象里
// 创建 MappedStatement 对象
builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType,
fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass,
resultSetTypeEnum, flushCache, useCache, resultOrdered,
keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets);
可以看到
// 创建 MappedStatement.Builder 对象
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)) // 获得 ResultMap 集合
.resultSetType(resultSetType)
.flushCacheRequired(valueOrDefault(flushCache, !isSelect))
.useCache(valueOrDefault(useCache, isSelect))
.cache(currentCache); // 在这里将之前生成的Cache封装到MappedStatement
可以看到这么一段代码.cache(currentCache); 这儿是缓存设置。
既然设置当前的缓存属性，那么我们的mapper xml 里面的<cache></cache>标签在哪儿解析的呢？
其实在解析每个mapper标签里各种属性的时候就已经解析了
最后一句创建cache对象
完整代码可以看到
点进去可以看到解析每个cache的属性
在MapperBuilderAssistant 类中 将cache赋值给currentCache
然后.cache(currentCache);设置在每个 MappedStatement对象里
在XMLStatementBuilder类中给添加到每个MappedStatement中，在存储到全局对象Configration里，也就上面所说的。
// 创建 MappedStatement 对象
builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType,
fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass,
resultSetTypeEnum, flushCache, useCache, resultOrdered,
keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets);
最后每个mapper缓存对象存储到全局configration里，每个mapper中的sql都使用一个cache，这个cache对象 key是mapper的namespace，有次可知二级缓存是mapper级别的，每一个sql 也就是每个sqlSession都在一个mapper里
然后来看看二级缓存是否使用
query查询方法里可以看大，在最上面看一级缓存的时候就已经看到了先是查询二级缓存
而这个if判断力是否走二级缓存，正是从我们解析mapper标签的的cache标签存MappedStatement里的。
然后再来看看 flushCacheIfRequired(ms);方法
可以看到如果是true的话 会清除二级缓存
private void flushCacheIfRequired(MappedStatement ms) {
Cache cache = ms.getCache();
if (cache != null && ms.isFlushCacheRequired()) { // 是否需要清空缓存
tcm.clear(cache);
}
}
可以看到在二级缓存没查到时候
这儿query走父类excutor中的query方法查询以及缓存，最后返回放到二级缓存中去。
具体什么情况下会清除二级缓存呢？
可以通过在sql标签里设置funshCache 等标签设置为ture 就可以，但默认除查询方法 在设置cache对象的时候回设置为ture。
但是默认非查询方法都会是true
在下面代码中可以看到
boolean isSelect = sqlCommandType == SqlCommandType.SELECT;
所以也就是说 flushCacheIfRequired 这个方法在二级缓存的非查询方法的时候是默认清除本地缓存的。
点击clear方法最终来到了下面代码
private TransactionalCache getTransactionalCache(Cache cache) {
return transactionalCaches.computeIfAbsent(cache, TransactionalCache::new);
}
transactionalCaches 是个map,在TransactionalCacheManager类中
private final Map<Cache, TransactionalCache> transactionalCaches = new HashMap<>();
TransactionalCacheManager类
/**
* Copyright 2009-2018 the original author or authors.
* <p>
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* <p>
* http://www.apache.org/licenses/LICENSE-2.0
* <p>
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.ibatis.cache;
import org.apache.ibatis.cache.decorators.TransactionalCache;
import java.util.HashMap;
import java.util.Map;
/**
* {@link TransactionalCache} 事务缓存管理器
*
* @author Clinton Begin
*/
public class TransactionalCacheManager {
/**
* // Cache 与 TransactionalCache 的映射关系表
*/
private final Map<Cache, TransactionalCache> transactionalCaches = new HashMap<>();
/**
* 清空缓存
*
* @param cache Cache 对象
*/
public void clear(Cache cache) {
getTransactionalCache(cache).clear();
}
/**
* 获得缓存中，指定 Cache + K 的值。
*
* @param cache Cache 对象
* @param key 键
* @return 值
*/
public Object getObject(Cache cache, CacheKey key) {
// 直接从TransactionalCache中获取缓存
return getTransactionalCache(cache).getObject(key);
}
/**
* 添加 Cache + KV ，到缓存中
*
* @param cache Cache 对象
* @param key 键
* @param value 值
*/
public void putObject(Cache cache, CacheKey key, Object value) {
// 直接存入TransactionalCache的缓存中
getTransactionalCache(cache).putObject(key, value);
}
/**
* 提交所有 TransactionalCache
*/
public void commit() {
for (TransactionalCache txCache : transactionalCaches.values()) {
txCache.commit();
}
}
/**
* 回滚所有 TransactionalCache
*/
public void rollback() {
for (TransactionalCache txCache : transactionalCaches.values()) {
txCache.rollback();
}
}
/**
* 获得 Cache 对应的 TransactionalCache 对象
*
* @param cache Cache 对象
* @return TransactionalCache 对象
*/
private TransactionalCache getTransactionalCache(Cache cache) {
return transactionalCaches.computeIfAbsent(cache, TransactionalCache::new);
}
}
可以看到这个类中，提供了二级缓存添加，清除。
既然二级缓存清除这个，那肯定就是存储在这个map里面
然后我们来看看二级缓存存储TransactionalCache对象
在当前类中看到存储putObject方法，会发现二级缓存实际存储在entriesToAddOnCommit这个类中
@Override
public void putObject(Object key, Object object) {
// 将键值对存入到 entriesToAddOnCommit 这个Map中中，而非真实的缓存对象 delegate 中
entriesToAddOnCommit.put(key, object);
}
这个类其实是个map
private final Map<Object, Object> entriesToAddOnCommit;
然后看获取方法getObject
@Override
public Object getObject(Object key) {
// 查询的时候是直接从delegate中去查询的，也就是从真正的缓存对象中查询
Object object = delegate.getObject(key);
// 如果不存在，则添加到 entriesMissedInCache 中
if (object == null) {
// 缓存未命中，则将 key 存入到 entriesMissedInCache 中
entriesMissedInCache.add(key);
}
// issue #146
// 如果 clearOnCommit 为 true ，表示处于持续清空状态，则返回 null
if (clearOnCommit) {
return null;
// 返回 value
} else {
return object;
}
}
从delegate.getObject(key)中获取key
如果没获取到存储到
private final Set<Object> entriesMissedInCache; 变量中
再看if中 clearOnCommit 变量 字面意思是在commit时候清除。
难道是在事务提交时候清除？返回Null ，二级缓存中没有获取到 再去以及缓存中查，然后没查到再去db查。这跟我们查看源码query查询的逻辑貌似对上了。
TransactionalCache 对象的构造方法
然后再sqlSession中查看commit方法 点击进入到Cache管理器中commit方法可以看到，tcm的commit方法 也就是清除本地缓存
在Excutor中不管调用commit还是close还是rowback 都会调用cache管理器中的tcm.commit();方法 然后会去rest方法，将缓存清除。
在看源码可以看到实际二级缓存值对象是存在一个map中
为什么存在一个map里？ 为什么不像一级缓存直接存在一个map中呢？ 为什么要用TransactionalCache 包装一下呢？
原因是为了防止脏数据的产生
那为什么会产生脏数据呢？
最后在Excutor中增删改方法实际都是调用update方法，而update会清空二级缓存。
最后总结 在commit,close,row 还是update操作时候都会清除二级缓存
所以对于二级缓存，我们尽量去使用修改频率不大的或者一直死数据，万年不变的如行政单位，省市级等数据比较适合使用二级缓存。
