為什么80%的碼農都做不了架構師？>>> ??

#0 系列目錄#

• 深入淺出MyBatis系列
• 【深入淺出MyBatis系列一】MyBatis入門
• 【深入淺出MyBatis系列二】配置簡介（MyBatis源碼篇）
• 【深入淺出MyBatis系列三】Mapper映射文件配置
• 【深入淺出MyBatis系列四】強大的動態SQL
• 【深入淺出MyBatis系列五】SQL執行流程分析（源碼篇）
• 【深入淺出MyBatis系列六】插件原理
• 【深入淺出MyBatis系列七】分頁插件
• 【深入淺出MyBatis系列八】SQL自動生成插件
• 【深入淺出MyBatis系列九】改造Cache插件
• 【深入淺出MyBatis系列十】與Spring集成
• 【深入淺出MyBatis系列十一】緩存源碼分析
• 【深入淺出MyBatis系列十二】終結篇：MyBatis原理深入解析

#1 緩存介紹# MyBatis支持聲明式數據緩存（declarative data caching）。當一條SQL語句被標記為“可緩存”后，首次執行它時從數據庫獲取的所有數據會被存儲在一段高速緩存中，今后執行這條語句時就會從高速緩存中讀取結果，而不是再次命中數據庫。MyBatis提供了默認下基于Java HashMap的緩存實現，以及用于與OSCache、Ehcache、Hazelcast和Memcached連接的默認連接器。MyBatis還提供API供其他緩存實現使用。

重點的那句話就是：MyBatis執行SQL語句之后，這條語句就是被緩存，以后再執行這條語句的時候，會直接從緩存中拿結果，而不是再次執行SQL。

這也就是大家常說的MyBatis一級緩存，一級緩存的作用域scope是SqlSession。MyBatis同時還提供了一種全局作用域global scope的緩存，這也叫做二級緩存，也稱作全局緩存。

MyBatis將數據緩存設計成兩級結構，分為一級緩存、二級緩存：

一級緩存是Session會話級別的緩存，位于表示一次數據庫會話的SqlSession對象之中，又被稱之為本地緩存。一級緩存是MyBatis內部實現的一個特性，用戶不能配置，默認情況下自動支持的緩存，用戶沒有定制它的權利（不過這也不是絕對的，可以通過開發插件對它進行修改）；

二級緩存是Application應用級別的緩存，它的是生命周期很長，跟Application的聲明周期一樣，也就是說它的作用范圍是整個Application應用。

MyBatis中一級緩存和二級緩存的組織如下圖所示：

#2 一級緩存# 一級緩存的工作機制：

一級緩存是Session會話級別的，一般而言，一個SqlSession對象會使用一個Executor對象來完成會話操作，Executor對象會維護一個Cache緩存，以提高查詢性能。關于一級緩存的詳細實現，可參見MyBatis一級緩存實現。

##2.1 緩存測試## 同個session進行兩次相同查詢：

@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只進行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} User{id=1, name='format', age=23, birthday=Sun Oct 12 23:20:13 CST 2014}

同個session進行兩次不同的查詢：

@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進行兩次數據庫查詢：

==> 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，進行相同查詢：

@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進行了兩次數據庫查詢：

==> 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,查詢之后更新數據，再次查詢相同的語句：

@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}

很明顯，結果驗證了一級緩存的概念，在同個SqlSession中，查詢語句相同的sql會被緩存，但是一旦執行新增或更新或刪除操作，緩存就會被清除。

##2.2 源碼分析## 在分析MyBatis的一級緩存之前，我們先簡單看下MyBatis中幾個重要的類和接口：

org.apache.ibatis.session.Configuration類：MyBatis全局配置信息類

org.apache.ibatis.session.SqlSessionFactory接口：操作SqlSession的工廠接口，具體的實現類是DefaultSqlSessionFactory

org.apache.ibatis.session.SqlSession接口：執行sql，管理事務的接口，具體的實現類是DefaultSqlSession

org.apache.ibatis.executor.Executor接口：sql執行器，SqlSession執行sql最終是通過該接口實現的，常用的實現類有SimpleExecutor和CachingExecutor,這些實現類都使用了裝飾者設計模式

一級緩存的作用域是SqlSession，那么我們就先看一下SqlSession的select過程：

這是DefaultSqlSession（SqlSession接口實現類，MyBatis默認使用這個類）的selectList源碼（我們例子上使用的是selectOne方法，調用selectOne方法最終會執行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最終會調用Executor接口的方法。接下來我們看下DefaultSqlSession中的executor接口屬性具體是哪個實現類。DefaultSqlSession的構造過程（DefaultSqlSessionFactory內部）：

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構造DefaultSqlSession的時候，Executor接口的實現類是由Configuration構造的：

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根據ExecutorType的不同而創建，最常用的是SimpleExecutor，本文的例子也是創建這個實現類。 最后我們發現如果cacheEnabled這個屬性為true的話，那么executor會被包一層裝飾器，這個裝飾器是 CachingExecutor。其中cacheEnabled這個屬性是mybatis總配置文件中settings節點中cacheEnabled子節點的值，默認就是true，也就是說我們在mybatis總配置文件中不配cacheEnabled的話，它也是默認為打開的。

現在，問題就剩下一個了，CachingExecutor執行sql的時候到底做了什么？帶著這個問題，我們繼續走下去（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 deadlocksreturn list;}}return delegate.<E>query(ms, parameterObject, rowBounds, resultHandler, key, boundSql); }

其中Cache cache = ms.getCache();這句代碼中，這個cache實際上就是個二級緩存，由于我們沒有開啟二級緩存(二級緩存的內容下面會分析)，因此這里執行了最后一句話。這里的delegate也就是SimpleExecutor,SimpleExecutor沒有Override父類的query方法，因此最終執行了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 #601if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {clearLocalCache(); // issue #482}}return list; }

BaseExecutor的屬性localCache是個PerpetualCache類型的實例，PerpetualCache 類是實現了MyBatis的Cache緩存接口的實現類之一，內部有個Map 類型的屬性用來存儲緩存數據。 這個localCache的類型在BaseExecutor內部是寫死的。 這個localCache就是一級緩存！

接下來我們看下為何執行新增或更新或刪除操作，一級緩存就會被清除這個問題。首先MyBatis處理新增或刪除的時候，最終都是調用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();} }

很明顯，這里調用了CachingExecutor的update方法：

public int update(MappedStatement ms, Object parameterObject) throws SQLException {flushCacheIfRequired(ms);return delegate.update(ms, parameterObject); }

這里的flushCacheIfRequired方法清除的是二級緩存，我們之后會分析。 CachingExecutor委托給了(之前已經分析過)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); }

我們看到了關鍵的一句代碼： clearLocalCache(); 進去看看：

public void clearLocalCache() {if (!closed) {localCache.clear();localOutputParameterCache.clear();} }

沒錯，就是這條，sqlsession沒有關閉的話，進行新增、刪除、修改操作的話就是清除一級緩存，也就是SqlSession的緩存。

#3 二級緩存# 二級緩存的作用域是全局，換句話說，二級緩存已經脫離SqlSession的控制了。二級緩存的作用域是全局的，二級緩存在SqlSession關閉或提交之后才會生效。

在分析MyBatis的二級緩存之前，我們先簡單看下MyBatis中一個關于二級緩存的類(其他相關的類和接口之前已經分析過)：

org.apache.ibatis.mapping.MappedStatement：

MappedStatement類在Mybatis框架中用于表示XML文件中一個sql語句節點，即一個<select />、<update />或者<insert />標簽。Mybatis框架在初始化階段會對XML配置文件進行讀取，將其中的sql語句節點對象化為一個個MappedStatement對象。

二級緩存的工作機制：

一個SqlSession對象會使用一個Executor對象來完成會話操作，MyBatis的二級緩存機制的關鍵就是對這個Executor對象做文章。如果用戶配置了"cacheEnabled=true"，那么MyBatis在為SqlSession對象創建Executor對象時，會對Executor對象加上一個裝飾者：CachingExecutor，這時SqlSession使用CachingExecutor對象來完成操作請求。CachingExecutor對于查詢請求，會先判斷該查詢請求在Application級別的二級緩存中是否有緩存結果，如果有查詢結果，則直接返回緩存結果；如果緩存中沒有，再交給真正的Executor對象來完成查詢操作，之后CachingExecutor會將真正Executor返回的查詢結果放置到緩存中，然后在返回給用戶。

MyBatis的二級緩存設計得比較靈活，你可以使用MyBatis自己定義的二級緩存實現；你也可以通過實現org.apache.ibatis.cache.Cache接口自定義緩存；也可以使用第三方內存緩存庫，如Memcached等。

##3.1 緩存配置## 二級緩存跟一級緩存不同，一級緩存不需要配置任何東西，且默認打開。 二級緩存就需要配置一些東西。本文就說下最簡單的配置，在mapper文件上加上這句配置即可。其實二級緩存跟3個配置有關：

mybatis全局配置文件中的setting中的cacheEnabled需要為true(默認為true，不設置也行)

mapper配置文件中需要加入<cache>節點

mapper配置文件中的select節點需要加上屬性useCache需要為true(默認為true，不設置也行)

##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);// 注意，這里一定要提交。 不提交還是會查詢兩次數據庫sqlSession.commit();User user2 = (User)sqlSession2.selectOne(sql, 1);log.debug(user2);} finally {sqlSession.close();sqlSession2.close();} }

MyBatis僅進行了一次數據庫查詢：

==> 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僅進行了一次數據庫查詢：

==> 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執行了兩次數據庫查詢：

==> 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標簽之后會使用builderAssistant的userNewCache方法，這里的builderAssistant是一個MapperBuilderAssistant類型的幫助類，每個XMLMappedBuilder構造的時候都會實例化這個屬性，MapperBuilderAssistant類內部有個Cache類型的currentCache屬性，這個屬性也就是mapper配置文件中 cache節點所代表的值：

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，現在mapper配置文件中的cache節點被解析到了XMLMapperBuilder實例中的builderAssistant屬性中的currentCache值里。

接下來XMLMapperBuilder會解析select節點，解析select節點的時候使用XMLStatementBuilder進行解析(也包括其他insert，update，delete節點)：

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 parsingXMLIncludeTransformer 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); }

這段代碼前面都是解析一些標簽的屬性，我們看到了最后一行使用builderAssistant添加MappedStatement，其中builderAssistant屬性是構造XMLStatementBuilder的時候通過XMLMappedBuilder傳入的，我們繼續看builderAssistant的addMappedStatement方法：

進入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/>被設置到了XMLMapperBuilder的builderAssistant屬性中，XMLMapperBuilder中使用XMLStatementBuilder遍歷CRUD節點，遍歷CRUD節點的時候將這個cache節點設置到這些CRUD節點中，這個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); }

進入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)); }

我們看到，數據被加入到了entriesToAddOnCommit中，這個entriesToAddOnCommit是什么東西呢，它是TransactionalCache的一個Map屬性：

private Map<Object, AddEntry> entriesToAddOnCommit;

AddEntry是TransactionalCache內部的一個類：

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);} }

好了，現在我們發現使用二級緩存之后：查詢數據的話，先從二級緩存中拿數據，如果沒有的話，去一級緩存中拿，一級緩存也沒有的話再查詢數據庫。有了數據之后在丟到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();} }

發現調用了AddEntry的commit方法：

public void commit() {cache.putObject(key, value); }

發現了！ AddEntry的commit方法會把數據丟到cache中，也就是丟到二級緩存中！

關于為何調用close方法后，二級緩存才會生效，因為close方法內部會調用commit方法。本文就不具體說了。 讀者有興趣的話看一看源碼就知道為什么了。

#4 Cache接口# org.apache.ibatis.cache.Cache是MyBatis的緩存接口，想要實現自定義的緩存需要實現這個接口。MyBatis中關于Cache接口的實現類也使用了裝飾者設計模式。我們看下它的一些實現類：

簡單說明：

LRU – 最近最少使用的:移除最長時間不被使用的對象。

FIFO – 先進先出:按對象進入緩存的順序來移除它們。

SOFT – 軟引用:移除基于垃圾回收器狀態和軟引用規則的對象。

WEAK – 弱引用:更積極地移除基于垃圾收集器狀態和弱引用規則的對象。

<cacheeviction="FIFO" <!-- 可以通過cache節點的eviction屬性設置，也可以設置其他的屬性。-->flushInterval="60000"size="512"readOnly="true"/>

**cache-ref節點：**mapper配置文件中還可以加入cache-ref節點，它有個屬性namespace。如果每個mapper文件都是用cache-ref，且namespace都一樣，那么就代表著真正意義上的全局緩存。如果只用了cache節點，那僅代表這個這個mapper內部的查詢被緩存了，其他mapper文件的不起作用，這并不是所謂的全局緩存。

轉載于:https://my.oschina.net/xianggao/blog/552272

總結

以上是生活随笔為你收集整理的【深入浅出MyBatis系列十一】缓存源码分析的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。