国产xxxx99真实实拍_久久不雅视频_高清韩国a级特黄毛片_嗯老师别我我受不了了小说

資訊專欄INFORMATION COLUMN

【Mybatis系列】從源碼角度深度理解Mybatis的緩存特性

young.li / 571人閱讀

摘要：一級緩存介紹及相關(guān)配置。在這個章節(jié)，我們學(xué)習(xí)如何使用的一級緩存。一級緩存實(shí)驗(yàn)配置完畢后，通過實(shí)驗(yàn)的方式了解一級緩存的效果。源碼分析了解具體的工作流程后，我們隊(duì)查詢相關(guān)的核心類和一級緩存的源碼進(jìn)行走讀。

我，后端Java工程師，現(xiàn)在美團(tuán)點(diǎn)評工作。
愛健身，愛技術(shù)，也喜歡寫點(diǎn)文字。
個人網(wǎng)站: http://kailuncen.me
公眾號: KailunTalk (凱倫說)
前言

本文主要涉及以下三點(diǎn)。

Mybatis是什么。

Mybatis一級和二級緩存如何配置使用。

Mybatis一級和二級緩存的工作流程及源碼分析。

本次分析中涉及到的代碼和數(shù)據(jù)庫表均放在Github上，地址: mybatis-cache-demo。

目錄

為達(dá)到以上三個目的，本文按照以下順序展開。

Mybatis的基礎(chǔ)概念。

一級緩存介紹及相關(guān)配置。

一級緩存工作流程及源碼分析。

一級緩存總結(jié)。

二級緩存介紹及相關(guān)配置。

二級緩存源碼分析。

二級緩存總結(jié)。

全文總結(jié)。

Mybatis的基礎(chǔ)概念

本章節(jié)會對Mybatis進(jìn)行大體的介紹，分為官方定義和核心組件介紹。
首先是Mybatis官方定義，如下所示。

MyBatis是支持定制化SQL、存儲過程以及高級映射的優(yōu)秀的持久層框架。MyBatis避免了幾乎所有的JDBC代碼和手動設(shè)置參數(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的地方，通常來說每一張單表都會對應(yīng)著一個映射文件，在該文件中會定義Sql語句入?yún)⒑统鰠⒌男问健?/p>

下圖就是一個針對Student表操作的接口文件StudentMapper，在StudentMapper中，我們可以若干方法，這個方法背后就是代表著要執(zhí)行的Sql的意義。

通常也可以把涉及多表查詢的方法定義在StudentMapper中，如果查詢的主體仍然是Student表的信息。也可以將涉及多表查詢的語句多帶帶抽出一個獨(dú)立的接口文件。
在定義完接口文件后，我們會開發(fā)一個Sql映射文件，主要由mapper元素和select|insert|update|delete元素構(gòu)成，如下圖所示。

mapper元素代表這個文件是一個映射文件，使用namespace和具體的映射接口綁定起來，namespace的值就是這個接口的全限定類名。select|insert|update|delete代表的是Sql語句，映射接口中定義的每一個方法也會和映射文件中的語句通過id的方式綁定起來，方法名就是語句的id，同時(shí)會定義語句的入?yún)⒑统鰠ⅲ糜谕瓿珊蚃ava對象之間的轉(zhuǎn)換。

在Mybatis初始化的時(shí)候，每一個語句都會使用對應(yīng)的MappedStatement代表，使用namespace+語句本身的id來代表這個語句。如下代碼所示，使用mapper.StudentMapper.getStudentById代表其對應(yīng)的Sql。

SELECT id,name,age FROM student WHERE id = #{id}

在Mybatis執(zhí)行時(shí)，會進(jìn)入對應(yīng)接口的方法，通過類名加上方法名的組合生成id，找到需要的MappedStatement，交給執(zhí)行器使用。
至此，Mybatis的基礎(chǔ)概念介紹完畢。

一級緩存 一級緩存介紹

在系統(tǒng)代碼的運(yùn)行中，我們可能會在一個數(shù)據(jù)庫會話中，執(zhí)行多次查詢條件完全相同的Sql，鑒于日常應(yīng)用的大部分場景都是讀多寫少，這重復(fù)的查詢會帶來一定的網(wǎng)絡(luò)開銷，同時(shí)select查詢的量比較大的話，對數(shù)據(jù)庫的性能是有比較大的影響的。

如果是Mysql數(shù)據(jù)庫的話，在服務(wù)端和Jdbc端都開啟預(yù)編譯支持的話，可以在本地JVM端緩存Statement,可以在Mysql服務(wù)端直接執(zhí)行Sql，省去編譯Sql的步驟，但也無法避免和數(shù)據(jù)庫之間的重復(fù)交互。關(guān)于Jdbc和Mysql預(yù)編譯緩存的事情，可以看我的這篇博客JDBC和Mysql那些事。

Mybatis提供了一級緩存的方案來優(yōu)化在數(shù)據(jù)庫會話間重復(fù)查詢的問題。實(shí)現(xiàn)的方式是每一個SqlSession中都持有了自己的緩存，一種是SESSION級別，即在一個Mybatis會話中執(zhí)行的所有語句，都會共享這一個緩存。一種是STATEMENT級別，可以理解為緩存只對當(dāng)前執(zhí)行的這一個statement有效。如果用一張圖來代表一級查詢的查詢過程的話，可以用下圖表示。

每一個SqlSession中持有了自己的Executor，每一個Executor中有一個Local Cache。當(dāng)用戶發(fā)起查詢時(shí)，Mybatis會根據(jù)當(dāng)前執(zhí)行的MappedStatement生成一個key，去Local Cache中查詢，如果緩存命中的話，返回。如果緩存沒有命中的話，則寫入Local Cache，最后返回結(jié)果給用戶。

一級緩存配置

上文介紹了一級緩存的實(shí)現(xiàn)方式，解決了什么問題。在這個章節(jié)，我們學(xué)習(xí)如何使用Mybatis的一級緩存。只需要在Mybatis的配置文件中，添加如下語句，就可以使用一級緩存。共有兩個選項(xiàng)，SESSION或者STATEMENT，默認(rèn)是SESSION級別。

一級緩存實(shí)驗(yàn)

配置完畢后，通過實(shí)驗(yàn)的方式了解Mybatis一級緩存的效果。每一個單元測試后都請恢復(fù)被修改的數(shù)據(jù)。
首先是創(chuàng)建了一個示例表student,為其創(chuàng)建了對應(yī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;

在以下實(shí)驗(yàn)中，id為1的學(xué)生名稱是凱倫。

實(shí)驗(yàn)1

開啟一級緩存，范圍為會話級別，調(diào)用三次getStudentById，代碼如下所示:

public void getStudentById() throws Exception {
        SqlSession sqlSession = factory.openSession(true); // 自動提交事務(wù)
        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ù)的查詢使用了一級緩存。

實(shí)驗(yàn)2

在這次的試驗(yàn)中，我們增加了對數(shù)據(jù)庫的修改操作，驗(yàn)證在一次數(shù)據(jù)庫會話中，對數(shù)據(jù)庫發(fā)生了修改操作，一級緩存是否會失效。

@Test
public void addStudent() throws Exception {
        SqlSession sqlSession = factory.openSession(true); // 自動提交事務(wù)
        StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);
        System.out.println(studentMapper.getStudentById(1));
        System.out.println("增加了" + studentMapper.addStudent(buildStudent()) + "個學(xué)生");
        System.out.println(studentMapper.getStudentById(1));
        sqlSession.close();
}

執(zhí)行結(jié)果:

我們可以看到，在修改操作后執(zhí)行的相同查詢，查詢了數(shù)據(jù)庫，一級緩存失效。

實(shí)驗(yàn)3

開啟兩個SqlSession，在sqlSession1中查詢數(shù)據(jù)，使一級緩存生效，在sqlSession2中更新數(shù)據(jù)庫，驗(yàn)證一級緩存只在數(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) + "個學(xué)生的數(shù)據(jù)");
        System.out.println("studentMapper讀取數(shù)據(jù): " + studentMapper.getStudentById(1));
        System.out.println("studentMapper2讀取數(shù)據(jù): " + studentMapper2.getStudentById(1));
}


我們可以看到，sqlSession2更新了id為1的學(xué)生的姓名，從凱倫改為了小岑，但session1之后的查詢中，id為1的學(xué)生的名字還是凱倫，出現(xiàn)了臟數(shù)據(jù)，也證明了我們之前就得到的結(jié)論，一級緩存只存在于只在數(shù)據(jù)庫會話內(nèi)部共享。

一級緩存工作流程&源碼分析

這一章節(jié)主要從一級緩存的工作流程和源碼層面對一級緩存進(jìn)行學(xué)習(xí)。

工作流程

根據(jù)一級緩存的工作流程，我們繪制出一級緩存執(zhí)行的時(shí)序圖，如下圖所示。

主要步驟如下:

對于某個Select Statement，根據(jù)該Statement生成key。

判斷在Local Cache中,該key是否用對應(yīng)的數(shù)據(jù)存在。

如果命中，則跳過查詢數(shù)據(jù)庫，繼續(xù)往下走。

如果沒命中：
4.1 去數(shù)據(jù)庫中查詢數(shù)據(jù)，得到查詢結(jié)果；
4.2 將key和查詢到的結(jié)果作為key和value，放入Local Cache中。
4.3. 將查詢結(jié)果返回；

判斷緩存級別是否為STATEMENT級別，如果是的話，清空本地緩存。

源碼分析

了解具體的工作流程后，我們隊(duì)Mybatis查詢相關(guān)的核心類和一級緩存的源碼進(jìn)行走讀。這對于之后學(xué)習(xí)二級緩存時(shí)也有幫助。
SqlSession: 對外提供了用戶和數(shù)據(jù)庫之間交互需要的所有方法，隱藏了底層的細(xì)節(jié)。它的一個默認(rèn)實(shí)現(xiàn)類是DefaultSqlSession。

Executor: SqlSession向用戶提供操作數(shù)據(jù)庫的方法，但和數(shù)據(jù)庫操作有關(guān)的職責(zé)都會委托給Executor。

如下圖所示，Executor有若干個實(shí)現(xiàn)類，為Executor賦予了不同的能力，大家可以根據(jù)類名，自行私下學(xué)習(xí)每個類的基本作用。

在一級緩存章節(jié)，我們主要學(xué)習(xí)BaseExecutor。
BaseExecutor: BaseExecutor是一個實(shí)現(xiàn)了Executor接口的抽象類，定義若干抽象方法，在執(zhí)行的時(shí)候，把具體的操作委托給子類進(jìn)行執(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)的最基本的操作，有若干個實(shí)現(xiàn)類，使用裝飾器模式互相組裝，提供豐富的操控緩存的能力。


BaseExecutor成員變量之一的PerpetualCache，就是對Cache接口最基本的實(shí)現(xiàn)，其實(shí)現(xiàn)非常的簡內(nèi)部持有了hashmap，對一級緩存的操作其實(shí)就是對這個hashmap的操作。如下代碼所示。

public class PerpetualCache implements Cache {
  private String id;
  private Map cache = new HashMap();

在閱讀相關(guān)核心類代碼后，從源代碼層面對一級緩存工作中涉及到的相關(guān)代碼，出于篇幅的考慮，對源碼做適當(dāng)刪減，讀者朋友可以結(jié)合本文，后續(xù)進(jìn)行更詳細(xì)的學(xué)習(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);
}

如果用戶不進(jìn)行制定的話，Configuration在創(chuàng)建Executor時(shí)，默認(rèn)創(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的不同類型，會進(jìn)入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把具體的查詢職責(zé)委托給了Executor。如果只開啟了一級緩存的話，首先會進(jìn)入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，進(jìn)入該方法查看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ù)，同時(shí)維護(hù)了一個內(nèi)部的updatelist。在CacheKey的update方法中，會進(jìn)行一個hashcode和checksum的計(jì)算，同時(shí)把傳入的參數(shù)添加進(jìn)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中的元素一一對應(yīng)相等，那么就可以認(rèn)為是CacheKey相等。只要兩條Sql的下列五個值相同，即可以認(rèn)為是相同的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進(jìn)行寫入。
在query方法執(zhí)行的最后，會判斷一級緩存級別是否是STATEMENT級別，如果是的話，就清空緩存，這也就是STATEMENT級別的一級緩存無法共享localCache的原因。代碼如下所示。


if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
        clearLocalCache();
}


在源碼分析的最后，我們確認(rèn)一下，如果是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的緩存是一個粗粒度的緩存，沒有更新緩存和緩存過期的概念，同時(shí)只是使用了默認(rèn)的hashmap，也沒有做容量上的限定。


Mybatis的一級緩存最大范圍是SqlSession內(nèi)部，有多個SqlSession或者分布式的環(huán)境下，有操作數(shù)據(jù)庫寫的話，會引起臟數(shù)據(jù)，建議是把一級緩存的默認(rèn)級別設(shè)定為Statement，即不使用一級緩存。


二級緩存
二級緩存介紹

在上文中提到的一級緩存中，其最大的共享范圍就是一個SqlSession內(nèi)部，那么如何讓多個SqlSession之間也可以共享緩存呢，答案是二級緩存。
當(dāng)開啟二級緩存后，會使用CachingExecutor裝飾Executor，在進(jìn)入后續(xù)執(zhí)行前，先在CachingExecutor進(jìn)行二級緩存的查詢，具體的工作流程如下所示。

在二級緩存的使用中，一個namespace下的所有操作語句，都影響著同一個Cache，即二級緩存是被多個SqlSession共享著的，是一個全局的變量。
當(dāng)開啟緩存后，數(shù)據(jù)的查詢執(zhí)行的流程就是 二級緩存 -> 一級緩存 -> 數(shù)據(jù)庫。

二級緩存配置

要正確的使用二級緩存，需完成如下配置的。
1  在Mybatis的配置文件中開啟二級緩存。




2  在Mybatis的映射XML中配置cache或者 cache-ref 。


   


cache標(biāo)簽用于聲明這個namespace使用二級緩存，并且可以自定義配置。



type:   cache使用的類型，默認(rèn)是PerpetualCache，這在一級緩存中提到過。


eviction:  定義回收的策略，常見的有FIFO，LRU。


flushInterval:  配置一定時(shí)間自動刷新緩存，單位是毫秒


size:   最多緩存對象的個數(shù)


readOnly:   是否只讀，若配置可讀寫，則需要對應(yīng)的實(shí)體類能夠序列化。


blocking:    若緩存中找不到對應(yīng)的key，是否會一直blocking，直到有對應(yīng)的數(shù)據(jù)進(jìn)入緩存。





cache-ref代表引用別的命名空間的Cache配置，兩個命名空間的操作使用的是同一個Cache。

二級緩存實(shí)驗(yàn)

在本章節(jié)，通過實(shí)驗(yàn)，了解Mybatis二級緩存在使用上的一些特點(diǎn)。
在本實(shí)驗(yàn)中，id為1的學(xué)生名稱初始化為點(diǎn)點(diǎn)。


實(shí)驗(yàn)1


測試二級緩存效果，不提交事務(wù)，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é)果:

我們可以看到，當(dāng)sqlsession沒有調(diào)用commit()方法時(shí)，二級緩存并沒有起到作用。


實(shí)驗(yàn)2


測試二級緩存效果，當(dāng)提交事務(wù)時(shí)，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。


實(shí)驗(yàn)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ù)庫，并提交事務(wù)后，sqlsession2的StudentMapper namespace下的查詢走了數(shù)據(jù)庫，沒有走Cache。


實(shí)驗(yàn)4


驗(yàn)證Mybatis的二級緩存不適應(yīng)用于映射文件中存在多表查詢的情況。一般來說，我們會為每一個單表創(chuàng)建一個多帶帶的映射文件，如果存在涉及多個表的查詢的話，由于Mybatis的二級緩存是基于namespace的，多表查詢語句所在的namspace無法感應(yīng)到其他namespace中的語句對多表查詢中涉及的表進(jìn)行了修改，引發(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é)果:

在這個實(shí)驗(yàn)中，我們引入了兩張新的表，一張class，一張classroom。class中保存了班級的id和班級名，classroom中保存了班級id和學(xué)生id。我們在StudentMapper中增加了一個查詢方法getStudentByIdWithClassInfo，用于查詢學(xué)生所在的班級，涉及到多表查詢。在ClassMapper中添加了updateClassName，根據(jù)班級id更新班級名的操作。
當(dāng)sqlsession1的studentmapper查詢數(shù)據(jù)后，二級緩存生效。保存在StudentMapper的namespace下的cache中。當(dāng)sqlSession3的classMapper的updateClassName方法對class表進(jìn)行更新時(shí)，updateClassName不屬于StudentMapper的namespace，所以StudentMapper下的cache沒有感應(yīng)到變化，沒有刷新緩存。當(dāng)StudentMapper中同樣的查詢再次發(fā)起時(shí)，從緩存中讀取了臟數(shù)據(jù)。


實(shí)驗(yàn)5


為了解決實(shí)驗(yàn)4的問題呢，可以使用Cache ref，讓ClassMapper引用StudenMapper命名空間，這樣兩個映射文件對應(yīng)的Sql操作都使用的是同一塊緩存了。
執(zhí)行結(jié)果:

不過這樣做的后果是，緩存的粒度變粗了，多個Mapper namespace下的所有操作都會對緩存使用造成影響，其實(shí)這個緩存存在的意義已經(jīng)不大了。

二級緩存源碼分析

Mybatis二級緩存的工作流程和前文提到的一級緩存類似，只是在一級緩存處理前，用CachingExecutor裝飾了BaseExecutor的子類，實(shí)現(xiàn)了緩存的查詢和寫入功能，所以二級緩存直接從源碼開始分析。


源碼分析


源碼分析從CachingExecutor的query方法展開，源代碼走讀過程中涉及到的知識點(diǎn)較多，不能一一詳細(xì)講解，可以在文后留言，我會在交流環(huán)節(jié)更詳細(xì)的表示出來。
CachingExecutor的query方法，首先會從MappedStatement中獲得在配置初始化時(shí)賦予的cache。


Cache cache = ms.getCache();


本質(zhì)上是裝飾器模式的使用，具體的執(zhí)行鏈?zhǔn)?br>SynchronizedCache -> LoggingCache -> SerializedCache -> LruCache -> PerpetualCache。

以下是具體這些Cache實(shí)現(xiàn)類的介紹，他們的組合為Cache賦予了不同的能力。



SynchronizedCache: 同步Cache，實(shí)現(xiàn)比較簡單，直接使用synchronized修飾方法。


LoggingCache: 日志功能，裝飾類，用于記錄緩存的命中率，如果開啟了DEBUG模式，則會輸出命中率日志。


SerializedCache: 序列化功能，將值序列化后存到緩存中。該功能用于緩存返回一份實(shí)例的Copy，用于保存線程安全。


LruCache:  采用了Lru算法的Cache實(shí)現(xiàn)，移除最近最少使用的key/value。


PerpetualCache: 作為為最基礎(chǔ)的緩存類，底層實(shí)現(xiàn)比較簡單，直接使用了HashMap。



然后是判斷是否需要刷新緩存，代碼如下所示。


flushCacheIfRequired(ms);


在默認(rèn)的設(shè)置中SELECT語句不會刷新緩存，insert/update/delte會刷新緩存。進(jìn)入該方法。代碼如下所示。


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實(shí)現(xiàn)了Cache接口，CachingExecutor會默認(rèn)使用他包裝初始生成的Cache，作用是如果事務(wù)提交，對緩存的操作才會生效，如果事務(wù)回滾或者不提交事務(wù)，則不對緩存產(chǎn)生影響。
在TransactionalCache的clear，有以下兩句。清空了需要在提交時(shí)加入緩存的列表，同時(shí)設(shè)定提交時(shí)清空緩存，代碼如下所示。


@Override
public void clear() {
    clearOnCommit = true;
    entriesToAddOnCommit.clear();
}


CachingExecutor繼續(xù)往下走，ensureNoOutParams主要是用來處理存儲過程的，暫時(shí)不用考慮。


if (ms.isUseCache() && resultHandler == null) {
    ensureNoOutParams(ms, parameterObject, boundSql);


之后會嘗試從tcm中獲取緩存的列表。


List list = (List) tcm.getObject(cache, key);


在getObject方法中，會把獲取值的職責(zé)一路向后傳，最終到PerpetualCache。如果沒有查到，會把key加入Miss集合，這個主要是為了統(tǒng)計(jì)命中率。


Object object = delegate.getObject(key);
if (object == null) {
    entriesMissedInCache.add(key);
}


CachingExecutor繼續(xù)往下走，如果查詢到數(shù)據(jù)，則調(diào)用tcm.putObject方法，往緩存中放入值。


if (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));


因?yàn)槲覀兪褂昧薈achingExecutor，首先會進(jìn)入CachingExecutor實(shí)現(xiàn)的commit方法。


@Override
public void commit(boolean required) throws SQLException {
    delegate.commit(required);
    tcm.commit();
}


會把具體commit的職責(zé)委托給包裝的Executor。主要是看下tcm.commit()，tcm最終又會調(diào)用到TrancationalCache。


public void commit() {
    if (clearOnCommit) {
      delegate.clear();
    }
    flushPendingEntries();
    reset();
}


看到這里的clearOnCommit就想起剛才TrancationalCache的clear方法設(shè)置的標(biāo)志位，真正的清理Cache是放到這里來進(jìn)行的。具體清理的職責(zé)委托給了包裝的Cache類。之后進(jìn)入flushPendingEntries方法。代碼如下所示。


private void flushPendingEntries() {
    for (Map.Entry entry : entriesToAddOnCommit.entrySet()) {
      delegate.putObject(entry.getKey(), entry.getValue());
    }
    ................
}


在flushPendingEntries中，就把待提交的Map循環(huán)后，委托給包裝的Cache類，進(jìn)行putObject的操作。
后續(xù)的查詢操作會重復(fù)執(zhí)行這套流程。如果是insert|update|delete的話，會統(tǒng)一進(jìn)入CachingExecutor的update方法，其中調(diào)用了這個函數(shù)，代碼如下所示，因此不再贅述。


private void flushCacheIfRequired(MappedStatement ms) 

總結(jié)


Mybatis的二級緩存相對于一級緩存來說，實(shí)現(xiàn)了SqlSession之間緩存數(shù)據(jù)的共享，同時(shí)粒度更加的細(xì)，能夠到Mapper級別，通過Cache接口實(shí)現(xiàn)類不同的組合，對Cache的可控性也更強(qiáng)。


Mybatis在多表查詢時(shí)，極大可能會出現(xiàn)臟數(shù)據(jù)，有設(shè)計(jì)上的缺陷，安全使用的條件比較苛刻。


在分布式環(huán)境下，由于默認(rèn)的Mybatis Cache實(shí)現(xiàn)都是基于本地的，分布式環(huán)境下必然會出現(xiàn)讀取到臟數(shù)據(jù)，需要使用集中式緩存將Mybatis的Cache接口實(shí)現(xiàn)，有一定的開發(fā)成本，不如直接用Redis，Memcache實(shí)現(xiàn)業(yè)務(wù)上的緩存就好了。


全文總結(jié)

本文介紹了Mybatis的基礎(chǔ)概念，Mybatis一二級緩存的使用及源碼分析，并對于一二級緩存進(jìn)行了一定程度上的總結(jié)。
最終的結(jié)論是Mybatis的緩存機(jī)制設(shè)計(jì)的不是很完善，在使用上容易引起臟數(shù)據(jù)問題，個人建議不要使用Mybatis緩存，在業(yè)務(wù)層面上使用其他機(jī)制實(shí)現(xiàn)需要的緩存功能，讓Mybatis老老實(shí)實(shí)做它的ORM框架就好了哈哈。








歡迎多多留言，點(diǎn)贊，收藏哈~~~~
           
               
                                           
                       
                 
            
                     
             
               

                   
 文章版權(quán)歸作者所有，未經(jīng)允許請勿轉(zhuǎn)載,若此文章存在違規(guī)行為，您可以聯(lián)系管理員刪除。

                 
                   
轉(zhuǎn)載請注明本文地址：http://m.specialneedsforspecialkids.com/yun/61862.html

               

                      
               
              
              

                
相關(guān)文章

                
    
                             
                                                                    
  • 
                                                
    
                          
    【Mybatis系列】從源碼角度深度理解Mybatis的緩存特性
    
                                                     
    摘要：一級緩存介紹及相關(guān)配置。在這個章節(jié)，我們學(xué)習(xí)如何使用的一級緩存。一級緩存實(shí)驗(yàn)配置完畢后，通過實(shí)驗(yàn)的方式了解一級緩存的效果。源碼分析了解具體的工作流程后，我們隊(duì)查詢相關(guān)的核心類和一級緩存的源碼進(jìn)行走讀。

我，后端Java工程師，現(xiàn)在美團(tuán)點(diǎn)評工作。愛健身，愛技術(shù)，也喜歡寫點(diǎn)文字。個人網(wǎng)站: http://kailuncen.me公眾號: KailunTalk (凱倫說)
前言
本文主要涉及...
    
                                                   
                          
    
                                
    
                                    Ku_Andrew
                                    
                                    評論0 
                                    收藏0 
                                
    
                          
    
                      
    
                    
    •  
                                                                                                                       
  • 
                                                
    
                          
    java篇
    
                                                     
    摘要：多線程編程這篇文章分析了多線程的優(yōu)缺點(diǎn)，如何創(chuàng)建多線程，分享了線程安全和線程通信線程池等等一些知識。

中間件技術(shù)入門教程
中間件技術(shù)入門教程，本博客介紹了 ESB、MQ、JMS 的一些知識...
SpringBoot 多數(shù)據(jù)源
SpringBoot 使用主從數(shù)據(jù)源
簡易的后臺管理權(quán)限設(shè)計(jì)
從零開始搭建自己權(quán)限管理框架
Docker 多步構(gòu)建更小的 Java 鏡像
Docker  Jav...
    
                                                   
                          
    
                                
    
                                    honhon
                                    
                                    評論0 
                                    收藏0 
                                
    
                          
    
                      
    
                    
    •  
                                                                                       
  • 
                                                
    
                          
    Java深入-框架技巧
    
                                                     
    摘要：從使用到原理學(xué)習(xí)線程池關(guān)于線程池的使用，及原理分析分析角度新穎面向切面編程的基本用法基于注解的實(shí)現(xiàn)在軟件開發(fā)中，分散于應(yīng)用中多出的功能被稱為橫切關(guān)注點(diǎn)如事務(wù)安全緩存等。

Java 程序媛手把手教你設(shè)計(jì)模式中的撩妹神技 -- 上篇
遇一人白首，擇一城終老，是多么美好的人生境界，她和他歷經(jīng)風(fēng)雨慢慢變老，回首走過的點(diǎn)點(diǎn)滴滴，依然清楚的記得當(dāng)初愛情萌芽的模樣……
Java 進(jìn)階面試問題列表 -...
    
                                                   
                          
    
                                
    
                                    chengtao1633
                                    
                                    評論0 
                                    收藏0 
                                
    
                          
    
                      
    
                    
    •  
                                                                                       
  • 
                                                
    
                          
    MyBatis 源碼分析系列文章導(dǎo)讀
    
                                                     
    摘要：本文速覽本篇文章是我為接下來的源碼分析系列文章寫的一個導(dǎo)讀文章。年該項(xiàng)目從基金會遷出，并改名為。同期，停止維護(hù)。符號所在的行則是表示的執(zhí)行結(jié)果。同時(shí)，使用無需處理受檢異常，比如。另外，把寫在配置文件中，進(jìn)行集中管理，利于維護(hù)。

1.本文速覽
本篇文章是我為接下來的 MyBatis 源碼分析系列文章寫的一個導(dǎo)讀文章。本篇文章從 MyBatis 是什么（what），為什么要使用（why），...
    
                                                   
                          
    
                                
    
                                    weizx
                                    
                                    評論0 
                                    收藏0 
                                
    
                          
    
                      
    
                    
    •  
                                                                           
                

              

              
               

                  
                  
發(fā)表評論

                   
               

              

                

                  
0條評論
   
                
 
                      

              

           
           

              
 
                

                   
              
  

                  
最新活動
 
           
                             
              





                                
              

           

        
       
    
    
     

      
    

    
    

    
       
       

         
閱讀需要支付1元查看
  
         
     
       

      
  
    
    








        

            

              
              
            

             
        

    







<