MyBatis 的一、二级缓存的区别及源码分析

介绍

该笔记是在学习拉勾教育 Java 高薪训练营后，结合课程和老师的视频，自己跟踪源码后做的笔记。

一级、二级缓存区别

• 存储结构， 一级缓存是存在内存 Map 中。二级缓存存储介质多样，可在内存、硬盘中，需要进行序列化和反序列化；
• 范围， 一级缓存是 sqlSession 级别的缓存，二级缓存是跨 SqlSession 的；
• 失效场景， 一级、二级缓存都是在执行插入、更新、删除时会失效，需要重新从数据库获取，避免脏读。另外一级缓存不能用于分布式场景，二级缓存需要使用 redis 来实现；

一级缓存

在开启一次数据库会话中，如果执行多次相同的查询 SQL，MyBatis 在第二次执行时会将从缓存中直接获取返回结果，而不再去数据库中查询。
　　在 openSession 中通过 configuration.newExecutor(tx, execType) 创建 Executor 对象。每个 SqlSession 都会创建一个 Executor，每个 Executor 都有一个一级缓存 LocalCache。

// 开启会话
SqlSession sqlSession = sqlSessionFactory.openSession()

Executor

Executor 接口的默认抽象实现类为 BaseExecutor，实现 Executor 接口的大部分功能。使用了模板方法设计模式，封装了一次操作的整个流程。

BaseExecutor#query

当用户发起查询时，根据执行的语句生成 MappedStatement，到一级缓存 localCache 中获取，缓存命名就直接返回结果给用户，没命中就查询数据库，将结果写入 localCache，最后返回结果给用户。

　　在如下代码中，localCache 为一个 HashMap，在构造函数 BaseExecutor 中会进行创建，对一级缓存的操作就是对 HashMap 的操作。如下为模板方法的查询流程，除了 doQuery 方法由子类实现，其余流程都由 BaseExecutor 实现封装。

• 先从一级缓存 localCache 获取，获取到则直接返回；
• queryFromDatabase()，获取不到时，会调用该方法从数据库中查询；
• queryFromDatabase#doQuery()，由继承的子类实现该抽象方法，进行数据库查询操作；
• localCache.putObject()，将数据库返回的结果存储到一级缓存中 localCache。

补充说明，这个 key 是一级缓存 HashMap 的 key，由 MappedStatement 的 Id、SQL 的 offset、SQL 的 limit、SQL 本身以及 SQL 中的参数 Params 构成的。

换句话说，判断是否为相同的 SQL 由这五个决定 Statement Id + Offset + Limmit + Sql + Params。

    protected PerpetualCache localCache;

    @SuppressWarnings("unchecked")
    @Override
    public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
        // ...
        try {
            // queryStack + 1
            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);
            }
        }
        // ...
    }
    
    // 从数据库中读取操作
    private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
        // ...
        try {
            // 执行读操作
            list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
        } finally {
            // 从缓存中，移除占位对象
            localCache.removeObject(key);
        }
        // 添加到缓存中
        localCache.putObject(key, list);
        // ...
        return list;
    }

update

同上，更新的整个流程是先清空一级缓存，在调用子类实现的 doUpdate 方法。

    @Override
    public int update(MappedStatement ms, Object parameter) throws SQLException {
        // ...
        // 清空本地缓存
        clearLocalCache();
        // 执行写操作
        return doUpdate(ms, parameter);
    }
    
    protected abstract int doUpdate(MappedStatement ms, Object parameter)
            throws SQLException;

总结

• MyBatis 一级缓存的生命周期和 SqlSession 一致；
• MyBatis 一级缓存内部设计简单，只是一个没有容量限定的 HashMap，在缓存的功能性上有所欠缺；
• MyBatis 的一级缓存最大范围是 SqlSession 内部，有多个 SqlSession 或者分布式的环境下，数据库写操作会引起脏数据，建议设定缓存级别为 Statement。

二级缓存

当多个 SqlSession 之间需要共享缓存时，就要使用二级缓存 CachingExecutor。进入一级缓存的查询流程前，先在 CachingExecutor 进行二级缓存的查询。数据查询流程为二级缓存 -> 一级缓存 -> 数据库。
　　二级缓存的范围比一级缓存大，一级缓存局限在 SqlSession，二级缓存是在同一个 namespace 下的所有操作语句，即二级缓存被多个 SqlSession 共享，是一个全局变量。

二级缓存为 CachingExecutor，它会初始化创建一个 TransactionalCacheManager 对象，包含一个 HashMap。在构造函数中会传入一级缓存的执行器，这三个 BatchExecutor、ReuseExecutor、SimpleExecutor 中的一个。

    private final TransactionalCacheManager tcm = new TransactionalCacheManager();

    public CachingExecutor(Executor delegate) {
        this.delegate = delegate;
        // 设置 delegate 被当前执行器所包装
        delegate.setExecutorWrapper(this);
    }

query

• tcm.getObject()，先从二级缓存中获取结果；
• delegate.query()，结果为空时，在使用一级缓存执行器进入一级的执行流程。一级缓存有结果则返回，没则到数据库中获取；
• tcm.putObject()，将结果存到二级缓存中。

    @Override
    public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
            throws SQLException {
        Cache cache = ms.getCache();
        if (cache != null) {
            // 如果需要清空缓存，则进行清空
            flushCacheIfRequired(ms);
            if (ms.isUseCache() && resultHandler == null) {
                // 暂时忽略，存储过程相关
                ensureNoOutParams(ms, boundSql);
                @SuppressWarnings("unchecked")
                // 从二级缓存中，获取结果
                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); // issue #578 and #116
                }
                // 如果存在，则直接返回结果
                return list;
            }
        }
        // 不使用缓存，则从数据库中查询
        return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
    }

总结

• MyBatis 的二级缓存相对于一级缓存来说，实现了 SqlSession 之间缓存数据的共享，同时粒度更加的细，能够到 namespace 级别，通过 Cache 接口实现类不同的组合，对 Cache 的可控性也更强；
• MyBatis 在多表查询时，极大可能会出现脏数据，有设计上的缺陷，安全使用二级缓存的条件比较苛刻；
• 在分布式环境下，由于默认的 MyBatis Cache 实现都是基于本地的，分布式环境下必然会出现读取到脏数据，需要使用集中式缓存将 MyBatis 的 Cache 接口实现，有一定的开发成本，直接使用 Redis、Memcached 等分布式缓存可能成本更低，安全性也更高。

reference

• 聊聊 MyBatis 缓存机制