手册   游戏   WEB   字典   单词   在线工具  

mybatis 源码分析 (四) 一二级缓存分析

本篇博客主要讲了 mybatis 一二级缓存的构成, 以及一些容易出错地方的示例分析;

一, mybatis 缓存体系

mybatis 的一二级缓存体系大致如下:

首先当一二级缓存同时开启的时候, 首先命中二级缓存;

一级缓存位于 BaseExecutor 中不能关闭, 但是可以指定范围 STATEMENT,SESSION;

整个二级缓存虽然经过了很多事务相关的组件, 但是最终是落地在 MapperStatement 的 Cache 中 (Cache 的具体实例类型可以在 mapper xml 的 cache type 标签中指定, 默认 PerpetualCache), 而 MapperStatement 和 namespace 一一对应, 所以二级缓存的作用域是 mapper namespace;

在使用二级缓存的时候, 如果 cache 没有命中则向后查找, 然后查询的结果不是直接放到 cache 中, 而是首先放到 TransactionCache 的本地缓存中, 这里区分 entriesToAddOnCommit,entriesMissedInCache 是为了统计命令率, 最后在 sqlSession commit 的时候, 才会将 TransactionCache 的本地缓存提交到 cache 中, 此时 cache 才是对其他 sqlSession 可见的;

此外当需要分布式缓存的时候, 就需要将二级缓存放到 JVM 之外, 这里可以实现 cache 接口编写自己的 cache, 此时在实现的 cache 中就可以使用 ehcache,Redis 等外部缓存进行操作;

以上就大致是 mybatis 缓存的整体结构, 下面将分模块拆分测试一二级缓存;

二, 一级缓存

mybatis 的一级缓存一般情况很少使用, 其原因主要有两个:

一级缓存的生命周期同 SqlSession, 所以容易出现脏读;

一级缓存的 cache 的实现只能是 PerpetualCache, 所以不能指定容量等设置;

1. 脏读测试

指定一级缓存范围为 SESSION:

  1. <setting name="localCacheScope" value="SESSION"/>
  2. @Test
  3. public void test01() {
  4.   SqlSessionFactory sqlSessionFactory = DBUtils.getSessionFactory();
  5.   try (
  6.     SqlSession sqlSession1 = sqlSessionFactory.openSession(true);
  7.     SqlSession sqlSession2 = sqlSessionFactory.openSession(true);
  8.   ) {
  9.     UserMapper userMapper1 = sqlSession1.getMapper(UserMapper.class);
  10.     UserMapper userMapper2 = sqlSession2.getMapper(UserMapper.class);
  11.     log.info("---get: {}", userMapper1.getUser(1L));
  12.     log.info("---get: {}", userMapper2.getUser(1L));
  13.     log.info("---update: {}", userMapper1.setNameById(1L, "LiSi"));
  14.     log.info("---get: {}", userMapper1.getUser(1L));
  15.     log.info("---get: {}", userMapper2.getUser(1L));
  16.   }
  17. }

结果如下:

  1. [DEBUG] sanzao.db.UserMapper.getUser - ==>  Preparing: select * from user where id = ?
  2. [DEBUG] sanzao.db.UserMapper.getUser - ==> Parameters: 1(Long)
  3. [TRACE] sanzao.db.UserMapper.getUser - <==    Columns: id, username, password, address
  4. [TRACE] sanzao.db.UserMapper.getUser - <==        Row: 1, ZhangSan, 123456, TT
  5. [DEBUG] sanzao.db.UserMapper.getUser - <==      Total: 1
  6. [INFO] sanzao.Test01 - ---get: User{
  7. 	id=1, user_name='ZhangSan', password='123456', address='TT'	
  8. }
  9. [DEBUG] org.apache.ibatis.transaction.jdbc.JdbcTransaction - Opening JDBC Connection
  10. [DEBUG] org.apache.ibatis.datasource.pooled.PooledDataSource - Created connection 61073295.
  11. [DEBUG] sanzao.db.UserMapper.getUser - ==>  Preparing: select * from user where id = ?
  12. [DEBUG] sanzao.db.UserMapper.getUser - ==> Parameters: 1(Long)
  13. [TRACE] sanzao.db.UserMapper.getUser - <==    Columns: id, username, password, address
  14. [TRACE] sanzao.db.UserMapper.getUser - <==        Row: 1, ZhangSan, 123456, TT
  15. [DEBUG] sanzao.db.UserMapper.getUser - <==      Total: 1
  16. [INFO] sanzao.Test01 - ---get: User{
  17. 	id=1, user_name='ZhangSan', password='123456', address='TT'	
  18. }
  19. [DEBUG] sanzao.db.UserMapper.setNameById - ==>  Preparing: update user set username = ? where id = ?
  20. [DEBUG] sanzao.db.UserMapper.setNameById - ==> Parameters: LiSi(String), 1(Long)
  21. [DEBUG] sanzao.db.UserMapper.setNameById - <==    Updates: 1
  22. [INFO] sanzao.Test01 - ---update: 1
  23. [DEBUG] sanzao.db.UserMapper.getUser - ==> Parameters: 1(Long)
  24. [TRACE] sanzao.db.UserMapper.getUser - <==    Columns: id, username, password, address
  25. [TRACE] sanzao.db.UserMapper.getUser - <==        Row: 1, LiSi, 123456, TT
  26. [DEBUG] sanzao.db.UserMapper.getUser - <==      Total: 1
  27. [INFO] sanzao.Test01 - ---get: User{
  28. 	id=1, user_name='LiSi', password='123456', address='TT'	
  29. }
  30. [INFO] sanzao.Test01 - ---get: User{
  31. 	id=1, user_name='ZhangSan', password='123456', address='TT'	
  32. }

可以看到当 sqlSession1 更新的时候, sqlSession2 的缓存仍然有效所以出现了脏读; 所以通常都设置一级缓存的范围为: STATEMENT;

2. 源码分析

mybatis 的一级缓存主要和 Executor 整合比较多, 所以建议先查看我上一篇博客 Executor 详解 , 详细了解缓存命中的整体流程; 这里一级缓存的源码也很简单:

查询的时候, 首先查缓存, 命中则返回, 未命中就查数据库, 然后填充缓存;

更新, 提交等操作情况缓存;

  1. @SuppressWarnings("unchecked")
  2. @Override
  3. public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
  4.   ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
  5.   if (closed) { throw new ExecutorException("Executor was closed."); }
  6.   // 查询的时候一般不清楚缓存, 但是可以通过 xml 配置或者注解强制清除, queryStack == 0 是为了防止递归调用
  7.   if (queryStack == 0 && ms.isFlushCacheRequired()) { clearLocalCache(); }
  8.   List<E> list;
  9.   try {
  10.     queryStack++;
  11.     // 首先查看一级缓存
  12.     list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
  13.     if (list != null) {
  14.       handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
  15.     } else {
  16.       // 没有查到的时候直接到数据库查找
  17.       list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
  18.     }
  19.   } finally {
  20.     queryStack--;
  21.   }
  22.   if (queryStack == 0) {
  23.     // 延迟加载队列
  24.     for (DeferredLoad deferredLoad : deferredLoads) {
  25.       deferredLoad.load();
  26.     }
  27.     deferredLoads.clear();
  28.     if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
  29.       // 一级缓存本身不能关闭, 但是可以设置作用范围 STATEMENT, 每次都清除缓存
  30.       clearLocalCache();
  31.     }
  32.   }
  33.   return list;
  34. }

三, 二级缓存

mybatis 二级缓存要稍微复杂一点, 中间多了一步事务缓存:

首先无论是查询还是更新, 都会按要求清空缓存

flushCacheIfRequired

, 默认更新清空, 查询不清空, 也可以在 xml 或者注解中指定;

查询的时候, 先查缓存, 命中返回, 未命中查一级缓存, 数据库, 然后回填事务缓存, 注意这里不是直接填充到缓存中; 此时的事务缓存对任何的 SqlSession 都是不可见的, 因为自己查询的时候也是直接查询的目标缓存;

更新就直接委托给目标 Executor 执行;

最后 SqlSession 执行 commit 的时候, 将事务缓存刷新到目标缓存中;

1. 事务缓存测试

设置二级缓存:

  1. <setting name="cacheEnabled" value="true"/>
  2. <mapper namespace="***">
  3.   <cache/>
  4. </mapper>
  5. @Test
  6. public void test02() {
  7.   SqlSessionFactory sqlSessionFactory = DBUtils.getSessionFactory();
  8.   try (
  9.     SqlSession sqlSession1 = sqlSessionFactory.openSession(true);
  10.     SqlSession sqlSession2 = sqlSessionFactory.openSession(true);
  11.   ) {
  12.     UserMapper userMapper1 = sqlSession1.getMapper(UserMapper.class);
  13.     UserMapper userMapper2 = sqlSession2.getMapper(UserMapper.class);
  14.     User u1 = userMapper1.getUser(1L);
  15.     System.out.println("---get u1:" + u1);
  16.     User u2 = userMapper2.getUser(1L);
  17.     System.out.println("---get u2:" + u2);
  18.     User u3 = userMapper1.getUser(1L);
  19.     System.out.println("---get u3:" + u3);
  20.   }
  21. }

打印:

  1. DEBUG [main] - Cache Hit Ratio [sanzao.db.UserMapper]: 0.0
  2. DEBUG [main] - ==>  Preparing: select * from user where id = ?
  3. DEBUG [main] - ==> Parameters: 1(Long)
  4. DEBUG [main] - <==      Total: 1
  5. ---get u1: User{
  6. 	id=1, user_name='sanzao', password='123456', address='TT'	
  7. }
  8. DEBUG [main] - Cache Hit Ratio [sanzao.db.UserMapper]: 0.0
  9. DEBUG [main] - Opening JDBC Connection
  10. DEBUG [main] - Created connection 1613095350.
  11. DEBUG [main] - ==>  Preparing: select * from user where id = ?
  12. DEBUG [main] - ==> Parameters: 1(Long)
  13. DEBUG [main] - <==      Total: 1
  14. ---get u2: User{
  15. 	id=1, user_name='sanzao', password='123456', address='TT'	
  16. }
  17. DEBUG [main] - Cache Hit Ratio [sanzao.db.UserMapper]: 0.0
  18. ---get u3: User{
  19. 	id=1, user_name='sanzao', password='123456', address='TT'	
  20. }

可以看到:

SqlSession1 为提交事务缓存, 所以 SqlSession2 又从数据库中查了一次;

当 SqlSession1 再次查询的时候, 二级缓存未命中 Cache Hit Ratio 为 0, 但是命中了一级缓存, 所以并未再查数据库;

2. 二级缓存测试

这次我们提交缓存看看是否命中:

  1. @Test
  2. public void test03() {
  3.   SqlSessionFactory sqlSessionFactory = DBUtils.getSessionFactory();
  4.   try (
  5.     SqlSession sqlSession1 = sqlSessionFactory.openSession(true);
  6.     SqlSession sqlSession2 = sqlSessionFactory.openSession(true);
  7.   ) {
  8.     UserMapper userMapper1 = sqlSession1.getMapper(UserMapper.class);
  9.     UserMapper userMapper2 = sqlSession2.getMapper(UserMapper.class);
  10.     User u1 = userMapper1.getUser(1L);
  11.     System.out.println("---get u1:" + u1);
  12.     sqlSession1.commit();
  13.     User u2 = userMapper2.getUser(1L);
  14.     System.out.println("---get u2:" + u2);
  15.     int i = userMapper1.setNameById(1L, "LiSi");
  16.     System.out.println("---update user:" + i);
  17.     sqlSession1.commit();
  18.     User u3 = userMapper1.getUser(1L);
  19.     System.out.println("---get u3:" + u3);
  20.     sqlSession1.commit();
  21.     User u4 = userMapper2.getUser(1L);
  22.     System.out.println("---get u4:" + u4);
  23.   }
  24. }

打印:

  1. DEBUG [main] - Cache Hit Ratio [sanzao.db.UserMapper]: 0.0
  2. DEBUG [main] - ==>  Preparing: select * from user where id = ?
  3. DEBUG [main] - ==> Parameters: 1(Long)
  4. DEBUG [main] - <==      Total: 1
  5. ---get u1: User{
  6. 	id=1, user_name='sanzao', password='123456', address='TT'	
  7. }
  8. DEBUG [main] - Cache Hit Ratio [sanzao.db.UserMapper]: 0.5
  9. ---get u2: User{
  10. 	id=1, user_name='sanzao', password='123456', address='TT'	
  11. }
  12. DEBUG [main] - ==>  Preparing: update user set username = ? where id = ?
  13. DEBUG [main] - ==> Parameters: LiSi(String), 1(Long)
  14. DEBUG [main] - <==    Updates: 1
  15. ---update user: 1
  16. DEBUG [main] - Cache Hit Ratio [sanzao.db.UserMapper]: 0.3333333333333333
  17. DEBUG [main] - ==>  Preparing: select * from user where id = ?
  18. DEBUG [main] - ==> Parameters: 1(Long)
  19. DEBUG [main] - <==      Total: 1
  20. ---get u3: User{
  21. 	id=1, user_name='LiSi', password='123456', address='TT'	
  22. }
  23. DEBUG [main] - Cache Hit Ratio [sanzao.db.UserMapper]: 0.5
  24. ---get u4: User{
  25. 	id=1, user_name='LiSi', password='123456', address='TT'	
  26. }

这次就能看到当 SqlSession1 提交事务缓存后, SqlSession2 就能看到了;

3. 缓存配置测试

此外还可以配置各种二级缓存策略, 比如大小, 刷新间隔时间, 淘汰策略等, 这里主要就是使用了 Cache 接口的装饰者模式:

LRU - 最近最少使用: 移除最长时间不被使用的对象.

FIFO - 先进先出: 按对象进入缓存的顺序来移除它们.

SOFT - 软引用: 基于垃圾回收器状态和软引用规则移除对象.

WEAK - 弱引用: 更积极地基于垃圾收集器状态和弱引用规则移除对象.

但是需要注意的是这里的策略也能用户本地缓存, 对于分布式缓存有些策略还是有问题; 比如:

<cache eviction="FIFO" flushInterval="60000" size="2" readOnly="true"/>

这里主要定义了缓存大小 2, 使用 FIFO 策略更新;

  1. @Test
  2. public void test04() {
  3.   SqlSessionFactory sqlSessionFactory = DBUtils.getSessionFactory();
  4.   try (
  5.     SqlSession sqlSession1 = sqlSessionFactory.openSession(true);
  6.     SqlSession sqlSession2 = sqlSessionFactory.openSession(true);) {
  7.     UserMapper userMapper1 = sqlSession1.getMapper(UserMapper.class);
  8.     UserMapper userMapper2 = sqlSession2.getMapper(UserMapper.class);
  9.     System.out.println("---get user:" + userMapper1.getUser(1L));
  10.     sqlSession1.commit();
  11.     System.out.println("---get user:" + userMapper1.getUser(2L));
  12.     sqlSession1.commit();
  13.     System.out.println("---get user:" + userMapper1.getUser(3L));
  14.     sqlSession1.commit();
  15.     System.out.println("---get user:" + userMapper2.getUser(1L));
  16.     System.out.println("---get user:" + userMapper2.getUser(2L));
  17.     System.out.println("---get user:" + userMapper1.getUser(1L));
  18.     sqlSession2.commit();
  19.     System.out.println("------------");
  20.     System.out.println("---get user:" + userMapper1.getUser(1L));
  21.     System.out.println("---get user:" + userMapper1.getUser(2L));
  22.     System.out.println("---get user:" + userMapper1.getUser(3L));
  23.   }
  24. }

打印:

  1. DEBUG [main] - Cache Hit Ratio [sanzao.db.UserMapper]: 0.0
  2. DEBUG [main] - ==>  Preparing: select * from user where id = ?
  3. DEBUG [main] - ==> Parameters: 1(Long)
  4. DEBUG [main] - <==      Total: 1
  5. ---get user: User{
  6. 	id=1, user_name='s1', password='123456', address='TT'	
  7. }
  8. DEBUG [main] - Cache Hit Ratio [sanzao.db.UserMapper]: 0.0
  9. DEBUG [main] - ==>  Preparing: select * from user where id = ?
  10. DEBUG [main] - ==> Parameters: 2(Long)
  11. DEBUG [main] - <==      Total: 1
  12. ---get user: User{
  13. 	id=2, user_name='s2', password='123456', address='TT'	
  14. }
  15. DEBUG [main] - Cache Hit Ratio [sanzao.db.UserMapper]: 0.0
  16. DEBUG [main] - ==>  Preparing: select * from user where id = ?
  17. DEBUG [main] - ==> Parameters: 3(Long)
  18. DEBUG [main] - <==      Total: 1
  19. ---get user: User{
  20. 	id=3, user_name='s3', password='123456', address='TT'	
  21. }
  22. DEBUG [main] - Cache Hit Ratio [sanzao.db.UserMapper]: 0.0
  23. DEBUG [main] - ==>  Preparing: select * from user where id = ?
  24. DEBUG [main] - ==> Parameters: 1(Long)
  25. DEBUG [main] - <==      Total: 1
  26. ---get user: User{
  27. 	id=1, user_name='s1', password='123456', address='TT'	
  28. }
  29. DEBUG [main] - Cache Hit Ratio [sanzao.db.UserMapper]: 0.2
  30. ---get user: User{
  31. 	id=2, user_name='s2', password='123456', address='TT'	
  32. }
  33. DEBUG [main] - Cache Hit Ratio [sanzao.db.UserMapper]: 0.16666666666666666
  34. DEBUG [main] - ==>  Preparing: select * from user where id = ?
  35. DEBUG [main] - ==> Parameters: 1(Long)
  36. DEBUG [main] - <==      Total: 1
  37. ---get user: User{
  38. 	id=1, user_name='s1', password='123456', address='TT'	
  39. }
  40. ------------
  41. DEBUG [main] - Cache Hit Ratio [sanzao.db.UserMapper]: 0.2857142857142857
  42. ---get user: User{
  43. 	id=1, user_name='s1', password='123456', address='TT'	
  44. }
  45. DEBUG [main] - Cache Hit Ratio [sanzao.db.UserMapper]: 0.25
  46. DEBUG [main] - ==> Parameters: 2(Long)
  47. DEBUG [main] - <==      Total: 1
  48. ---get user: User{
  49. 	id=2, user_name='s2', password='123456', address='TT'	
  50. }
  51. DEBUG [main] - Cache Hit Ratio [sanzao.db.UserMapper]: 0.3333333333333333
  52. ---get user: User{
  53. 	id=3, user_name='s3', password='123456', address='TT'	
  54. }

从日志中可以看到对于 SqlSession1, 大小 2,FIFO 是生效的, 但是 SqlSession2 提交了之后, 就发现缓存 s1,s2,s3 都命中了;

至于源码太多了就不一次分析了, 对于上面说的使用装饰者模式, 可以在 CacheBuilder 中看到;

  1. public Cache build() {
  2.   setDefaultImplementations();
  3.   Cache cache = newBaseCacheInstance(implementation, id);
  4.   setCacheProperties(cache);
  5.   // issue #352, do not apply decorators to custom caches
  6.   if (PerpetualCache.class.equals(cache.getClass())) {
  7.     for (Class<? extends Cache> decorator : decorators) {
  8.       cache = newCacheDecoratorInstance(decorator, cache);
  9.       setCacheProperties(cache);
  10.     }
  11.     cache = setStandardDecorators(cache);
  12.   } else if (!LoggingCache.class.isAssignableFrom(cache.getClass())) {
  13.     cache = new LoggingCache(cache);
  14.   }
  15.   return cache;
  16. }

总结

mybatis 一级缓存的生命周期和 SqlSession 是一样的, 通常情况下不建议使用一级缓存, 通常将一级缓存范围设置为 STATEMENT;

使用 mybatis 二级的时候, 务必记得 SqlSession.commit , 否则二级缓存是不生效的;

在配置 mybatis 分布式二级缓存的时候, 要确保缓存淘汰等策略是可以用于分布式缓存的;

来源: https://www.cnblogs.com/sanzao/p/11414305.html


与本文相关文章

  1. mybatis 缓存的使用, 看这篇就够了
  2. MyBatis 源码分析
  3. Mybatis 苞米豆源码分析一: 动态注入
  4. MyBatis 实战 (二)- 一级缓存原理解析
  5. MyBatis 源码分析 (xml 解析及 sqlsession 获取)
  6. mybatis 专题 (二)----- 代码生成器, 关联查询, 缓存
  7. MyBatis 一级缓存避坑
  8. 深入浅出 Mybatis 系列 (三)--- 配置简介 (mybatis 源码篇)
暂无,快来抢沙发吧！
更多





黑ICP备17005318号-1