Mybatis二级缓存

Mybatis二级缓存
如何开启二级缓存

1.在配置文件中，将cacheEnabled属性设置为true （默认true）
```
<settings>
    <setting name="cacheEnabled" value="true"/>
</settings>
```
2.声明缓存空间

2.1 在xml文件中添加标签
```
"1.0" encoding="UTF-8"?>
mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.ys.mybatis.mapper.SecondCacheMapper">
 
    <cache/>
 
    <select id="getEmployeeById" resultType="com.ys.mybatis.DO.EmployeeDO" >
        select * from employee where id = #{id}
    select>
 
mapper>
```
2.2 在java文件中添加@CacheNamespace注解
```
@CacheNamespace
public interface SecondCacheMapper {
 
    @Select("select * from employee")
    List listAllEmployee();
 
}
```
2.3 + @CacheNamespaceRef 或 + @CacheNamespace

当我们一部分sql写在java文件中，一部分sql写在xml中，并且都希望开启二级缓存，则需要用到 + @CacheNamespaceRef （或 + @CacheNamespace）的组合的形式
```
"1.0" encoding="UTF-8"?>
mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.ys.mybatis.mapper.SecondCacheMapper">
 
    <cache/>
 
    <select id="getEmployeeById" resultType="com.ys.mybatis.DO.EmployeeDO" >
        select * from employee where id = #{id}
    select>
 
mapper>
```
```
@CacheNamespaceRef(name = "com.ys.mybatis.mapper.SecondCacheMapper")
public interface SecondCacheMapper {
 
    @Select("select * from employee")
    List listAllEmployee();
 
    EmployeeDO getEmployeeById(Integer id);
 
}
```
标签属性

type : 缓存类型。默认PerpetualCache

eviction : 清除策略。默认的清除策略是 LRU
- LRU – 最近最少使用：移除最长时间不被使用的对象。
- FIFO – 先进先出：按对象进入缓存的顺序来移除它们。
- SOFT – 软引用：基于垃圾回收器状态和软引用规则移除对象。
- WEAK – 弱引用：更积极地基于垃圾收集器状态和弱引用规则移除对象。
flushInterval : 刷新间隔。属性可以被设置为任意的正整数，设置的值应该是一个以毫秒为单位的合理时间量。默认情况是不设置，也就是没有刷新间隔，缓存仅仅会在调用语句时刷新。

size : 引用数目。属性可以被设置为任意正整数，要注意欲缓存对象的大小和运行环境中可用的内存资源。默认值是 1024。

readOnly : 只读,属性可以被设置为 true 或 false。只读的缓存会给所有调用者返回缓存对象的相同实例。因此这些对象不能被修改。这就提供了可观的性能提升。而可读写的缓存会（通过序列化）返回缓存对象的拷贝。速度上会慢一些，但是更安全，因此默认值是 false。

blocking : 是否阻塞，默认false。阻塞的情况下，如果一个sqlSession获取指定cacheKey的二级缓存为null时，在其实时查询数据、填充缓存之前，如果有其他sqlSession也尝试获取该cacheKey的二级缓存，则该sqlSession将处于blocking状态，直到上一个sqlSession将缓存填充完毕

二级缓存的构建

MapperBuilderAssistant#useNewCache
```
public Cache useNewCache(Class<? extends Cache> typeClass,
                         Class<? extends Cache> evictionClass,
                         Long flushInterval,
                         Integer size,
                         boolean readWrite,
                         boolean blocking,
                         Properties props) {
    Cache cache = new CacheBuilder(currentNamespace)
            // cache默认的类型是PerpetualCache
            .implementation(valueOrDefault(typeClass, PerpetualCache.class))
            // 如果未指定装饰器,则添加一个默认的装饰器(LruCache)
            .addDecorator(valueOrDefault(evictionClass, LruCache.class))
            .clearInterval(flushInterval)
            .size(size)
            .readWrite(readWrite)
            .blocking(blocking)
            .properties(props)
            .build();
    configuration.addCache(cache);
    currentCache = cache;
    return cache;
}
```
通过源码我们证实了：默认缓存类型是PerpetualCache，默认清除策略是LRU

CacheBuilder#build
```
public Cache build() {
    // 如果未指定默认缓存类型,则设置默认实现为PerpetualCache
    // 如果未指定装饰器,则添加一个负责清除缓存的装饰器(LruCache)
    setDefaultImplementations();
    // 将namespace作为缓存的id,实例化默认缓存对象
    Cache cache = newBaseCacheInstance(implementation, id);
    // 设置属性
    setCacheProperties(cache);
    // issue #352, do not apply decorators to custom caches
    if (PerpetualCache.class.equals(cache.getClass())) {
        for (Class<? extends Cache> decorator : decorators) {
            // 循环实例化装饰器Cache,并装饰当前cache
            cache = newCacheDecoratorInstance(decorator, cache);
            setCacheProperties(cache);
        }
        // 添加系统默认的装饰器
        // ScheduledCache : 如果设置了flushInterval,则添加该装饰器
        // SerializedCache : 默认添加
        // LoggingCache : 默认添加
        // SynchronizedCache : 默认添加
        // BlockingCache : 如果设置了blocking,则添加该装饰器
        cache = setStandardDecorators(cache);
    // 如果cache的最外层的装饰器不是LoggingCache,则cache的最外层再套一个LoggingCache
    } else if (!LoggingCache.class.isAssignableFrom(cache.getClass())) {
        cache = new LoggingCache(cache);
    }
    return cache;
}
```
由上述源码，我们得出默认情况下的Cache构造，如下图

可配置的装饰器

各装饰器的作用
1. BlockingCache : 防止缓存穿透
2. SynchronizedCache : 线程同步
3. LoggingCache : 打印二级缓存命中率
4. SerializedCache : 序列化、反序列化对象
5. ScheduledCache ：定时清除缓存，默认时长1小时
6. LruCache ：清除策略
7. PerpetualCache ：存储缓存
二级缓存在mybatis中的应用

相关源码 : CachingExecutor#query

前置知识点

CacheKey的组成
- statementId
- rowBounds
- sql
- 参数
- environment
PS : cacheKey相同才有命中缓存的可能，这个cacheKey的组成存在environment，表明不同数据源，二级缓存不会命中

Cache结构

和我们上述分析一致，默认配置下的二级缓存是五级的

flushCache & useCache

XMLStatementBuilder#parseStatementNode
- useCache : select默认true，insert、update、delete默认false
- flushCache : select默认false，insert、update、delete默认true
TransactionalCacheManager

TransactionalCache管理器。其getObject()、putObject()、clear()方法都会调用getTransactionalCache方法将原始的cache再套一个装饰器（TransactionalCache），然后再进行管理

TransactionalCache

开启二级缓存后，并不是所有的查询结果立刻放入二级缓存，而是将其放入暂存区，等执行commit方法后，才会将暂存区的数据put到二级缓存中。TransactionalCache结构如下：
```
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;
  private final Set<Object> entriesMissedInCache;
 
}
```
- clearOnCommit ：提交前，是否清除当前命名空间所有二级缓存
- entriesToAddOnCommit ：暂存区数据
分析CachingExecutor的query方法

关注点 1 : flushCacheIfRequired方法
```
private void flushCacheIfRequired(MappedStatement ms) {
    Cache cache = ms.getCache();
    if (cache != null && ms.isFlushCacheRequired()) {
        tcm.clear(cache);
    }
}
 
public void clear(Cache cache) {
    getTransactionalCache(cache).clear();
}
 
private TransactionalCache getTransactionalCache(Cache cache) {
    return transactionalCaches.computeIfAbsent(cache, TransactionalCache::new);
}
 
@Override
public void clear() {
    clearOnCommit = true;
    entriesToAddOnCommit.clear();
}
```
通过上述的方法调用，我们可以得出以下两点 :
1. 只有手动设置flushCache为true的增删改查，或者默认情况下的增删改，才会执行TransactionalCacheManager的clear方法
2. TransactionalCacheManager的clear方法，会将当前cache再套一层装饰器（TransactionalCache），然后将属性clearOnCommit设置为true，并清空暂存区的数据
关注点 2 : if成立的条件

只有useCache为true的查询，才能可能使用到二级缓存，并且增删改不可以设置其值为true。

关注点 3 : getObject方法
```
public Object getObject(Cache cache, CacheKey key) {
    return getTransactionalCache(cache).getObject(key);
}
 
private TransactionalCache getTransactionalCache(Cache cache) {
    return transactionalCaches.computeIfAbsent(cache, TransactionalCache::new);
}
 
@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;
    }
}
```
cache的getObject()方法也会将原本的cache再套一层装饰器（TransactionalCache），如果之前执行过 flushCacheIfRequired 方法（该方法会将 clearOnCommit 设置为true）则会返回 null，即使命中二级缓存（防止脏数据）

获取二级缓存的条件

根据我们对CachingExecutor的query方法进行分析，我们总结一下可以命中二级缓存的条件 :
1. 全局缓存设置cacheEnabled为true（默认为true）
2. 指定命名空间中存在标签或者@CacheNamespace注解
3. MappedStatement的flushCache属性为false （如果属性为true，则会执行flushCacheIfRequired方法，该方法会将clearOnCommit属性设置为true，执行getObject方法将会一直返回null）
4. MappedStatement的useCache属性为true （只有

如何开启二级缓存

1.在配置文件中，将cacheEnabled属性设置为true （默认true）

2.声明缓存空间

2.1 在xml文件中添加标签

2.2 在java文件中添加@CacheNamespace注解

2.3 + @CacheNamespaceRef 或 + @CacheNamespace

标签属性

二级缓存的构建

二级缓存在mybatis中的应用

前置知识点

CacheKey的组成

Cache结构

flushCache & useCache

TransactionalCacheManager

TransactionalCache

分析CachingExecutor的query方法

关注点 1 : flushCacheIfRequired方法

关注点 2 : if成立的条件

关注点 3 : getObject方法

获取二级缓存的条件