1. 前言
前面近一個月去寫自己的mybatis框架了，對mybatis原始碼分析止步不前，此文繼續前面的文章。開始分析mybatis一，二級快取的實現。
附上自己的專案github地址：https://github.com/xbcrh/simple-ibatis
對mybatis感興趣的同學可關注下，全手寫的一個orm框架，實現了sql的基本功能和物件關係對映。
廢話不說，開始解析mybatis快取原始碼實現。
2. mybatis中快取的實現方式
見mybatis原始碼包 org.apache.ibatis.cache
2.1 mybatis快取實現介面類：cache
public interface Cache { // 獲取快取的ID String getId(); // 放入快取 void putObject(Object key, Object value); // 從快取中獲取 Object getObject(Object key); // 移除快取 Object removeObject(Object key); // 清除快取 void clear(); // 獲取快取大小 int getSize(); // 獲取鎖 ReadWriteLock getReadWriteLock(); }
mybatis自定義了快取介面類，提供了基本的快取增刪改查的操作。在此基礎上，提供了基礎快取實現類PerpetualCache。原始碼如下：
2.2 mybatis快取基本實現類：PerpetualCache
public class PerpetualCache implements Cache { // 快取的ID private String id; // 使用HashMap充當快取（老套路，快取底層實現基本都是map） private Map<Object, Object> cache = new HashMap<Object, Object>(); // 唯一構造方法（即快取必須有ID） public PerpetualCache(String id) { this.id = id; } // 獲取快取的唯一ID public String getId() { return id; } // 獲取快取的大小，實際就是hashmap的大小 public int getSize() { return cache.size(); } // 放入快取，實際就是放入hashmap public void putObject(Object key, Object value) { cache.put(key, value); } // 從快取獲取，實際就是從hashmap中獲取 public Object getObject(Object key) { return cache.get(key); } // 從快取移除 public Object removeObject(Object key) { return cache.remove(key); } // hashmap清除資料方法 public void clear() { cache.clear(); } // 暫時沒有其實現 public ReadWriteLock getReadWriteLock() { return null; } // 快取是否相同 public boolean equals(Object o) { if (getId() == null) throw new CacheException("Cache instances require an ID."); if (this == o) return true; // 快取本身，肯定相同 if (!(o instanceof Cache)) return false; // 沒有實現cache類，直接返回false Cache otherCache = (Cache) o; // 強制轉換為cache return getId().equals(otherCache.getId()); // 直接比較ID是否相等 } // 獲取hashCode public int hashCode() { if (getId() == null) throw new CacheException("Cache instances require an ID."); return getId().hashCode(); } }
PerpetualCache 類其實是對HashMap的封裝，通過對map的put和get等操作實現快取的存取等功能。mybatis中除了基本的快取實現類外還提供了一系列的裝飾類（此處是用到裝飾者模式），此處拿較為重要的裝飾類LruCache進行分析。
2.3 Lru淘汰策略實現分析
Lru是一種快取淘汰策略，其核心思想是”如果資料最近被訪問過，那麼將來被訪問的機率也更高“，LruCache 是基於LinkedHashMap實現，LinkedHashMap繼承自HashMap,來分析下為什麼LinkedHashMap可以當做Lru快取實現。
public class LinkedHashMap<K,V> extends HashMap<K,V> implements Map<K,V>
LinkedHashMap繼承HashMap類,實際上就是對HashMap的一個封裝。
// 內部維護了一個自定義的Entry，整合HashMap中的node類 static class Entry<K,V> extends HashMap.Node<K,V> { // linkedHashmap用來連線節點的欄位，根據這兩個欄位可查詢按順序插入的節點 Entry<K,V> before, after; Entry(int hash, K key, V value, Node<K,V> next) { super(hash, key, value, next); } }
構造方法見如下：
public LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder) { // 呼叫HashMap的構造方法 super(initialCapacity, loadFactor); // 訪問順序維護，預設false不開啟 this.accessOrder = accessOrder; }
引入兩種圖來理解HashMap與LinkedHashMap
以上是HashMap的結構，採用拉鍊法解決衝突。LinkedHashMap在HashMap基礎上增加了一個雙向連結串列來表示節點插入順序。
如上，節點上多出的紅色和藍色箭頭代表了Entry中的before和after。在put元素時，會自動在尾節點後加上該元素，維持雙向連結串列。瞭解LinkedHashMap結構後，在看看究竟什麼是維護節點的訪問順序。先說結論，當開啟accessOrder後，在對元素進行get操作時，會將該元素放在雙向連結串列的隊尾節點。原始碼如下：
public V get(Object key) { Node<K,V> e; // 呼叫HashMap的getNode方法，獲取元素 if ((e = getNode(hash(key), key)) == null) return null; // 預設為false，如果開啟維護連結串列訪問順序，執行如下方法 if (accessOrder) afterNodeAccess(e); return e.value; } // 方法實現（將e放入尾節點處） void afterNodeAccess(Node<K,V> e) { // move node to last LinkedHashMap.Entry<K,V> last; // 當節點不是雙向連結串列的尾節點時 if (accessOrder && (last = tail) != e) { LinkedHashMap.Entry<K,V> p = (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after; // 將待調整的e節點賦值給p p.after = null; if (b == null) // 說明e為頭節點，將老e的下一節點值為頭節點 head = a; else b.after = a;// 否則，e的上一節點直接指向e的下一節點 if (a != null) a.before = b; // e的下一節點的上節點為e的上一節點 else last = b; if (last == null) head = p; else { p.before = last; // last和p互相連線 last.after = p; } tail = p; // 將雙向連結串列的尾節點指向p ++modCount; // 修改次數加以 } }
程式碼很簡單，如上面的圖，我訪問了節點值為3的節點，那木經過get操作後，結構變成如下:
經過如上分析我們知道，如果限制雙向連結串列的長度，每次刪除頭節點的值，就變為一個lru的淘汰策略了。舉個例子，我想限制雙向連結串列的長度為3，依次put 1 2 3，連結串列為 1 -> 2 -> 3，訪問元素2，連結串列變為 1 -> 3-> 2，然後put 4 ，發現連結串列長度超過3了，淘汰1，連結串列變為3 -> 2 ->4；
那木linkedHashMap是怎樣知道自定義的限制策略，看程式碼，因為LinkedHashMap中沒有提供自己的put方法，是直接呼叫的HashMap的put方法，檢視hashMap程式碼如下：
// hashMap final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) { Node<K,V>[] tab; Node<K,V> p; int n, i; if ((tab = table) == null || (n = tab.length) == 0) n = (tab = resize()).length; if ((p = tab[i = (n - 1) & hash]) == null) tab[i] = newNode(hash, key, value, null); else { Node<K,V> e; K k; if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) e = p; else if (p instanceof TreeNode) e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value); else { for (int binCount = 0; ; ++binCount) { if ((e = p.next) == null) { p.next = newNode(hash, key, value, null); if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st treeifyBin(tab, hash); break; } if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) break; p = e; } } if (e != null) { // existing mapping for key V oldValue = e.value; if (!onlyIfAbsent || oldValue == null) e.value = value; afterNodeAccess(e); return oldValue; } } ++modCount; if (++size > threshold) resize(); // 看這個方法 afterNodeInsertion(evict); return null; } // linkedHashMap重寫了此方法 void afterNodeInsertion(boolean evict) { // possibly remove eldest LinkedHashMap.Entry<K,V> first; // removeEldestEntry預設返回fasle if (evict && (first = head) != null && removeEldestEntry(first)) { K key = first.key; // 移除雙向連結串列中的頭指標元素 removeNode(hash(key), key, null, false, true); } }
原來只需要重新實現removeEldestEntry就可以自定義實現lru功能了。瞭解基本的lru原理後，開始分析LruCache。
2.4 快取包裝類 - LruCache
public class LruCache implements Cache { // 被裝飾的快取類，即真實的快取類，提供真正的快取能力 private final Cache delegate; // 內部維護的一個linkedHashMap,用來實現LRU功能 private Map<Object, Object> keyMap; // 待淘汰的快取元素 private Object eldestKey; // 唯一構造方法 public LruCache(Cache delegate) { this.delegate = delegate; // 被裝飾的快取類 setSize(1024); // 設定快取大小 } .... }
經分析，LruCache還是個裝飾類。內部除了維護真正的Cache外，還維護了一個LinkedHashMap，用來實現Lru功能，檢視其構造方法。
// 唯一構造方法 public LruCache(Cache delegate) { this.delegate = delegate; // 被裝飾的快取類 setSize(1024); // 設定快取大小 } // setSize()是構造方法中方法 public void setSize(final int size) { // 初始化keyMap keyMap = new LinkedHashMap<Object, Object>(size, .75F, true) { private static final long serialVersionUID = 4267176411845948333L; // 什麼時候自動刪除快取元素，此處是根據當快取數量超過指定的數量，在LinkedHashMap內部刪除元素 protected boolean removeEldestEntry(Map.Entry<Object, Object> eldest) { boolean tooBig = size() > size; if (tooBig) { // 將待刪除元素賦值給eldestKey，後續會根據此值是否為空在真實快取中刪除 eldestKey = eldest.getKey(); } return tooBig; } }; }
和上文分析一樣，重寫了removeEldestEntry方法。此方法返回一個boolean值，當快取的大小超過自定義大小，返回true,此時linkedHashMap中會自動刪除eldest元素。在真實快取cache中也將此元素刪除。保持真實cache和linkedHashMap元素一致。其實就是用linkedHashMap的lru特性來保證cache也具有此lru特性。
分析put方法和get方法驗證此結論.。
@Override public Object getObject(Object key) { keyMap.get(key); // 觸發linkedHashMap中get方法，將key對應的元素放入隊尾 return delegate.getObject(key); // 呼叫真實的快取get方法 } // 放入快取時，除了在真實快取中放一份外，還會在LinkedHashMap中放一份 @Override public void putObject(Object key, Object value) { delegate.putObject(key, value); // 呼叫LinkedHashMap的方法 cycleKeyList(key); } private void cycleKeyList(Object key) { // linkedHashMap中put，會觸發removeEldestEntry方法，如果快取大小超過指定大小，則將雙向連結串列對頭值賦值給eldestKey keyMap.put(key, key); // 檢查eldestKey是否為空。不為空，則代表此元素是淘汰的元素了，需要在真實快取中刪除。 if (eldestKey != null) { // 真實快取中刪除 delegate.removeObject(eldestKey); eldestKey = null; } }
介紹完Cache基本實現後，開始分析mybatis中一級快取
3. mybatis一級快取使用原始碼分析
此處是僅介紹mybatis的實現，沒有涉及到與Spring整合，先介紹mybatis最基本的sql執行語法。預設大家掌握了SqlSessionFactoryBuilder，SqlSessionFactory，SqlSession用法。後面我會寫一篇部落格分析SQL在mybatis中執行的過程，會介紹到這些基礎知識。
InputStream inputStream = Resources.getResourceAsStream("com/xiaobing/resource/mybatisConfig.xml"); // 構建位元組流
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder(); // 構建SqlSessionFactoryBuilder
SqlSessionFactory factory = builder.build(inputStream); // 構建SqlSessionFactory
SqlSession sqlSession = factory.openSession(); // 生成SqlSession
List<SysUser> userList = sqlSession.selectList("com.xiaobing.mapper.SysUserMapper.getSysUser"); // 執行SysUserMapper類的getSysUser方法
前文構建SqlSession的內容大家感興趣可自行檢視，此處僅分析執行過程。檢視selectList方法，mybatis中sqlSession的預設實現為DefaultSqlSession
public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) { try { // 每個mapper檔案會解析生成一個MappedStatement MappedStatement ms = configuration.getMappedStatement(statement); // 呼叫真實的查詢方法，此處是呼叫executor的方法。executor採用了裝飾者模式，若該mapper檔案未啟用二級快取，則預設為BaseExecutor。 // 若該mapper檔案啟用了二級快取，則使用的是CachingExecutor 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(); } }
因為此處使用的是裝飾者模式，BaseExecutor是最基礎的執行器，使用了一級快取，CachingExecutor是對BaseExecutor進行一次封裝，若開啟二級快取開關，在使用一級快取前，先使用二級快取。後文介紹二級快取會分析這兩個Executor生成地方。先分析BaseExecutor的一級快取實現。
// BaseExecutor.java /** * 查詢，並建立好CacheKey物件 * @param ms Mapper.xml檔案的select,delete,update,insert這些DML標籤的封裝類 * @param parameter 引數物件 * @param rowBounds Mybatis的分頁物件 * @param resultHandler 結果處理器物件 */ public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException { BoundSql boundSql = ms.getBoundSql(parameter); // 獲取boundSql物件 CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql); // 生成快取KEY return query(ms, parameter, rowBounds, resultHandler, key, boundSql); // 執行如下方法 } @SuppressWarnings("unchecked") 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."); //如果將flushCacheRequired為true，則會在執行器執行之前就清空本地一級快取 if (queryStack == 0 && ms.isFlushCacheRequired()) { clearLocalCache(); } List<E> list; try { queryStack++; // 請求堆疊加一 // 如果此次查詢的resultHandler為null（預設為null），則嘗試從本地快取中獲取已經快取的的結果 list = resultHandler == null ? (List<E>) localCache.getObject(key) : null; if (list != null) { //如果查到localCache快取，處理localOutputParameterCache，即對儲存過程的sql進行特殊處理 handleLocallyCachedOutputParameters(ms, key, parameter, boundSql); } else { // 從資料庫中查詢，並將結果放入到localCache list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql); } } finally { // 請求堆疊減一 queryStack--; } if (queryStack == 0) { // 載入延遲載入List for (DeferredLoad deferredLoad : deferredLoads) { deferredLoad.load(); } deferredLoads.clear(); // issue #601 if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) { clearLocalCache(); // issue #482 } } return list; } 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一級快取很好理解，對於同一個SqlSession物件（即同一個Executor），執行同一條語句時，BaseExecutor會先從自己的快取中查詢，是否存在此條語句的結果，若能找到，則直接返回（暫且忽略儲存過程處理）。若沒有找到，則查詢資料庫，將結果放入此快取，供下次使用。mybatis預設開啟一級快取。
4. mybatis二級快取使用原始碼分析
4.1 配置方式
在全域性配置檔案中mybatis-config.xml中加入如下設定
<settings> <setting name="cacheEnabled" value="true"/> </settings>
在具體mapper.xml中配置<cache/>標籤或者<cache-ref/>標籤
<cache></cache>或者<cache-ref/>
或者採用註解配置方式，在mapper.java檔案上配置註解
@CacheNamespace 或者 @CacheNamespaceRef
4.1 mybatis解析二級快取標籤
還是採用上面sqlSession方式程式碼來debug
InputStream inputStream = Resources.getResourceAsStream("com/xiaobing/resource/mybatisConfig.xml"); // 構建位元組流
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder(); // 構建SqlSessionFactoryBuilder
SqlSessionFactory factory = builder.build(inputStream); // 構建SqlSessionFactory
進入檢視builder.build()方法
// SqlSessionFactoryBuilder.java /**根據流構建SqlSessionFactory*/ public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) { try { /**構建XML檔案解析器*/ XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties); /**開始解析mybatis-config.xml檔案並構建全域性變數Configuration*/ return build(parser.parse()); } catch (Exception e) { throw ExceptionFactory.wrapException("Error building SqlSession.", e); } finally { ErrorContext.instance().reset(); try { inputStream.close(); } catch (IOException e) { // Intentionally ignore. Prefer previous error. } } }
進入parser.parse()方法,，進一步分析
public Configuration parse() { if (parsed) { throw new BuilderException("Each XMLConfigBuilder can only be used once."); } parsed = true; parseConfiguration(parser.evalNode("/configuration")); return configuration; } private void parseConfiguration(XNode root) { try { propertiesElement(root.evalNode("properties")); //issue #117 read properties first // 讀取properties配置 typeAliasesElement(root.evalNode("typeAliases")); // 讀取別名設定 pluginElement(root.evalNode("plugins")); // 讀取外掛設定 objectFactoryElement(root.evalNode("objectFactory")); // 讀取物件工廠設定 objectWrapperFactoryElement(root.evalNode("objectWrapperFactory")); // 讀取物件包裝工廠設定 settingsElement(root.evalNode("settings")); // 讀取setting設定 environmentsElement(root.evalNode("environments")); // read it after objectFactory and objectWrapperFactory issue #631 // 讀取環境設定 databaseIdProviderElement(root.evalNode("databaseIdProvider")); // 讀取資料庫ID提供資訊 typeHandlerElement(root.evalNode("typeHandlers")); // 讀取型別轉換處理器 mapperElement(root.evalNode("mappers")); // 解析mapper檔案 } catch (Exception e) { throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e); } }
此處僅分析<cache/> 和 <cache-ref/>標籤的解析，<cache/> 和 <cache-ref/>存在具體的mapper.xml檔案中，分析mapperElement()方法。因為在mybatis-config.xml檔案中關於<mapper>標籤的值可配置package,resource,url,class等配置。如
<mappers>
<mapper class="com.xiaobing.mapper.SysUserMapper"/>
</mappers>
分析mapperElement()方法
/** * 對映檔案支援四種配置,package,resource,url,class四種 * 如在mybatis-config.xml中配置 * <mappers> <mapper class="com.xiaobing.mapper.SysUserMapper"/> </mappers> * */ private void mapperElement(XNode parent) throws Exception { if (parent != null) { for (XNode child : parent.getChildren()) { if ("package".equals(child.getName())) { // 若配置的是package，在講package下的所有mapper檔案進行解析 String mapperPackage = child.getStringAttribute("name"); configuration.addMappers(mapperPackage); } else { String resource = child.getStringAttribute("resource"); String url = child.getStringAttribute("url"); String mapperClass = child.getStringAttribute("class"); if (resource != null && url == null && mapperClass == null) { // 若配置的是resource，在解析resource對應的mapper.xml ErrorContext.instance().resource(resource); InputStream inputStream = Resources.getResourceAsStream(resource); // 獲取xml檔案位元組流 XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments()); // 構建xml檔案構造器 mapperParser.parse(); // 解析xml檔案 } else if (resource == null && url != null && mapperClass == null) { // 若配置的是url，在解析url對應的mapper.xml ErrorContext.instance().resource(url); InputStream inputStream = Resources.getUrlAsStream(url); XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments()); mapperParser.parse(); } else if (resource == null && url == null && mapperClass != null) { // 若配置的是class，在解析class對應的mapper檔案 Class<?> mapperInterface = Resources.classForName(mapperClass); configuration.addMapper(mapperInterface); // 分析addMapper()方法 } else { throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one."); } } } } }
因為我採用的是class配置，所以分析configuration.addMapper()方法
// Configuration.java public <T> void addMapper(Class<T> type) { mapperRegistry.addMapper(type); }
繼續進入mapperRegistry.addMapper進行分析
// MapperRegistry.java public <T> void addMapper(Class<T> type) { if (type.isInterface()) { // mapper介面 if (hasMapper(type)) { // 若mapper已被註冊 throw new BindingException("Type " + type + " is already known to the MapperRegistry."); } boolean loadCompleted = false; try { knownMappers.put(type, new MapperProxyFactory<T>(type)); // 註冊對映介面 // It's important that the type is added before the parser is run // otherwise the binding may automatically be attempted by the // mapper parser. If the type is already known, it won't try. MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type); // 生成註解構造器 parser.parse(); // 解析mapper上的註解 loadCompleted = true; } finally { if (!loadCompleted) { knownMappers.remove(type); } } } }
knownMappers.put(type, new MapperProxyFactory<T>(type));這裡很重要，是註冊mapper檔案代理物件。此處只做快取的解釋，不做註冊詳解，後面在分析sql執行流程時單獨去分析。
parser.parse()是對mapper檔案進行解析的關鍵，繼續分析
// MapperAnnotationBuilder.java // 解析配置檔案 public void parse() { String resource = type.toString(); // 介面的全限定名 class com.test.userMapper if (!configuration.isResourceLoaded(resource)) { // 是否載入過 loadXmlResource(); // 在預設路徑下（預設和mapper介面同個包下），載入xml檔案 configuration.addLoadedResource(resource); // 設為該mapper配置檔案已解析 assistant.setCurrentNamespace(type.getName()); // 設定構建助力器當前名稱空間 com.test.userMapper parseCache(); // 解析CacheNamespace註解，構建一個Cache物件，並儲存到Mybatis全域性配置資訊中 parseCacheRef(); //解析CacheNamespace註解，引用CacheRef對應的Cache物件。 // 由此可知，當引入了<cache/>和<cacheRef/>後，該名稱空間的快取物件變為了CacheRef引用的快取物件 Method[] methods = type.getMethods(); // 獲取方法 for (Method method : methods) { try { if (!method.isBridge()) { // issue #237 若該方法不是橋接方法 parseStatement(method); //構建MapperStatement物件，並新增到Mybatis全域性配置資訊中 } } catch (IncompleteElementException e) { //當出現未完成元素時，新增構建Method時丟擲異常的MethodResolver例項，到下個Mapper的解析時再次嘗試解析 configuration.addIncompleteMethod(new MethodResolver(this, method)); } } } parsePendingMethods(); // 解析未完成解析的Method }
通過上面的程式碼註釋，可知，當解析mapper.java檔案前，會先在同個資料夾下檢視是否存在mapper.xml檔案，若存在，則先解析mapper.xml檔案。在解析mapper.xml檔案時,若在mapper.xml中寫了快取<cache/>或<cache-ref>,也會生成二級快取。若同時還在mapper.java檔案裡寫了@CacheNamespace註解。則會進行報錯，因為出現了兩個快取。此時我們根據註解配置去分析。去分析parseCache()和parseCacheRef()，看配置了註解@CacheNamespace和CacheNamespaceRef之後快取具體怎樣生成。
// MapperAnnotationBuilder.java private void parseCache() { // 獲取是否有@CacheNamespace 註解 CacheNamespace cacheDomain = type.getAnnotation(CacheNamespace.class); if (cacheDomain != null) { /* * 構建一個快取物件，具體分析 * */ assistant.useNewCache(cacheDomain.implementation(), cacheDomain.eviction(), cacheDomain.flushInterval(), cacheDomain.size(), cacheDomain.readWrite(), null); } }
// mapperBuilderAssistant.java public Cache useNewCache(Class<? extends Cache> typeClass, // 基本快取類 Class<? extends Cache> evictionClass, // 快取裝飾類 Long flushInterval, // 快取重新整理間隔 Integer size, // 快取大小 boolean readWrite, // 快取可讀寫 Properties props) { typeClass = valueOrDefault(typeClass, PerpetualCache.class); // 沒有設定則採用預設的PerpetualCache evictionClass = valueOrDefault(evictionClass, LruCache.class); // 沒有設定則採用預設的LruCache Cache cache = new CacheBuilder(currentNamespace) // 名稱空間作為快取唯一ID .implementation(typeClass) .addDecorator(evictionClass) .clearInterval(flushInterval) .size(size) .readWrite(readWrite) .properties(props) .build(); configuration.addCache(cache); // 加入到全域性快取 currentCache = cache; // 當前快取設為cache,由此可知，快取是mapper級別 return cache; }
此處是生成了二級快取的地方，並設定當前mapper檔案的快取為這個生成的二級快取。若沒有配置@CacheNamespaceRef，那木此mapper檔案就使用了這個自己生成的二級快取。那@CacheNamespaceRef是用來幹嘛的？回到上面程式碼處進行分析。
// MapperAnnotationBuilder.java private void parseCacheRef() { // @CacheNamespaceRef 相當於<cacheRef/>標籤 CacheNamespaceRef cacheDomainRef = type.getAnnotation(CacheNamespaceRef.class); if (cacheDomainRef != null) { assistant.useCacheRef(cacheDomainRef.value().getName()); // 構建快取引用,進入分析 } }
public Cache useCacheRef(String namespace) { if (namespace == null) { throw new BuilderException("cache-ref element requires a namespace attribute."); } try { unresolvedCacheRef = true; Cache cache = configuration.getCache(namespace); // 獲取被引用的快取 if (cache == null) { //被引用的快取是否存在 throw new IncompleteElementException("No cache for namespace '" + namespace + "' could be found."); } currentCache = cache; // 設定當前快取物件為被引用的快取物件 unresolvedCacheRef = false; // 標誌設定為false,代表有快取引用。 return cache; } catch (IllegalArgumentException e) { throw new IncompleteElementException("No cache for namespace '" + namespace + "' could be found.", e); } }
由上文可知，當配置了@CacheNamespaceRef和@CacheNamespace後，該mapper檔案對應的快取以@CacheNamespaceRef引用的快取為準。這樣可是使得不同的mapper檔案有相同的快取。
4.2 快取具體使用場景
上文說了，開啟二級快取後，sqlSession中的Executor是CachingExecutor，檢視生成CachingExecutor具體位置。繼續從那段測試程式碼分析
SqlSession sqlSession = factory.openSession(); // 生成SqlSession List<SysUser> userList = sqlSession.selectList("com.xiaobing.mapper.SysUserMapper.getSysUser"); // 執行SysUserMapper類的getSysUser方法
debug進入DefaultSqlSessionfactory.openSession()方法
// DefaultSqlSessionfactory.java public SqlSession openSession() { return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false); } ... 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); // 生成執行器 return new DefaultSqlSession(configuration, executor, autoCommit); } 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(); } } ....
分析Executor executor = configuration.newExecutor(tx, execType);此段程式碼
// Configuration.java public Executor newExecutor(Transaction transaction, ExecutorType executorType) { executorType = executorType == null ? defaultExecutorType : executorType; // 預設為SimpleExecutor executorType = executorType == null ? ExecutorType.SIMPLE : executorType; Executor executor; ....... if (cacheEnabled) { // 若開啟二級快取，則生成CachingExecutor executor = new CachingExecutor(executor); } ....... }
當執行查詢語句時，會執行Executor的query()方法。分析CachingExecutor中query()方法究竟是怎樣使用二級快取。
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException { // mapper.xml設定了<cache>或者mapper.java使用了二級快取註解 Cache cache = ms.getCache(); if (cache != null) { // 若該mapper檔案中執行的上一條語句是更新語句（增刪改），則會清空該mapper檔案對應的二級快取 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); // 呼叫後續的Executor執行語句，後續的Executor會繼續使用一級快取。 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); // 若沒開啟二級快取，則呼叫後續的Executor執行語句。後續的Executor會繼續使用一級快取。 } // 此處的update包括增刪改 public int update(MappedStatement ms, Object parameterObject) throws SQLException { // 清空二級快取 flushCacheIfRequired(ms); return delegate.update(ms, parameterObject); }
通過上面分析可知，二級快取的實現是mapper級別的。只要對這個mapper檔案使用@CacheNamespace註解或對應的xml使用<cache/>等標籤，那木該mapper在生成時就會註冊一個mapper級別的快取。在後續
對這一mapper檔案任何查詢語句程式操作的時候，都會使用到這個二級快取。二級快取就相當於在一級快取上在加入一個快取。二級快取Cache的實現是在LruCache上在封裝了一層TransactionCache,為了防止髒資料的產生。感興趣的可以自行去檢視。以上便是關於mybatis快取的內容。
4. 總結驗證
我們知道，二級快取是mapper級別的，在mybatis初始化時便生成了。當此mapper檔案中有更新語句時，才會重新整理二級快取。舉個例子，有MapperA.java和MapperB.java兩個檔案，並都開啟了二級快取，cacheA和cacheB。MapperA.java中有一條查詢語句select1，此查詢語句關聯了B的表。在第一次執行MapperA.java中select1時，會從庫中取出資料，並放入在cacheA中。當mapperB.java中如果有一條更新語句update2,執行update2，會重新整理二級快取cacheB。但不會重新整理cacheA，因為update2並不在MapperA.java中。那此時cacheA中存在的資料便是髒資料了。
其實也有解決辦法，即在MapperA.java中使用@CacheNamespaceRef = "mapperB.java".讓兩個檔案公用同一個二級快取。這樣就OK啦
若對mybatis感興趣的小夥伴，請移步我github專案，從零手寫了一個ORM框架，希望你的star和交流：https://github.com/xbcrh/simple-ibatis