关键词：
缓存就是内存中的数据，常常来自对数据库查询结果的保存。使用缓存，我们可以避免频繁的与数据库进行交互，进而提高响应速度MyBatis也提供了对缓存的支持，分为一级缓存和二级缓存，可以通过下图来理解：
①、一级缓存是SqlSession级别的缓存。在操作数据库时需要构造sqlSession对象，在对象中有一个数据结构（HashMap）用于存储缓存数据。不同的sqlSession之间的缓存数据区域（HashMap）是互相不影响的。
②、二级缓存是mapper级别的缓存，多个SqlSession去操作同一个Mapper的sql语句，多个SqlSession可以共用二级缓存，二级缓存是跨SqlSession的
一级缓存
默认是开启的
①、我们使用同一个sqlSession，对User表根据相同id进行两次查询，查看他们发出sql语句的情况
@Test
public void firstLevelCacheTest() throws IOException
// 1. 通过类加载器对配置文件进行加载，加载成了字节输入流，存到内存中 注意：配置文件并没有被解析
InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
// 2. (1)解析了配置文件，封装configuration对象 （2）创建了DefaultSqlSessionFactory工厂对象
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
// 3.问题：openSession()执行逻辑是什么？
// 3. (1)创建事务对象 （2）创建了执行器对象cachingExecutor (3)创建了DefaultSqlSession对象
SqlSession sqlSession = sqlSessionFactory.openSession();
// 4. 委派给Executor来执行，Executor执行时又会调用很多其他组件（参数设置、解析sql的获取，sql的执行、结果集的封装）
User user = sqlSession.selectOne("com.itheima.mapper.UserMapper.findByCondition", 1);
User user2 = sqlSession.selectOne("com.itheima.mapper.UserMapper.findByCondition", 1);
System.out.println(user == user2);
sqlSession.close();
查看控制台打印情况：
② 同样是对user表进行两次查询，只不过两次查询之间进行了一次update操作。
@Test
public void test3() throws IOException
// 1. 通过类加载器对配置文件进行加载，加载成了字节输入流，存到内存中 注意：配置文件并没有被解析
InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
// 2. (1)解析了配置文件，封装configuration对象 （2）创建了DefaultSqlSessionFactory工厂对象
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
// 3.问题：openSession()执行逻辑是什么？
// 3. (1)创建事务对象 （2）创建了执行器对象cachingExecutor (3)创建了DefaultSqlSession对象
SqlSession sqlSession = sqlSessionFactory.openSession();
// 4. 委派给Executor来执行，Executor执行时又会调用很多其他组件（参数设置、解析sql的获取，sql的执行、结果集的封装）
User user = sqlSession.selectOne("com.itheima.mapper.UserMapper.findByCondition", 1);
User user1 = new User();
user1.setId(1);
user1.setUsername("zimu");
sqlSession.update("com.itheima.mapper.UserMapper.updateUser",user1);
sqlSession.commit();
User user2 = sqlSession.selectOne("com.itheima.mapper.UserMapper.findByCondition", 1);
System.out.println(user == user2);
System.out.println(user);
System.out.println(user2);
System.out.println("MyBatis源码环境搭建成功....");
sqlSession.close();
查看控制台打印情况：
③、总结
1、第一次发起查询用户id为1的用户信息，先去找缓存中是否有id为1的用户信息，如果没有，从 数据库查询用户信息。得到用户信息，将用户信息存储到一级缓存中。
2、 如果中间sqlSession去执行commit操作（执行插入、更新、删除），则会清空SqlSession中的 一级缓存，这样做的目的为了让缓存中存储的是最新的信息，避免脏读。
3、 第二次发起查询用户id为1的用户信息，先去找缓存中是否有id为1的用户信息，缓存中有，直 接从缓存中获取用户信息
一级缓存原理探究与源码分析
问题1：一级缓存 底层数据结构到底是什么？
问题2：一级缓存的工作流程是怎样的？
一级缓存 底层数据结构到底是什么？
之前说不同SqlSession的一级缓存互不影响,所以我从SqlSession这个类入手
可以看到，org.apache.ibatis.session.SqlSession中有一个和缓存有关的方法——clearCache()刷新缓存的方法，点进去，找到它的实现类DefaultSqlSession
@Override
public void clearCache()
executor.clearLocalCache();
再次点进去executor.clearLocalCache(),再次点进去并找到其实现类BaseExecutor，
@Override
public void clearLocalCache()
if (!closed)
localCache.clear();
localOutputParameterCache.clear();
进入localCache.clear()方法。进入到了org.apache.ibatis.cache.impl.PerpetualCache类中
package org.apache.ibatis.cache.impl;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;
import org.apache.ibatis.cache.Cache;
import org.apache.ibatis.cache.CacheException;
/**
* @author Clinton Begin
*/
public class PerpetualCache implements Cache
private final String id;
private Map<Object, Object> cache = new HashMap<Object, Object>();
public PerpetualCache(String id)
this.id = id;
//省略部分...
@Override
public void clear()
cache.clear();
//省略部分...
我们看到了PerpetualCache类中有一个属性private Map<Object, Object> cache = new HashMap<Object, Object>()，很明显它是一个HashMap，我们所调用的.clear()方法，实际上就是调用的Map的clear方法
得出结论：
一级缓存的数据结构确实是HashMap
一级缓存的执行流程
我们进入到org.apache.ibatis.executor.Executor中
看到一个方法CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) ，见名思意是一个创建CacheKey的方法
找到它的实现类和方法org.apache.ibatis.executor.BaseExecuto.createCacheKey
我们分析一下创建CacheKey的这块代码：
public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql)
if (closed)
throw new ExecutorException("Executor was closed.");
//初始化CacheKey
CacheKey cacheKey = new CacheKey();
//存入statementId
cacheKey.update(ms.getId());
//分别存入分页需要的Offset和Limit
cacheKey.update(rowBounds.getOffset());
cacheKey.update(rowBounds.getLimit());
//把从BoundSql中封装的sql取出并存入到cacheKey对象中
cacheKey.update(boundSql.getSql());
//下面这一块就是封装参数
List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry();
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);
//从configuration对象中（也就是载入配置文件后存放的对象）把EnvironmentId存入
/**
* <environments default="development">
* <environment id="development"> //就是这个id
* <!--当前事务交由JDBC进行管理-->
* <transactionManager type="JDBC"></transactionManager>
* <!--当前使用mybatis提供的连接池-->
* <dataSource type="POOLED">
* <property name="driver" value="$jdbc.driver"/>
* <property name="url" value="$jdbc.url"/>
* <property name="username" value="$jdbc.username"/>
* <property name="password" value="$jdbc.password"/>
* </dataSource>
* </environment>
* </environments>
*/
if (configuration.getEnvironment() != null)
// issue #176
cacheKey.update(configuration.getEnvironment().getId());
//返回
return cacheKey;
我们再点进去cacheKey.update()方法看一看
public class CacheKey implements Cloneable, Serializable
private static final long serialVersionUID = 1146682552656046210L;
public static final CacheKey NULL_CACHE_KEY = new NullCacheKey();
private static final int DEFAULT_MULTIPLYER = 37;
private static final int DEFAULT_HASHCODE = 17;
private final int multiplier;
private int hashcode;
private long checksum;
private int count;
//值存入的地方
private transient List<Object> updateList;
//省略部分方法......
//省略部分方法......
public void update(Object object)
int baseHashCode = object == null ? 1 : ArrayUtil.hashCode(object);
count++;
checksum += baseHashCode;
baseHashCode *= count;
hashcode = multiplier * hashcode + baseHashCode;
//看到把值传入到了一个list中
updateList.add(object);
//省略部分方法......
我们知道了那些数据是在CacheKey对象中如何存储的了。下面我们返回createCacheKey()方法。
我们进入BaseExecutor，可以看到一个query()方法：
这里我们很清楚的看到，在执行query()方法前，CacheKey方法被创建了
我们可以看到，创建CacheKey后调用了query()方法，我们再次点进去：
在执行SQL前如何在一级缓存中找不到Key，那么将会执行sql，我们来看一下执行sql前后会做些什么，进入list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
分析一下：
private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException
List<E> list;
//1. 把key存入缓存，value放一个占位符
localCache.putObject(key, EXECUTION_PLACEHOLDER);
try
//2. 与数据库交互
list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
finally
//3. 如果第2步出了什么异常，把第1步存入的key删除
localCache.removeObject(key);
//4. 把结果存入缓存
localCache.putObject(key, list);
if (ms.getStatementType() == StatementType.CALLABLE)
localOutputParameterCache.putObject(key, parameter);
return list;
一级缓存源码分析结论：
- 一级缓存的数据结构是一个
HashMap<Object,Object>，它的value就是查询结果，它的key是CacheKey，CacheKey中有一个list属性，statementId,params,rowbounds,sql等参数都存入到了这个list中 - 先创建
CacheKey，会首先根据CacheKey查询缓存中有没有，如果有，就处理缓存中的参数，如果没有，就执行sql，执行sql后执行sql后把结果存入缓存
二级缓存
注意：Mybatis的二级缓存不是默认开启的，是需要经过配置才能使用的
启用二级缓存
分为三步走：
1）开启映射器配置文件中的缓存配置：
<settings>
<setting name="cacheEnabled" value="true"/>
</settings>
- 在需要使用二级缓存的Mapper配置文件中配置<cache>标签
<!--type：cache使用的类型，默认是PerpetualCache，这在一级缓存中提到过。
eviction： 定义回收的策略，常见的有FIFO，LRU。
flushInterval： 配置一定时间自动刷新缓存，单位是毫秒。
size： 最多缓存对象的个数。
readOnly： 是否只读，若配置可读写，则需要对应的实体类能够序列化。
blocking： 若缓存中找不到对应的key，是否会一直blocking，直到有对应的数据进入缓存。
-->
<cache></cache>
3）在具体CURD标签上配置 useCache=true
<select id="findById" resultType="com.itheima.pojo.User" useCache="true">
select * from user where id = #id
</select>
** 注意：实体类要实现Serializable接口，因为二级缓存会将对象写进硬盘，就必须序列化，以及兼容对象在网络中的传输
具体实现
/**
* 测试一级缓存
*/
@Test
public void secondLevelCacheTest() throws IOException
InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
// 2. (1)解析了配置文件，封装configuration对象 （2）创建了DefaultSqlSessionFactory工厂对象
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
// 3.问题：openSession()执行逻辑是什么？
// 3. (1)创建事务对象 （2）创建了执行器对象cachingExecutor (3)创建了DefaultSqlSession对象
SqlSession sqlSession1 = sqlSessionFactory.openSession();
// 发起第一次查询，查询ID为1的用户
User user1 = sqlSession1.selectOne("com.itheima.mapper.UserMapper.findByCondition", 1);
// ***必须调用sqlSession1.commit()或者close(),一级缓存中的内容才会刷新到二级缓存中
sqlSession1.commit();// close();
// 发起第二次查询，查询ID为1的用户
SqlSession sqlSession2 = sqlSessionFactory.openSession();
User user2 = sqlSession2.selectOne("com.itheima.mapper.UserMapper.findByCondition", 1);
System.out.println(user1 == user2);
System.out.println(user1);
System.out.println(user2);
sqlSession1.close();
sqlSession2.close();
二级缓存源码分析
问题：
① cache标签如何被解析的（二级缓存的底层数据结构是什么？）？
② 同时开启一级缓存二级缓存，优先级？
③ 为什么只有执行sqlSession.commit或者sqlSession.close二级缓存才会生效
④ 更新方法为什么不会清空二级缓存？
标签 < cache/> 的解析
二级缓存和具体的命名空间绑定，一个Mapper中有一个Cache, 相同Mapper中的MappedStatement共用同一个Cache
根据之前的mybatis源码剖析，xml的解析工作主要交给XMLConfigBuilder.parse()方法来实现
// XMLConfigBuilder.parse()
public Configuration parse()
if (parsed)
throw new BuilderException("Each XMLConfigBuilder can only be used once.");
parsed = true;
parseConfiguration(parser.eval（"/configuration"));// 在这里
return configuration;
// parseConfiguration()
// 既然是在xml中添加的，那么我们就直接看关于mappers标签的解析
private void parseConfiguration(XNode root)
try
Properties settings = settingsAsPropertiess(root.eval（"settings"));
propertiesElement(root.eval（"properties"));
loadCustomVfs(settings);
typeAliasesElement(root.eval（"typeAliases"));
pluginElement(root.eval（"plugins"));
objectFactoryElement(root.eval（"objectFactory"));
objectWrapperFactoryElement(root.eval（"objectWrapperFactory"));
reflectionFactoryElement(root.eval（"reflectionFactory"));
settingsElement(settings);
// read it after objectFactory and objectWrapperFactory issue #631
environmentsElement(root.eval（"environments"));
databaseIdProviderElement(root.eval（"databaseIdProvider"));
typeHandlerElement(root.eval（"typeHandlers"));
// 就是这里
mapperElement(root.eval（"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.");
我们来看看解析Mapper.xml
// XMLMapperBuilder.parse()
public void parse()
if (!configuration.isResourceLoaded(resource))
// 解析mapper属性
configurationElement(parser.eval（"/mapper"));
configuration.addLoadedResource(resource);
bindMapperForNamespace();
parsePendingResultMaps();
parsePendingChacheRefs();
parsePendingStatements();
// configurationElement()
private void configurationElement(XNode context)
try
String namespace = context.getStringAttribute("namespace");
if (namespace == null || namespace.equals(""))
throw new BuilderException("Mappers namespace cannot be empty");
builderAssistant.setCurrentNamespace(namespace);
cacheRefElement(context.eval（"cache-ref"));
// 最终在这里看到了关于cache属性的处理
cacheElement(context.eval（"cache"));
parameterMapElement(context.eval（"/mapper/parameterMap"));
resultMapElements(context.eval（"/mapper/resultMap"));
sqlElement(context.eval（"/mapper/sql"));
// 这里会将生成的Cache包装到对应的MappedStatement
buildStatementFromContext(context.eval（"select|insert|update|delete"));
catch (Exception e)
throw new BuilderException("Error parsing Mapper XML. Cause: " + e, e);
// cacheElement()
private void cacheElement(XNode context) throws Exception
if (context != null)
//解析<cache/>标签的type属性，这里我们可以自定义cache的实现类，比如redisCache，如果没有自定义，这里使用和一级缓存相同的PERPETUAL
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();
// 构建Cache对象
builderAssistant.useNewCache(typeClass, evictionClass, flushInterval, size, readWrite, blocking, props);
先来看看是如何构建Cache对象的
MapperBuilderAssistant.useNewCache()
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)
//这里如果我们定义了<cache/>中的type，就使用自定义的Cache,否则使用和一级缓存相同的PerpetualCache
.implementation(valueOrDefault(typeClass, PerpetualCache.class))
.addDecorator(valueOrDefault(evictionClass, LruCache.class))
.clearInterval(flushInterval)
.size(size)
.readWrite(readWrite)
.blocking(blocking)
.properties(props)
.build();
// 2.添加到Configuration中
configuration.addCache(cache);
// 3.并将cache赋值给MapperBuilderAssistant.currentCache
currentCache = cache;
return cache;
我们看到一个Mapper.xml只会解析一次<cache/>标签，也就是只创建一次Cache对象，放进configuration中，并将cache赋值给MapperBuilderAssistant.currentCache
buildStatementFromContext(context.eval（"select|insert|update|delete"));将Cache包装到MappedStatement
// 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");
...
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");
LanguageDriver langDriver = getLanguageDriver(lang);
...
// 创建MappedStatement对象
builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType,
fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass,
resultSetTypeEnum, flushCache, useCache, resultOrdered,
keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets);
// builderAssistant.addMappedStatement()
public MappedStatement addMappedStatement(
String id,
...)
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)
...
.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属性引用的是同一个
有关于<cache/>标签的解析就到这了。
查询源码分析
CachingExecutor
// CachingExecutor
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);
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中
// 我们在上面解析blog.xml时分析过每一个MappedStatement都有一个Cache对象，就是这里
Cache cache = ms.getCache();
// 如果配置文件中没有配置 <cache>，则 cache 为空
if (cache != null)
//如果需要刷新缓存的话就刷新：flushCache="true"
flushCacheIfRequired(ms);
if (ms.isUseCache() && resultHandler == null)
ensureNoOutParams(ms, boundSql);
// 访问二级缓存
List<E> list = (List<E>) tcm.getObject(cache, key);
// 缓存未命中
if (list == null)
// 如果没有值，则执行查询，这个查询实际也是先走一级缓存查询，一级缓存也没有的话，则进行DB查询
list = delegate.<E>query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
// 缓存查询结果
tcm.putObject(cache, key, list);
return list;
return delegate.<E>query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
如果设置了flushCache="true"，则每次查询都会刷新缓存
<!-- 执行此语句清空缓存 -->
<select id="findbyId" resultType="com.itheima.pojo.user" useCache="true" flushCache="true" >
select * from t_demo
</select>
如上，注意二级缓存是从 MappedStatement 中获取的。由于 MappedStatement 存在于全局配置中，可以多个 CachingExecutor 获取到，这样就会出现线程安全问题。除此之外，若不加以控制，多个事务共用一个缓存实例，会导致脏读问题。至于脏读问题，需要借助其他类来处理，也就是上面代码中 tcm 变量对应的类型。下面分析一下。
TransactionalCacheManager
/** 事务缓存管理器 */
public class TransactionalCacheManager
// Cache 与 TransactionalCache 的映射关系表
private final Map<Cache, TransactionalCache> transactionalCaches = new HashMap<Cache, TransactionalCache>();
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 txCache = transactionalCaches.get(cache);
if (txCache == null)
// TransactionalCache 也是一种装饰类，为 Cache 增加事务功能
// 创建一个新的TransactionalCache，并将真正的Cache对象存进去
txCache = new TransactionalCache(cache);
transactionalCaches.put(cache, txCache);
return txCache;
TransactionalCacheManager 内部维护了 Cache 实例与 TransactionalCache 实例间的映射关系，该类也仅负责维护两者的映射关系，真正做事的还是 TransactionalCache。TransactionalCache 是一种缓存装饰器，可以为 Cache 实例增加事务功能。下面分析一下该类的逻辑。
TransactionalCache
public class TransactionalCache implements Cache
//真正的缓存对象，和上面的Map<Cache, TransactionalCache>中的Cache是同一个
private final Cache delegate;
private boolean clearOnCommit;
// 在事务被提交前，所有从数据库中查询的结果将缓存在此集合中
private final Map<Object, Object> entriesToAddOnCommit;
// 在事务被提交前，当缓存未命中时，CacheKey 将会被存储在此集合中
private final Set<Object> entriesMissedInCache;
@Override
public Object getObject(Object key)
// 查询的时候是直接从delegate中去查询的，也就是从真正的缓存对象中查询
Object object = delegate.getObject(key);
if (object == null)
// 缓存未命中，则将 key 存入到 entriesMissedInCache 中
entriesMissedInCache.add(key);
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("...");
存储二级缓存对象的时候是放到了TransactionalCache.entriesToAddOnCommit这个map中，但是每次查询的时候是直接从TransactionalCache.delegate中去查询的，所以这个二级缓存查询数据库后，设置缓存值是没有立刻生效的，主要是因为直接存到 delegate 会导致脏数据问题
为何只有SqlSession提交或关闭之后？
那我们来看下SqlSession.commit()方法做了什么
SqlSession
@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);
二级缓存的刷新
我们来看看SqlSession的更新操作
public int update(String statement, Object parameter)
int var4;
try
this.dirty = true;
MappedStatement ms = this.configuration.getMappedStatement(statement);
var4 = this.executor.update(ms, this.wrapCollection(parameter));
catch (Exception var8)
throw ExceptionFactory.wrapException("Error updating database. Cause: " + var8, var8);
finally
ErrorContext.instance().reset();
return var4;
public int update(MappedStatement ms, Object parameterObject) throws SQLException
this.flushCacheIfRequired(ms);
return this.delegate.update(ms, parameterObject);
private void flushCacheIfRequired(MappedStatement ms)
//获取MappedStatement对应的Cache，进行清空
Cache cache = ms.getCache();
//SQL需设置flushCache="true" 才会执行清空
if (cache != null && ms.isFlushCacheRequired())
this.tcm.clear(cache);
MyBatis二级缓存只适用于不常进行增、删、改的数据，比如国家行政区省市区街道数据。一但数据变更，MyBatis会清空缓存。因此二级缓存不适用于经常进行更新的数据。
总结：
在二级缓存的设计上，MyBatis大量地运用了装饰者模式，如CachingExecutor, 以及各种Cache接口的装饰器。
- 二级缓存实现了Sqlsession之间的缓存数据共享，属于namespace级别
- 二级缓存具有丰富的缓存策略。
- 二级缓存可由多个装饰器，与基础缓存组合而成
- 二级缓存工作由 一个缓存装饰执行器CachingExecutor和 一个事务型预缓存TransactionalCache 完成
mybatis缓存的使用和源码分析
Mybatis缓存使用在Mybatis中缓存分为一级缓存和二级缓存，二级缓存又称为全局缓存，默认一级缓存和二级缓存都是开启的，只是二级缓存的使用需要配置才能生效，在Mybatis中一级缓存是SqlSession级别也就是会话级别的，而二级缓... 查看详情
mybatis一级缓存与二级缓存
MyBatis一级缓存 MyBatis一级缓存默认开启，一级缓存为Session级别的缓存，在执行以下操作时一级缓存会清空 1.执行session.clearCache(); 2.执行CUD操作 3.session.close();//不是同一个Session对象了 MyBatis二级缓存 需要配... 查看详情
mybatis从入门到精通—源码剖析之二级缓存细节(代码片段)
⼆级缓存构建在⼀级缓存之上，在收到查询请求时，MyBatis⾸先会查询⼆级缓存，若⼆级缓存未命中，再去查询⼀级缓存，⼀级缓存没有，再查询数据库。⼆级缓存------》⼀级缓存------》数据库与⼀级缓存不同，⼆级缓存和具体... 查看详情
mybatis-缓存机制
MyBatis包含一个非常强大的查询缓存特性,它可以非常方便地配置和定制。缓存可以极大的提升查询效率。MyBatis系统中默认定义了两级缓存，一级缓存和二级缓存。–1、默认情况下，只有一级缓存（SqlSession级别的缓存，也称为本... 查看详情
mybatis一级缓存和二级缓存
MyBatis中的缓存一级缓存： Mybatis一级缓存的作用域是同一个SqlSession,在同一个sqlSession中执行两次相同的SQL语句，第一次执行完毕后会将数据库中查询的数据写到缓存（内存），第二次会从缓存中获取数据不再从数据库中查询... 查看详情
mybatis缓存
MyBatis缓存MyBatis包含一个非常强大的查询缓存特性，它可以非常方便地定制和配置缓存。缓存可以极大的提升查询效率。MyBatis系统中默认定义了两级缓存：一级缓存和二级缓存默认情况下，只有一级缓存开启。（SqlSession级别的... 查看详情
mybatis一级缓存和二级缓存的区别
区别1.一级缓存Mybatis的一级缓存是指SQLSession，一级缓存的作用域是SQlSession,Mabits默认开启一级缓存。在同一个SqlSession中，执行相同的SQL查询时;第一次会去查询数据库，并写在缓存中，第二次会直接从缓存中取。... 查看详情
mybatis源码分析五mybatis的缓存
...Batis运行过程应用MyBatis缓存的二层体系一级缓存一级缓存源码分析二级缓存二级缓存源码分析二级缓存的创建缓存创建的时机二级缓存创建的方法 查看详情
mybatis源码分析五mybatis的缓存
...Batis运行过程应用MyBatis缓存的二层体系一级缓存一级缓存源码分析二级缓存二级缓存源码分析二级缓存的创建缓存创建的时机二级缓存创建的方法 查看详情
mybatis的一级缓存和二级缓存
一级缓存是SqlSession级别的缓存，当使用了clearCache方法和，或者close方法的话，这个缓存失效，如果还有同样的查询，则还会发送一次查询SqlSessionsession=SqlSessionFactoryUtil.getSession();Empemp=session.selectOne("queryEmpByNo",7900);System.out... 查看详情
mybatis一级缓存和二级缓存
缓存详细介绍,结果集展示https://blog.csdn.net/u013036274/article/details/55815104 配置信息http://www.pianshen.com/article/16399265/ ************详细介绍*************https://my.oschina.net/zjllovecode/blog/18175 查看详情
mybatis-一级缓存与二级缓存
1.1 什么是查询缓存mybatis提供查询缓存，用于减轻数据压力，提高数据库性能。mybaits提供一级缓存，和二级缓存。 一级缓存是SqlSession级别的缓存。在操作数据库时需要构造sqlSession对象，在对象中有一个(内存区... 查看详情
从根上理解mybatis的一级二级缓存
1\\.写在前头这篇帖子主要讲一级缓存，它的作用范围和源码分析（本来想把一二级缓存合在一起，发现太长了）2\\.准备工作2.1两个要用的实体类publicclassDepartmentpublicDepartment(Stringid)this.id=id;privateStringid;/***部门名称*/privateStringname... 查看详情
ssm框架mybatis笔记---表之间的关联关系；mybatis事务；mybatis缓存机制；orm概述
MyBatis框架提供两级缓存，一级缓存和二级缓存，默认开启一级缓存。缓存就是为了提交查询效率MyBatis框架提供两级缓存，一级缓存和二级缓存，默认开启一级缓存。缓存就是为了提交查询效率 查看详情
mybatis一二级缓存的源码研究(代码片段)
Mybatis的一级缓存Mybatis对缓存提供支持，但是在没有配置的默认情况下，它只开启一级缓存，一级缓存只是相对于同一个SqlSession而言。所以在参数和SQL完全一样的情况下，我们使用同一个SqlSession对象调用一个Mapper... 查看详情
mybatis学习--缓存（一级和二级缓存）
声明：学习摘要！MyBatis缓存 我们知道，频繁的数据库操作是非常耗费性能的（主要是因为对于DB而言，数据是持久化在磁盘中的，因此查询操作需要通过IO，IO操作速度相比内存操作速度慢了好几个量级），尤其是对于一些... 查看详情
mybatis的一级缓存和二级缓存(代码片段)
一级缓存一级缓存在mybatis中默认是开启的并且是session级别，它的作用域为一次sqlSession会话。mybatis默认是开启了一级缓存的。一级缓存的作用域有两种：session（默认）和statment，可通过设置local-cache-scope的值... 查看详情
mybatis:缓存机制
...缓存，减少与数据库交互次数，减少系统开销，提高效率MyBatis系统中默认定义了两级缓存：一级缓存和二级缓存一级缓存开启。（SqlSession级别的缓存，也称为本地缓存）二级缓存需要手动开启和配置，他 查看详情