1 緩存介紹#
MyBatis支持聲明式數(shù)據(jù)緩存（declarative data caching）坡氯。當(dāng)一條SQL語句被標(biāo)記為“可緩存”后鸟赫，首次執(zhí)行它時從數(shù)據(jù)庫獲取的所有數(shù)據(jù)會被存儲在一段高速緩存中，今后執(zhí)行這條語句時就會從高速緩存中讀取結(jié)果垒棋，而不是再次命中數(shù)據(jù)庫捌肴。MyBatis提供了默認(rèn)下基于Java HashMap的緩存實現(xiàn)，以及用于與OSCache乡摹、Ehcache、Hazelcast和Memcached連接的默認(rèn)連接器采转。MyBatis還提供API供其他緩存實現(xiàn)使用聪廉。
重點的那句話就是：MyBatis執(zhí)行SQL語句之后，這條語句就是被緩存故慈，以后再執(zhí)行這條語句的時候板熊，會直接從緩存中拿結(jié)果，而不是再次執(zhí)行SQL察绷。
這也就是大家常說的MyBatis一級緩存干签，一級緩存的作用域scope是SqlSession。MyBatis同時還提供了一種全局作用域global scope的緩存拆撼，這也叫做二級緩存容劳，也稱作全局緩存喘沿。
MyBatis將數(shù)據(jù)緩存設(shè)計成兩級結(jié)構(gòu)，分為一級緩存竭贩、二級緩存：
一級緩存是Session會話級別的緩存蚜印，位于表示一次數(shù)據(jù)庫會話的SqlSession對象之中，又被稱之為本地緩存娶视。一級緩存是MyBatis內(nèi)部實現(xiàn)的一個特性，用戶不能配置睁宰，默認(rèn)情況下自動支持的緩存肪获，用戶沒有定制它的權(quán)利（不過這也不是絕對的，可以通過開發(fā)插件對它進(jìn)行修改）柒傻；
二級緩存是Application應(yīng)用級別的緩存孝赫，它的是生命周期很長，跟Application的聲明周期一樣红符，也就是說它的作用范圍是整個Application應(yīng)用青柄。
MyBatis中一級緩存和二級緩存的組織如下圖所示：
2 一級緩存#
一級緩存的工作機制：
一級緩存是Session會話級別的，一般而言预侯，一個SqlSession對象會使用一個Executor對象來完成會話操作致开，Executor對象會維護(hù)一個Cache緩存，以提高查詢性能萎馅。關(guān)于一級緩存的詳細(xì)實現(xiàn)双戳，可參見MyBatis一級緩存實現(xiàn)。
2.1 緩存測試##
- 同個session進(jìn)行兩次相同查詢：
@Test
public void test() {
SqlSession sqlSession = sqlSessionFactory.openSession();
try {
User user = (User)sqlSession.selectOne("org.format.mybatis.cache.UserMapper.getById", 1);
log.debug(user);
User user2 = (User)sqlSession.selectOne("org.format.mybatis.cache.UserMapper.getById", 1);
log.debug(user2);
} finally {
sqlSession.close();
}
}
MyBatis只進(jìn)行1次數(shù)據(jù)庫查詢：
==> Preparing: select * from USERS WHERE ID = ?
==> Parameters: 1(Integer)
<== Total: 1
User{id=1, name='format', age=23, birthday=Sun Oct 12 23:20:13 CST 2014}
User{id=1, name='format', age=23, birthday=Sun Oct 12 23:20:13 CST 2014}
- 同個session進(jìn)行兩次不同的查詢：
@Test
public void test() {
SqlSession sqlSession = sqlSessionFactory.openSession();
try {
User user = (User)sqlSession.selectOne("org.format.mybatis.cache.UserMapper.getById", 1);
log.debug(user);
User user2 = (User)sqlSession.selectOne("org.format.mybatis.cache.UserMapper.getById", 2);
log.debug(user2);
} finally {
sqlSession.close();
}
}
MyBatis進(jìn)行兩次數(shù)據(jù)庫查詢：
==> Preparing: select * from USERS WHERE ID = ?
==> Parameters: 1(Integer)
<== Total: 1
User{id=1, name='format', age=23, birthday=Sun Oct 12 23:20:13 CST 2014}
==> Preparing: select * from USERS WHERE ID = ?
==> Parameters: 2(Integer)
<== Total: 1
User{id=2, name='FFF', age=50, birthday=Sat Dec 06 17:12:01 CST 2014}
- 不同session糜芳，進(jìn)行相同查詢：
@Test
public void test() {
SqlSession sqlSession = sqlSessionFactory.openSession();
SqlSession sqlSession2 = sqlSessionFactory.openSession();
try {
User user = (User)sqlSession.selectOne("org.format.mybatis.cache.UserMapper.getById", 1);
log.debug(user);
User user2 = (User)sqlSession2.selectOne("org.format.mybatis.cache.UserMapper.getById", 1);
log.debug(user2);
} finally {
sqlSession.close();
sqlSession2.close();
}
}
MyBatis進(jìn)行了兩次數(shù)據(jù)庫查詢：
==> Preparing: select * from USERS WHERE ID = ?
==> Parameters: 1(Integer)
<== Total: 1
User{id=1, name='format', age=23, birthday=Sun Oct 12 23:20:13 CST 2014}
==> Preparing: select * from USERS WHERE ID = ?
==> Parameters: 1(Integer)
<== Total: 1
User{id=1, name='format', age=23, birthday=Sun Oct 12 23:20:13 CST 2014}
- 同個session,查詢之后更新數(shù)據(jù)飒货，再次查詢相同的語句：
@Test
public void test() {
SqlSession sqlSession = sqlSessionFactory.openSession();
try {
User user = (User)sqlSession.selectOne("org.format.mybatis.cache.UserMapper.getById", 1);
log.debug(user);
user.setAge(100);
sqlSession.update("org.format.mybatis.cache.UserMapper.update", user);
User user2 = (User)sqlSession.selectOne("org.format.mybatis.cache.UserMapper.getById", 1);
log.debug(user2);
sqlSession.commit();
} finally {
sqlSession.close();
}
}
更新操作之后緩存會被清除：
==> Preparing: select * from USERS WHERE ID = ?
==> Parameters: 1(Integer)
<== Total: 1
User{id=1, name='format', age=23, birthday=Sun Oct 12 23:20:13 CST 2014}
==> Preparing: update USERS SET NAME = ? , AGE = ? , BIRTHDAY = ? where ID = ?
==> Parameters: format(String), 23(Integer), 2014-10-12 23:20:13.0(Timestamp), 1(Integer)
<== Updates: 1
==> Preparing: select * from USERS WHERE ID = ?
==> Parameters: 1(Integer)
<== Total: 1
User{id=1, name='format', age=23, birthday=Sun Oct 12 23:20:13 CST 2014}
很明顯，結(jié)果驗證了一級緩存的概念峭竣，在同個SqlSession中塘辅，查詢語句相同的sql會被緩存，但是一旦執(zhí)行新增或更新或刪除操作皆撩，緩存就會被清除扣墩。
2.2 源碼分析##
在分析MyBatis的一級緩存之前，我們先簡單看下MyBatis中幾個重要的類和接口：
org.apache.ibatis.session.Configuration類：MyBatis全局配置信息類
org.apache.ibatis.session.SqlSessionFactory接口：操作SqlSession的工廠接口扛吞，具體的實現(xiàn)類是DefaultSqlSessionFactory
org.apache.ibatis.session.SqlSession接口：執(zhí)行sql沮榜，管理事務(wù)的接口，具體的實現(xiàn)類是DefaultSqlSession
org.apache.ibatis.executor.Executor接口：sql執(zhí)行器喻粹，SqlSession執(zhí)行sql最終是通過該接口實現(xiàn)的蟆融，常用的實現(xiàn)類有SimpleExecutor和CachingExecutor,這些實現(xiàn)類都使用了裝飾者設(shè)計模式
一級緩存的作用域是SqlSession，那么我們就先看一下SqlSession的select過程：
- 這是DefaultSqlSession（SqlSession接口實現(xiàn)類守呜，MyBatis默認(rèn)使用這個類）的selectList源碼（我們例子上使用的是selectOne方法型酥，調(diào)用selectOne方法最終會執(zhí)行selectList方法）：
public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
try {
MappedStatement ms = configuration.getMappedStatement(statement);
List<E> result = executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
return result;
} catch (Exception e) {
throw ExceptionFactory.wrapException("Error querying database. Cause: " + e, e);
} finally {
ErrorContext.instance().reset();
}
}
- 我們看到SqlSession最終會調(diào)用Executor接口的方法山憨。接下來我們看下DefaultSqlSession中的executor接口屬性具體是哪個實現(xiàn)類。DefaultSqlSession的構(gòu)造過程（DefaultSqlSessionFactory內(nèi)部）：
private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
Transaction tx = null;
try {
final Environment environment = configuration.getEnvironment();
final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
final Executor executor = configuration.newExecutor(tx, execType, autoCommit);
return new DefaultSqlSession(configuration, executor);
} catch (Exception e) {
closeTransaction(tx); // may have fetched a connection so lets call close()
throw ExceptionFactory.wrapException("Error opening session. Cause: " + e, e);
} finally {
ErrorContext.instance().reset();
}
}
- 我們看到DefaultSqlSessionFactory構(gòu)造DefaultSqlSession的時候弥喉，Executor接口的實現(xiàn)類是由Configuration構(gòu)造的：
public Executor newExecutor(Transaction transaction, ExecutorType executorType, boolean autoCommit) {
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, autoCommit);
}
executor = (Executor) interceptorChain.pluginAll(executor);
return executor;
}
Executor根據(jù)ExecutorType的不同而創(chuàng)建郁竟，最常用的是SimpleExecutor，本文的例子也是創(chuàng)建這個實現(xiàn)類由境。 最后我們發(fā)現(xiàn)如果cacheEnabled這個屬性為true的話棚亩，那么executor會被包一層裝飾器，這個裝飾器是 CachingExecutor虏杰。其中cacheEnabled這個屬性是mybatis總配置文件中settings節(jié)點中cacheEnabled子節(jié)點的值讥蟆，默認(rèn)就是true，也就是說我們在mybatis總配置文件中不配cacheEnabled的話纺阔，它也是默認(rèn)為打開的瘸彤。
- 現(xiàn)在，問題就剩下一個了笛钝，CachingExecutor執(zhí)行sql的時候到底做了什么质况？帶著這個問題，我們繼續(xù)走下去（CachingExecutor的query方法）：
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);
if (!dirty) {
cache.getReadWriteLock().readLock().lock();
try {
@SuppressWarnings("unchecked")
List<E> cachedList = (List<E>) cache.getObject(key);
if (cachedList != null) return cachedList;
} finally {
cache.getReadWriteLock().readLock().unlock();
}
}
List<E> list = delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
tcm.putObject(cache, key, list); // issue #578. Query must be not synchronized to prevent deadlocks
return list;
}
}
return delegate.<E>query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}
其中Cache cache = ms.getCache();這句代碼中玻靡，這個cache實際上就是個二級緩存结榄，由于我們沒有開啟二級緩存(二級緩存的內(nèi)容下面會分析)，因此這里執(zhí)行了最后一句話囤捻。這里的delegate也就是SimpleExecutor,SimpleExecutor沒有Override父類的query方法潭陪，因此最終執(zhí)行了SimpleExecutor的父類BaseExecutor的query方法。
- 所以一級緩存最重要的代碼就是BaseExecutor的query方法!
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();
}
deferredLoads.clear(); // issue #601
if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
clearLocalCache(); // issue #482
}
}
return list;
}
BaseExecutor的屬性localCache是個PerpetualCache類型的實例最蕾，PerpetualCache類是實現(xiàn)了MyBatis的Cache緩存接口的實現(xiàn)類之一依溯，內(nèi)部有個Map類型的屬性用來存儲緩存數(shù)據(jù)。這個localCache的類型在BaseExecutor內(nèi)部是寫死的瘟则。這個localCache就是一級緩存黎炉！
- 接下來我們看下為何執(zhí)行新增或更新或刪除操作，一級緩存就會被清除這個問題醋拧。首先MyBatis處理新增或刪除的時候慷嗜，最終都是調(diào)用update方法，也就是說新增或者刪除操作在MyBatis眼里都是一個更新操作丹壕。我們看下DefaultSqlSession的update方法：
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();
}
}
很明顯庆械，這里調(diào)用了CachingExecutor的update方法：
public int update(MappedStatement ms, Object parameterObject) throws SQLException {
flushCacheIfRequired(ms);
return delegate.update(ms, parameterObject);
}
這里的flushCacheIfRequired方法清除的是二級緩存，我們之后會分析菌赖。 CachingExecutor委托給了(之前已經(jīng)分析過)SimpleExecutor的update方法缭乘，SimpleExecutor沒有 Override父類BaseExecutor的update方法，因此我們看BaseExecutor的update方法：
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);
}
- 我們看到了關(guān)鍵的一句代碼： clearLocalCache(); 進(jìn)去看看：
public void clearLocalCache() {
if (!closed) {
localCache.clear();
localOutputParameterCache.clear();
}
}
沒錯琉用，就是這條堕绩，sqlsession沒有關(guān)閉的話策幼，進(jìn)行新增、刪除奴紧、修改操作的話就是清除一級緩存特姐，也就是SqlSession的緩存。
3 二級緩存#
二級緩存的作用域是全局黍氮，換句話說唐含，二級緩存已經(jīng)脫離SqlSession的控制了。二級緩存的作用域是全局的沫浆，二級緩存在SqlSession關(guān)閉或提交之后才會生效捷枯。
在分析MyBatis的二級緩存之前，我們先簡單看下MyBatis中一個關(guān)于二級緩存的類(其他相關(guān)的類和接口之前已經(jīng)分析過)件缸，org.apache.ibatis.mapping.MappedStatement：
MappedStatement類在Mybatis框架中用于表示XML文件中一個sql語句節(jié)點铜靶，即一個<select />叔遂、<update />或者<insert />標(biāo)簽他炊。Mybatis框架在初始化階段會對XML配置文件進(jìn)行讀取，將其中的sql語句節(jié)點對象化為一個個MappedStatement對象已艰。
二級緩存的工作機制：
一個SqlSession對象會使用一個Executor對象來完成會話操作痊末，MyBatis的二級緩存機制的關(guān)鍵就是對這個Executor對象做文章。如果用戶配置了"cacheEnabled=true"哩掺，那么MyBatis在為SqlSession對象創(chuàng)建Executor對象時凿叠，會對Executor對象加上一個裝飾者：CachingExecutor，這時SqlSession使用CachingExecutor對象來完成操作請求嚼吞。CachingExecutor對于查詢請求盒件，會先判斷該查詢請求在Application級別的二級緩存中是否有緩存結(jié)果，如果有查詢結(jié)果舱禽，則直接返回緩存結(jié)果炒刁；如果緩存中沒有，再交給真正的Executor對象來完成查詢操作誊稚，之后CachingExecutor會將真正Executor返回的查詢結(jié)果放置到緩存中翔始，然后在返回給用戶。
MyBatis的二級緩存設(shè)計得比較靈活里伯，你可以使用MyBatis自己定義的二級緩存實現(xiàn)城瞎；你也可以通過實現(xiàn)org.apache.ibatis.cache.Cache接口自定義緩存；也可以使用第三方內(nèi)存緩存庫疾瓮，如Memcached等脖镀。
3.1 緩存配置##
二級緩存跟一級緩存不同，一級緩存不需要配置任何東西狼电，且默認(rèn)打開认然。 二級緩存就需要配置一些東西补憾。本文就說下最簡單的配置，在mapper文件上加上這句配置即可卷员。其實二級緩存跟3個配置有關(guān)：
- mybatis全局配置文件中的setting中的cacheEnabled需要為true(默認(rèn)為true盈匾，不設(shè)置也行)
- mapper配置文件中需要加入<cache>節(jié)點
- mapper配置文件中的select節(jié)點需要加上屬性useCache需要為true(默認(rèn)為true，不設(shè)置也行)
3.2 緩存測試##
- 不同SqlSession毕骡，查詢相同語句削饵，第一次查詢之后commit SqlSession：
@Test
public void testCache2() {
SqlSession sqlSession = sqlSessionFactory.openSession();
SqlSession sqlSession2 = sqlSessionFactory.openSession();
try {
String sql = "org.format.mybatis.cache.UserMapper.getById";
User user = (User)sqlSession.selectOne(sql, 1);
log.debug(user);
// 注意，這里一定要提交未巫。 不提交還是會查詢兩次數(shù)據(jù)庫
sqlSession.commit();
User user2 = (User)sqlSession2.selectOne(sql, 1);
log.debug(user2);
} finally {
sqlSession.close();
sqlSession2.close();
}
}
MyBatis僅進(jìn)行了一次數(shù)據(jù)庫查詢：
==> Preparing: select * from USERS WHERE ID = ?
==> Parameters: 1(Integer)
<== Total: 1
User{id=1, name='format', age=23, birthday=Sun Oct 12 23:20:13 CST 2014}
User{id=1, name='format', age=23, birthday=Sun Oct 12 23:20:13 CST 2014}
- 不同SqlSession窿撬，查詢相同語句迎瞧，第一次查詢之后close SqlSession：
@Test
public void testCache2() {
SqlSession sqlSession = sqlSessionFactory.openSession();
SqlSession sqlSession2 = sqlSessionFactory.openSession();
try {
String sql = "org.format.mybatis.cache.UserMapper.getById";
User user = (User)sqlSession.selectOne(sql, 1);
log.debug(user);
sqlSession.close();
User user2 = (User)sqlSession2.selectOne(sql, 1);
log.debug(user2);
} finally {
sqlSession2.close();
}
}
MyBatis僅進(jìn)行了一次數(shù)據(jù)庫查詢：
==> Preparing: select * from USERS WHERE ID = ?
==> Parameters: 1(Integer)
<== Total: 1
User{id=1, name='format', age=23, birthday=Sun Oct 12 23:20:13 CST 2014}
User{id=1, name='format', age=23, birthday=Sun Oct 12 23:20:13 CST 2014}
- 不同SqlSesson脓恕，查詢相同語句邑彪。 第一次查詢之后SqlSession不提交：
@Test
public void testCache2() {
SqlSession sqlSession = sqlSessionFactory.openSession();
SqlSession sqlSession2 = sqlSessionFactory.openSession();
try {
String sql = "org.format.mybatis.cache.UserMapper.getById";
User user = (User)sqlSession.selectOne(sql, 1);
log.debug(user);
User user2 = (User)sqlSession2.selectOne(sql, 1);
log.debug(user2);
} finally {
sqlSession.close();
sqlSession2.close();
}
}
MyBatis執(zhí)行了兩次數(shù)據(jù)庫查詢：
==> Preparing: select * from USERS WHERE ID = ?
==> Parameters: 1(Integer)
<== Total: 1
User{id=1, name='format', age=23, birthday=Sun Oct 12 23:20:13 CST 2014}
==> Preparing: select * from USERS WHERE ID = ?
==> Parameters: 1(Integer)
<== Total: 1
User{id=1, name='format', age=23, birthday=Sun Oct 12 23:20:13 CST 2014}
3.3 源碼分析##
- XMLMappedBuilder（解析每個mapper配置文件的解析類缆瓣，每一個mapper配置都會實例化一個XMLMapperBuilder類）的解析方法：
private void configurationElement(XNode context) {
try {
String namespace = context.getStringAttribute("namespace");
if (namespace.equals("")) {
throw new BuilderException("Mapper's namespace cannot be empty");
}
builderAssistant.setCurrentNamespace(namespace);
cacheRefElement(context.evalNode("cache-ref"));
cacheElement(context.evalNode("cache"));
parameterMapElement(context.evalNodes("/mapper/parameterMap"));
resultMapElements(context.evalNodes("/mapper/resultMap"));
sqlElement(context.evalNodes("/mapper/sql"));
buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
} catch (Exception e) {
throw new BuilderException("Error parsing Mapper XML. Cause: " + e, e);
}
}
- 我們看到了解析cache的那段代碼：
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);
Properties props = context.getChildrenAsProperties();
builderAssistant.useNewCache(typeClass, evictionClass, flushInterval, size, readWrite, props);
}
}
- 解析完cache標(biāo)簽之后會使用builderAssistant的userNewCache方法粹污，這里的builderAssistant是一個MapperBuilderAssistant類型的幫助類扑浸，每個XMLMappedBuilder構(gòu)造的時候都會實例化這個屬性襟交，MapperBuilderAssistant類內(nèi)部有個Cache類型的currentCache屬性歇拆，這個屬性也就是mapper配置文件中 cache節(jié)點所代表的值：
public Cache useNewCache(Class<? extends Cache> typeClass,
Class<? extends Cache> evictionClass,
Long flushInterval,
Integer size,
boolean readWrite,
Properties props) {
typeClass = valueOrDefault(typeClass, PerpetualCache.class);
evictionClass = valueOrDefault(evictionClass, LruCache.class);
Cache cache = new CacheBuilder(currentNamespace)
.implementation(typeClass)
.addDecorator(evictionClass)
.clearInterval(flushInterval)
.size(size)
.readWrite(readWrite)
.properties(props)
.build();
configuration.addCache(cache);
currentCache = cache;
return cache;
}
OK新啼，現(xiàn)在mapper配置文件中的cache節(jié)點被解析到了XMLMapperBuilder實例中的builderAssistant屬性中的currentCache值里追城。
- 接下來XMLMapperBuilder會解析select節(jié)點，解析select節(jié)點的時候使用XMLStatementBuilder進(jìn)行解析(也包括其他insert燥撞，update座柱，delete節(jié)點)：
public void parseStatementNode() {
String id = context.getStringAttribute("id");
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");
LanguageDriver langDriver = getLanguageDriver(lang);
Class<?> resultTypeClass = resolveClass(resultType);
String resultSetType = context.getStringAttribute("resultSetType");
StatementType statementType = StatementType.valueOf(context.getStringAttribute("statementType", StatementType.PREPARED.toString()));
ResultSetType resultSetTypeEnum = resolveResultSetType(resultSetType);
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());
// Parse selectKey after includes and remove them.
processSelectKeyNodes(id, parameterTypeClass, langDriver);
// Parse the SQL (pre: <selectKey> and <include> were parsed and removed)
SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass);
String resultSets = context.getStringAttribute("resultSets");
String keyProperty = context.getStringAttribute("keyProperty");
String keyColumn = context.getStringAttribute("keyColumn");
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))
? new Jdbc3KeyGenerator() : new NoKeyGenerator();
}
builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType,
fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass,
resultSetTypeEnum, flushCache, useCache, resultOrdered,
keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets);
}
這段代碼前面都是解析一些標(biāo)簽的屬性，我們看到了最后一行使用builderAssistant添加MappedStatement物舒，其中builderAssistant屬性是構(gòu)造XMLStatementBuilder的時候通過XMLMappedBuilder傳入的色洞，我們繼續(xù)看builderAssistant的addMappedStatement方法：
- 進(jìn)入setStatementCache：
private void setStatementCache(
boolean isSelect,
boolean flushCache,
boolean useCache,
Cache cache,
MappedStatement.Builder statementBuilder) {
flushCache = valueOrDefault(flushCache, !isSelect);
useCache = valueOrDefault(useCache, isSelect);
statementBuilder.flushCacheRequired(flushCache);
statementBuilder.useCache(useCache);
statementBuilder.cache(cache);
}
最終mapper配置文件中的<cache/>被設(shè)置到了XMLMapperBuilder的builderAssistant屬性中，XMLMapperBuilder中使用XMLStatementBuilder遍歷CRUD節(jié)點冠胯，遍歷CRUD節(jié)點的時候?qū)⑦@個cache節(jié)點設(shè)置到這些CRUD節(jié)點中火诸，這個cache就是所謂的二級緩存！
- 接下來我們回過頭來看查詢的源碼涵叮，CachingExecutor的query方法：
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. Query must be not synchronized to prevent deadlocks
}
return list;
}
}
return delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}
- 進(jìn)入TransactionalCacheManager的putObject方法：
public void putObject(Cache cache, CacheKey key, Object value) {
getTransactionalCache(cache).putObject(key, value);
}
private TransactionalCache getTransactionalCache(Cache cache) {
TransactionalCache txCache = transactionalCaches.get(cache);
if (txCache == null) {
txCache = new TransactionalCache(cache);
transactionalCaches.put(cache, txCache);
}
return txCache;
}
- TransactionalCache的putObject方法：
public void putObject(Object key, Object object) {
entriesToRemoveOnCommit.remove(key);
entriesToAddOnCommit.put(key, new AddEntry(delegate, key, object));
}
我們看到惭蹂，數(shù)據(jù)被加入到了entriesToAddOnCommit中，這個entriesToAddOnCommit是什么東西呢割粮，它是TransactionalCache的一個Map屬性：
private Map<Object, AddEntry> entriesToAddOnCommit;
AddEntry是TransactionalCache內(nèi)部的一個類：
private static class AddEntry {
private Cache cache;
private Object key;
private Object value;
public AddEntry(Cache cache, Object key, Object value) {
this.cache = cache;
this.key = key;
this.value = value;
}
public void commit() {
cache.putObject(key, value);
}
}
好了盾碗，現(xiàn)在我們發(fā)現(xiàn)使用二級緩存之后：查詢數(shù)據(jù)的話，先從二級緩存中拿數(shù)據(jù)舀瓢，如果沒有的話廷雅，去一級緩存中拿，一級緩存也沒有的話再查詢數(shù)據(jù)庫。有了數(shù)據(jù)之后在丟到TransactionalCache這個對象的entriesToAddOnCommit屬性中航缀。
接下來我們來驗證為什么SqlSession commit或close之后商架，二級緩存才會生效這個問題。
- DefaultSqlSession的commit方法：
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方法：
public void commit(boolean required) throws SQLException {
delegate.commit(required);
tcm.commit();
dirty = false;
}
- tcm.commit即 TransactionalCacheManager的commit方法：
public void commit() {
for (TransactionalCache txCache : transactionalCaches.values()) {
txCache.commit();
}
}
- TransactionalCache的commit方法：
public void commit() {
delegate.getReadWriteLock().writeLock().lock();
try {
if (clearOnCommit) {
delegate.clear();
} else {
for (RemoveEntry entry : entriesToRemoveOnCommit.values()) {
entry.commit();
}
}
for (AddEntry entry : entriesToAddOnCommit.values()) {
entry.commit();
}
reset();
} finally {
delegate.getReadWriteLock().writeLock().unlock();
}
}
- 發(fā)現(xiàn)調(diào)用了AddEntry的commit方法：
public void commit() {
cache.putObject(key, value);
}
發(fā)現(xiàn)了芥玉！ AddEntry的commit方法會把數(shù)據(jù)丟到cache中蛇摸，也就是丟到二級緩存中！
關(guān)于為何調(diào)用close方法后灿巧，二級緩存才會生效赶袄，因為close方法內(nèi)部會調(diào)用commit方法。本文就不具體說了抠藕。 讀者有興趣的話看一看源碼就知道為什么了饿肺。
4 Cache接口#
org.apache.ibatis.cache.Cache是MyBatis的緩存接口，想要實現(xiàn)自定義的緩存需要實現(xiàn)這個接口盾似。MyBatis中關(guān)于Cache接口的實現(xiàn)類也使用了裝飾者設(shè)計模式敬辣。我們看下它的一些實現(xiàn)類：
簡單說明：
LRU – 最近最少使用的:移除最長時間不被使用的對象。
FIFO – 先進(jìn)先出:按對象進(jìn)入緩存的順序來移除它們零院。
SOFT – 軟引用:移除基于垃圾回收器狀態(tài)和軟引用規(guī)則的對象溉跃。
WEAK – 弱引用:更積極地移除基于垃圾收集器狀態(tài)和弱引用規(guī)則的對象。
<cache
eviction="FIFO" <!-- 可以通過cache節(jié)點的eviction屬性設(shè)置门粪，也可以設(shè)置其他的屬性喊积。-->
flushInterval="60000"
size="512"
readOnly="true"/>
cache-ref節(jié)點：mapper配置文件中還可以加入cache-ref節(jié)點烹困，它有個屬性namespace玄妈。如果每個mapper文件都是用cache-ref，且namespace都一樣髓梅，那么就代表著真正意義上的全局緩存拟蜻。如果只用了cache節(jié)點，那僅代表這個這個mapper內(nèi)部的查詢被緩存了枯饿，其他mapper文件的不起作用酝锅，這并不是所謂的全局緩存。
