Mybatis缓存原理

一级缓存

一级缓存是SqlSession级别的缓存，每个HTTP请求都会创建一个新的SqlSession即DefaultSqlSession，默认开启，可通过localCacheScope=STATEMENT关闭一级缓存，参数不一致会导致缓存失效，在查询过程中发生了数据的修改也会导致缓存失效。

public abstract class BaseExecutor implements Executor {
    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) { // 已经关闭，则抛出 ExecutorException 异常
            throw new ExecutorException("Executor was closed.");
        }
        if (queryStack == 0 && ms.isFlushCacheRequired()) {
            clearLocalCache(); // 清空本地缓存，若queryStack为零，并要求清空本地缓存
        }
        List<E> list;
        try {
            queryStack++;
            list = resultHandler == null ? (List<E>) localCache.getObject(key) : null; // 从一级缓存中，获取查询结果
            if (list != null) { // 获取到，则进行处理
                handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
            } else {// 获得不到，则从数据库中查询
                list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
            }
        } finally {
            queryStack--;
        }
        if (queryStack == 0) {
            for (DeferredLoad deferredLoad : deferredLoads) {
                deferredLoad.load();
            }
            deferredLoads.clear();
            if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
                clearLocalCache();
            }
        }
        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提供二级缓存的接口及实现，缓存实现时必需实体类实现Serializable接口，二级缓存在sqlSession关闭或提交之后才会生效。二级缓存使用是通过全局配置文件中的cacheEnabled，cacheEnabled默认为true，且需要在Mapper.xml映射文件中出使用cache标签标注，实体类必须要实现Serializable接口：

<setting name="cacheEnabled" value="true"/>

或者使用@CacheNamespace与@Select或@SelectProvider注解配合使用

@CacheNamespace
public interface UserMapper {
    @Select(value = "select * from t_user")
    List<User> selectAllUser();
}

解析

二级缓存在结构设计上采用装饰器+责任链模式。从最内层到最外层依次是PerpetualCache、LruCache、SerializedCache、LoggingCache、SynchronizedCache。

private void cacheElement(XNode context) {
    if (context != null) {
        String type = context.getStringAttribute("type", "PERPETUAL");// 解析cache节点的type属性
        Class<? extends Cache> typeClass = typeAliasRegistry.resolveAlias(type);// 根据type的String获取class类型
        String eviction = context.getStringAttribute("eviction", "LRU"); // 获取缓存过期策略:默认是LRU
        Class<? extends Cache> evictionClass = typeAliasRegistry.resolveAlias(eviction);
        // flushInterval刷新间隔，可被设置为任意正整数，设置的值应该是一个以毫秒为单位的合理时间量。默认不设置即没有刷新间隔，缓存仅在调用语句时刷新
        Long flushInterval = context.getLongAttribute("flushInterval");
        // size引用数目，可被设置为任意正整数，要注意缓存对象的大小和运行环境中可用的内存资源。默认值是1024
        Integer size = context.getIntAttribute("size");
        // readOnly只读，可被设置为true或false。只读的缓存会给所有调用者返回缓存对象的相同实例。因此这些对象不能被修改。
        // 而可读写的缓存会通过序列化返回缓存对象的拷贝，速度上会慢一些，但更安全默认值false
        boolean readWrite = !context.getBooleanAttribute("readOnly", false);
        boolean blocking = context.getBooleanAttribute("blocking", false);
        Properties props = context.getChildrenAsProperties();
        // 把缓存节点加入到Configuration中
        builderAssistant.useNewCache(typeClass, evictionClass, flushInterval, size, readWrite, blocking, props);
    }
}
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)
        .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;
}
public Cache build() {
    setDefaultImplementations();
    Cache cache = newBaseCacheInstance(implementation, id);
    setCacheProperties(cache);
    if (PerpetualCache.class.equals(cache.getClass())) {
        for (Class<? extends Cache> decorator : decorators) { // 通过LruCache对PerpetualCache进行装饰
            cache = newCacheDecoratorInstance(decorator, cache);
            setCacheProperties(cache);
        }
        cache = setStandardDecorators(cache); // 剩余集中Cache对LruCache依次装饰
    } 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：调度缓存，负责定时清空缓存
            ((ScheduledCache) cache).setClearInterval(clearInterval);
        }
        if (readWrite) {  // 将LRU 装饰到Serialized
            cache = new SerializedCache(cache); //SerializedCache：缓存序列化和反序列化存储
        }
        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);
    }
}

SynchronizedCache线程同步缓存区实现了线程同步功能，与序列化缓存区共同保证二级缓存线程安全。若blocking=false关闭则SynchronizedCache位于责任链的最前端，否则就位于BlockingCache后面而BlockingCache位于责任链的最前端，从而保证了整条责任链是线程同步的。

public class SynchronizedCache implements Cache {
    private final Cache delegate;
    public SynchronizedCache(Cache delegate) {
        this.delegate = delegate;
    }
    @Override
    public synchronized int getSize() {
        return delegate.getSize();
    }
    @Override
    public synchronized void putObject(Object key, Object object) {
        delegate.putObject(key, object);
    }
    @Override
    public synchronized Object getObject(Object key) {
        return delegate.getObject(key);
    }
    @Override
    public synchronized Object removeObject(Object key) {
        return delegate.removeObject(key);
    }
    @Override
    public synchronized void clear() {
        delegate.clear();
    }
}

LoggingCache统计命中率以及打印日志，若日志中出现了Cache Hit Ratio便表示命中了二级缓存

public class LoggingCache implements Cache {
    private final Log log;
    private final Cache delegate;
    protected int requests = 0;
    protected int hits = 0;
    public LoggingCache(Cache delegate) {
        this.delegate = delegate;
        this.log = LogFactory.getLog(getId());
    }
    @Override
    public int getSize() {
        return delegate.getSize();
    }
    @Override
    public void putObject(Object key, Object object) {
        delegate.putObject(key, object);
    }
    @Override
    public Object getObject(Object key) {
        requests++;
        final Object value = delegate.getObject(key);
        if (value != null) {
            hits++;
        }
        if (log.isDebugEnabled()) {
            log.debug("Cache Hit Ratio [" + getId() + "]: " + getHitRatio());
        }
        return value;
    }
    @Override
    public Object removeObject(Object key) {
        return delegate.removeObject(key);
    }
    @Override
    public void clear() {
        delegate.clear();
    }
    private double getHitRatio() {
        return (double) hits / (double) requests;
    }
}

ScheduledCache过期清理缓存区，@CacheNamespace(flushInterval=100L)设置过期清理时间默认1个小时，若设置flushInterval为0代表永远不清除，操作缓存时都会进行检查缓存是否过期。

public class ScheduledCache implements Cache {
    private final Cache delegate;
    protected long clearInterval;
    protected long lastClear;
    public ScheduledCache(Cache delegate) {
        this.delegate = delegate;
        this.clearInterval = 60 * 60 * 1000; // 1 hour
        this.lastClear = System.currentTimeMillis();
    }
    public void setClearInterval(long clearInterval) {
        this.clearInterval = clearInterval;
    }
    @Override
    public int getSize() {
        clearWhenStale();
        return delegate.getSize();
    }
    @Override
    public void putObject(Object key, Object object) {
        clearWhenStale();
        delegate.putObject(key, object);
    }
    @Override
    public Object getObject(Object key) {
        return clearWhenStale() ? null : delegate.getObject(key);
    }
    @Override
    public Object removeObject(Object key) {
        clearWhenStale();
        return delegate.removeObject(key);
    }
    @Override
    public void clear() {
        lastClear = System.currentTimeMillis();
        delegate.clear();
    }
    private boolean clearWhenStale() {
        if (System.currentTimeMillis() - lastClear > clearInterval) {
            clear();
            return true;
        }
        return false;
    }
}

LruCache防溢出缓冲区，内部使用链表实现最近最少使用防溢出机制

public class LoggingCache implements Cache {
    private final Log log;
    private final Cache delegate;
    protected int requests = 0;
    protected int hits = 0;
    public LoggingCache(Cache delegate) {
        this.delegate = delegate;
        this.log = LogFactory.getLog(getId());
    }
    @Override
    public int getSize() {
        return delegate.getSize();
    }
    @Override
    public void putObject(Object key, Object object) {
        delegate.putObject(key, object);
    }
    @Override
    public Object getObject(Object key) {
        requests++;
        final Object value = delegate.getObject(key);
        if (value != null) {
            hits++;
        }
        if (log.isDebugEnabled()) {
            log.debug("Cache Hit Ratio [" + getId() + "]: " + getHitRatio());
        }
        return value;
    }
    @Override
    public Object removeObject(Object key) {
        return delegate.removeObject(key);
    }
    @Override
    public void clear() {
        delegate.clear();
    }
    private double getHitRatio() {
        return (double) hits / (double) requests;
    }
}

SerializedCache序列化缓存实现类

public class SerializedCache implements Cache {
    private final Cache delegate;
    public SerializedCache(Cache delegate) {
        this.delegate = delegate;
    }
    @Override
    public int getSize() {
        return delegate.getSize();
    }
    @Override
    public void putObject(Object key, Object object) {
        if (object == null || object instanceof Serializable) {
            delegate.putObject(key, serialize((Serializable) object));
        } else {
            throw new CacheException("SharedCache failed to make a copy of a non-serializable object: " + object);
        }
    }
    @Override
    public Object getObject(Object key) {
        Object object = delegate.getObject(key);
        return object == null ? null : deserialize((byte[]) object);
    }
    @Override
    public Object removeObject(Object key) {
        return delegate.removeObject(key);
    }
    @Override
    public void clear() {
        delegate.clear();
    }
    private byte[] serialize(Serializable value) {
        try (ByteArrayOutputStream bos = new ByteArrayOutputStream();
             ObjectOutputStream oos = new ObjectOutputStream(bos)) {
            oos.writeObject(value);
            oos.flush();
            return bos.toByteArray();
        } catch (Exception e) {
            throw new CacheException("Error serializing object.  Cause: " + e, e);
        }
    }
    private Serializable deserialize(byte[] value) {
        Serializable result;
        try (ByteArrayInputStream bis = new ByteArrayInputStream(value);
             ObjectInputStream ois = new CustomObjectInputStream(bis)) {
            result = (Serializable) ois.readObject();
        } catch (Exception e) {
            throw new CacheException("Error deserializing object.  Cause: " + e, e);
        }
        return result;
    }
    public static class CustomObjectInputStream extends ObjectInputStream {
        public CustomObjectInputStream(InputStream in) throws IOException {
            super(in);
        }
        @Override
        protected Class<?> resolveClass(ObjectStreamClass desc) throws ClassNotFoundException {
            return Resources.classForName(desc.getName());
        }
    }
}

PerpetualCache缓存默认实现类

public class PerpetualCache implements Cache {
  private final String id;
  private Map<Object, Object> cache = new HashMap<>();
  public PerpetualCache(String id) {
    this.id = id;
  }
  @Override
  public int getSize() {
    return cache.size();
  }
  @Override
  public void putObject(Object key, Object value) {
    cache.put(key, value);
  }
  @Override
  public Object getObject(Object key) {
    return cache.get(key);
  }
  @Override
  public Object removeObject(Object key) {
    return cache.remove(key);
  }
  @Override
  public void clear() {
    cache.clear();
  }
}

查询缓存

二级缓存使用命中条件：会话提交后，SQL语句和参数相同，相关的statementId，RowBounds相同，且设置为自动提交事务并不会命中二级缓存。同一命名空间进行了增删改操作会导致二级缓存失效，在查询的select标签上设置useCache=false不缓存数据到二级缓存中。

对于flushCache参数，当update、insert、delete标签设置该参数为false时，做数据更改不会导致缓存失效，该标签在select标签上与增删改标签语义相反。

由于二级索引是对同一命名空间生效，对于类似联合查询表，若更新了其他几个表，会导致缓存不能及时更新，可使用cache-ref来指定引用mapper映射文件的缓存机制，但cache-ref只能指定一个命名空间。

若会话一与会话二是两条隔离的事务，但由于二级缓存的存在导致彼此可能发生脏读。若会话二的修改直接填充到二级缓存，会话一查询时缓存中存在即直接返回数据，此时会话二回滚会话一读到的数据就是脏数据。为了解决这一问题Mybatis二级缓存机制就引入了事务管理器暂存区，所有变动的数据都会暂时存放到事务管理器的暂存区中，只有执行提交动作后才会真正的将数据从暂存区中填充到二级缓存中。

public class CachingExecutor implements Executor {
    public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
        Cache cache = ms.getCache(); // 判断mapper中是否开启了二级缓存<cache></cache>
        if (cache != null) { // 判断是否配置了cache
            flushCacheIfRequired(ms); // 判断是否需要刷新缓存
            if (ms.isUseCache() && resultHandler == null) {
                ensureNoOutParams(ms, boundSql);
                List<E> list = (List<E>) tcm.getObject(cache, key); // 先去二级缓存中获取
                if (list == null) { // 二级缓存中没有获取到，通过查询数据库去查询
                    list = delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
                    tcm.putObject(cache, key, list); // 加入到二级缓存中
                }
                return list;
            }
        }
        return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql); // 没有整合二级缓存，直接去查询
    }
    private void flushCacheIfRequired(MappedStatement ms) {
        Cache cache = ms.getCache();
        if (cache != null && ms.isFlushCacheRequired()) {
            tcm.clear(cache);
        }
    }
    public int update(MappedStatement ms, Object parameterObject) throws SQLException {
        flushCacheIfRequired(ms);
        return delegate.update(ms, parameterObject);
    }
}

整合第三方缓存

整合Redis，首先添加依赖，然后将全局配置文件中cache标签中type属性设置为org.mybatis.caches.redis.RedisCache

<dependency>
    <groupId>org.mybatis.caches</groupId>
    <artifactId>mybatis-redis</artifactId>
    <version>1.0.0-beta2</version>
</dependency>

整合ehcache，将全局配置文件中cache标签中type属性设置为org.mybatis.caches.ehcache.EhcacheCache

<dependency>
    <groupId>org.ehcache</groupId>
    <artifactId>ehcache</artifactId>
    <version>3.8.1</version>
</dependency>
<dependency>
    <groupId>org.mybatis.caches</groupId>
    <artifactId>mybatis-ehcache</artifactId>
    <version>1.2.0</version>
</dependency>