Mybatis之缓存原理

拼搏现实的明天。 2023-01-06 01:56 147阅读 0赞

# MyBatis缓存 #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MzEzNjM1_size_16_color_FFFFFF_t_70][]

MyBatis中的缓存相关类都在cache包下面，而且定义了一个顶级接口Cache，默认只有一个实现类PerpetualCache，PerpetualCache中是内部维护了一个HashMap来实现缓存。

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

在MyBatis中存在两种缓存，即一级缓存和二级缓存。

## 一级缓存 ##

一级缓存也叫本地缓存，在MyBatis中，一级缓存是在会话(SqlSession)层面实现的，这就说明一级缓存作用范围只能在同一个SqlSession中，跨SqlSession是无效的。

MyBatis中一级缓存是默认开启的，不需要任何配置。我们先来看一个例子验证一下一级缓存是不是真的存在，作用范围又是不是真的只是对同一个SqlSession有效。

### 一级缓存真的存在吗 ###

package com.lonelyWolf.mybatis;
    
    import com.lonelyWolf.mybatis.mapper.UserAddressMapper;
    import com.lonelyWolf.mybatis.mapper.UserMapper;
    import com.lonelyWolf.mybatis.model.LwUser;
    import org.apache.ibatis.io.Resources;
    import org.apache.ibatis.session.SqlSession;
    import org.apache.ibatis.session.SqlSessionFactory;
    import org.apache.ibatis.session.SqlSessionFactoryBuilder;
    
    import java.io.IOException;
    import java.io.InputStream;
    import java.util.List;
    
    public class TestMyBatisCache {
        public static void main(String[] args) throws IOException {
            String resource = "mybatis-config.xml";
            //读取mybatis-config配置文件
            InputStream inputStream = Resources.getResourceAsStream(resource);
            //创建SqlSessionFactory对象
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
            //创建SqlSession对象
            SqlSession session = sqlSessionFactory.openSession();
    
            UserMapper userMapper = session.getMapper(UserMapper.class);
            List<LwUser> userList =  userMapper.selectUserAndJob();
            List<LwUser> userList2 =  userMapper.selectUserAndJob();
        }
    }

执行后，输出结果如下：

![f8ccf28c1237be7b4c33a28f3a46a922.png][]

我们可以看到，sql语句只打印了一次，这就说明第2次用到了缓存，这也足以证明一级缓存确实是存在的而且默认就是是开启的。

### 一级缓存作用范围 ###

现在我们再来验证一下一级缓存是否真的只对同一个SqlSession有效，我们对上面的示例代码进行如下改变：

SqlSession session1 = sqlSessionFactory.openSession();
     SqlSession session2 = sqlSessionFactory.openSession();
    
     UserMapper userMapper1 = session1.getMapper(UserMapper.class);
     UserMapper userMapper2 = session2.getMapper(UserMapper.class);
     List<LwUser> userList =  userMapper1.selectUserAndJob();
     List<LwUser> userList2 =  userMapper2.selectUserAndJob();

这时候再次运行，输出结果如下：

![1534e3864c391d2befc1d38170c0366d.png][]

可以看到，打印了2次，没有用到缓存，也就是不同SqlSession中不能共享一级缓存。

### 一级缓存原理分析 ###

首先让我们来想一想，既然一级缓存的作用域只对同一个SqlSession有效，那么一级缓存应该存储在哪里比较合适是呢？

是的，自然是存储在SqlSession内是最合适的，那我们来看看SqlSession的唯一实现类DefaultSqlSession：

public class DefaultSqlSession implements SqlSession {
    
      private Configuration configuration;
      private Executor executor;
    
      private boolean autoCommit;
      private boolean dirty;
      private List<Cursor<?>> cursorList;

DefaultSqlSession中只有5个成员属性，后面3个不用说，肯定不可能用来存储缓存，然后Configuration又是一个全局的配置文件，也不合适存储一级缓存，这么看来就只有Executor比较合适了，因为我们知道，SqlSession只提供对外接口，实际执行sql的就是Executor。

既然这样，那我们就进去看看Executor的实现类BaseExecutor：

public abstract class BaseExecutor implements Executor {
    
      private static final Log log = LogFactory.getLog(BaseExecutor.class);
    
      protected Transaction transaction;
      protected Executor wrapper;
    
      protected ConcurrentLinkedQueue<DeferredLoad> deferredLoads;
      protected PerpetualCache localCache;//一级缓存
      protected PerpetualCache localOutputParameterCache;
      protected Configuration configuration;

看到果然有一个localCache。而上面我们有提到PerpetualCache内缓存是用一个HashMap来存储缓存的，那么接下来大家肯定就有以下问题：

*  缓存是什么时候创建的？
 *  缓存的key是怎么定义的？
 *  缓存在何时使用
 *  缓存在什么时候会失效?

接下来就让我们逐一分析

1、一级缓存CacheKey的构成

既然缓存那么肯定是针对的查询语句，一级缓存的创建就是在BaseExecutor中的query方法内创建的：

@Override
      public <E> List<E> 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);
     }

createCacheKey这个方法的代码就不贴了，在这里我总结了一下CacheKey的组成，CacheKey主要是由以下6部分组成

*  1、将Statement中的id添加到CacheKey对象中的updateList属性
 *  2、将offset(分页偏移量)添加到CacheKey对象中的updateList属性(如果没有分页则默认0)
 *  3、将limit(每页显示的条数)添加到CacheKey对象中的updateList属性(如果没有分页则默认Integer.MAX\_VALUE)
 *  4、将sql语句(包括占位符?)添加到CacheKey对象中的updateList属性
 *  5、循环用户传入的参数，并将每个参数添加到CacheKey对象中的updateList属性
 *  6、如果有配置Environment，则将Environment中的id添加到CacheKey对象中的updateList属性

2、一级缓存的使用

创建完CacheKey之后，我们继续进入query方法：

@SuppressWarnings("unchecked")
      @Override
      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) {
          throw new ExecutorException("Executor was closed.");
        }
        if (queryStack == 0 && ms.isFlushCacheRequired()) {
          clearLocalCache();
        }
        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();
          }
          // issue #601
          deferredLoads.clear();
          if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
            // issue #482
            clearLocalCache();
          }
        }
        return list;
      }

可以看到，在查询之前就会去localCache中根据CacheKey对象来获取缓存，获取不到才会调用后面的queryFromDatabase方法

3、一级缓存的创建

queryFromDatabase方法中会将查询得到的结果存储到localCache中

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;
      }

4、一级缓存什么时候会被清除

一级缓存的清除主要有以下两个地方：

*  1、就是获取缓存之前会先进行判断用户是否配置了flushCache=true属性（参考一级缓存的创建代码截图），如果配置了则会清除一级缓存。
 *  2、MyBatis全局配置属性localCacheScope配置为Statement时，那么完成一次查询就会清除缓存。
 *  3、在执行commit，rollback，update方法时会清空一级缓存。

PS：利用插件我们也可以自己去将缓存清除，后面我们会介绍插件相关知识。

## 二级缓存 ##

一级缓存因为只能在同一个SqlSession中共享，所以会存在一个问题，在分布式或者多线程的环境下，不同会话之间对于相同的数据可能会产生不同的结果，因为跨会话修改了数据是不能互相感知的，所以就有可能存在脏数据的问题，正因为一级缓存存在这种不足，所以我们需要一种作用域更大的缓存，这就是二级缓存。

### 二级缓存的作用范围 ###

一级缓存作用域是SqlSession级别，所以它存储的SqlSession中的BaseExecutor之中，但是二级缓存目的就是要实现作用范围更广，那肯定是要实现跨会话共享的，在MyBatis中二级缓存的作用域是namespace，也就是作用范围是同一个命名空间，所以很显然二级缓存是需要存储在SqlSession之外的，那么二级缓存应该存储在哪里合适呢？

在MyBatis中为了实现二级缓存，专门用了一个装饰器来维护，这就是我们上一篇文章介绍Executor时还留下的没有介绍的一个对象：CachingExecutor。

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

二级缓存相关的配置有三个地方：1、mybatis-config中有一个全局配置属性，这个不配置也行，因为默认就是true。

想详细了解mybatis-config的可以点击这里。2、在Mapper映射文件内需要配置缓存标签：

想详细了解Mapper映射的所有标签属性配置可以点击这里。3、在select查询语句标签上配置useCache属性，如下：

<select id="selectUserAndJob" resultMap="JobResultMap2" useCache="true">
            select * from lw_user
    </select>

以上配置第1点是默认开启的，也就是说我们只要配置第2点就可以打开二级缓存了，而第3点是当我们需要针对某一条语句来配置二级缓存时候则可以使用。

不过开启二级缓存的时候有两点需要注意：1、需要commit事务之后才会生效 2、如果使用的是默认缓存，那么结果集对象需要实现序列化接口(Serializable)

如果不实现序列化接口则会报如下错误：

![34b15c5c6a4da1f29eb2738c4ad1f6c7.png][]

接下来我们通过一个例子来验证一下二级缓存的存在，还是用上面一级缓存的例子进行如下改造：

SqlSession session1 = sqlSessionFactory.openSession();
    UserMapper userMapper1 = session1.getMapper(UserMapper.class);
    List<LwUser> userList =  userMapper1.selectUserAndJob();
    session1.commit();//注意这里需要commit,否则缓存不会生效
    
    SqlSession session2 = sqlSessionFactory.openSession();
    UserMapper userMapper2 = session2.getMapper(UserMapper.class);
    List<LwUser> userList2 =  userMapper2.selectUserAndJob();

然后UserMapper.xml映射文件中，新增如下配置：

运行代码，输出如下结果:

![2dfb8e5a1a70bb6d364aef60c8051aca.png][]

上面输出结果中只输出了一次sql，说明用到了缓存，而因为我们是跨会话的，所以肯定就是二级缓存生效了。

### 二级缓存原理分析 ###

上面我们提到二级缓存是通过CachingExecutor对象来实现的，那么就让我们先来看看这个对象：

public class CachingExecutor implements Executor {
    
      private Executor delegate;
      private TransactionalCacheManager tcm = new TransactionalCacheManager();

我们看到CachingExecutor中只有2个属性，第1个属性不用说了，因为CachingExecutor本身就是Executor的包装器，所以属性TransactionalCacheManager肯定就是用来管理二级缓存的，我们再进去看看TransactionalCacheManager对象是如何管理缓存的：

private Map<Cache, TransactionalCache> transactionalCaches = new HashMap<Cache, TransactionalCache>();

TransactionalCacheManager内部非常简单，也是维护了一个HashMap来存储缓存。HashMap中的value是一个TransactionalCache对象，继承了Cache。

public class TransactionalCache implements Cache {
    
      private static final Log log = LogFactory.getLog(TransactionalCache.class);
    
      private Cache delegate;//二级缓存对象
      private boolean clearOnCommit;//true表示提交事务的时候就清楚缓存
      private Map<Object, Object> entriesToAddOnCommit;//这里记录了临时缓存，当commit的时候，将其加入到二级缓存中
      private Set<Object> entriesMissedInCache;//记录未命中缓存的key值

注意上面有一个属性是临时存储二级缓存的，为什么要有这个属性，我们下面会解释。

1、二级缓存的创建和使用

我们在读取mybatis-config全局配置文件的时候会根据我们配置的Executor类型来创建对应的三种Executor中的一种，然后如果我们开启了二级缓存之后，只要开启(全局配置文件中配置为true)就会使用CachingExecutor来对我们的三种基本Executor进行包装，即使Mapper.xml映射文件没有开启也会进行包装。

接下来我们看看CachingExecutor中的query方法：

@Override
      public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
        BoundSql boundSql = ms.getBoundSql(parameterObject);
        CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);
        return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
      }

query方法

@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, parameterObject, boundSql);
            @SuppressWarnings("unchecked")
            List<E> list = (List<E>) tcm.getObject(cache, key);
            if (list == null) {
              list = delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
              tcm.putObject(cache, key, list); // issue #578 and #116
            }
            return list;
          }
        }
        return delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
      }

上面方法大致经过如下流程：

*  1、创建一级缓存的CacheKey
 *  2、获取二级缓存
 *  3、如果没有获取到二级缓存则执行被包装的Executor对象中的query方法，此时会走一级缓存中的流程。
 *  4、查询到结果之后将结果进行缓存。

需要注意的是在事务提交之前，并不会真正存储到二级缓存，而是先存储到一个临时属性，等事务提交之后才会真正存储到二级缓存。这么做的目的就是防止脏读。因为假如你在一个事务中修改了数据，然后去查询，这时候直接缓存了，那么假如事务回滚了呢？所以这里会先临时存储一下。所以我们看一下commit方法：

@Override
      public void commit(boolean required) throws SQLException {
        delegate.commit(required);
        tcm.commit();//这里存储的临时缓存的值，真正提交到二级缓存中
      }

### 二级缓存如何进行包装 ###

最开始我们提到了一些缓存的包装类，这些都到底有什么用呢？在回答这个问题之前，我们先断点一下看看获取到的二级缓存长啥样：

![4413146136653ada1004f9c17dbc73f7.png][]

从上面可以看到，经过了层层包装，从内到外一次经过如下包装：

*  1、PerpetualCache：第一层缓存，这个是缓存的唯一实现类，肯定需要。
 *  2、LruCache：二级缓存淘汰机制之一。因为我们配置的默认机制，而默认就是LRU算法淘汰机制。淘汰机制总共有4中，我们可以自己进行手动配置。
 *  3、SerializedCache：序列化缓存。这就是为什么开启了默认二级缓存我们的结果集对象需要实现序列化接口。
 *  4、LoggingCache：日志缓存。
 *  5、SynchronizedCache：同步缓存机制。这个是为了保证多线程机制下的线程安全性。

下面就是MyBatis中所有缓存的包装汇总：

![819c7fec8b6dc2a85dd128b4e01d85c4.png][]

## 二级缓存应该开启吗 ##

既然一级缓存默认是开启的，而二级缓存是需要我们手动开启的，那么我们什么时候应该开启二级缓存呢？

1、因为所有的update操作(insert,delete,uptede)都会触发缓存的刷新，从而导致二级缓存失效，所以二级缓存适合在读多写少的场景中开启。

2、因为二级缓存针对的是同一个namespace，所以建议是在单表操作的Mapper中使用，或者是在相关表的Mapper文件中共享同一个缓存。

## 自定义缓存 ##

一级缓存可能存在脏读情况，那么二级缓存是否也可能存在呢？

是的，默认的二级缓存毕竟也是存储在本地缓存，所以对于微服务下是可能出现脏读的情况的，所以这时候我们可能会需要自定义缓存，比如利用redis来存储缓存，而不是存储在本地内存当中。

### MyBatis官方提供的第三方缓存 ###

MyBatis官方也提供了一些第三方缓存的支持，如：encache和redis。下面我们以redis为例来演示一下：引入pom文件：

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

然后缓存配置如下：

然后在默认的resource路径下新建一个redis.properties文件：

host=localhost
    port=6379
    12

然后执行上面的示例，查看Cache，已经被Redis包装：

![1bd8303410fd0ffdc87b95806ba39bc9.png][]

### 自己实现二级缓存 ###

如果要实现一个自己的缓存的话，那么我们只需要新建一个类实现Cache接口就好了，然后重写其中的方法,如下：

package com.lonelyWolf.mybatis.cache;
    
    import org.apache.ibatis.cache.Cache;
    
    public class MyCache implements Cache {
        @Override
        public String getId() {
            return null;
        }
        @Override
        public void putObject(Object o, Object o1) {
    
        }
        @Override
        public Object getObject(Object o) {
            return null;
        }
    
        @Override
        public Object removeObject(Object o) {
            return null;
        }
    
        @Override
        public void clear() {
        }
    
        @Override
        public int getSize() {
            return 0;
        }
    }

上面自定义的缓存中,我们只需要在对应方法，如putObject方法，我们把缓存存到我们想存的地方就行了，方法全部重写之后，然后配置的时候type配上我们自己的类就可以实现了，在这里我们就不做演示了

# 总结 #

本文主要分析了MyBatis的缓存是如何实现的，并且分别演示了一级缓存和二级缓存，并分析了一级缓存和二级缓存所存在的问题，最后也介绍了如何使用第三方缓存和如何自定义我们自己的缓存，通过本文，我想大家应该可以彻底掌握MyBatis的缓存工作原理了。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MzEzNjM1_size_16_color_FFFFFF_t_70]: /images/20221119/80d2283549cb416cb84eac6e28e311a7.png
[f8ccf28c1237be7b4c33a28f3a46a922.png]: https://img-blog.csdnimg.cn/img_convert/f8ccf28c1237be7b4c33a28f3a46a922.png
[1534e3864c391d2befc1d38170c0366d.png]: https://img-blog.csdnimg.cn/img_convert/1534e3864c391d2befc1d38170c0366d.png
[34b15c5c6a4da1f29eb2738c4ad1f6c7.png]: https://img-blog.csdnimg.cn/img_convert/34b15c5c6a4da1f29eb2738c4ad1f6c7.png
[2dfb8e5a1a70bb6d364aef60c8051aca.png]: https://img-blog.csdnimg.cn/img_convert/2dfb8e5a1a70bb6d364aef60c8051aca.png
[4413146136653ada1004f9c17dbc73f7.png]: https://img-blog.csdnimg.cn/img_convert/4413146136653ada1004f9c17dbc73f7.png
[819c7fec8b6dc2a85dd128b4e01d85c4.png]: https://img-blog.csdnimg.cn/img_convert/819c7fec8b6dc2a85dd128b4e01d85c4.png
[1bd8303410fd0ffdc87b95806ba39bc9.png]: https://img-blog.csdnimg.cn/img_convert/1bd8303410fd0ffdc87b95806ba39bc9.png