前言
主題是Mybatis一級和二級緩存的應用及源碼分析。希望在本場chat結(jié)束后，能夠幫助讀者朋友明白以下三點。
Mybatis是什么。
Mybatis一級和二級緩存如何配置使用。
Mybatis一級和二級緩存的工作流程及源碼分析。
本次分析中涉及到的代碼和數(shù)據(jù)庫表均放在Github上，地址:
https://github.com/kailuncen/mybatis-cache-demo
目錄
為達到以上三個目的，本文按照以下順序展開。
Mybatis的基礎概念。
一級緩存介紹及相關(guān)配置。
一級緩存工作流程及源碼分析。
一級緩存總結(jié)。
二級緩存介紹及相關(guān)配置。
二級緩存源碼分析。
二級緩存總結(jié)。
全文總結(jié)。
Mybatis的基礎概念
本章節(jié)會對Mybatis進行大體的介紹，分為官方定義和核心組件介紹。
首先是Mybatis官方定義，如下所示。
MyBatis是支持定制化SQL、存儲過程以及高級映射的優(yōu)秀的持久層框架。MyBatis避免了幾乎所有的JDBC代碼和手動設置參數(shù)以及獲取結(jié)果集。MyBatis可以對配置和原生Map使用簡單的XML或注解，將接口和Java 的POJOs(Plain Old Java Objects,普通的 Java對象)映射成數(shù)據(jù)庫中的記錄。
其次是Mybatis的幾個核心概念。
SqlSession : 代表和數(shù)據(jù)庫的一次會話，向用戶提供了操作數(shù)據(jù)庫的方法。
MappedStatement: 代表要發(fā)往數(shù)據(jù)庫執(zhí)行的指令，可以理解為是Sql的抽象表示。
Executor: 具體用來和數(shù)據(jù)庫交互的執(zhí)行器，接受MappedStatement作為參數(shù)。
映射接口: 在接口中會要執(zhí)行的Sql用一個方法來表示，具體的Sql寫在映射文件中。
映射文件: 可以理解為是Mybatis編寫Sql的地方，通常來說每一張單表都會對應著一個映射文件，在該文件中會定義Sql語句入?yún)⒑统鰠⒌男问健?/p>
下圖就是一個針對Student表操作的接口文件StudentMapper，在StudentMapper中，我們可以若干方法，這個方法背后就是代表著要執(zhí)行的Sql的意義。
通常也可以把涉及多表查詢的方法定義在StudentMapper中，如果查詢的主體仍然是Student表的信息。也可以將涉及多表查詢的語句單獨抽出一個獨立的接口文件。
在定義完接口文件后，我們會開發(fā)一個Sql映射文件，主要由mapper元素和select|insert|update|delete元素構(gòu)成，如下圖所示。
mapper元素代表這個文件是一個映射文件，使用namespace和具體的映射接口綁定起來，namespace的值就是這個接口的全限定類名。select|insert|update|delete代表的是Sql語句，映射接口中定義的每一個方法也會和映射文件中的語句通過id的方式綁定起來，方法名就是語句的id，同時會定義語句的入?yún)⒑统鰠?，用于完成和Java對象之間的轉(zhuǎn)換。
在Mybatis初始化的時候，每一個語句都會使用對應的MappedStatement代表，使用namespace+語句本身的id來代表這個語句。如下代碼所示，使用mapper.StudentMapper.getStudentById代表其對應的Sql。
SELECT id,name,age FROM student WHERE id = #{id}
在Mybatis執(zhí)行時，會進入對應接口的方法，通過類名加上方法名的組合生成id，找到需要的MappedStatement，交給執(zhí)行器使用。 至此，Mybatis的基礎概念介紹完畢。
一級緩存
一級緩存介紹
在系統(tǒng)代碼的運行中，我們可能會在一個數(shù)據(jù)庫會話中，執(zhí)行多次查詢條件完全相同的Sql，鑒于日常應用的大部分場景都是讀多寫少，這重復的查詢會帶來一定的網(wǎng)絡開銷，同時select查詢的量比較大的話，對數(shù)據(jù)庫的性能是有比較大的影響的。
如果是Mysql數(shù)據(jù)庫的話，在服務端和Jdbc端都開啟預編譯支持的話，可以在本地JVM端緩存Statement,可以在Mysql服務端直接執(zhí)行Sql，省去編譯Sql的步驟，但也無法避免和數(shù)據(jù)庫之間的重復交互。關(guān)于Jdbc和Mysql預編譯緩存的事情，可以看我的這篇博客JDBC和Mysql那些事。
https://my.oschina.net/kailuncen/blog/905395
Mybatis提供了一級緩存的方案來優(yōu)化在數(shù)據(jù)庫會話間重復查詢的問題。實現(xiàn)的方式是每一個SqlSession中都持有了自己的緩存，一種是SESSION級別，即在一個Mybatis會話中執(zhí)行的所有語句，都會共享這一個緩存。一種是STATEMENT級別，可以理解為緩存只對當前執(zhí)行的這一個statement有效。如果用一張圖來代表一級查詢的查詢過程的話，可以用下圖表示。
每一個SqlSession中持有了自己的Executor，每一個Executor中有一個Local Cache。當用戶發(fā)起查詢時，Mybatis會根據(jù)當前執(zhí)行的MappedStatement生成一個key，去Local Cache中查詢，如果緩存命中的話，返回。如果緩存沒有命中的話，則寫入Local Cache，最后返回結(jié)果給用戶。
一級緩存配置
上文介紹了一級緩存的實現(xiàn)方式，解決了什么問題。在這個章節(jié)，我們學習如何使用Mybatis的一級緩存。只需要在Mybatis的配置文件中，添加如下語句，就可以使用一級緩存。共有兩個選項，SESSION或者STATEMENT，默認是SESSION級別。
一級緩存實驗
配置完畢后，通過實驗的方式了解Mybatis一級緩存的效果。每一個單元測試后都請恢復被修改的數(shù)據(jù)。
首先是創(chuàng)建了一個示例表student,為其創(chuàng)建了對應的POJO類和增改的方法，具體可以在entity包和Mapper包中查看。
CREATE TABLE `student` (
`id` int(11) unsigned NOT NULL AUTO_INCREMENT,
`name` varchar(200) COLLATE utf8_bin DEFAULT NULL,
`age` tinyint(3) unsigned DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8 COLLATE=utf8_bin;
在以下實驗中，id為1的學生名稱是凱倫。
實驗1
開啟一級緩存，范圍為會話級別，調(diào)用三次getStudentById，代碼如下所示:
public void getStudentById() throws Exception {
SqlSession sqlSession = factory.openSession(true); // 自動提交事務
StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);
System.out.println(studentMapper.getStudentById(1));
System.out.println(studentMapper.getStudentById(1));
System.out.println(studentMapper.getStudentById(1));
}
執(zhí)行結(jié)果:
我們可以看到，只有第一次真正查詢了數(shù)據(jù)庫,后續(xù)的查詢使用了一級緩存。
實驗2
在這次的試驗中，我們增加了對數(shù)據(jù)庫的修改操作，驗證在一次數(shù)據(jù)庫會話中，對數(shù)據(jù)庫發(fā)生了修改操作，一級緩存是否會失效。
@Test
public void addStudent() throws Exception {
SqlSession sqlSession = factory.openSession(true); // 自動提交事務
StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);
System.out.println(studentMapper.getStudentById(1));
System.out.println("增加了" + studentMapper.addStudent(buildStudent()) + "個學生");
System.out.println(studentMapper.getStudentById(1));
sqlSession.close();
}
執(zhí)行結(jié)果:
我們可以看到，在修改操作后執(zhí)行的相同查詢，查詢了數(shù)據(jù)庫，一級緩存失效。
實驗3
開啟兩個SqlSession，在sqlSession1中查詢數(shù)據(jù)，使一級緩存生效，在sqlSession2中更新數(shù)據(jù)庫，驗證一級緩存只在數(shù)據(jù)庫會話內(nèi)部共享。
@Test
public void testLocalCacheScope() throws Exception {
SqlSession sqlSession1 = factory.openSession(true);
SqlSession sqlSession2 = factory.openSession(true);
StudentMapper studentMapper = sqlSession1.getMapper(StudentMapper.class);
StudentMapper studentMapper2 = sqlSession2.getMapper(StudentMapper.class);
System.out.println("studentMapper讀取數(shù)據(jù): " + studentMapper.getStudentById(1));
System.out.println("studentMapper讀取數(shù)據(jù): " + studentMapper.getStudentById(1));
System.out.println("studentMapper2更新了" + studentMapper2.updateStudentName("小岑",1) + "個學生的數(shù)據(jù)");
System.out.println("studentMapper讀取數(shù)據(jù): " + studentMapper.getStudentById(1));
System.out.println("studentMapper2讀取數(shù)據(jù): " + studentMapper2.getStudentById(1));
}
我們可以看到，sqlSession2更新了id為1的學生的姓名，從凱倫改為了小岑，但session1之后的查詢中，id為1的學生的名字還是凱倫，出現(xiàn)了臟數(shù)據(jù)，也證明了我們之前就得到的結(jié)論，一級緩存只存在于只在數(shù)據(jù)庫會話內(nèi)部共享。
一級緩存工作流程&源碼分析
這一章節(jié)主要從一級緩存的工作流程和源碼層面對一級緩存進行學習。
工作流程
根據(jù)一級緩存的工作流程，我們繪制出一級緩存執(zhí)行的時序圖，如下圖所示。
主要步驟如下:
1. 對于某個Select Statement，根據(jù)該Statement生成key。
2. 判斷在Local Cache中,該key是否用對應的數(shù)據(jù)存在。
3. 如果命中，則跳過查詢數(shù)據(jù)庫，繼續(xù)往下走。
4. 如果沒命中
4.1 ?去數(shù)據(jù)庫中查詢數(shù)據(jù)，得到查詢結(jié)果；
4.2 ?將key和查詢到的結(jié)果作為key和value，放入Local Cache中。
4.3. 將查詢結(jié)果返回；
5. 判斷緩存級別是否為STATEMENT級別，如果是的話，清空本地緩存。
源碼分析
了解具體的工作流程后，我們隊Mybatis查詢相關(guān)的核心類和一級緩存的源碼進行走讀。這對于之后學習二級緩存時也有幫助。 SqlSession: 對外提供了用戶和數(shù)據(jù)庫之間交互需要的所有方法，隱藏了底層的細節(jié)。它的一個默認實現(xiàn)類是DefaultSqlSession。
Executor: SqlSession向用戶提供操作數(shù)據(jù)庫的方法，但和數(shù)據(jù)庫操作有關(guān)的職責都會委托給Executor。
如下圖所示，Executor有若干個實現(xiàn)類，為Executor賦予了不同的能力，大家可以根據(jù)類名，自行私下學習每個類的基本作用。
在一級緩存章節(jié)，我們主要學習BaseExecutor。
BaseExecutor: BaseExecutor是一個實現(xiàn)了Executor接口的抽象類，定義若干抽象方法，在執(zhí)行的時候，把具體的操作委托給子類進行執(zhí)行。
protected abstract int doUpdate(MappedStatement ms, Object parameter) throws SQLException;
protected abstract List doFlushStatements(boolean isRollback) throws SQLException;
protected abstract List doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException;
protected abstract Cursor doQueryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds, BoundSql boundSql) throws SQLException;
在一級緩存的介紹中，我們提到對Local Cache的查詢和寫入是在Executor內(nèi)部完成的。在閱讀BaseExecutor的代碼后，我們也發(fā)現(xiàn)Local Cache就是它內(nèi)部的一個成員變量，如下代碼所示。
public abstract class BaseExecutor implements Executor {
protected ConcurrentLinkedQueue deferredLoads;
protected PerpetualCache localCache;
Cache: Mybatis中的Cache接口，提供了和緩存相關(guān)的最基本的操作，有若干個實現(xiàn)類，使用裝飾器模式互相組裝，提供豐富的操控緩存的能力。
BaseExecutor成員變量之一的PerpetualCache，就是對Cache接口最基本的實現(xiàn)，其實現(xiàn)非常的簡內(nèi)部持有了hashmap，對一級緩存的操作其實就是對這個hashmap的操作。如下代碼所示。
public class PerpetualCache implements Cache {
private String id;
private Map cache = new HashMap();
在閱讀相關(guān)核心類代碼后，從源代碼層面對一級緩存工作中涉及到的相關(guān)代碼，出于篇幅的考慮，對源碼做適當刪減，讀者朋友可以結(jié)合本文，后續(xù)進行更詳細的學習。
為了執(zhí)行和數(shù)據(jù)庫的交互，首先會通過DefaultSqlSessionFactory開啟一個SqlSession，在創(chuàng)建SqlSession的過程中，會通過Configuration類創(chuàng)建一個全新的Executor，作為DefaultSqlSession構(gòu)造函數(shù)的參數(shù)，代碼如下所示。
private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
............
final Executor executor = configuration.newExecutor(tx, execType);
return new DefaultSqlSession(configuration, executor, autoCommit);
}
如果用戶不進行制定的話，Configuration在創(chuàng)建Executor時，默認創(chuàng)建的類型就是SimpleExecutor,它是一個簡單的執(zhí)行類，只是單純執(zhí)行Sql。以下是具體用來創(chuàng)建的代碼。
public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
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);
}
// 尤其可以注意這里，如果二級緩存開關(guān)開啟的話，是使用CahingExecutor裝飾BaseExecutor的子類
if (cacheEnabled) {
executor = new CachingExecutor(executor);
}
executor = (Executor) interceptorChain.pluginAll(executor);
return executor;
}
在SqlSession創(chuàng)建完畢后，根據(jù)Statment的不同類型，會進入SqlSession的不同方法中，如果是Select語句的話，最后會執(zhí)行到SqlSession的selectList，代碼如下所示。
@Override
public List selectList(String statement, Object parameter, RowBounds rowBounds) {
MappedStatement ms = configuration.getMappedStatement(statement);
return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
}
在上文的代碼中，SqlSession把具體的查詢職責委托給了Executor。如果只開啟了一級緩存的話，首先會進入BaseExecutor的query方法。代碼如下所示。
@Override
public List query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
BoundSql boundSql = ms.getBoundSql(parameter);
CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
}
在上述代碼中，會先根據(jù)傳入的參數(shù)生成CacheKey，進入該方法查看CacheKey是如何生成的，代碼如下所示。
CacheKey cacheKey = new CacheKey();
cacheKey.update(ms.getId());
cacheKey.update(rowBounds.getOffset());
cacheKey.update(rowBounds.getLimit());
cacheKey.update(boundSql.getSql());
//后面是update了sql中帶的參數(shù)
cacheKey.update(value);
在上述的代碼中，我們可以看到它將MappedStatement的Id、sql的offset、Sql的limit、Sql本身以及Sql中的參數(shù)傳入了CacheKey這個類，最終生成了CacheKey。我們看一下這個類的結(jié)構(gòu)。
private static final int DEFAULT_MULTIPLYER = 37;
private static final int DEFAULT_HASHCODE = 17;
private int multiplier;
private int hashcode;
private long checksum;
private int count;
private List updateList;
public CacheKey() {
this.hashcode = DEFAULT_HASHCODE;
this.multiplier = DEFAULT_MULTIPLYER;
this.count = 0;
this.updateList = new ArrayList();
}
首先是它的成員變量和構(gòu)造函數(shù)，有一個初始的hachcode和乘數(shù)，同時維護了一個內(nèi)部的updatelist。在CacheKey的update方法中，會進行一個hashcode和checksum的計算，同時把傳入的參數(shù)添加進updatelist中。如下代碼所示。
public void update(Object object) {
int baseHashCode = object == null ? 1 : ArrayUtil.hashCode(object);
count++;
checksum += baseHashCode;
baseHashCode *= count;
hashcode = multiplier * hashcode + baseHashCode;
updateList.add(object);
}
我們是如何判斷CacheKey相等的呢，在CacheKey的equals方法中給了我們答案，代碼如下所示。
@Override
public boolean equals(Object object) {
.............
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;
}
除去hashcode，checksum和count的比較外，只要updatelist中的元素一一對應相等，那么就可以認為是CacheKey相等。只要兩條Sql的下列五個值相同，即可以認為是相同的Sql。
Statement Id + Offset + Limmit + Sql + Params
BaseExecutor的query方法繼續(xù)往下走，代碼如下所示。
list = resultHandler == null ? (List) localCache.getObject(key) : null;
if (list != null) {
// 這個主要是處理存儲過程用的。
handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
} else {
list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
}
如果查不到的話，就從數(shù)據(jù)庫查，在queryFromDatabase中，會對localcache進行寫入。
在query方法執(zhí)行的最后，會判斷一級緩存級別是否是STATEMENT級別，如果是的話，就清空緩存，這也就是STATEMENT級別的一級緩存無法共享localCache的原因。代碼如下所示。
if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
clearLocalCache();
}
在源碼分析的最后，我們確認一下，如果是insert/delete/update方法，緩存就會刷新的原因。
SqlSession的insert方法和delete方法，都會統(tǒng)一走update的流程，代碼如下所示。
@Override
public int insert(String statement, Object parameter) {
return update(statement, parameter);
}
@Override
public int delete(String statement) {
return update(statement, null);
}
update方法也是委托給了Executor執(zhí)行。BaseExecutor的執(zhí)行方法如下所示。
@Override
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);
}
每次執(zhí)行update前都會清空localCache。
至此，一級緩存的工作流程講解以及源碼分析完畢。
總結(jié)
Mybatis一級緩存的生命周期和SqlSession一致。
Mybatis的緩存是一個粗粒度的緩存，沒有更新緩存和緩存過期的概念，同時只是使用了默認的hashmap，也沒有做容量上的限定。
Mybatis的一級緩存最大范圍是SqlSession內(nèi)部，有多個SqlSession或者分布式的環(huán)境下，有操作數(shù)據(jù)庫寫的話，會引起臟數(shù)據(jù)，建議是把一級緩存的默認級別設定為Statement，即不使用一級緩存。
二級緩存
二級緩存介紹
在上文中提到的一級緩存中，其最大的共享范圍就是一個SqlSession內(nèi)部，那么如何讓多個SqlSession之間也可以共享緩存呢，答案是二級緩存。 當開啟二級緩存后，會使用CachingExecutor裝飾Executor，在進入后續(xù)執(zhí)行前，先在CachingExecutor進行二級緩存的查詢，具體的工作流程如下所示。
在二級緩存的使用中，一個namespace下的所有操作語句，都影響著同一個Cache，即二級緩存是被多個SqlSession共享著的，是一個全局的變量。 當開啟緩存后，數(shù)據(jù)的查詢執(zhí)行的流程就是 二級緩存 -> 一級緩存 -> 數(shù)據(jù)庫。
二級緩存配置
要正確的使用二級緩存，需完成如下配置的。
1 在Mybatis的配置文件中開啟二級緩存。
2 在Mybatis的映射XML中配置cache或者 cache-ref 。
cache標簽用于聲明這個namespace使用二級緩存，并且可以自定義配置。
type: cache使用的類型，默認是PerpetualCache，這在一級緩存中提到過。
eviction: 定義回收的策略，常見的有FIFO，LRU。
flushInterval: 配置一定時間自動刷新緩存，單位是毫秒
size: 最多緩存對象的個數(shù)
readOnly: 是否只讀，若配置可讀寫，則需要對應的實體類能夠序列化。
blocking: 若緩存中找不到對應的key，是否會一直blocking，直到有對應的數(shù)據(jù)進入緩存。
cache-ref代表引用別的命名空間的Cache配置，兩個命名空間的操作使用的是同一個Cache。
二級緩存實驗
在本章節(jié)，通過實驗，了解Mybatis二級緩存在使用上的一些特點。
在本實驗中，id為1的學生名稱初始化為點點。
實驗1
測試二級緩存效果，不提交事務，sqlSession1查詢完數(shù)據(jù)后，sqlSession2相同的查詢是否會從緩存中獲取數(shù)據(jù)。
@Test
public void testCacheWithoutCommitOrClose() throws Exception {
SqlSession sqlSession1 = factory.openSession(true);
SqlSession sqlSession2 = factory.openSession(true);
StudentMapper studentMapper = sqlSession1.getMapper(StudentMapper.class);
StudentMapper studentMapper2 = sqlSession2.getMapper(StudentMapper.class);
System.out.println("studentMapper讀取數(shù)據(jù): " + studentMapper.getStudentById(1));
System.out.println("studentMapper2讀取數(shù)據(jù): " + studentMapper2.getStudentById(1));
}
執(zhí)行結(jié)果:
我們可以看到，當sqlsession沒有調(diào)用commit()方法時，二級緩存并沒有起到作用。
實驗2
測試二級緩存效果，當提交事務時，sqlSession1查詢完數(shù)據(jù)后，sqlSession2相同的查詢是否會從緩存中獲取數(shù)據(jù)。
@Test
public void testCacheWithCommitOrClose() throws Exception {
SqlSession sqlSession1 = factory.openSession(true);
SqlSession sqlSession2 = factory.openSession(true);
StudentMapper studentMapper = sqlSession1.getMapper(StudentMapper.class);
StudentMapper studentMapper2 = sqlSession2.getMapper(StudentMapper.class);
System.out.println("studentMapper讀取數(shù)據(jù): " + studentMapper.getStudentById(1));
sqlSession1.commit();
System.out.println("studentMapper2讀取數(shù)據(jù): " + studentMapper2.getStudentById(1));
}
從圖上可知，sqlsession2的查詢，使用了緩存，緩存的命中率是0.5。
實驗3
測試update操作是否會刷新該namespace下的二級緩存。
@Test
public void testCacheWithUpdate() throws Exception {
SqlSession sqlSession1 = factory.openSession(true);
SqlSession sqlSession2 = factory.openSession(true);
SqlSession sqlSession3 = factory.openSession(true);
StudentMapper studentMapper = sqlSession1.getMapper(StudentMapper.class);
StudentMapper studentMapper2 = sqlSession2.getMapper(StudentMapper.class);
StudentMapper studentMapper3 = sqlSession3.getMapper(StudentMapper.class);
System.out.println("studentMapper讀取數(shù)據(jù): " + studentMapper.getStudentById(1));
sqlSession1.commit();
System.out.println("studentMapper2讀取數(shù)據(jù): " + studentMapper2.getStudentById(1));
studentMapper3.updateStudentName("方方",1);
sqlSession3.commit();
System.out.println("studentMapper2讀取數(shù)據(jù): " + studentMapper2.getStudentById(1));
}
我們可以看到，在sqlSession3更新數(shù)據(jù)庫，并提交事務后，sqlsession2的StudentMapper namespace下的查詢走了數(shù)據(jù)庫，沒有走Cache。
實驗4
驗證Mybatis的二級緩存不適應用于映射文件中存在多表查詢的情況。一般來說，我們會為每一個單表創(chuàng)建一個單獨的映射文件，如果存在涉及多個表的查詢的話，由于Mybatis的二級緩存是基于namespace的，多表查詢語句所在的namspace無法感應到其他namespace中的語句對多表查詢中涉及的表進行了修改，引發(fā)臟數(shù)據(jù)問題。
@Test
public void testCacheWithDiffererntNamespace() throws Exception {
SqlSession sqlSession1 = factory.openSession(true);
SqlSession sqlSession2 = factory.openSession(true);
SqlSession sqlSession3 = factory.openSession(true);
StudentMapper studentMapper = sqlSession1.getMapper(StudentMapper.class);
StudentMapper studentMapper2 = sqlSession2.getMapper(StudentMapper.class);
ClassMapper classMapper = sqlSession3.getMapper(ClassMapper.class);
System.out.println("studentMapper讀取數(shù)據(jù): " + studentMapper.getStudentByIdWithClassInfo(1));
sqlSession1.close();
System.out.println("studentMapper2讀取數(shù)據(jù): " + studentMapper2.getStudentByIdWithClassInfo(1));
classMapper.updateClassName("特色一班",1);
sqlSession3.commit();
System.out.println("studentMapper2讀取數(shù)據(jù): " + studentMapper2.getStudentByIdWithClassInfo(1));
}
執(zhí)行結(jié)果:
在這個實驗中，我們引入了兩張新的表，一張class，一張classroom。class中保存了班級的id和班級名，classroom中保存了班級id和學生id。我們在StudentMapper中增加了一個查詢方法getStudentByIdWithClassInfo，用于查詢學生所在的班級，涉及到多表查詢。在ClassMapper中添加了updateClassName，根據(jù)班級id更新班級名的操作。
當sqlsession1的studentmapper查詢數(shù)據(jù)后，二級緩存生效。保存在StudentMapper的namespace下的cache中。當sqlSession3的classMapper的updateClassName方法對class表進行更新時，updateClassName不屬于StudentMapper的namespace，所以StudentMapper下的cache沒有感應到變化，沒有刷新緩存。當StudentMapper中同樣的查詢再次發(fā)起時，從緩存中讀取了臟數(shù)據(jù)。
實驗5
為了解決實驗4的問題呢，可以使用Cache ref，讓ClassMapper引用StudenMapper命名空間，這樣兩個映射文件對應的Sql操作都使用的是同一塊緩存了。
執(zhí)行結(jié)果:
不過這樣做的后果是，緩存的粒度變粗了，多個Mapper namespace下的所有操作都會對緩存使用造成影響，其實這個緩存存在的意義已經(jīng)不大了。
二級緩存源碼分析
Mybatis二級緩存的工作流程和前文提到的一級緩存類似，只是在一級緩存處理前，用CachingExecutor裝飾了BaseExecutor的子類，實現(xiàn)了緩存的查詢和寫入功能，所以二級緩存直接從源碼開始分析。
源碼分析
源碼分析從CachingExecutor的query方法展開，源代碼走讀過程中涉及到的知識點較多，不能一一詳細講解，可以在文后留言，我會在交流環(huán)節(jié)更詳細的表示出來。
CachingExecutor的query方法，首先會從MappedStatement中獲得在配置初始化時賦予的cache。
Cache cache = ms.getCache();
本質(zhì)上是裝飾器模式的使用，具體的執(zhí)行鏈是
SynchronizedCache -> LoggingCache -> SerializedCache -> LruCache -> PerpetualCache。
以下是具體這些Cache實現(xiàn)類的介紹，他們的組合為Cache賦予了不同的能力。
SynchronizedCache: 同步Cache，實現(xiàn)比較簡單，直接使用synchronized修飾方法。
LoggingCache: 日志功能，裝飾類，用于記錄緩存的命中率，如果開啟了DEBUG模式，則會輸出命中率日志。
SerializedCache: 序列化功能，將值序列化后存到緩存中。該功能用于緩存返回一份實例的Copy，用于保存線程安全。
LruCache: 采用了Lru算法的Cache實現(xiàn)，移除最近最少使用的key/value。
PerpetualCache: 作為為最基礎的緩存類，底層實現(xiàn)比較簡單，直接使用了HashMap。
然后是判斷是否需要刷新緩存，代碼如下所示。
flushCacheIfRequired(ms);
在默認的設置中SELECT語句不會刷新緩存，insert/update/delte會刷新緩存。進入該方法。代碼如下所示。
private void flushCacheIfRequired(MappedStatement ms) {
Cache cache = ms.getCache();
if (cache != null && ms.isFlushCacheRequired()) {
tcm.clear(cache);
}
}
Mybatis的CachingExecutor持有了TransactionalCacheManager，即上述代碼中的tcm。
TransactionalCacheManager中持有了一個Map，代碼如下所示。
private Map transactionalCaches = new HashMap();
這個Map保存了Cache和用TransactionalCache包裝后的Cache的映射關(guān)系。
TransactionalCache實現(xiàn)了Cache接口，CachingExecutor會默認使用他包裝初始生成的Cache，作用是如果事務提交，對緩存的操作才會生效，如果事務回滾或者不提交事務，則不對緩存產(chǎn)生影響。
在TransactionalCache的clear，有以下兩句。清空了需要在提交時加入緩存的列表，同時設定提交時清空緩存，代碼如下所示。
@Override
public void clear() {
clearOnCommit = true;
entriesToAddOnCommit.clear();
}
CachingExecutor繼續(xù)往下走，ensureNoOutParams主要是用來處理存儲過程的，暫時不用考慮。
if (ms.isUseCache() && resultHandler == null) {
ensureNoOutParams(ms, parameterObject, boundSql);
之后會嘗試從tcm中獲取緩存的列表。
List list = (List) tcm.getObject(cache, key);
在getObject方法中，會把獲取值的職責一路向后傳，最終到PerpetualCache。如果沒有查到，會把key加入Miss集合，這個主要是為了統(tǒng)計命中率。
Object object = delegate.getObject(key);
if (object == null) {
entriesMissedInCache.add(key);
}
CachingExecutor繼續(xù)往下走，如果查詢到數(shù)據(jù)，則調(diào)用tcm.putObject方法，往緩存中放入值。
f (list == null) {
list = delegate. query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
tcm.putObject(cache, key, list); // issue #578 and #116
}
tcm的put方法也不是直接操作緩存，只是在把這次的數(shù)據(jù)和key放入待提交的Map中。
@Override
public void putObject(Object key, Object object) {
entriesToAddOnCommit.put(key, object);
}
從以上的代碼分析中，我們可以明白，如果不調(diào)用commit方法的話，由于TranscationalCache的作用，并不會對二級緩存造成直接的影響。因此我們看看Sqlsession的commit方法中做了什么。代碼如下所示。
@Override
public void commit(boolean force) {
try {
executor.commit(isCommitOrRollbackRequired(force));
因為我們使用了CachingExecutor，首先會進入CachingExecutor實現(xiàn)的commit方法。
@Override
public void commit(boolean required) throws SQLException {
delegate.commit(required);
tcm.commit();
}
會把具體commit的職責委托給包裝的Executor。主要是看下tcm.commit()，tcm最終又會調(diào)用到TrancationalCache。
public void commit() {
if (clearOnCommit) {
delegate.clear();
}
flushPendingEntries();
reset();
}
看到這里的clearOnCommit就想起剛才TrancationalCache的clear方法設置的標志位，真正的清理Cache是放到這里來進行的。具體清理的職責委托給了包裝的Cache類。之后進入flushPendingEntries方法。代碼如下所示。
private void flushPendingEntries() {
for (Map.Entry entry : entriesToAddOnCommit.entrySet()) {
delegate.putObject(entry.getKey(), entry.getValue());
}
................
}
在flushPendingEntries中，就把待提交的Map循環(huán)后，委托給包裝的Cache類，進行putObject的操作。 后續(xù)的查詢操作會重復執(zhí)行這套流程。如果是insert|update|delete的話，會統(tǒng)一進入CachingExecutor的update方法，其中調(diào)用了這個函數(shù)，代碼如下所示，因此不再贅述。
private void flushCacheIfRequired(MappedStatement ms)
總結(jié)
Mybatis的二級緩存相對于一級緩存來說，實現(xiàn)了SqlSession之間緩存數(shù)據(jù)的共享，同時粒度更加的細，能夠到Mapper級別，通過Cache接口實現(xiàn)類不同的組合，對Cache的可控性也更強。
Mybatis在多表查詢時，極大可能會出現(xiàn)臟數(shù)據(jù)，有設計上的缺陷，安全使用的條件比較苛刻。
在分布式環(huán)境下，由于默認的Mybatis Cache實現(xiàn)都是基于本地的，分布式環(huán)境下必然會出現(xiàn)讀取到臟數(shù)據(jù)，需要使用集中式緩存將Mybatis的Cache接口實現(xiàn)，有一定的開發(fā)成本，不如直接用Redis，Memcache實現(xiàn)業(yè)務上的緩存就好了。
全文總結(jié)
本文介紹了Mybatis的基礎概念，Mybatis一二級緩存的使用及源碼分析，并對于一二級緩存進行了一定程度上的總結(jié)。 最終的結(jié)論是Mybatis的緩存機制設計的不是很完善，在使用上容易引起臟數(shù)據(jù)問題，個人建議不要使用Mybatis緩存，在業(yè)務層面上使用其他機制實現(xiàn)需要的緩存功能，讓Mybatis老老實實做它的ORM框架就好了哈哈。
