前言

不知道大家看到這張圖感覺怎么樣，不是難，一共也沒有幾個(gè)組件，但是真的讓我想當(dāng)頭疼，因?yàn)樵诿嬖嚨臅r(shí)候，就這張圖，對，你沒看錯(cuò)，就這幾個(gè)組件，那是讓我相當(dāng)難受啊

MyBatis中SQL執(zhí)行的整體過程

在 SqlSession 中，會將執(zhí)行 SQL 的過程交由Executor執(zhí)行器去執(zhí)行，過程大致如下：

1、通過DefaultSqlSessionFactory創(chuàng)建與數(shù)據(jù)庫交互的 SqlSession “會話”，其內(nèi)部會創(chuàng)建一個(gè)Executor執(zhí)行器對象
2、然后Executor執(zhí)行器通過StatementHandler創(chuàng)建對應(yīng)的java.sql.Statement對象，并通過ParameterHandler設(shè)置參數(shù)，然后執(zhí)行數(shù)據(jù)庫相關(guān)操作
如果是數(shù)據(jù)庫更新操作，則可能需要通過KeyGenerator先設(shè)置自增鍵，然后返回受影響的 行數(shù)
如果是數(shù)據(jù)庫查詢操作，則需要將數(shù)據(jù)庫返回的ResultSet結(jié)果集對象包裝ResultSetWrapper，然后通過DefaultResultSetHandler對結(jié)果集進(jìn)行映射，最后返回 Java 對象

上面還涉及到一級緩存、二級緩存和延遲加載等其他處理過程，下面我們來看一下具體的執(zhí)行過程

SQL執(zhí)行過程（一）之Executor

在MyBatis的SQL執(zhí)行過程中，Executor執(zhí)行器擔(dān)當(dāng)著一個(gè)重要的角色，相關(guān)操作都需要通過它來執(zhí)行，相當(dāng)于一個(gè)調(diào)度器，把SQL語句交給它，它來調(diào)用各個(gè)組件執(zhí)行操作

其中一級緩存和二級緩存都是在Executor執(zhí)行器中完成的

Executor執(zhí)行器接口的實(shí)現(xiàn)類如下圖所示：

org.apache.ibatis.executor.BaseExecutor：實(shí)現(xiàn)Executor接口，提供骨架方法，支持一級緩存，指定幾個(gè)抽象的方法交由不同的子類去實(shí)現(xiàn)
org.apache.ibatis.executor.SimpleExecutor：繼承 BaseExecutor 抽象類，簡單的 Executor 實(shí)現(xiàn)類（默認(rèn)）
org.apache.ibatis.executor.ReuseExecutor：繼承 BaseExecutor 抽象類，可重用的 Executor 實(shí)現(xiàn)類，相比SimpleExecutor，在Statement執(zhí)行完操作后不會立即關(guān)閉，而是緩存起來，執(zhí)行的SQL作為key，下次執(zhí)行相同的SQL時(shí)優(yōu)先從緩存中獲取Statement對象
org.apache.ibatis.executor.BatchExecutor：繼承 BaseExecutor 抽象類，支持批量執(zhí)行的 Executor 實(shí)現(xiàn)類
org.apache.ibatis.executor.CachingExecutor：實(shí)現(xiàn) Executor 接口，支持二級緩存的 Executor 的實(shí)現(xiàn)類，實(shí)際采用了裝飾器模式，裝飾對象為左邊三個(gè)Executor類

Executor

org.apache.ibatis.executor.Executor：執(zhí)行器接口，代碼如下：

public interface Executor {/*** ResultHandler 空對象*/ResultHandler NO_RESULT_HANDLER = null;/*** 更新或者插入或者刪除* 由傳入的 MappedStatement 的 SQL 所決定*/int update(MappedStatement ms, Object parameter) throws SQLException;/*** 查詢，帶 ResultHandler + CacheKey + BoundSql*/<E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler,CacheKey cacheKey, BoundSql boundSql) throws SQLException;/*** 查詢，帶 ResultHandler*/<E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler)throws SQLException;/*** 查詢，返回 Cursor 游標(biāo)*/<E> Cursor<E> queryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds) throws SQLException;/*** 刷入批處理語句*/List<BatchResult> flushStatements() throws SQLException;/*** 提交事務(wù)*/void commit(boolean required) throws SQLException;/*** 回滾事務(wù)*/void rollback(boolean required) throws SQLException;/*** 創(chuàng)建 CacheKey 對象*/CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql);/*** 判斷是否緩存*/boolean isCached(MappedStatement ms, CacheKey key);/*** 清除本地緩存*/void clearLocalCache();/*** 延遲加載*/void deferLoad(MappedStatement ms, MetaObject resultObject, String property, CacheKey key, Class<?> targetType);/*** 獲得事務(wù)*/Transaction getTransaction();/*** 關(guān)閉事務(wù)*/void close(boolean forceRollback);/*** 判斷事務(wù)是否關(guān)閉*/boolean isClosed();/*** 設(shè)置包裝的 Executor 對象*/void setExecutorWrapper(Executor executor); }

執(zhí)行器接口定義了操作數(shù)據(jù)庫的相關(guān)方法：

• 數(shù)據(jù)庫的讀和寫操作
• 事務(wù)相關(guān)
• 緩存相關(guān)
• 設(shè)置延遲加載
• 設(shè)置包裝的 Executor 對象

BaseExecutor

org.apache.ibatis.executor.BaseExecutor：實(shí)現(xiàn)Executor接口，提供骨架方法，指定幾個(gè)抽象的方法交由不同的子類去實(shí)現(xiàn)，例如：

protected abstract int doUpdate(MappedStatement ms, Object parameter) throws SQLException;protected abstract List<BatchResult> doFlushStatements(boolean isRollback) throws SQLException;protected abstract <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException;protected abstract <E> Cursor<E> doQueryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds,BoundSql boundSql) throws SQLException;

上面這四個(gè)方法交由不同的子類去實(shí)現(xiàn)，分別是：更新數(shù)據(jù)庫、刷入批處理語句、查詢數(shù)據(jù)庫和查詢數(shù)據(jù)返回游標(biāo)

構(gòu)造方法

public abstract class BaseExecutor implements Executor {private static final Log log = LogFactory.getLog(BaseExecutor.class);/*** 事務(wù)對象*/protected Transaction transaction;/*** 包裝的 Executor 對象*/protected Executor wrapper;/*** DeferredLoad（延遲加載）隊(duì)列*/protected ConcurrentLinkedQueue<DeferredLoad> deferredLoads;/*** 本地緩存，即一級緩存，內(nèi)部就是一個(gè) HashMap 對象*/protected PerpetualCache localCache;/*** 本地輸出類型參數(shù)的緩存，和存儲過程有關(guān)*/protected PerpetualCache localOutputParameterCache;/*** 全局配置*/protected Configuration configuration;/*** 記錄當(dāng)前會話正在查詢的數(shù)量*/protected int queryStack;/*** 是否關(guān)閉*/private boolean closed;protected BaseExecutor(Configuration configuration, Transaction transaction) {this.transaction = transaction;this.deferredLoads = new ConcurrentLinkedQueue<>();this.localCache = new PerpetualCache("LocalCache");this.localOutputParameterCache = new PerpetualCache("LocalOutputParameterCache");this.closed = false;this.configuration = configuration;this.wrapper = this;} }

其中上面的屬性可根據(jù)注釋進(jìn)行查看

一級緩存

這里提一下localCache屬性，本地緩存，用于一級緩存，MyBatis的一級緩存是什么呢？

每當(dāng)我們使用 MyBatis 開啟一次和數(shù)據(jù)庫的會話，MyBatis 都會創(chuàng)建出一個(gè) SqlSession 對象，表示與數(shù)據(jù)庫的一次會話，而每個(gè) SqlSession 都會創(chuàng)建一個(gè) Executor 對象
在對數(shù)據(jù)庫的一次會話中，我們有可能會反復(fù)地執(zhí)行完全相同的查詢語句，每一次查詢都會訪問一次數(shù)據(jù)庫，如果在極短的時(shí)間內(nèi)做了完全相同的查詢，那么它們的結(jié)果極有可能完全相同，由于查詢一次數(shù)據(jù)庫的代價(jià)很大，如果不采取一些措施的話，可能造成很大的資源浪費(fèi)
為了解決這一問題，減少資源的浪費(fèi)，MyBatis 會在每一次 SqlSession 會話對象中建立一個(gè)簡單的緩存，將每次查詢到的結(jié)果緩存起來，當(dāng)下次查詢的時(shí)候，如果之前已有完全一樣的查詢，則會先嘗試從這個(gè)簡單的緩存中獲取結(jié)果返回給用戶，不需要再進(jìn)行一次數(shù)據(jù)庫查詢了 注意，這個(gè)“簡單的緩存”就是一級緩存，且默認(rèn)開啟，無法“關(guān)閉”
MyBatis 的一次會話：在一個(gè) SqlSession 會話對象中創(chuàng)建一個(gè)localCache本地緩存，對于每一次查詢，都會根據(jù)查詢條件嘗試去localCache本地緩存中獲取緩存數(shù)據(jù)，如果存在，就直接從緩存中取出數(shù)據(jù)然后返回給用戶，否則訪問數(shù)據(jù)庫進(jìn)行查詢，將查詢結(jié)果存入緩存并返回給用戶（如果設(shè)置的緩存區(qū)域?yàn)镾TATEMENT，默認(rèn)為SESSION，在一次會話中所有查詢執(zhí)行后會清空當(dāng)前 SqlSession 會話中的localCache本地緩存，相當(dāng)于“關(guān)閉”了一級緩存）
所有的數(shù)據(jù)庫更新操作都會清空當(dāng)前 SqlSession 會話中的本地緩存
如上描述，MyBatis的一級緩存在多個(gè) SqlSession 會話時(shí)，可能導(dǎo)致數(shù)據(jù)的不一致性，某一個(gè) SqlSession 更新了數(shù)據(jù)而其他 SqlSession 無法獲取到更新后的數(shù)據(jù)，出現(xiàn)數(shù)據(jù)不一致性，這種情況是不允許出現(xiàn)了，所以我們通常選擇“關(guān)閉”一級緩存

clearLocalCache方法

clearLocalCache()方法，清空一級（本地）緩存，如果全局配置中設(shè)置的localCacheScope緩存區(qū)域?yàn)镾TATEMENT（默認(rèn)為SESSION），則在每一次查詢后會調(diào)用該方法，相當(dāng)于關(guān)閉了一級緩存，代碼如下：

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

createCacheKey方法

createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql)方法，根據(jù)本地查詢的相關(guān)信息創(chuàng)建一個(gè)CacheKey緩存key對象，代碼如下：

@Override public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {if (closed) {throw new ExecutorException("Executor was closed.");}// <1> 創(chuàng)建 CacheKey 對象CacheKey cacheKey = new CacheKey();// <2> 設(shè)置 id、offset、limit、sql 到 CacheKey 對象中cacheKey.update(ms.getId());cacheKey.update(rowBounds.getOffset());cacheKey.update(rowBounds.getLimit());cacheKey.update(boundSql.getSql());// <3> 設(shè)置 ParameterMapping 數(shù)組的元素對應(yīng)的每個(gè) value 到 CacheKey 對象中List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry();// mimic DefaultParameterHandler logicfor (ParameterMapping parameterMapping : parameterMappings) {if (parameterMapping.getMode() != ParameterMode.OUT) { // 該參數(shù)需要作為入?yún)bject value;String propertyName = parameterMapping.getProperty();/** 獲取該屬性值*/if (boundSql.hasAdditionalParameter(propertyName)) {// 從附加參數(shù)中獲取value = boundSql.getAdditionalParameter(propertyName);} else if (parameterObject == null) {// 入?yún)ο鬄榭談t直接返回 nullvalue = null;} else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {// 入?yún)⒂袑?yīng)的類型處理器則直接返回該參數(shù)value = parameterObject;} else {// 從入?yún)ο笾蝎@取該屬性的值MetaObject metaObject = configuration.newMetaObject(parameterObject);value = metaObject.getValue(propertyName);}cacheKey.update(value);}}// <4> 設(shè)置 Environment.id 到 CacheKey 對象中if (configuration.getEnvironment() != null) {// issue #176cacheKey.update(configuration.getEnvironment().getId());}return cacheKey; }

創(chuàng)建一個(gè)CacheKey實(shí)例對象

將入?yún)⒅械膇d、offset、limit、sql，通過CacheKey的update方法添加到其中，它的方法如下：public void update(Object object) { // 方法參數(shù) object 的 hashcode int baseHashCode = object == null ? 1 : ArrayUtil.hashCode(object); this.count++; // checksum 為 baseHashCode 的求和 this.checksum += baseHashCode; // 計(jì)算新的 hashcode 值 baseHashCode *= this.count; this.hashcode = this.multiplier * this.hashcode + baseHashCode; // 添加 object 到 updateList 中 this.updateList.add(object); }

獲取本次查詢的入?yún)⒅?#xff0c;通過CacheKey的update方法添加到其中

獲取本次環(huán)境的Environment.id，通過CacheKey的update方法添加到其中

返回CacheKey實(shí)例對象，這樣就可以為本次查詢生成一個(gè)唯一的緩存key對象，可以看看CacheKey重寫的equal方法：

@Override public boolean equals(Object object) {if (this == object) {return true;} if (!(object instanceof CacheKey)) { return false; } final CacheKey cacheKey = (CacheKey) object;if (hashcode != cacheKey.hashcode) { return false;} if (checksum != cacheKey.checksum) { return false;} if (count != cacheKey.count) {return false; } for (int i = 0; i < updateList.size(); i++) { Object thisObject = updateList.get(i); Object thatObject = cacheKey.updateList.get(i); if (!ArrayUtil.equals(thisObject, thatObject)) { return false; } } return true; }

query相關(guān)方法

查詢數(shù)據(jù)庫因?yàn)樯婕暗揭患壘彺?#xff0c;所以這里有多層方法，最終訪問數(shù)據(jù)庫的doQuery方法是交由子類去實(shí)現(xiàn)的，總共分為三層：

1、根據(jù)入?yún)@取BoundSql和CacheKey對象，然后再去調(diào)用查詢方法
2、涉及到一級緩存和延遲加載的處理，緩存未命中則再去調(diào)用查詢數(shù)據(jù)庫的方法
3、保存一些信息供一級緩存使用，內(nèi)部調(diào)用doQuery方法執(zhí)行數(shù)據(jù)庫的讀操作

接下來我們分別來看看這三個(gè)方法

① 數(shù)據(jù)庫查詢操作的入口

代碼格式：query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler)方法，代碼如下

@Override public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler)throws SQLException {// <1> 獲得 BoundSql 對象BoundSql boundSql = ms.getBoundSql(parameter);// <2> 創(chuàng)建 CacheKey 對象CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);// <3> 查詢r(jià)eturn query(ms, parameter, rowBounds, resultHandler, key, boundSql); }

通過MappedStatement對象根據(jù)入?yún)@取BoundSql對象，如果是動態(tài)SQL則需要進(jìn)行解析，獲取到最終的SQL，替換成?占位符

調(diào)用createCacheKey方法為本次查詢創(chuàng)建一個(gè)CacheKey對象

繼續(xù)調(diào)用query(...)方法執(zhí)行查詢

② 處理數(shù)據(jù)庫查詢操作，涉及到一級緩存

代碼格式：query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)方法，代碼如下：

@Override 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());// <1> 已經(jīng)關(guān)閉，則拋出 ExecutorException 異常if (closed) {throw new ExecutorException("Executor was closed.");}// <2> 清空本地緩存，如果 queryStack 為零，并且要求清空本地緩存（配置了 flushCache = true）if (queryStack == 0 && ms.isFlushCacheRequired()) {clearLocalCache();}List<E> list;try {// <3> queryStack + 1queryStack++;// <4> 從一級緩存中，獲取查詢結(jié)果list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;if (list != null) { // <4.1> 獲取到，則進(jìn)行處理// 處理緩存存儲過程的結(jié)果handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);} else { // <4.2> 獲得不到，則從數(shù)據(jù)庫中查詢list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);}} finally {// <5> queryStack - 1queryStack--;}if (queryStack == 0) { // <6> 如果當(dāng)前會話的所有查詢執(zhí)行完了// <6.1> 執(zhí)行延遲加載for (DeferredLoad deferredLoad : deferredLoads) {deferredLoad.load();}// issue #601// <6.2> 清空 deferredLoadsdeferredLoads.clear();// <6.3> 如果緩存級別是 LocalCacheScope.STATEMENT ，則進(jìn)行清理if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {// issue #482clearLocalCache();}}// <7> 返回查詢結(jié)果return list; }

當(dāng)前會話已經(jīng)被關(guān)閉則拋出異常

如果queryStack為0（表示是當(dāng)前會話只有本次查詢而沒有其他的查詢了），并且要求清空本地緩存（配置了flushCache=true），那么直接清空一級（本地）緩存

當(dāng)前會話正在查詢的數(shù)量加一，queryStack++

從localCache一級緩存獲取緩存的查詢結(jié)果如果有緩存數(shù)據(jù)，則需要處理儲存過程的情況，將需要作為出參（OUT）的參數(shù)設(shè)置到本次查詢的入?yún)⒌膶傩灾腥绻麤]有緩存數(shù)據(jù)，則調(diào)用queryFromDatabase方法，執(zhí)行數(shù)據(jù)庫查詢操作

當(dāng)前會話正在查詢的數(shù)量減一，queryStack--

如果當(dāng)前會話所有查詢都執(zhí)行完執(zhí)行當(dāng)前會話中的所有的延遲加載deferredLoads，這種延遲加載屬于查詢后的延遲，和后續(xù)講到的獲取屬性時(shí)再加載不同，這里的延遲加載是在哪里生成的呢？在DefaultResultSetHandler中進(jìn)行結(jié)果映射時(shí)，如果某個(gè)屬性配置的是子查詢，并且本次的子查詢在一級緩存中有緩存數(shù)據(jù)，那么將會創(chuàng)建一個(gè)DeferredLoad對象保存在deferredLoads中，該屬性值先設(shè)置為DEFERRED延遲加載對象（final修飾的Object對象），待當(dāng)前會話所有的查詢結(jié)束后，也就是當(dāng)前執(zhí)行步驟，則會從一級緩存獲取到數(shù)據(jù)設(shè)置到返回結(jié)果中清空所有的延遲加載deferredLoads對象如果全局配置的緩存級別為STATEMENT（默認(rèn)為SESSION），則清空當(dāng)前會話中一級緩存的所有數(shù)據(jù)

返回查詢結(jié)果

③ 執(zhí)行數(shù)據(jù)庫查詢操作

代碼格式：queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)方法，代碼如下：

private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds,ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {List<E> list;// <1> 在緩存中，添加正在執(zhí)行的占位符對象，因?yàn)檎趫?zhí)行的查詢不允許提前加載需要延遲加載的屬性，可見 DeferredLoad#canLoad() 方法localCache.putObject(key, EXECUTION_PLACEHOLDER);try {// <2> 執(zhí)行讀操作list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);} finally {// <3> 從緩存中，移除占位對象localCache.removeObject(key);}// <4> 添加到緩存中l(wèi)ocalCache.putObject(key, list);// <5> 如果是存儲過程，則將入?yún)⑿畔⒈４姹４?#xff0c;跟一級緩存處理存儲過程相關(guān)if (ms.getStatementType() == StatementType.CALLABLE) {localOutputParameterCache.putObject(key, parameter);}// <6> 返回查詢結(jié)果return list; }

在緩存中，添加正在執(zhí)行的EXECUTION_PLACEHOLDER占位符對象，因?yàn)檎趫?zhí)行的查詢不允許提前加載需要延遲加載的屬性，可見 DeferredLoad#canLoad() 方法

調(diào)用查詢數(shù)據(jù)庫doQuery方法，該方法交由子類實(shí)現(xiàn)

刪除第1步添加的占位符

將查詢結(jié)果添加到localCache一級緩存中

如果是存儲過程，則將入?yún)⑿畔⒈４姹４?#xff0c;跟一級緩存處理存儲過程相關(guān)，可見上面的第②個(gè)方法的第4.1步

返回查詢結(jié)果

update方法

update(MappedStatement ms, Object parameter)方法，執(zhí)行更新數(shù)據(jù)庫的操作，代碼如下：

@Override public int update(MappedStatement ms, Object parameter) throws SQLException {ErrorContext.instance().resource(ms.getResource()).activity("executing an update").object(ms.getId());// <1> 已經(jīng)關(guān)閉，則拋出 ExecutorException 異常if (closed) {throw new ExecutorException("Executor was closed.");}// <2> 清空本地緩存clearLocalCache();// <3> 執(zhí)行寫操作return doUpdate(ms, parameter); }

當(dāng)前會話已經(jīng)被關(guān)閉則拋出異常

清空當(dāng)前會話中一級緩存的所有數(shù)據(jù)

調(diào)用更新數(shù)據(jù)庫doUpdate方法，該方法交由子類實(shí)現(xiàn)

其他方法

除了上面介紹的幾個(gè)重要的方法以外，還有其他很多方法，例如獲取當(dāng)前事務(wù)，提交事務(wù)，回滾事務(wù)，關(guān)閉會話等等，這里我就不一一列出來了，大家可以自行閱讀類源碼，我下面會進(jìn)行涉及，但是不會那么精細(xì)

二級緩存

問題

在講到的一級緩存中，緩存數(shù)據(jù)僅在當(dāng)前的 SqlSession 會話中進(jìn)行共享，可能會導(dǎo)致多個(gè) SqlSession 出現(xiàn)數(shù)據(jù)不一致性的問題

如果需要在多個(gè) SqlSession 之間需要共享緩存數(shù)據(jù)，則需要使用到二級緩存

開啟二級緩存后，會使用CachingExecutor對象裝飾其他的Executor類，這樣會先在CachingExecutor進(jìn)行二級緩存的查詢，緩存未命中則進(jìn)入裝飾的對象中，進(jìn)行一級緩存的查詢

流程如下圖所示：

在全局配置對象中cacheEnabled是否開啟緩存屬性默認(rèn)為true，可以在mybatis-config.xml配置文件中添加以下配置關(guān)閉：

<configuration><settings><setting name="cacheEnabled" value="false" /></settings> </configuration>

我們來看看MyBatis是如何實(shí)現(xiàn)二級緩存的

CachingExecutor

org.apache.ibatis.executor.CachingExecutor：實(shí)現(xiàn) Executor 接口，支持二級緩存的 Executor 的實(shí)現(xiàn)類

構(gòu)造方法

public class CachingExecutor implements Executor {/*** 被委托的 Executor 對象*/private final Executor delegate;/*** TransactionalCacheManager 對象*/private final TransactionalCacheManager tcm = new TransactionalCacheManager();public CachingExecutor(Executor delegate) {this.delegate = delegate;// 設(shè)置 delegate 被當(dāng)前執(zhí)行器所包裝delegate.setExecutorWrapper(this);} }

• delegate 屬性，為被委托的Executor對象，具體的數(shù)據(jù)庫操作都是交由它去執(zhí)行
• tcm 屬性，TransactionalCacheManager對象，支持事務(wù)的緩存管理器，因?yàn)槎壘彺媸侵С挚?SqlSession 共享的，此處需要考慮事務(wù)，那么，必然需要做到事務(wù)提交時(shí)，才將當(dāng)前事務(wù)中查詢時(shí)產(chǎn)生的緩存，同步到二級緩存中，所以需要通過TransactionalCacheManager來實(shí)現(xiàn)

query方法

處理數(shù)據(jù)庫查詢操作的方法，涉及到二級緩存，會將Cache二級緩存對象裝飾成TransactionalCache對象并存放在TransactionalCacheManager管理器中，代碼如下：

@Override public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds,ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {// <1> 獲取 Cache 二級緩存對象Cache cache = ms.getCache();// <2> 如果配置了二級緩存if (cache != null) {// <2.1> 如果需要清空緩存，則進(jìn)行清空flushCacheIfRequired(ms);// <2.2> 如果當(dāng)前操作需要使用緩存（默認(rèn)開啟）if (ms.isUseCache() && resultHandler == null) {// <2.2.1> 如果是存儲過程相關(guān)操作，保證所有的參數(shù)模式為 ParameterMode.INensureNoOutParams(ms, boundSql);// <2.2.2> 從二級緩存中獲取結(jié)果，會裝飾成 TransactionalCacheList<E> list = (List<E>) tcm.getObject(cache, key);if (list == null) {// <2.2.3> 如果不存在，則從數(shù)據(jù)庫中查詢list = delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);// <2.2.4> 將緩存結(jié)果保存至 TransactionalCachetcm.putObject(cache, key, list); // issue #578 and #116}// <2.2.5> 直接返回結(jié)果return list;}}// <3> 沒有使用二級緩存，則調(diào)用委托對象的方法return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql); }

獲取Cache二級緩存對象

如果該對象不為空，表示配置了二級緩存如果需要清空緩存，則進(jìn)行清空如果當(dāng)前操作需要使用緩存（默認(rèn)開啟）如果是存儲過程相關(guān)操作，保證所有的參數(shù)模式為http://ParameterMode.IN通過TransactionalCacheManager從二級緩存中獲取結(jié)果，會裝飾成TransactionalCach對象如果緩存未命中，則調(diào)用委托對象的query方法將緩存結(jié)果保存至TransactionalCache對象中，并未真正的保存至Cache二級緩存中，需要待事務(wù)提交才會保存過去，其中緩存未命中的也會設(shè)置緩存結(jié)果為null直接返回結(jié)果

沒有使用二級緩存，則調(diào)用委托對象的方法

update方法

@Override public int update(MappedStatement ms, Object parameterObject) throws SQLException {// 如果需要清空緩存，則進(jìn)行清空flushCacheIfRequired(ms);// 執(zhí)行 delegate 對應(yīng)的方法return delegate.update(ms, parameterObject); }private void flushCacheIfRequired(MappedStatement ms) {Cache cache = ms.getCache();if (cache != null && ms.isFlushCacheRequired()) {tcm.clear(cache);} }

數(shù)據(jù)庫的更新操作，如果配置了需要清空緩存，則清空二級緩存

這里就和一級緩存不同，一級緩存是所有的更新操作都會清空一級緩存

commit方法

@Override public void commit(boolean required) throws SQLException {// 執(zhí)行 delegate 對應(yīng)的方法delegate.commit(required);// 提交 TransactionalCacheManagertcm.commit(); }

在事務(wù)提交后，通過TransactionalCacheManager二級緩存管理器，將本次事務(wù)生成的緩存數(shù)據(jù)從TransactionalCach中設(shè)置到正真的Cache二級緩存中

rollback方法

@Override public void rollback(boolean required) throws SQLException {try {// 執(zhí)行 delegate 對應(yīng)的方法delegate.rollback(required);} finally {if (required) {// 回滾 TransactionalCacheManagertcm.rollback();}} }

在事務(wù)回滾后，如果需要的話，通過TransactionalCacheManager二級緩存管理器，將本次事務(wù)生成的緩存數(shù)據(jù)從TransactionalCach中移除

close方法

@Override public void close(boolean forceRollback) {try {// issues #499, #524 and #573if (forceRollback) {tcm.rollback();} else {tcm.commit();}} finally {delegate.close(forceRollback);} }

在事務(wù)關(guān)閉前，如果是強(qiáng)制回滾操作，則TransactionalCacheManager二級緩存管理器，將本次事務(wù)生成的緩存數(shù)據(jù)從TransactionalCach中移除，否則還是將緩存數(shù)據(jù)設(shè)置到正真的Cache二級緩存中

TransactionalCacheManager

org.apache.ibatis.cache.TransactionalCacheManager：二級緩存管理器，因?yàn)槎壘彺媸侵С挚?SqlSession 共享的，所以需要通過它來實(shí)現(xiàn)，當(dāng)事務(wù)提交時(shí)，才將當(dāng)前事務(wù)中查詢時(shí)產(chǎn)生的緩存，同步到二級緩存中，代碼如下：

public class TransactionalCacheManager {/*** Cache 和 TransactionalCache 的映射*/private final Map<Cache, TransactionalCache> transactionalCaches = new HashMap<>();public void clear(Cache cache) {getTransactionalCache(cache).clear();}public Object getObject(Cache cache, CacheKey key) {return getTransactionalCache(cache).getObject(key);}public void putObject(Cache cache, CacheKey key, Object value) {// 首先，獲得 Cache 對應(yīng)的 TransactionalCache 對象// 然后，添加 KV 到 TransactionalCache 對象中g(shù)etTransactionalCache(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) {return transactionalCaches.computeIfAbsent(cache, TransactionalCache::new);}}

• getTransactionalCache(Cache cache)方法，根據(jù)Cache二級緩存對象獲取對應(yīng)的TransactionalCache對象，如果沒有則創(chuàng)建一個(gè)保存起來
• getObject(Cache cache, CacheKey key)方法，會先調(diào)用getTransactionalCache(Cache cache)方法獲取對應(yīng)的TransactionalCache對象，然后根據(jù)CacheKey從該對象中獲取緩存結(jié)果
• putObject(Cache cache, CacheKey key, Object value)方法，同樣也先調(diào)用getTransactionalCache(Cache cache)方法獲取對應(yīng)的TransactionalCache對象，根據(jù)該對象將結(jié)果進(jìn)行緩存
• commit()方法，遍歷transactionalCaches，依次調(diào)用TransactionalCache的提交方法
• rollback()方法，遍歷transactionalCaches，依次調(diào)用TransactionalCache的回滾方法

TransactionalCache

org.apache.ibatis.cache.decorators.TransactionalCache：用來裝飾二級緩存的對象，作為二級緩存一個(gè)事務(wù)的緩沖區(qū)

在一個(gè)SqlSession會話中，該類包含所有需要添加至二級緩存的的緩存數(shù)據(jù)，當(dāng)提交事務(wù)后會全部刷出到二級緩存中，或者事務(wù)回滾后移除這些緩存數(shù)據(jù)，代碼如下：

public class TransactionalCache implements Cache {private static final Log log = LogFactory.getLog(TransactionalCache.class);/*** 委托的 Cache 對象。** 實(shí)際上，就是二級緩存 Cache 對象。*/private final Cache delegate;/*** 提交時(shí)，清空 {@link #delegate}** 初始時(shí)，該值為 false* 清理后{@link #clear()} 時(shí)，該值為 true ，表示持續(xù)處于清空狀態(tài)** 因?yàn)榭赡苁聞?wù)還未提交，所以不能直接清空所有的緩存，而是設(shè)置一個(gè)標(biāo)記，獲取緩存的時(shí)候返回 null 即可* 先清空下面這個(gè)待提交變量，待事務(wù)提交的時(shí)候才真正的清空緩存**/private boolean clearOnCommit;/*** 待提交的 Key-Value 映射*/private final Map<Object, Object> entriesToAddOnCommit;/*** 查找不到的 KEY 集合*/private final Set<Object> entriesMissedInCache;public TransactionalCache(Cache delegate) {this.delegate = delegate;this.clearOnCommit = false;this.entriesToAddOnCommit = new HashMap<>();this.entriesMissedInCache = new HashSet<>();}@Overridepublic Object getObject(Object key) {// issue #116// <1> 從 delegate 中獲取 key 對應(yīng)的 valueObject object = delegate.getObject(key);if (object == null) {// <2> 如果不存在，則添加到 entriesMissedInCache 中entriesMissedInCache.add(key);}// issue #146if (clearOnCommit) {// <3> 如果 clearOnCommit 為 true ，表示處于持續(xù)清空狀態(tài)，則返回 nullreturn null;} else {return object;}}@Overridepublic void putObject(Object key, Object object) {// 暫存 KV 到 entriesToAddOnCommit 中entriesToAddOnCommit.put(key, object);}@Overridepublic void clear() {// <1> 標(biāo)記 clearOnCommit 為 trueclearOnCommit = true;// <2> 清空 entriesToAddOnCommitentriesToAddOnCommit.clear();}public void commit() {// <1> 如果 clearOnCommit 為 true ，則清空 delegate 緩存if (clearOnCommit) {delegate.clear();}// 將 entriesToAddOnCommit、entriesMissedInCache 刷入 delegate 中flushPendingEntries();// 重置reset();}public void rollback() {// <1> 從 delegate 移除出 entriesMissedInCacheunlockMissedEntries();// <2> 重置reset();}private void reset() {clearOnCommit = false;entriesToAddOnCommit.clear();entriesMissedInCache.clear();}private void flushPendingEntries() {for (Map.Entry<Object, Object> entry : entriesToAddOnCommit.entrySet()) {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 {delegate.removeObject(entry);} catch (Exception e) {log.warn("Unexpected exception while notifiying a rollback to the cache adapter."+ "Consider upgrading your cache adapter to the latest version. Cause: " + e);}}} }

根據(jù)上面的注釋查看每個(gè)屬性的作用，我們依次來看下面的方法，看看在不同事務(wù)之前是如何處理二級緩存的

• putObject(Object key, Object object)方法，添加緩存數(shù)據(jù)時(shí)，先把緩存數(shù)據(jù)保存在entriesToAddOnCommit中，這個(gè)對象屬于當(dāng)前事務(wù)，事務(wù)還未提交，其他事務(wù)是不能訪問到的
• clear()方法，設(shè)置clearOnCommit標(biāo)記為true，告訴當(dāng)前事務(wù)正處于持續(xù)清空狀態(tài)，先把entriesToAddOnCommit清空，也就是當(dāng)前事務(wù)中還未提交至二級緩存的緩存數(shù)據(jù)，事務(wù)還未提交，不能直接清空二級緩存中的數(shù)據(jù)，否則影響到其他事務(wù)了
• commit()方法，事務(wù)提交后，如果clearOnCommit為true，表示正處于持續(xù)清空狀態(tài)，需要先把二級緩存中的數(shù)據(jù)全部清空，然后再把當(dāng)前事務(wù)生成的緩存設(shè)置到二級緩存中，然后重置當(dāng)前對象這里為什么處于清空狀態(tài)把二級緩存的數(shù)據(jù)清空后，還要將當(dāng)前事務(wù)生成的緩存數(shù)據(jù)再設(shè)置到二級緩存中呢？因?yàn)楫?dāng)前事務(wù)調(diào)用clear()方法后可能有新生成了新的緩存數(shù)據(jù)，而不能把這些忽略掉
• getObject(Object key)方法先從delegate二級緩存對象中獲取結(jié)果如果緩存未命中則將該key添加到entriesMissedInCache屬性中，因?yàn)槎壘彺嬉矔⒕彺嫖疵械膋ey起來，數(shù)據(jù)為null如果clearOnCommit為true，即使你緩存命中了也返回null，因?yàn)橛|發(fā)clear()方法的話，本來需要清空二級緩存的，但是事務(wù)還未提交，所以先標(biāo)記一個(gè)緩存持續(xù)清理的這么一個(gè)狀態(tài)，這樣相當(dāng)于在當(dāng)前事務(wù)中既清空了二級緩存數(shù)據(jù)，也不影響其他事務(wù)的二級緩存數(shù)據(jù)返回獲取到的結(jié)果，可能為null

Executor在哪被創(chuàng)建

前面對Executor執(zhí)行器接口以及實(shí)現(xiàn)類都有分析過，那么它是在哪創(chuàng)建的呢？

public class DefaultSqlSessionFactory implements SqlSessionFactory {private final Configuration configuration;@Overridepublic SqlSession openSession() {return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);}private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level,boolean autoCommit) {Transaction tx = null;try {// 獲得 Environment 對象final Environment environment = configuration.getEnvironment();// 創(chuàng)建 Transaction 對象final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);// 創(chuàng)建 Executor 對象final Executor executor = configuration.newExecutor(tx, execType);// 創(chuàng)建 DefaultSqlSession 對象return new DefaultSqlSession(configuration, executor, autoCommit);} catch (Exception e) {// 如果發(fā)生異常，則關(guān)閉 Transaction 對象closeTransaction(tx); // may have fetched a connection so lets call close()throw ExceptionFactory.wrapException("Error opening session. Cause: " + e, e);} finally {ErrorContext.instance().reset();}} }

我們所有的數(shù)據(jù)庫操作都是在MyBatis的一個(gè)SqlSession會話中執(zhí)行的，在它被創(chuàng)建的時(shí)候，會先通過Configuration全局配置對象的newExecutor方法創(chuàng)建一個(gè)Executor執(zhí)行器

newExecutor(Transaction transaction, ExecutorType executorType)方法，根據(jù)執(zhí)行器類型創(chuàng)建執(zhí)行Executor執(zhí)行器，代碼如下：

public Executor newExecutor(Transaction transaction, ExecutorType executorType) {// <1> 獲得執(zhí)行器類型executorType = executorType == null ? defaultExecutorType : executorType;executorType = executorType == null ? ExecutorType.SIMPLE : executorType;// <2> 創(chuàng)建對應(yīng)實(shí)現(xiàn)的 Executor 對象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);}// <3> 如果開啟緩存，創(chuàng)建 CachingExecutor 對象，進(jìn)行包裝if (cacheEnabled) {executor = new CachingExecutor(executor);}// <4> 應(yīng)用插件executor = (Executor) interceptorChain.pluginAll(executor);return executor; }

獲得執(zhí)行器類型，默認(rèn)為SIMPLE

創(chuàng)建對應(yīng)的Executor對象，默認(rèn)就是SimpleExecutor執(zhí)行器了

如果全局配置了開啟二級緩存，則將Executor對象，封裝成CachingExecutor對象

插件鏈應(yīng)用該對象，在后續(xù)會講到

啊，不知不覺2W字了，寫源碼的東西是真的浪費(fèi)時(shí)間的好東西啊，比刷抖音都消耗時(shí)間。但是也是真的香，看著自己整理的這些筆記，那是相當(dāng)有成就感

最后，希望各位在學(xué)習(xí)的過程中，能夠重視一下源碼的閱讀，因?yàn)樵创a中很多的方法其實(shí)都已經(jīng)注釋好了，很方便閱讀

總結(jié)

以上是生活随笔為你收集整理的全局程序集缓存gac中安装程序集_我就不信2W字把源码拆的这么碎，你还不明白mybatis缓存...的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。