1. 驗證二級緩存

在上一篇帖子中的 User 和 Department 實體類依然要用，這里就不再贅述了，要啟用二級緩存，需要在 Mapper.xml 文件中指定 cache 標(biāo)簽，如下：

UserMapper.xml

    
        select * from user
    

    

Department.xml

    
        select * from department;
    
    
    

在 Department.xml 中的 cache 標(biāo)簽指定了 readOnly 屬性，因為該配置相對比較重要，所以我們在這里把它講解一下：

readOnly 默認(rèn)為 false，這種情況下通過二級緩存查詢出來的數(shù)據(jù)會進行一次 序列化深拷貝。在這里大家需要回想一下介紹一級緩存時舉的例子：一級緩存查詢出來返回的是 該對象的引用，若我們對它修改，再查詢 時觸發(fā)一級緩存獲得的便是 被修改過的數(shù)據(jù)。但是，二級緩存的序列化機制則不同，它獲取到的是 緩存深拷貝的對象，這樣對二級緩存進行修改操作不影響后續(xù)查詢結(jié)果。

如果將該屬性配置為 true 的話，那么它就會變得和一級緩存一樣，返回的是對象的引用，這樣做的好處是 避免了深拷貝的開銷。

為什么會有這種機制呢？

因為二級緩存是 Mapper級別 的，不能保證其他 SqlSession 不對二級緩存進行修改，所以這也是一種保護機制。

我們驗證一下這個例子，Department 和 User 的查詢都執(zhí)行了兩遍（注意 事務(wù)提交之后 才能使二級緩存生效）：

public static void main(String[] args) {
        InputStream xml = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        // 開啟二級緩存需要在同一個SqlSessionFactory下，二級緩存存在于 SqlSessionFactory 生命周期，如此才能命中二級緩存
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(xml);

        SqlSession sqlSession1 = sqlSessionFactory.openSession();
        UserMapper userMapper1 = sqlSession1.getMapper(UserMapper.class);
        DepartmentMapper departmentMapper1 = sqlSession1.getMapper(DepartmentMapper.class);

        System.out.println("----------department第一次查詢 ↓------------");
        List departments1 = departmentMapper1.findAll();
        System.out.println("----------user第一次查詢 ↓------------");
        List users1 = userMapper1.findAll();

        // 提交事務(wù)，使二級緩存生效
        sqlSession1.commit();

        SqlSession sqlSession2 = sqlSessionFactory.openSession();
        UserMapper userMapper2 = sqlSession2.getMapper(UserMapper.class);
        DepartmentMapper departmentMapper2 = sqlSession2.getMapper(DepartmentMapper.class);

        System.out.println("----------department第二次查詢 ↓------------");
        List departments2 = departmentMapper2.findAll();
        System.out.println("----------user第二次查詢 ↓------------");
        List users2 = userMapper2.findAll();

        sqlSession1.close();
        sqlSession2.close();
}

Department 和 User 的同一條查詢語句都執(zhí)行了兩遍，因為 Department 指定了 readOnly 為true，那么 兩次查詢返回的對象均為同一個引用，而 User 則反之，Debug 試一下：

cache 的其他屬性

接下來我們測試驗證下二級緩存的生效：

   SqlSession sqlSession1 = sqlSessionFactory.openSession();
   DepartmentMapper departmentMapper1 = sqlSession1.getMapper(DepartmentMapper.class);

   System.out.println("----------department第一次查詢 ↓------------");
   List departments1 = departmentMapper1.findAll();

   // 使二級緩存生效
   sqlSession1.commit();

   SqlSession sqlSession2 = sqlSessionFactory.openSession();
   DepartmentMapper departmentMapper2 = sqlSession2.getMapper(DepartmentMapper.class);

   System.out.println("----------department第二次查詢 ↓------------");
   List departments2 = departmentMapper2.findAll();

第一次 Query，會去數(shù)據(jù)庫中查

第二次 Query，直接從二級緩存中取

2. 二級緩存的原理

二級緩存對象 Cache

在加載 Mapper 文件（org.apache.ibatis.builder.xml.XMLConfigBuilder#mappersElement 方法）時，定義了加載 cache 標(biāo)簽的步驟（org.apache.ibatis.builder.xml.XMLMapperBuilder#configurationElement 方法），代碼如下：

public class XMLMapperBuilder extends BaseBuilder {
    // ...
    
    private void configurationElement(XNode context) {
        try {
            // 若想要在多個命名空間中共享相同的緩存配置和實例，可以使用 cache-ref 元素來引用另一個緩存
            cacheRefElement(context.evalNode("cache-ref"));
            // 配置二級緩存
            cacheElement(context.evalNode("cache"));
            // ...
        } catch (Exception e) {
            throw new BuilderException("Error parsing Mapper XML. The XML location is '" + resource + "'. Cause: " + e, e);
        }
    }
}

具體解析邏輯如下：

public class XMLMapperBuilder extends BaseBuilder {
    // ...
    
    private void cacheElement(XNode context) {
        if (context != null) {
            // 二級緩存實現(xiàn)類，默認(rèn) PerpetualCache，我們在一級緩存也提到過
            String type = context.getStringAttribute("type", "PERPETUAL");
            Class typeClass = typeAliasRegistry.resolveAlias(type);
            // 緩存清除策略，默認(rèn) LRU
            String eviction = context.getStringAttribute("eviction", "LRU");
            Class evictionClass = typeAliasRegistry.resolveAlias(eviction);
            // 定時清除間隔
            Long flushInterval = context.getLongAttribute("flushInterval");
            // 緩存引用數(shù)量
            Integer size = context.getIntAttribute("size");
            // readOnly上文我們提到過，默認(rèn) false
            boolean readWrite = !context.getBooleanAttribute("readOnly", false);
            // blocking 默認(rèn) false
            boolean blocking = context.getBooleanAttribute("blocking", false);
            Properties props = context.getChildrenAsProperties();
            // 創(chuàng)建緩存對象
            builderAssistant.useNewCache(typeClass, evictionClass, flushInterval, size, readWrite, blocking, props);
        }
    }
}

我們繼續(xù)看創(chuàng)建二級緩存對象的邏輯 org.apache.ibatis.builder.MapperBuilderAssistant#useNewCache，可以發(fā)現(xiàn)，創(chuàng)建 Cache 對象使用了 建造者模式：

建造者 CacheBuilder 并沒有被組合在任意一種緩存的實現(xiàn)類中，而是根據(jù)如下代碼中 implementation(valueOrDefault(typeClass, PerpetualCache.class)) 邏輯指定了要創(chuàng)建的緩存類型，并在 build 方法中使用反射創(chuàng)建對應(yīng)實現(xiàn)類：

public class MapperBuilderAssistant extends BaseBuilder {
    // ...

    public Cache useNewCache(Class typeClass, Class evictionClass, Long flushInterval,
                             Integer size, boolean readWrite, boolean blocking, Properties props) {
        // 建造者模式，將標(biāo)簽屬性賦值
        Cache cache = new CacheBuilder(currentNamespace).implementation(valueOrDefault(typeClass, PerpetualCache.class))
                .addDecorator(valueOrDefault(evictionClass, LruCache.class)).clearInterval(flushInterval).size(size)
                .readWrite(readWrite).blocking(blocking).properties(props).build();

        // 添加到全局配置中
        configuration.addCache(cache);
        currentCache = cache;
        return cache;
    }
}

其中 addDecorator(valueOrDefault(evictionClass, LruCache.class)) 邏輯添加了 裝飾器，使用了 裝飾器模式，將 LruCache 類型的裝飾器添加到 decorators 中：

public class CacheBuilder {

    private final List> decorators;

    public CacheBuilder addDecorator(Class decorator) {
        // 將 LruCache 裝飾器添加到 decorators
        if (decorator != null) {
            this.decorators.add(decorator);
        }
        return this;
    }
    
    // ...
}

在 CacheBuilder#build 方法中，如下為封裝裝飾器的邏輯：

public class CacheBuilder {
    // ...

    public Cache build() {
        setDefaultImplementations();
        // 反射創(chuàng)建 PerpetualCache
        Cache cache = newBaseCacheInstance(implementation, id);
        setCacheProperties(cache);

        // 封裝裝飾器的邏輯
        if (PerpetualCache.class.equals(cache.getClass())) {
            for (Class decorator : decorators) {
                cache = newCacheDecoratorInstance(decorator, cache);
                setCacheProperties(cache);
            }
            // 初始化基礎(chǔ)必要的裝飾器
            cache = setStandardDecorators(cache);
        } else if (!LoggingCache.class.isAssignableFrom(cache.getClass())) {
            cache = new LoggingCache(cache);
        }
        return cache;
    }
    

    private Cache setStandardDecorators(Cache cache) {
        try {
            MetaObject metaCache = SystemMetaObject.forObject(cache);
            if (size != null && metaCache.hasSetter("size")) {
                metaCache.setValue("size", size);
            }
            // 定時清空二級緩存
            if (clearInterval != null) {
                cache = new ScheduledCache(cache);
                ((ScheduledCache) cache).setClearInterval(clearInterval);
            }
            // readOnly屬性相關(guān)的讀寫緩存
            if (readWrite) {
                cache = new SerializedCache(cache);
            }
            // 日志緩存和同步緩存（借助 ReentrantLock 實現(xiàn)）
            cache = new LoggingCache(cache);
            cache = new SynchronizedCache(cache);
            // 阻塞屬性的緩存
            if (blocking) {
                cache = new BlockingCache(cache);
            }
            return cache;
        } catch (Exception e) {
            throw new CacheException("Error building standard cache decorators.  Cause: " + e, e);
        }
    }

}

所有裝飾器都在 org.apache.ibatis.cache.decorators 包下，唯獨 PerpetualCache 在org.apache.ibatis.cache.impl 包下：

PerpetualCache 中不包含 delegate 屬性表示裝飾器，說明它將作為最基礎(chǔ)的實現(xiàn)類被其他裝飾器裝飾，而其他裝飾器中均含有 delegate 屬性來裝飾其他實現(xiàn)。

默認(rèn)創(chuàng)建的二級緩存類型如下：

類關(guān)系圖如下：

query 方法對二級緩存的應(yīng)用

org.apache.ibatis.executor.CachingExecutor#query 方法使用了二級緩存，如下代碼所示：

public class CachingExecutor implements Executor {

  // 事務(wù)緩存管理器
  private final TransactionalCacheManager tcm = new TransactionalCacheManager();
  
  @Override
  public  List query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
      throws SQLException {
    // 先獲取二級緩存，該對象便是上文中創(chuàng)建的被裝飾器裝飾的 PerpetualCache
    Cache cache = ms.getCache();
    if (cache != null) {
      // 判斷是否需要清除緩存
      flushCacheIfRequired(ms);
      if (ms.isUseCache() && resultHandler == null) {
        ensureNoOutParams(ms, boundSql);
        // 從二級緩存中取
        @SuppressWarnings("unchecked")
        List list = (List) tcm.getObject(cache, key);
        if (list == null) {
          // 沒取到二級緩存，嘗試取一級緩存或去數(shù)據(jù)庫查詢
          list = delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
          // “添加二級緩存”
          tcm.putObject(cache, key, list); // issue #578 and #116
        }
        return list;
      }
    }
    
    // 沒有二級緩存的話，執(zhí)行的是我們在一級緩存中介紹的方法，要么取一級緩存，否則去數(shù)據(jù)庫查
    return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
  }
  
  // ...
}

上述邏輯比較清晰，我們在上文中提到過，只有 事務(wù)提交的時候才會將二級緩存保存，但是其中有 tcm.putObject(cache, key, list); 邏輯，似乎在這里保存了二級緩存，而此時事務(wù)還未提交，這便需要我們一探究竟。它會執(zhí)行到 TransactionalCacheManager#putObject 方法：

public class TransactionalCacheManager {

    private final Map transactionalCaches = new HashMap();
    
    public void putObject(Cache cache, CacheKey key, Object value) {
        getTransactionalCache(cache).putObject(key, value);
    }
    
    private TransactionalCache getTransactionalCache(Cache cache) {
        return MapUtil.computeIfAbsent(transactionalCaches, cache, TransactionalCache::new);
    }
}

TransactionalCacheManager 事務(wù)緩存管理器會創(chuàng)建并管理 TransactionalCache 對象，TransactionalCache 同樣是 Cache 裝飾器，它將裝飾在 SynchronizedCache 上：

public class TransactionalCache implements Cache {

    // 被裝飾對象，默認(rèn)是 SynchronizedCache
    private final Cache delegate;
    // 該元素將保存在事務(wù) commit 時被保存的鍵值對緩存
    private final Map entriesToAddOnCommit;

    @Override
    public void putObject(Object key, Object object) {
        entriesToAddOnCommit.put(key, object);
    }
    
    // ...
}

putObject 執(zhí)行時便是向 entriesToAddOnCommit 添加元素，記錄二級緩存鍵值對，并沒有真正添加到二級緩存 PerpetualCache 對象中。此外，entriesToAddOnCommit 的命名，也暗示了在事務(wù)提交時緩存才會被保存。那么接下來，便需要看一下事務(wù)提交邏輯。

在上文測試二級緩存的代碼中，有 sqlSession1.commit(); 邏輯。在事務(wù)提交時，它會走到 CachingExecutor#commit 方法，其中會調(diào)用到 TransactionalCacheManager#commit 方法，如下：

public class CachingExecutor implements Executor {
    // ...
    
    private final TransactionalCacheManager tcm = new TransactionalCacheManager();

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

在該方法中，會遍歷所有的事務(wù)緩存 TransactionalCache，并逐一調(diào)用它們的 commit 方法，

public class TransactionalCacheManager {

    private final Map transactionalCaches = new HashMap();
    
    public void commit() {
        for (TransactionalCache txCache : transactionalCaches.values()) {
            txCache.commit();
        }
    }
    
    // ...

commit 方法會調(diào)用 delegate.commit 方法，而 delegate 為被裝飾對象，最后便會將二級緩存記錄：

public class TransactionalCache implements Cache {

    private final Map entriesToAddOnCommit;

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

    private void flushPendingEntries() {
        // 事務(wù)提交，將 entriesToAddOnCommit 中所有待添加的二級緩存添加
        for (Map.Entry entry : entriesToAddOnCommit.entrySet()) {
            delegate.putObject(entry.getKey(), entry.getValue());
        }
        for (Object entry : entriesMissedInCache) {
            if (!entriesToAddOnCommit.containsKey(entry)) {
                delegate.putObject(entry, null);
            }
        }
    }

    private void reset() {
        clearOnCommit = false;
        entriesToAddOnCommit.clear();
        entriesMissedInCache.clear();
    }
    
    // ...
}

緩存失效

事務(wù)回滾是不是會使本次事務(wù)中相關(guān)的二級緩存失效呢？

public class TransactionalCache implements Cache {

    public void rollback() {
        unlockMissedEntries();
        reset();
    }

    private void reset() {
        clearOnCommit = false;
        entriesToAddOnCommit.clear();
        entriesMissedInCache.clear();
    }

    private void unlockMissedEntries() {
        for (Object entry : entriesMissedInCache) {
            try {
                delegate.removeObject(entry);
            } catch (Exception e) {
                log.warn("Unexpected exception while notifying a rollback to the cache adapter. "
                        + "Consider upgrading your cache adapter to the latest version. Cause: " + e);
            }
        }
    }
    // ...
}

的確如此，它會將未被緩存的元素清除 reset()，也會把在本次事務(wù)中操作過的數(shù)據(jù)在二級緩存中移除 unlockMissedEntries()。

那數(shù)據(jù)發(fā)生新增、修改或刪除呢？同樣會清除緩存

public class CachingExecutor implements Executor {

    @Override
    public int update(MappedStatement ms, Object parameterObject) throws SQLException {
        flushCacheIfRequired(ms);
        return delegate.update(ms, parameterObject);
    }
    

    private void flushCacheIfRequired(MappedStatement ms) {
        Cache cache = ms.getCache();
        // 默認(rèn) flushCacheRequired 為 true
        if (cache != null && ms.isFlushCacheRequired()) {
            tcm.clear(cache);
        }
    }

它將調(diào)用 TransactionalCache#clear 方法，將待生效的 entriesToAddOnCommit 二級緩存清除，并標(biāo)記 clearOnCommit 為 true，在事務(wù)提交時，二級緩存會執(zhí)行清除緩存的 clear 方法：

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

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

緩存生效范圍

到這里，我們已經(jīng)基本弄清楚二級緩存生效的原理了，那么接下來我們需要解釋“為什么二級緩存是 Mapper 級別的？”其實也非常簡單，看如下代碼：

public class CachingExecutor implements Executor {
  
  @Override
  public  List query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
      throws SQLException {
    // 先獲取二級緩存，該對象便是上文中創(chuàng)建的被裝飾器裝飾的 PerpetualCache
    Cache cache = ms.getCache();
    // ...
  }
    // ...
}

在執(zhí)行查詢時，二級緩存 Cache 是在 MappedStatement 中獲取的，Mapper 中每個 SQL 聲明都對應(yīng)唯一的 MappedStatement，當(dāng)同一條 SQL 被執(zhí)行時，它們都會去取同樣的緩存，所以可以說它是 Mapper 級別的，說成 MappedStatement 級別更準(zhǔn)確，二級緩存支持多個 SqlSession 共享。

為什么要在事務(wù)提交后才生效？

在這里我們討論一個問題：為什么二級要在事務(wù)提交后才能生效呢？

因為二級緩存可以在不同的 SqlSession 間生效，畫個圖你就明白了：

如果 SqlSession1先修改了數(shù)據(jù)，再查詢數(shù)據(jù)，如果二級緩存在事務(wù)未提交時就生效，那么 SqlSession2 調(diào)用同樣的查詢時便會從 二級緩存中獲取數(shù)據(jù)，但是此時 SqlSession1回滾了事務(wù)，那么此時就會導(dǎo)致 SqlSession2 從二級緩存獲取的數(shù)據(jù) 變成臟數(shù)據(jù)，這就是為什么二級緩存要在事務(wù)提交后才能生效的原因。

3. 為什么要擴展二級緩存？

MyBatis 中設(shè)計一級緩存和二級緩存的目的是為了提高數(shù)據(jù)庫訪問的效率，但它們的作用范圍和使用場景有所不同，各自有其特定的用途和優(yōu)勢。

一級緩存 默認(rèn)開啟，是基于 SqlSession 的，也就是說，它的作用范圍僅限于一次數(shù)據(jù)庫會話，所以當(dāng)會話關(guān)閉后，緩存就會被清除。這意味著不同會話之間無法共享緩存數(shù)據(jù)。而 二級緩存 是基于 Mapper 級別的，需要顯式配置開啟，可以在多個 SqlSession 之間共享。當(dāng)然也由于二級緩存的作用范圍更廣，因此需要更復(fù)雜的緩存失效策略和數(shù)據(jù)一致性管理，以避免數(shù)據(jù)不一致的問題。二級緩存的引入是為了在更大范圍內(nèi)（多個會話之間）提高數(shù)據(jù)訪問的效率，特別是在讀多寫少的應(yīng)用場景。

4. 總結(jié)

二級緩存本質(zhì)上是 HashMap，在 PerpetualCache 實現(xiàn)類中

二級緩存是 Mapper 級別的，可以在不同 SqlSession 間共享

特殊的 readOnly 標(biāo)簽，默認(rèn)為 false，表示二級緩存中是被深拷貝的對象

二級緩存需要在事務(wù)提交后才能生效

執(zhí)行 Insert、Delete、Update 語句會使 當(dāng)前 Mapper 下的二級緩存失效

審核編輯 黃宇