前言

不知道大家看到這張圖感覺怎么樣，不是難，一共也沒有幾個組件，但是真的讓我想當頭疼，因為在面試的時候，就這張圖，對，你沒看錯，就這幾個組件，那是讓我相當難受啊

MyBatis中SQL執行的整體過程

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

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

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

SQL執行過程（一）之Executor

在MyBatis的SQL執行過程中，Executor執行器擔當著一個重要的角色，相關操作都需要通過它來執行，相當于一個調度器，把SQL語句交給它，它來調用各個組件執行操作

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

Executor執行器接口的實現類如下圖所示：

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

Executor

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

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 游標*/<E> Cursor<E> queryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds) throws SQLException;/*** 刷入批處理語句*/List<BatchResult> flushStatements() throws SQLException;/*** 提交事務*/void commit(boolean required) throws SQLException;/*** 回滾事務*/void rollback(boolean required) throws SQLException;/*** 創建 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);/*** 獲得事務*/Transaction getTransaction();/*** 關閉事務*/void close(boolean forceRollback);/*** 判斷事務是否關閉*/boolean isClosed();/*** 設置包裝的 Executor 對象*/void setExecutorWrapper(Executor executor); }

執行器接口定義了操作數據庫的相關方法：

• 數據庫的讀和寫操作
• 事務相關
• 緩存相關
• 設置延遲加載
• 設置包裝的 Executor 對象

BaseExecutor

org.apache.ibatis.executor.BaseExecutor：實現Executor接口，提供骨架方法，指定幾個抽象的方法交由不同的子類去實現，例如：

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;

上面這四個方法交由不同的子類去實現，分別是：更新數據庫、刷入批處理語句、查詢數據庫和查詢數據返回游標

構造方法

public abstract class BaseExecutor implements Executor {private static final Log log = LogFactory.getLog(BaseExecutor.class);/*** 事務對象*/protected Transaction transaction;/*** 包裝的 Executor 對象*/protected Executor wrapper;/*** DeferredLoad（延遲加載）隊列*/protected ConcurrentLinkedQueue<DeferredLoad> deferredLoads;/*** 本地緩存，即一級緩存，內部就是一個 HashMap 對象*/protected PerpetualCache localCache;/*** 本地輸出類型參數的緩存，和存儲過程有關*/protected PerpetualCache localOutputParameterCache;/*** 全局配置*/protected Configuration configuration;/*** 記錄當前會話正在查詢的數量*/protected int queryStack;/*** 是否關閉*/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;} }

其中上面的屬性可根據注釋進行查看

一級緩存

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

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

clearLocalCache方法

clearLocalCache()方法，清空一級（本地）緩存，如果全局配置中設置的localCacheScope緩存區域為STATEMENT（默認為SESSION），則在每一次查詢后會調用該方法，相當于關閉了一級緩存，代碼如下：

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

createCacheKey方法

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

@Override public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {if (closed) {throw new ExecutorException("Executor was closed.");}// <1> 創建 CacheKey 對象CacheKey cacheKey = new CacheKey();// <2> 設置 id、offset、limit、sql 到 CacheKey 對象中cacheKey.update(ms.getId());cacheKey.update(rowBounds.getOffset());cacheKey.update(rowBounds.getLimit());cacheKey.update(boundSql.getSql());// <3> 設置 ParameterMapping 數組的元素對應的每個 value 到 CacheKey 對象中List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry();// mimic DefaultParameterHandler logicfor (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) {// 入參對象為空則直接返回 nullvalue = null;} else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {// 入參有對應的類型處理器則直接返回該參數value = parameterObject;} else {// 從入參對象中獲取該屬性的值MetaObject metaObject = configuration.newMetaObject(parameterObject);value = metaObject.getValue(propertyName);}cacheKey.update(value);}}// <4> 設置 Environment.id 到 CacheKey 對象中if (configuration.getEnvironment() != null) {// issue #176cacheKey.update(configuration.getEnvironment().getId());}return cacheKey; }

創建一個CacheKey實例對象

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

獲取本次查詢的入參值，通過CacheKey的update方法添加到其中

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

返回CacheKey實例對象，這樣就可以為本次查詢生成一個唯一的緩存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相關方法

查詢數據庫因為涉及到一級緩存，所以這里有多層方法，最終訪問數據庫的doQuery方法是交由子類去實現的，總共分為三層：

1、根據入參獲取BoundSql和CacheKey對象，然后再去調用查詢方法
2、涉及到一級緩存和延遲加載的處理，緩存未命中則再去調用查詢數據庫的方法
3、保存一些信息供一級緩存使用，內部調用doQuery方法執行數據庫的讀操作

接下來我們分別來看看這三個方法

① 數據庫查詢操作的入口

代碼格式：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> 創建 CacheKey 對象CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);// <3> 查詢return query(ms, parameter, rowBounds, resultHandler, key, boundSql); }

通過MappedStatement對象根據入參獲取BoundSql對象，如果是動態SQL則需要進行解析，獲取到最終的SQL，替換成?占位符

調用createCacheKey方法為本次查詢創建一個CacheKey對象

繼續調用query(...)方法執行查詢

② 處理數據庫查詢操作，涉及到一級緩存

代碼格式：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> 已經關閉，則拋出 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> 從一級緩存中，獲取查詢結果list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;if (list != null) { // <4.1> 獲取到，則進行處理// 處理緩存存儲過程的結果handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);} else { // <4.2> 獲得不到，則從數據庫中查詢list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);}} finally {// <5> queryStack - 1queryStack--;}if (queryStack == 0) { // <6> 如果當前會話的所有查詢執行完了// <6.1> 執行延遲加載for (DeferredLoad deferredLoad : deferredLoads) {deferredLoad.load();}// issue #601// <6.2> 清空 deferredLoadsdeferredLoads.clear();// <6.3> 如果緩存級別是 LocalCacheScope.STATEMENT ，則進行清理if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {// issue #482clearLocalCache();}}// <7> 返回查詢結果return list; }

當前會話已經被關閉則拋出異常

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

當前會話正在查詢的數量加一，queryStack++

從localCache一級緩存獲取緩存的查詢結果如果有緩存數據，則需要處理儲存過程的情況，將需要作為出參（OUT）的參數設置到本次查詢的入參的屬性中如果沒有緩存數據，則調用queryFromDatabase方法，執行數據庫查詢操作

當前會話正在查詢的數量減一，queryStack--

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

返回查詢結果

③ 執行數據庫查詢操作

代碼格式：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> 在緩存中，添加正在執行的占位符對象，因為正在執行的查詢不允許提前加載需要延遲加載的屬性，可見 DeferredLoad#canLoad() 方法localCache.putObject(key, EXECUTION_PLACEHOLDER);try {// <2> 執行讀操作list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);} finally {// <3> 從緩存中，移除占位對象localCache.removeObject(key);}// <4> 添加到緩存中localCache.putObject(key, list);// <5> 如果是存儲過程，則將入參信息保存保存，跟一級緩存處理存儲過程相關if (ms.getStatementType() == StatementType.CALLABLE) {localOutputParameterCache.putObject(key, parameter);}// <6> 返回查詢結果return list; }

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

調用查詢數據庫doQuery方法，該方法交由子類實現

刪除第1步添加的占位符

將查詢結果添加到localCache一級緩存中

如果是存儲過程，則將入參信息保存保存，跟一級緩存處理存儲過程相關，可見上面的第②個方法的第4.1步

返回查詢結果

update方法

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

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

當前會話已經被關閉則拋出異常

清空當前會話中一級緩存的所有數據

調用更新數據庫doUpdate方法，該方法交由子類實現

其他方法

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

二級緩存

問題

在講到的一級緩存中，緩存數據僅在當前的 SqlSession 會話中進行共享，可能會導致多個 SqlSession 出現數據不一致性的問題

如果需要在多個 SqlSession 之間需要共享緩存數據，則需要使用到二級緩存

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

流程如下圖所示：

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

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

我們來看看MyBatis是如何實現二級緩存的

CachingExecutor

org.apache.ibatis.executor.CachingExecutor：實現 Executor 接口，支持二級緩存的 Executor 的實現類

構造方法

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

• delegate 屬性，為被委托的Executor對象，具體的數據庫操作都是交由它去執行
• tcm 屬性，TransactionalCacheManager對象，支持事務的緩存管理器，因為二級緩存是支持跨 SqlSession 共享的，此處需要考慮事務，那么，必然需要做到事務提交時，才將當前事務中查詢時產生的緩存，同步到二級緩存中，所以需要通過TransactionalCacheManager來實現

query方法

處理數據庫查詢操作的方法，涉及到二級緩存，會將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> 如果需要清空緩存，則進行清空flushCacheIfRequired(ms);// <2.2> 如果當前操作需要使用緩存（默認開啟）if (ms.isUseCache() && resultHandler == null) {// <2.2.1> 如果是存儲過程相關操作，保證所有的參數模式為 ParameterMode.INensureNoOutParams(ms, boundSql);// <2.2.2> 從二級緩存中獲取結果，會裝飾成 TransactionalCacheList<E> list = (List<E>) tcm.getObject(cache, key);if (list == null) {// <2.2.3> 如果不存在，則從數據庫中查詢list = delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);// <2.2.4> 將緩存結果保存至 TransactionalCachetcm.putObject(cache, key, list); // issue #578 and #116}// <2.2.5> 直接返回結果return list;}}// <3> 沒有使用二級緩存，則調用委托對象的方法return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql); }

獲取Cache二級緩存對象

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

沒有使用二級緩存，則調用委托對象的方法

update方法

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

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

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

commit方法

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

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

rollback方法

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

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

close方法

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

在事務關閉前，如果是強制回滾操作，則TransactionalCacheManager二級緩存管理器，將本次事務生成的緩存數據從TransactionalCach中移除，否則還是將緩存數據設置到正真的Cache二級緩存中

TransactionalCacheManager

org.apache.ibatis.cache.TransactionalCacheManager：二級緩存管理器，因為二級緩存是支持跨 SqlSession 共享的，所以需要通過它來實現，當事務提交時，才將當前事務中查詢時產生的緩存，同步到二級緩存中，代碼如下：

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 對應的 TransactionalCache 對象// 然后，添加 KV 到 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) {return transactionalCaches.computeIfAbsent(cache, TransactionalCache::new);}}

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

TransactionalCache

org.apache.ibatis.cache.decorators.TransactionalCache：用來裝飾二級緩存的對象，作為二級緩存一個事務的緩沖區

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

public class TransactionalCache implements Cache {private static final Log log = LogFactory.getLog(TransactionalCache.class);/*** 委托的 Cache 對象。** 實際上，就是二級緩存 Cache 對象。*/private final Cache delegate;/*** 提交時，清空 {@link #delegate}** 初始時，該值為 false* 清理后{@link #clear()} 時，該值為 true ，表示持續處于清空狀態** 因為可能事務還未提交，所以不能直接清空所有的緩存，而是設置一個標記，獲取緩存的時候返回 null 即可* 先清空下面這個待提交變量，待事務提交的時候才真正的清空緩存**/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 對應的 valueObject object = delegate.getObject(key);if (object == null) {// <2> 如果不存在，則添加到 entriesMissedInCache 中entriesMissedInCache.add(key);}// issue #146if (clearOnCommit) {// <3> 如果 clearOnCommit 為 true ，表示處于持續清空狀態，則返回 nullreturn null;} else {return object;}}@Overridepublic void putObject(Object key, Object object) {// 暫存 KV 到 entriesToAddOnCommit 中entriesToAddOnCommit.put(key, object);}@Overridepublic void clear() {// <1> 標記 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);}}} }

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

• putObject(Object key, Object object)方法，添加緩存數據時，先把緩存數據保存在entriesToAddOnCommit中，這個對象屬于當前事務，事務還未提交，其他事務是不能訪問到的
• clear()方法，設置clearOnCommit標記為true，告訴當前事務正處于持續清空狀態，先把entriesToAddOnCommit清空，也就是當前事務中還未提交至二級緩存的緩存數據，事務還未提交，不能直接清空二級緩存中的數據，否則影響到其他事務了
• commit()方法，事務提交后，如果clearOnCommit為true，表示正處于持續清空狀態，需要先把二級緩存中的數據全部清空，然后再把當前事務生成的緩存設置到二級緩存中，然后重置當前對象這里為什么處于清空狀態把二級緩存的數據清空后，還要將當前事務生成的緩存數據再設置到二級緩存中呢？因為當前事務調用clear()方法后可能有新生成了新的緩存數據，而不能把這些忽略掉
• getObject(Object key)方法先從delegate二級緩存對象中獲取結果如果緩存未命中則將該key添加到entriesMissedInCache屬性中，因為二級緩存也會將緩存未命中的key起來，數據為null如果clearOnCommit為true，即使你緩存命中了也返回null，因為觸發clear()方法的話，本來需要清空二級緩存的，但是事務還未提交，所以先標記一個緩存持續清理的這么一個狀態，這樣相當于在當前事務中既清空了二級緩存數據，也不影響其他事務的二級緩存數據返回獲取到的結果，可能為null

Executor在哪被創建

前面對Executor執行器接口以及實現類都有分析過，那么它是在哪創建的呢？

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();// 創建 Transaction 對象final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);// 創建 Executor 對象final Executor executor = configuration.newExecutor(tx, execType);// 創建 DefaultSqlSession 對象return new DefaultSqlSession(configuration, executor, autoCommit);} catch (Exception e) {// 如果發生異常，則關閉 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();}} }

我們所有的數據庫操作都是在MyBatis的一個SqlSession會話中執行的，在它被創建的時候，會先通過Configuration全局配置對象的newExecutor方法創建一個Executor執行器

newExecutor(Transaction transaction, ExecutorType executorType)方法，根據執行器類型創建執行Executor執行器，代碼如下：

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

獲得執行器類型，默認為SIMPLE

創建對應的Executor對象，默認就是SimpleExecutor執行器了

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

插件鏈應用該對象，在后續會講到

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

最后，希望各位在學習的過程中，能夠重視一下源碼的閱讀，因為源碼中很多的方法其實都已經注釋好了，很方便閱讀

總結

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

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