吃透Mybatis原始碼-快取的理解
來來來，給俏如來紮起。感謝老鐵們對俏如來的支援，2021一路有你，2022我們繼續加油！你的肯定是我最大的動力
博主在參加部落格之星評比，點選連結 ， https://bbs.csdn.net/topics/603957267 瘋狂打Call！五星好評 ⭐⭐⭐⭐⭐ 感謝
前言
對於Mybatis的快取在上一章節《吃透Mybatis原始碼-Mybatis執行流程》我們有提到一部分，這篇文章我們對將詳細分析一下Mybatis的一級快取和二級快取。
一級快取
市面上流行的ORM框架都支援快取，不管是Hibernate還是Mybatis都支援一級快取和二級快取，目的是把資料快取到JVM記憶體中，減少和資料庫的互動來提高查詢速度。同時MyBatis還可以整合三方快取技術。
Mybatis一級緩預設開啟，是SqlSession級別的，也就是說需要同一個SqlSession執行同樣的SQL和引數才有可能命中快取。如：
同一個SqlSession執行同一個SQL，發現控制檯紀錄檔只執行了一次SQL記錄，說明第二次查詢是走快取了。但是要注意的是，當SqlSession執行了delete,update,insert語句後，快取會被清除。
那麼一級快取在哪兒呢？下面給大家介紹一個類。
Mybatis中提供的快取都是Cache的實現類，但是真正實現快取的是PerpetualCache，其中維護了一個Map<Object, Object> cache = new HashMap<Object, Object>() 結構來快取資料。其他的快取類採用了裝飾模式對PerpetualCache做增強。比如：LruCache 在PerpetualCache 的基礎上增加了最近最少使用的快取清楚策略,當快取到達上限時候，刪除最近最少使用的快取 （Least Recently Use）。程式碼如下
public class LruCache implements Cache {
//對 PerpetualCache 做裝飾
private final Cache delegate;
下面對其他的快取類做一個介紹
PerpetualCache: 基礎快取類- LruCache ： LRU 策略的快取 當快取到達上限時候，刪除最近最少使用的快取 （Least Recently Use），eviction=「LRU」（默 認）
- FifoCache : FIFO 策略的快取 當快取到達上限時候，刪除最先入隊的快取，設定eviction=「FIFO」
- SoftCache WeakCache ：帶清理策略的快取 通過 JVM 的軟參照和弱參照來實現快取，當 JVM 記憶體不足時，會自動清理掉這些快取，基於 SoftReference 和 WeakReference
- SynchronizedCache ： 同步快取 基於 synchronized 關鍵字實現，解決並行問題
- ScheduledCache ： 定時排程的快取，在進行 get/put/remove/getSize 等操作前，判斷 快取時間是否超過了設定的最長快取時間（預設是 一小時），如果是則清空快取–即每隔一段時間清 空一次快取
- SerializedCache ：支援序列化的快取 將物件序列化以後存到快取中，取出時反序列化
TransactionalCache：事務快取，在二級快取中使用，可一次存入多個快取，移除多個快取 。通過TransactionalCacheManager 中用 Map 維護對應關係。
一級快取到底儲存在哪兒？
一級快取在SimpleExecutor 的父類別 BaseExecutor 執行器中，如下
public abstract class BaseExecutor implements Executor {
private static final Log log = LogFactory.getLog(BaseExecutor.class);
protected Transaction transaction;
protected Executor wrapper;
protected ConcurrentLinkedQueue<DeferredLoad> deferredLoads;
//一級快取
protected PerpetualCache localCache;
PerpetualCache快取類原始碼如下
public class PerpetualCache implements Cache {
private final String id;
//快取
private Map<Object, Object> cache = new HashMap<Object, Object>();
那麼一級快取在什麼時候建立的？
在 BaseExecutor 中的構造器中建立了一級快取，而執行器Executor 是儲存在SqlSession中的，也就是說當建立SqlSession的時候，就會建立 SimpleExecutor，而在SimpleExecutor的構造器中會呼叫BaseExecutor的構造器來建立一級快取。見：org.apache.ibatis.executor.SimpleExecutor#SimpleExecutor
public class SimpleExecutor extends BaseExecutor {
//執行器構造器
public SimpleExecutor(Configuration configuration, Transaction transaction) {
//呼叫父類別構造器
super(configuration, transaction);
}
下面是 BaseExecutor 的執行器 org.apache.ibatis.executor.BaseExecutor#BaseExecutor
public abstract class BaseExecutor implements Executor {
private static final Log log = LogFactory.getLog(BaseExecutor.class);
protected Transaction transaction;
protected Executor wrapper;
//一級快取
protected PerpetualCache localCache;
protected PerpetualCache localOutputParameterCache;
protected Configuration configuration;
protected BaseExecutor(Configuration configuration, Transaction transaction) {
this.transaction = transaction;
this.deferredLoads = new ConcurrentLinkedQueue<DeferredLoad>();
//建立一級快取
this.localCache = new PerpetualCache("LocalCache");
this.localOutputParameterCache = new PerpetualCache("LocalOutputParameterCache");
this.closed = false;
this.configuration = configuration;
this.wrapper = this;
}
一級快取怎麼儲存的？
一級快取是在執行查詢的時候會先走二級快取，二級快取麼有就會走一級快取，以及快取沒有就會走資料庫查詢，然後放入一級快取和二級快取。我們來看一下原始碼流程 ，見：org.apache.ibatis.executor.CachingExecutor#query
@Override
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
BoundSql boundSql = ms.getBoundSql(parameterObject);
//構建快取的Key
CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);
//執行查詢
return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}
這裡在嘗試構建Cachekey ，cachekey時由：MappedStatement的id(如：cn.xx.xx.xxMapper.selectByid) ，分頁，Sql,引數值一起構建而成的，一級二級快取都是如此。
@Override
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
throws SQLException {
//開啟了二級快取才會存在Cache
Cache cache = ms.getCache();
if (cache != null) {
flushCacheIfRequired(ms);
if (ms.isUseCache() && resultHandler == null) {
ensureNoOutParams(ms, 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 and #116
}
return list;
}
}
return delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}
這裡我們看到，在執行org.apache.ibatis.executor.CachingExecutor#query 查詢的時候會先走二級快取，二級快取沒有會繼續呼叫 org.apache.ibatis.executor.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();
}
// issue #601
deferredLoads.clear();
if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
// issue #482
clearLocalCache();
}
}
return list;
}
上面程式碼會先走一級快取拿資料，如果一級快取沒有，就走資料庫獲取資料，然後加入一級快取org.apache.ibatis.executor.BaseExecutor#queryFromDatabase
private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
List<E> list;
localCache.putObject(key, EXECUTION_PLACEHOLDER);
try {
//走資料庫查詢資料
list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
} finally {
localCache.removeObject(key);
}
//把資料寫入一級快取
localCache.putObject(key, list);
if (ms.getStatementType() == StatementType.CALLABLE) {
localOutputParameterCache.putObject(key, parameter);
}
return list;
}
到這裡我們就看到了一級快取和二級快取的執行流程，注意的是：先執行二級快取再執行一級快取。
這裡畫一個一級快取的圖
二級快取
第一步：二級快取需要在mybatis-config.xml 設定中開啟，如下
<setting name="cacheEnabled" value="true"/>
當然其實該設定預設是開啟的，也就是預設會使用 CachingExecutor 裝飾基本的執行器。
第二步驟：需要在mapper.xml中設定 < cache/>如下
<mapper namespace="cn.whale.mapper.StudentMapper">
<cache type="org.apache.ibatis.cache.impl.PerpetualCache"
size="1024"
eviction="LRU"
flushInterval="120000"
readOnly="false"/>
...省略...
解釋一下上面的設定，首先<cache/> 是在某個mapper.xml中指定的，也就是說二級快取作用於當前的namespace.
- type : 代表的是使用什麼型別的快取，只要是實現了 Cache 介面的實現類都可以
- size ：快取的個數，預設是1024 個物件
- eviction ： 快取剔除策略 ，LRU – 最近最少使用的：移除最長時間不被使用的物件（預設）；FIFO – 先進先出：按物件進入快取的順序來移除它們 ；SOFT – 軟參照：移除基於垃圾回收器狀態和軟參照規則的物件；WEAK – 弱參照：更積極地移除基於垃圾收集器狀態和弱參照規則的物件
- flushInterval ：定時自動清空快取間隔 自動重新整理時間，單位 ms，未設定時只有呼叫時重新整理
- readOnly ：快取時候唯讀
- blocking ：是否使用可重入鎖實現 快取的並行控制 true，會使用 BlockingCache 對 Cache 進行裝飾 預設 false
Mapper.xml 設定了之後，select()會被快取。update()、delete()、insert() 會重新整理快取，下面是測試案例
可以看到，這裡使用了2個SqlSesion 2次執行了相同的SQL，引數相同，看控制檯紀錄檔只執行了一次SQL，說明是命中的二級快取。因為滿足條件：同一個 namespace下的相同的SQL被執行，儘管使用的SqlSession不是同一個。
但是你可能注意到一個細節，就是session.commit() 為什麼要提交事務呢？這就要說到二級快取的儲存結構了，如果不執行commit是不會寫入二級快取的。在 CachingExecutor 中有一個屬性private final TransactionalCacheManager tcm = new TransactionalCacheManager(); 看名字肯能夠看出二級快取和事務有關係。結構如下
public class CachingExecutor implements Executor {
private final Executor delegate;
//二級快取，通過TransactionalCacheManager來管理
private final TransactionalCacheManager tcm = new TransactionalCacheManager();
TransactionalCacheManager 中維護了一個 HashMap<Cache, TransactionalCache>()
public class TransactionalCacheManager {
//二級快取的HashMap
private final Map<Cache, TransactionalCache> transactionalCaches = new HashMap<Cache, TransactionalCache>();
在TransactionCache中維護了一個 Map<Object, Object> entriesToAddOnCommit;
public class TransactionalCache implements Cache {
private static final Log log = LogFactory.getLog(TransactionalCache.class);
private final Cache delegate;
private boolean clearOnCommit;
//二級快取臨時儲存
private final Map<Object, Object> entriesToAddOnCommit;
...省略...
//寫入二級快取
@Override
public void putObject(Object key, Object object) {
entriesToAddOnCommit.put(key, object);
}
當執行查詢的時候，從資料庫查詢出來資料回寫入TransactionalCache的entriesToAddOnCommit中，我們來看一下二級快取寫入的流程，見：org.apache.ibatis.executor.CachingExecutor#query
@Override
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
throws SQLException {
//如果mapper.xml設定了 <cache/> 就會建立 Cache
Cache cache = ms.getCache();
if (cache != null) {
flushCacheIfRequired(ms);
if (ms.isUseCache() && resultHandler == null) {
ensureNoOutParams(ms, 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 and #116
}
return list;
}
}
return delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}
如果mapper.xml設定了 就會建立 Cache，Cache不為null，才會走到二級快取的流程，此時程式碼來到org.apache.ibatis.cache.TransactionalCacheManager#putObject
public class TransactionalCacheManager {
//儲存二級快取
private final Map<Cache, TransactionalCache> transactionalCaches = new HashMap<Cache, TransactionalCache>();
public void putObject(Cache cache, CacheKey key, Object value) {
//通過cache為key拿到 TransactionalCache ，把資料put進去
getTransactionalCache(cache).putObject(key, value);
}
儲存資料的是TransactionalCache ，見org.apache.ibatis.cache.decorators.TransactionalCache#putObject
public class TransactionalCache implements Cache {
private static final Log log = LogFactory.getLog(TransactionalCache.class);
//正在的二級快取儲存位置
private final Cache delegate;
private boolean clearOnCommit;
//臨時的二級快取儲存位置
private final Map<Object, Object> entriesToAddOnCommit;
@Override
public void putObject(Object key, Object object) {
entriesToAddOnCommit.put(key, object);
}
我們看到，資料寫到了 TransactionalCache#entriesToAddOnCommit 一個Map中。只有在執行commit的時候資料才會真正寫入二級快取。
我們來看下SqlSession.commit方法是如何觸發二級快取真正的寫入的,見：org.apache.ibatis.session.defaults.DefaultSqlSession#commit()
@Override
public void commit() {
commit(false);
}
@Override
public void commit(boolean force) {
try {
//呼叫執行器提交事務
executor.commit(isCommitOrRollbackRequired(force));
dirty = false;
} catch (Exception e) {
throw ExceptionFactory.wrapException("Error committing transaction. Cause: " + e, e);
} finally {
ErrorContext.instance().reset();
}
}
程式碼來到org.apache.ibatis.executor.CachingExecutor#commit
@Override
public void commit(boolean required) throws SQLException {
//提交事務
delegate.commit(required);
//呼叫org.apache.ibatis.cache.TransactionalCacheManager#commit提交事務
tcm.commit();
}
程式碼來到org.apache.ibatis.cache.TransactionalCacheManager#commit
public void commit() {
for (TransactionalCache txCache : transactionalCaches.values()) {
//呼叫 TransactionalCache#commit
txCache.commit();
}
}
程式碼來到org.apache.ibatis.cache.decorators.TransactionalCache#commit
public class TransactionalCache implements Cache {
private static final Log log = LogFactory.getLog(TransactionalCache.class);
//真正的二級快取儲存位置，本質是一個 PerpetualCache
private final Cache delegate;
//臨時儲存二級快取
private final Map<Object, Object> entriesToAddOnCommit;
public void commit() {
if (clearOnCommit) {
delegate.clear();
}
//這裡在寫入快取，儲存到TransactionalCache中的delegate欄位，本質是一個PerpetualCache
flushPendingEntries();
//把entriesToAddOnCommit清除掉
reset();
}
private void flushPendingEntries() {
for (Map.Entry<Object, Object> entry : entriesToAddOnCommit.entrySet()) {
//從entriesToAddOnCommit中拿到臨時的快取資料，寫入快取，最終會寫入PerpetualCache#cache欄位中
delegate.putObject(entry.getKey(), entry.getValue());
}
for (Object entry : entriesMissedInCache) {
if (!entriesToAddOnCommit.containsKey(entry)) {
delegate.putObject(entry, null);
}
}
}
private void reset() {
clearOnCommit = false;
//清除entriesToAddOnCommit
entriesToAddOnCommit.clear();
entriesMissedInCache.clear();
}
所以我們總結一下二級快取的寫入流程，二級快取通過 TransactionalCacheManager中的一個Map<Cache, TransactionalCache>管理的，當執行query查詢處資料的時候，會把資料寫入TransactionalCache中的 Map<Object, Object> entriesToAddOnCommit 中臨時儲存。當執行commit的時候才會把entriesToAddOnCommit中的資料寫入TransactionalCache中的 Cache delegate ，其本質和一級快取一樣，也是一個 PerpetualCache。
當我們做第二次query的時候會嘗試通過 TransactionalCacheManager#getObject 從二級快取獲取資料
public class TransactionalCacheManager {
private final Map<Cache, TransactionalCache> transactionalCaches = new HashMap<Cache, TransactionalCache>();
//獲取二級快取
public Object getObject(Cache cache, CacheKey key) {
return getTransactionalCache(cache).getObject(key);
}
然後會從 TransactionalCache中的delegate中獲取快取
public class TransactionalCache implements Cache {
private static final Log log = LogFactory.getLog(TransactionalCache.class);
//二級快取
private final Cache delegate;
...省略...
@Override
public Object getObject(Object key) {
// issue #116
//從二級快取獲取資料
Object object = delegate.getObject(key);
if (object == null) {
entriesMissedInCache.add(key);
}
// issue #146
if (clearOnCommit) {
return null;
} else {
return object;
}
}
所以記得，二級快取一定要commit才會起作用。下面花了一個一級快取和二級快取的結構圖
三方快取框架
除了使用Mybatis自帶的快取，也可以使用第三方快取方式，比如：比如 ehcache 和 redis 下面以Redis為例 ，首先匯入mybatis整合redis的依賴
<dependency>
<groupId>org.mybatis.caches</groupId>
<artifactId>mybatis-redis</artifactId>
<version>1.0.0-beta2</version>
</dependency>
第二步驟：在mapper.xml設定快取
<cache type="org.mybatis.caches.redis.RedisCache"
eviction="FIFO"
flushInterval="60000"
size="512" readOnly="true"/>
這裡type使用了RedisCache,RedisCache也是實現了Cache介面的，接著我們需要設定Redis的連結屬性，預設RedisCache類會讀取名字為 : redis.properties 的組態檔
host=127.0.0.1
password=123456
port=6379
connectionTimeout=5000
soTimeout=5000
database=0
再次執行測試程式碼，檢視Redis效果如下
博主在參加部落格之星評比，點選連結 ， https://bbs.csdn.net/topics/603957267 瘋狂打Call！五星好評 ⭐⭐⭐⭐⭐ 感謝