Mybatis系列第12篇：掌握缓存为查询提速!

Mybatis系列目标：从入门开始开始掌握一个高级开发所需要的Mybatis技能。

这是mybatis系列第12篇，源码位于文章尾部！

什么是缓存？

缓存就是存储数据的一个地方（称作：Cache），当程序要读取数据时，会首先从缓存中获取，有则直接返回，否则从其他存储设备中获取，缓存最重要的一点就是从其内部获取数据的速度是非常快的，通过缓存可以加快数据的访问速度。比如我们从db中获取数据，中间需要经过网络传输耗时，db server从磁盘读取数据耗时等，如果这些数据直接放在jvm对应的内存中，访问是不是会快很多。

mybatis中的缓存

通常情况下mybatis会访问数据库获取数据，中间涉及到网络通信，数据库从磁盘中读取数据，然后将数据返回给mybatis，总的来说耗时还是挺长的，mybatis为了加快数据查询的速度，在其内部引入了缓存来加快数据的查询速度。

mybatis中分为一级缓存和二级缓存。

一级缓存是SqlSession级别的缓存，在操作数据库时需要构造 sqlSession对象，在对象中有一个数据结构（HashMap）用于存储缓存数据，不同的sqlSession之间的缓存数据区域（HashMap）是互相不影响的。

二级缓存是mapper级别的缓存，多个SqlSession去操作同一个Mapper的sql语句，多个SqlSession可以共用二级缓存，二级缓存是跨SqlSession的。

下面我们详细说一下一级缓存和二级缓存的各种用法和注意点。

一级缓存

一级缓存是SqlSession级别的缓存，每个SqlSession都有自己单独的一级缓存，多个SqlSession之间的一级缓存是相互隔离的，互不影响，mybatis中一级缓存是默认自动开启的。

一级缓存工作原理：在同一个SqlSession中去多次去执行同样的查询，每次执行的时候会先到一级缓存中查找，如果缓存中有就直接返回，如果一级缓存中没有相关数据，mybatis就会去db中进行查找，然后将查找到的数据放入一级缓存中，第二次执行同样的查询的时候，会发现缓存中已经存在了，会直接返回。一级缓存的存储介质是内存，是用一个HashMap来存储数据的，所以访问速度是非常快的。

一级缓存案例

案例sql脚本
  1. DROP DATABASE IF EXISTS `javacode2018`;
  2. CREATE DATABASE `javacode2018`;
  3.  
  4. USE `javacode2018`;
  5.  
  6. DROP TABLE IF EXISTS t_user;
  7. CREATE TABLE t_user(
  8.   id int AUTO_INCREMENT PRIMARY KEY COMMENT '用户id',
  9.   name VARCHAR(32) NOT NULL DEFAULT '' COMMENT '用户名',
  10.   age SMALLINT NOT NULL DEFAULT 1 COMMENT '年龄'
  11. ) COMMENT '用户表';
  12. INSERT INTO t_user VALUES (1,'路人甲Java',30),(2,'张学友',50),(3,'刘德华',50);
下面是查询用户信息，返回一个list
  1. <select id="getList1" resultType="com.javacode2018.chat05.demo9.model.UserModel" parameterType="map">
  2.     SELECT id,name,age FROM t_user
  3.     <where>
  4.         <if test="id!=null">
  5.             AND id = #{id}
  6.         </if>
  7.         <if test="name!=null and name.toString()!=''">
  8.             AND name = #{name}
  9.         </if>
  10.         <if test="age!=null">
  11.             AND age = #{age}
  12.         </if>
  13.     </where>
  14. </select>
对应的mapper接口方法
List<UserModel> getList1(Map<String, Object> paramMap);
测试用例
  1. com.javacode2018.chat05.demo9.Demo9Test#level1CacheTest1
  2.  
  3. /**
  4.  * 一级缓存测试
  5.  *
  6.  * @throws IOException
  7.  */
  8. @Test
  9. public void level1CacheTest1() throws IOException {
  10.     String mybatisConfig = "demo9/mybatis-config.xml";
  11.     this.before(mybatisConfig);
  12.     try (SqlSession sqlSession = this.sqlSessionFactory.openSession(true);) {
  13.         UserMapper mapper = sqlSession.getMapper(UserMapper.class);
  14.         //第一次查询
  15.         List<UserModel> userModelList1 = mapper.getList1(null);
  16.         log.info("{}", userModelList1);
  17.         //第二次查询
  18.         List<UserModel> userModelList2 = mapper.getList1(null);
  19.         log.info("{}", userModelList2);
  20.         log.info("{}", userModelList1 == userModelList2);
  21.     }
  22. }

上面的代码在同一个SqlSession中去执行了2次获取用户列表信息，2次查询结果分别放在userModelList1和userModelList2，最终代码中也会判断这两个集合是否相等，下面我们运行一下看看会访问几次db？

运行输出
  1. 01:15.312 [main] DEBUG c.j.c.d.mapper.UserMapper.getList1 - ==>  Preparing: SELECT id,name,age FROM t_user 
  2. 01:15.340 [main] DEBUG c.j.c.d.mapper.UserMapper.getList1 - ==> Parameters: 
  3. 01:15.364 [main] DEBUG c.j.c.d.mapper.UserMapper.getList1 - <==      Total: 3
  4. 01:15.364 [main] INFO  c.j.chat05.demo9.Demo9Test - [UserModel(id=1, name=路人甲Java, age=30), UserModel(id=2, name=张学友, age=50), UserModel(id=3, name=刘德华, age=50)]
  5. 01:15.367 [main] INFO  c.j.chat05.demo9.Demo9Test - [UserModel(id=1, name=路人甲Java, age=30), UserModel(id=2, name=张学友, age=50), UserModel(id=3, name=刘德华, age=50)]
  6. 01:15.367 [main] INFO  c.j.chat05.demo9.Demo9Test - true

从输出中可以看出看到，sql只输出了一次，说明第一次会访问数据库，第二次直接从缓存中获取的，最后输出了一个true，也说明两次返回结果是同一个对象，第二次直接从缓存中获取数据的，加快了查询的速度。

清空一级缓存的3种方式

同一个SqlSession中查询同样的数据，mybatis默认会从一级缓存中获取，如果缓存中没有，才会访问db，那么我们如何去情况一级缓存呢，强制让查询去访问db呢？

让一级缓存失效有3种方式：

  1. SqlSession中执行增、删、改操作，此时sqlsession会自动清理其内部的一级缓存

  2. 调用SqlSession中的clearCache方法清理其内部的一级缓存

  3. 设置Mapper xml中select元素的flushCache属性值为true，那么执行查询的时候会先清空一级缓存中的所有数据，然后去db中获取数据

上面方式任何一种都会让当前SqlSession中的以及缓存失效，进而去db中获取数据，下面我们来分别演示这3种情况。

方式1：增删改让一级缓存失效

当执行增删改操时，mybatis会将当前SqlSession一级缓存中的所有数据都清除。

案例代码：
  1. com.javacode2018.chat05.demo9.Demo9Test#level1CacheTest2
  2.  
  3. /**
  4.  * 增删改使一级缓存失效
  5.  *
  6.  * @throws IOException
  7.  */
  8. @Test
  9. public void level1CacheTest2() throws IOException {
  10.     String mybatisConfig = "demo9/mybatis-config.xml";
  11.     this.before(mybatisConfig);
  12.     try (SqlSession sqlSession = this.sqlSessionFactory.openSession(true);) {
  13.         UserMapper mapper = sqlSession.getMapper(UserMapper.class);
  14.         //第一次查询
  15.         List<UserModel> userModelList1 = mapper.getList1(null);
  16.         log.info("{}", userModelList1);
  17.         //新增一条数据
  18.         mapper.insert1(UserModel.builder().id(100).name("路人").age(30).build());
  19.         //第二次查询
  20.         List<UserModel> userModelList2 = mapper.getList1(null);
  21.         log.info("{}", userModelList2);
  22.         log.info("{}", userModelList1 == userModelList2);
  23.     }
  24. }

上面同一个SqlSession中执行了3个操作，同样的查询执行了2次，2次查询中间夹了一个插入操作。

运行输出
  1. 21:55.097 [main] DEBUG c.j.c.d.mapper.UserMapper.getList1 - ==>  Preparing: SELECT id,name,age FROM t_user 
  2. 21:55.135 [main] DEBUG c.j.c.d.mapper.UserMapper.getList1 - ==> Parameters: 
  3. 21:55.159 [main] DEBUG c.j.c.d.mapper.UserMapper.getList1 - <==      Total: 3
  4. 21:55.159 [main] INFO  c.j.chat05.demo9.Demo9Test - [UserModel(id=1, name=路人甲Java, age=30), UserModel(id=2, name=张学友, age=50), UserModel(id=3, name=刘德华, age=50)]
  5. 21:55.161 [main] DEBUG c.j.c.d.mapper.UserMapper.insert1 - ==>  Preparing: INSERT INTO t_user (id,name,age) VALUES (?,?,?) 
  6. 21:55.162 [main] DEBUG c.j.c.d.mapper.UserMapper.insert1 - ==> Parameters: 100(Integer), 路人(String), 30(Integer)
  7. 21:55.165 [main] DEBUG c.j.c.d.mapper.UserMapper.insert1 - <==    Updates: 1
  8. 21:55.166 [main] DEBUG c.j.c.d.mapper.UserMapper.getList1 - ==>  Preparing: SELECT id,name,age FROM t_user 
  9. 21:55.166 [main] DEBUG c.j.c.d.mapper.UserMapper.getList1 - ==> Parameters: 
  10. 21:55.167 [main] DEBUG c.j.c.d.mapper.UserMapper.getList1 - <==      Total: 4
  11. 21:55.168 [main] INFO  c.j.chat05.demo9.Demo9Test - [UserModel(id=1, name=路人甲Java, age=30), UserModel(id=2, name=张学友, age=50), UserModel(id=3, name=刘德华, age=50), UserModel(id=100, name=路人, age=30)]
  12. 21:55.168 [main] INFO  c.j.chat05.demo9.Demo9Test - false

从输出中可以看出2次查询都访问了db，并且两次查询的结果是不一样的，两个集合也不相等，插入数据让缓存失效是可以理解的，插入操作可能会改变数据库中的数据，所以如果再从缓存中去获取，可能获取到的数据和db中的数据不一致的情况，mybatis为了避免这种情况，在执行插入操作的时候，会将SqlSession中的一级缓存清空。当然删除和修改也同样会改变db中的数据，如果在同一个SqlSession中去执行删除或者修改数据的时候，mybatis也一样会清除一级缓存中的所有数据，删除和修改大家自己可以写2个例子试试，看看是否也会清理一级缓存中的数据。

方式2：SqlSession.clearCache清理一级缓存

SqlSession.clearCache()方法会将当前SqlSession一级缓存中的所有数据清除。

案例代码：
  1. com.javacode2018.chat05.demo9.Demo9Test#level1CacheTest3
  2.  
  3. /**
  4.  * 调用sqlSession.clearCache()清理一级缓存
  5.  *
  6.  * @throws IOException
  7.  */
  8. @Test
  9. public void level1CacheTest3() throws IOException {
  10.     String mybatisConfig = "demo9/mybatis-config.xml";
  11.     this.before(mybatisConfig);
  12.     try (SqlSession sqlSession = this.sqlSessionFactory.openSession(true);) {
  13.         UserMapper mapper = sqlSession.getMapper(UserMapper.class);
  14.         //第一次查询
  15.         List<UserModel> userModelList1 = mapper.getList1(null);
  16.         log.info("{}", userModelList1);
  17.         //调用clearCache方法清理当前SqlSession中的缓存
  18.         sqlSession.clearCache();
  19.         //第二次查询
  20.         List<UserModel> userModelList2 = mapper.getList1(null);
  21.         log.info("{}", userModelList2);
  22.         log.info("{}", userModelList1 == userModelList2);
  23.     }
  24. }
运行输出
  1. 31:21.937 [main] DEBUG c.j.c.d.mapper.UserMapper.getList1 - ==>  Preparing: SELECT id,name,age FROM t_user 
  2. 31:21.966 [main] DEBUG c.j.c.d.mapper.UserMapper.getList1 - ==> Parameters: 
  3. 31:21.985 [main] DEBUG c.j.c.d.mapper.UserMapper.getList1 - <==      Total: 4
  4. 31:21.985 [main] INFO  c.j.chat05.demo9.Demo9Test - [UserModel(id=1, name=路人甲Java, age=30), UserModel(id=2, name=张学友, age=50), UserModel(id=3, name=刘德华, age=50), UserModel(id=100, name=路人, age=30)]
  5. 31:21.988 [main] DEBUG c.j.c.d.mapper.UserMapper.getList1 - ==>  Preparing: SELECT id,name,age FROM t_user 
  6. 31:21.988 [main] DEBUG c.j.c.d.mapper.UserMapper.getList1 - ==> Parameters: 
  7. 31:21.989 [main] DEBUG c.j.c.d.mapper.UserMapper.getList1 - <==      Total: 4
  8. 31:21.989 [main] INFO  c.j.chat05.demo9.Demo9Test - [UserModel(id=1, name=路人甲Java, age=30), UserModel(id=2, name=张学友, age=50), UserModel(id=3, name=刘德华, age=50), UserModel(id=100, name=路人, age=30)]
  9. 31:21.990 [main] INFO  c.j.chat05.demo9.Demo9Test - false

从输出中可以看出，2次同样的查询都访问了db。

方式3：Select元素的flushCache置为true

将Mapper xml中select元素的flushCache属性置为true的时候，每次执行这个select元素对应的查询之前，mybatis会将当前SqlSession中一级缓存中的所有数据都清除。

案例代码

新增一个select元素的查询，将flushCache元素置为true，注意：select元素这个属性的默认值是false。

  1. <select id="getList2" flushCache="true" resultType="com.javacode2018.chat05.demo9.model.UserModel" parameterType="map">
  2.     SELECT id,name,age FROM t_user
  3.     <where>
  4.         <if test="id!=null">
  5.             AND id = #{id}
  6.         </if>
  7.         <if test="name!=null and name.toString()!=''">
  8.             AND name = #{name}
  9.         </if>
  10.         <if test="age!=null">
  11.             AND age = #{age}
  12.         </if>
  13.     </where>
  14. </select>
对应测试用例
  1. com.javacode2018.chat05.demo9.Demo9Test#level1CacheTest4
  2.  
  3. /**
  4.  * 将Mapper xml中select元素的flushCache属性置为true的时候，每次执行这个select元素对应的查询之前，mybatis会将当前SqlSession中一级缓存中的所有数据都清除。
  5.  *
  6.  * @throws IOException
  7.  */
  8. @Test
  9. public void level1CacheTest4() throws IOException {
  10.     String mybatisConfig = "demo9/mybatis-config.xml";
  11.     this.before(mybatisConfig);
  12.     try (SqlSession sqlSession = this.sqlSessionFactory.openSession(true);) {
  13.         UserMapper mapper = sqlSession.getMapper(UserMapper.class);
  14.         //查询1：getList1
  15.         log.info("查询1 start");
  16.         log.info("查询1：getList1->{}", mapper.getList1(null));
  17.         //查询2：getList1
  18.         log.info("查询2 start");
  19.         log.info("查询2：getList1->{}", mapper.getList1(null));
  20.         //查询3：getList2
  21.         log.info("查询3 start");
  22.         log.info("查询3：getList2->{}", mapper.getList2(null));
  23.         //查询4：getList2
  24.         log.info("查询4 start");
  25.         log.info("查询4：getList2->{}", mapper.getList2(null));
  26.         //查询5：getList1
  27.         log.info("查询5 start");
  28.         log.info("查询5：getList1->{}", mapper.getList1(null));
  29.     }
  30. }

注意上面的代码，代码中有5次查询，第1次、第2次、第5次查询调用的都是getList1，这个查询对应的mapper xml中的select元素的flushCache属性没有设置，默认是false；而第3次和第4次查询调用的是getList2，getList2这个查询对应的mapper xml中的select(id=getList2)，它的flushCache属性设置的是true，说明第3和第4次查询会清空当前一级缓存中所有数据。

最终效果应该是查询1访问db拿去数据，然后将其丢到一级缓存中，查询2会直接从一级缓存中拿到数据，而查询3走的是getList2，发现flushCache为true，会先清空一级缓存中所有数据，也就是此时查询1放入缓存的数据会被清理掉，然后查询3会访问db获取数据，然后丢到缓存中；而查询4走的是getList2，发现flushCache为true，会先清空缓存，所以3放入一级缓存的数据会被清空，然后导致查询4也会访问db，查询5去一级缓存中查询数据，因为查询1和2放入缓存的数据都被查询3清空了，所以导致查询5发现一级缓存中没有数据，也会访问db去获取数据。

我们来运行一下看看看看是否和我们分析的一致。

运行输出
  1. 20:10.872 [main] INFO  c.j.chat05.demo9.Demo9Test - 查询1 start
  2. 20:11.164 [main] DEBUG c.j.c.d.mapper.UserMapper.getList1 - ==>  Preparing: SELECT id,name,age FROM t_user 
  3. 20:11.195 [main] DEBUG c.j.c.d.mapper.UserMapper.getList1 - ==> Parameters: 
  4. 20:11.216 [main] DEBUG c.j.c.d.mapper.UserMapper.getList1 - <==      Total: 4
  5. 20:11.216 [main] INFO  c.j.chat05.demo9.Demo9Test - 查询1：getList1->[UserModel(id=1, name=路人甲Java, age=30), UserModel(id=2, name=张学友, age=50), UserModel(id=3, name=刘德华, age=50), UserModel(id=100, name=路人, age=30)]
  6. 20:11.218 [main] INFO  c.j.chat05.demo9.Demo9Test - 查询2 start
  7. 20:11.218 [main] INFO  c.j.chat05.demo9.Demo9Test - 查询2：getList1->[UserModel(id=1, name=路人甲Java, age=30), UserModel(id=2, name=张学友, age=50), UserModel(id=3, name=刘德华, age=50), UserModel(id=100, name=路人, age=30)]
  8. 20:11.219 [main] INFO  c.j.chat05.demo9.Demo9Test - 查询3 start
  9. 20:11.219 [main] DEBUG c.j.c.d.mapper.UserMapper.getList2 - ==>  Preparing: SELECT id,name,age FROM t_user 
  10. 20:11.219 [main] DEBUG c.j.c.d.mapper.UserMapper.getList2 - ==> Parameters: 
  11. 20:11.222 [main] DEBUG c.j.c.d.mapper.UserMapper.getList2 - <==      Total: 4
  12. 20:11.222 [main] INFO  c.j.chat05.demo9.Demo9Test - 查询3：getList2->[UserModel(id=1, name=路人甲Java, age=30), UserModel(id=2, name=张学友, age=50), UserModel(id=3, name=刘德华, age=50), UserModel(id=100, name=路人, age=30)]
  13. 20:11.222 [main] INFO  c.j.chat05.demo9.Demo9Test - 查询4 start
  14. 20:11.223 [main] DEBUG c.j.c.d.mapper.UserMapper.getList2 - ==>  Preparing: SELECT id,name,age FROM t_user 
  15. 20:11.223 [main] DEBUG c.j.c.d.mapper.UserMapper.getList2 - ==> Parameters: 
  16. 20:11.225 [main] DEBUG c.j.c.d.mapper.UserMapper.getList2 - <==      Total: 4
  17. 20:11.225 [main] INFO  c.j.chat05.demo9.Demo9Test - 查询4：getList2->[UserModel(id=1, name=路人甲Java, age=30), UserModel(id=2, name=张学友, age=50), UserModel(id=3, name=刘德华, age=50), UserModel(id=100, name=路人, age=30)]
  18. 20:11.225 [main] INFO  c.j.chat05.demo9.Demo9Test - 查询5 start
  19. 20:11.225 [main] DEBUG c.j.c.d.mapper.UserMapper.getList1 - ==>  Preparing: SELECT id,name,age FROM t_user 
  20. 20:11.225 [main] DEBUG c.j.c.d.mapper.UserMapper.getList1 - ==> Parameters: 
  21. 20:11.230 [main] DEBUG c.j.c.d.mapper.UserMapper.getList1 - <==      Total: 4
  22. 20:11.230 [main] INFO  c.j.chat05.demo9.Demo9Test - 查询5：getList1->[UserModel(id=1, name=路人甲Java, age=30), UserModel(id=2, name=张学友, age=50), UserModel(id=3, name=刘德华, age=50), UserModel(id=100, name=路人, age=30)]

大家认真看一下上面的输出，查询1/3/4/5访问了db，查询2从缓存中获取的，和我们上面分析的过程一致。

一级缓存使用总结

  1. 一级缓存是SqlSession级别的，每个人SqlSession有自己的一级缓存，不同的SqlSession之间一级缓存是相互隔离的

  2. mybatis中一级缓存默认是自动开启的

  3. 当在同一个SqlSession中执行同样的查询的时候，会先从一级缓存中查找，如果找到了直接返回，如果没有找到会去访问db，然后将db返回的数据丢到一级缓存中，下次查询的时候直接从缓存中获取

  4. 一级缓存清空的3种方式（1：SqlSession中执行增删改会使一级缓存失效；2：调用SqlSession.clearCache方法会使一级缓存失效；3：Mapper xml中的select元素的flushCache属性置为true，那么执行这个查询会使一级缓存失效）

二级缓存

二级缓存的使用

一级缓存使用上存在局限性，必须要在同一个SqlSession中执行同样的查询，一级缓存才能提升查询速度，如果想在不同的SqlSession之间使用缓存来加快查询速度，此时我们需要用到二级缓存了。

二级缓存是mapper级别的缓存，每个mapper xml有个namespace，二级缓存和namespace绑定的，每个namespace关联一个二级缓存，多个SqlSession可以共用二级缓存，二级缓存是跨SqlSession的。

二级缓存默认是没有开启的，需要我们在mybatis全局配置文件中进行开启：

  1. <settings>
  2.     <!-- 开启二级缓存 -->
  3.     <setting name="cacheEnabled" value="true"/>
  4. </settings>

上面配置好了以后，还需要在对应的mapper xml加上下面配置，表示这个mapper中的查询开启二级缓存：

<cache/>

配置就这么简单。

一二级缓存共存时查询原理

一二级缓存如果都开启的情况下，数据查询过程如下：

  1. 当发起一个查询的时候，mybatis会先访问这个namespace对应的二级缓存，如果二级缓存中有数据则直接返回，否则继续向下

  2. 查询一级缓存中是否有对应的数据，如果有则直接返回，否则继续向下

  3. 访问db获取需要的数据，然后放在当前SqlSession对应的二级缓存中，并且在本地内存中的另外一个地方存储一份（这个地方我们就叫TransactionalCache）

  4. 当SqlSession关闭的时候，也就是调用SqlSession的close方法的时候，此时会将TransactionalCache中的数据放到二级缓存中，并且会清空当前SqlSession一级缓存中的数据。

二级缓存案例

mybatis全局配置文件开启二级缓存配置
  1. <settings>
  2.     <!-- 开启二级缓存 -->
  3.     <setting name="cacheEnabled" value="true"/>
  4. </settings>
mapper xml中使用cache元素开启二级缓存
  1. <!-- 启用二级缓存 -->
  2. <cache/>
  3.  
  4. <select id="getList1" resultType="com.javacode2018.chat05.demo9.model.UserModel" parameterType="map">
  5.     SELECT id,name,age FROM t_user
  6.     <where>
  7.         <if test="id!=null">
  8.             AND id = #{id}
  9.         </if>
  10.         <if test="name!=null and name.toString()!=''">
  11.             AND name = #{name}
  12.         </if>
  13.         <if test="age!=null">
  14.             AND age = #{age}
  15.         </if>
  16.     </where>
  17. </select>
测试用例
  1. com.javacode2018.chat05.demo9.Demo9Test#level2CacheTest1
  2.  
  3. /**
  4.  * 二级缓存测试
  5.  *
  6.  * @throws IOException
  7.  */
  8. @Test
  9. public void level2CacheTest1() throws IOException {
  10.     String mybatisConfig = "demo9/mybatis-config1.xml";
  11.     this.before(mybatisConfig);
  12.     for (int i = 0; i < 2; i++) {
  13.         try (SqlSession sqlSession = this.sqlSessionFactory.openSession(true);) {
  14.             UserMapper mapper = sqlSession.getMapper(UserMapper.class);
  15.             List<UserModel> userModelList1 = mapper.getList1(null);
  16.             log.info("{}", userModelList1);
  17.         }
  18.     }
  19. }

上面执行了2次查询，每次查询都是新的SqlSession，运行一下看看效果。

执行输出
  1. 34:36.574 [main] DEBUG c.j.chat05.demo9.mapper.UserMapper - Cache Hit Ratio [com.javacode2018.chat05.demo9.mapper.UserMapper]: 0.0
  2. 34:36.831 [main] DEBUG c.j.c.d.mapper.UserMapper.getList1 - ==>  Preparing: SELECT id,name,age FROM t_user 
  3. 34:36.864 [main] DEBUG c.j.c.d.mapper.UserMapper.getList1 - ==> Parameters: 
  4. 34:36.883 [main] DEBUG c.j.c.d.mapper.UserMapper.getList1 - <==      Total: 4
  5. 34:36.883 [main] INFO  c.j.chat05.demo9.Demo9Test - [UserModel(id=1, name=路人甲Java, age=30), UserModel(id=2, name=张学友, age=50), UserModel(id=3, name=刘德华, age=50), UserModel(id=100, name=路人, age=30)]
  6. 34:36.894 [main] DEBUG c.j.chat05.demo9.mapper.UserMapper - Cache Hit Ratio [com.javacode2018.chat05.demo9.mapper.UserMapper]: 0.5
  7. 34:36.895 [main] INFO  c.j.chat05.demo9.Demo9Test - [UserModel(id=1, name=路人甲Java, age=30), UserModel(id=2, name=张学友, age=50), UserModel(id=3, name=刘德华, age=50), UserModel(id=100, name=路人, age=30)]

注意上面第一行日志输出：

Cache Hit Ratio [com.javacode2018.chat05.demo9.mapper.UserMapper]: 0.0

对这行做一个解释：com.javacode2018.chat05.demo9.mapper.UserMapper是上面查询访问的mapper xml的namesapce的值，去这个namespace对应的二级缓存中去查询数据，没有查询到，输出中的0.0表示命中率，这次没有命中，所以命中率为0

然后就去db中访问数据了，会将db中返回的数据放在一级缓存中，第一次运行完毕之后会自动调用SqlSession的close方法，然后db中返回的数据会被丢到二级缓存中，第二次查询的时候就直接从二级缓存中获取到数据返回了，所以第二次查询输出如下：

  1. 34:36.894 [main] DEBUG c.j.chat05.demo9.mapper.UserMapper - Cache Hit Ratio [com.javacode2018.chat05.demo9.mapper.UserMapper]: 0.5
  2. 34:36.895 [main] INFO  c.j.chat05.demo9.Demo9Test - [UserModel(id=1, name=路人甲Java, age=30), UserModel(id=2, name=张学友, age=50), UserModel(id=3, name=刘德华, age=50), UserModel(id=100, name=路人, age=30)]

2次查询都去访问了二级缓存，第二次命中了，命中率为1/2=0.5

清空或者跳过二级缓存的3种方式

当二级缓存开启的时候，在某个mapper xml中添加cache元素之后，这个mapper xml中所有的查询都默认开启了二级缓存，那么我们如何清空或者跳过二级缓存呢？3种方式如下：

  1. 对应的mapper中执行增删改查会清空二级缓存中数据

  2. select元素的flushCache属性置为true，会先清空二级缓存中的数据，然后再去db中查询数据，然后将数据再放到二级缓存中

  3. select元素的useCache属性置为true，可以使这个查询跳过二级缓存，然后去查询数据

下面我们来演示一下每种方式对应的效果。

方式1：增删改会清除二级缓存中的数据

下面我们主要演示一下新增对二级缓存的影响。

案例代码
  1. com.javacode2018.chat05.demo9.Demo9Test#level2CacheTest2
  2.  
  3. /**
  4.  * 增删改会清除二级缓存中的数据
  5.  *
  6.  * @throws IOException
  7.  */
  8. @Test
  9. public void level2CacheTest2() throws IOException {
  10.     String mybatisConfig = "demo9/mybatis-config1.xml";
  11.     this.before(mybatisConfig);
  12.     try (SqlSession sqlSession = this.sqlSessionFactory.openSession(true);) {
  13.         UserMapper mapper = sqlSession.getMapper(UserMapper.class);
  14.         List<UserModel> userModelList1 = mapper.getList1(null);
  15.         log.info("{}", userModelList1);
  16.     }
  17.     try (SqlSession sqlSession = this.sqlSessionFactory.openSession(true);) {
  18.         UserMapper mapper = sqlSession.getMapper(UserMapper.class);
  19.         //新增一条数据
  20.         mapper.insert1(UserModel.builder().id(Integer.valueOf(System.nanoTime() % 100000 + "")).name("路人").age(30).build());
  21.     }
  22.     try (SqlSession sqlSession = this.sqlSessionFactory.openSession(true);) {
  23.         UserMapper mapper = sqlSession.getMapper(UserMapper.class);
  24.         List<UserModel> userModelList1 = mapper.getList1(null);
  25.         log.info("{}", userModelList1);
  26.     }
  27. }

上面使用了3个不同的SqlSession，第一次和第三次都调用了getList1执行查询，中间执行了一个插入操作，mybatis执行插入的时候，会先清除当前namespace对应的二级缓存中的数据，所以上面2次查询最终都会访问db，来运行一下看看效果。

运行输出
  1. 23:00.620 [main] DEBUG c.j.chat05.demo9.mapper.UserMapper - Cache Hit Ratio [com.javacode2018.chat05.demo9.mapper.UserMapper]: 0.0
  2. 23:00.900 [main] DEBUG c.j.c.d.mapper.UserMapper.getList1 - ==>  Preparing: SELECT id,name,age FROM t_user 
  3. 23:00.924 [main] DEBUG c.j.c.d.mapper.UserMapper.getList1 - ==> Parameters: 
  4. 23:00.948 [main] DEBUG c.j.c.d.mapper.UserMapper.getList1 - <==      Total: 3
  5. 23:00.948 [main] INFO  c.j.chat05.demo9.Demo9Test - [UserModel(id=1, name=路人甲Java, age=30), UserModel(id=2, name=张学友, age=50), UserModel(id=3, name=刘德华, age=50)]
  6. 23:00.951 [main] DEBUG c.j.c.d.mapper.UserMapper.insert1 - ==>  Preparing: INSERT INTO t_user (id,name,age) VALUES (?,?,?) 
  7. 23:00.953 [main] DEBUG c.j.c.d.mapper.UserMapper.insert1 - ==> Parameters: 79600(Integer), 路人(String), 30(Integer)
  8. 23:00.955 [main] DEBUG c.j.c.d.mapper.UserMapper.insert1 - <==    Updates: 1
  9. 23:00.959 [main] DEBUG c.j.chat05.demo9.mapper.UserMapper - Cache Hit Ratio [com.javacode2018.chat05.demo9.mapper.UserMapper]: 0.0
  10. 23:00.959 [main] DEBUG c.j.c.d.mapper.UserMapper.getList1 - ==>  Preparing: SELECT id,name,age FROM t_user 
  11. 23:00.959 [main] DEBUG c.j.c.d.mapper.UserMapper.getList1 - ==> Parameters: 
  12. 23:00.961 [main] DEBUG c.j.c.d.mapper.UserMapper.getList1 - <==      Total: 4
  13. 23:00.961 [main] INFO  c.j.chat05.demo9.Demo9Test - [UserModel(id=1, name=路人甲Java, age=30), UserModel(id=2, name=张学友, age=50), UserModel(id=3, name=刘德华, age=50), UserModel(id=79600, name=路人, age=30)]
  14. 23:00.961 [main] DEBUG c.j.c.d.mapper.UserMapper.insert1 - ==>  Preparing: INSERT INTO t_user (id,name,age) VALUES (?,?,?) 
  15. 23:00.962 [main] DEBUG c.j.c.d.mapper.UserMapper.insert1 - ==> Parameters: 94100(Integer), 路人(String), 30(Integer)
  16. 23:00.967 [main] DEBUG c.j.c.d.mapper.UserMapper.insert1 - <==    Updates: 1

从输出中可以看出，2次查询都访问了db。上面演示的是插入会清空二级缓存的数据，同样删除和修改也会先清除当前namespace对应的二级缓存中的数据。

方式2：select元素的flushCache属性置为true

当将mapper xml中select元素的flushCache属性置为true，会先清空二级缓存中的数据，然后再去db中查询数据，然后将数据再放到二级缓存中。

代码
  1. <select id="getList2" flushCache="true" resultType="com.javacode2018.chat05.demo9.model.UserModel"
  2.         parameterType="map">
  3.     SELECT id,name,age FROM t_user
  4.     <where>
  5.         <if test="id!=null">
  6.             AND id = #{id}
  7.         </if>
  8.         <if test="name!=null and name.toString()!=''">
  9.             AND name = #{name}
  10.         </if>
  11.         <if test="age!=null">
  12.             AND age = #{age}
  13.         </if>
  14.     </where>
  15. </select>
测试用例
  1. com.javacode2018.chat05.demo9.Demo9Test#level2CacheTest3
  2.  
  3. /**
  4.  * 当将mapper xml中select元素的flushCache属性置为true，会先清空二级缓存中的数据，然后再去db中查询数据，然后将数据再放到二级缓存中
  5.  *
  6.  * @throws IOException
  7.  */
  8. @Test
  9. public void level2CacheTest3() throws IOException {
  10.     String mybatisConfig = "demo9/mybatis-config1.xml";
  11.     this.before(mybatisConfig);
  12.     //先查询2次getList1,getList1第二次会从二级缓存中拿到数据
  13.     log.info("getList1查询");
  14.     for (int i = 0; i < 2; i++) {
  15.         try (SqlSession sqlSession = this.sqlSessionFactory.openSession(true);) {
  16.             UserMapper mapper = sqlSession.getMapper(UserMapper.class);
  17.             List<UserModel> userModelList1 = mapper.getList1(null);
  18.             log.info("{}", userModelList1);
  19.         }
  20.     }
  21.     //getList2的flushCache为true，所以查询之前会先将对应的二级缓存中的所有数据清空，所以二次都会访问db
  22.     log.info("getList2查询");
  23.     for (int i = 0; i < 2; i++) {
  24.         try (SqlSession sqlSession = this.sqlSessionFactory.openSession(true);) {
  25.             UserMapper mapper = sqlSession.getMapper(UserMapper.class);
  26.             List<UserModel> userModelList1 = mapper.getList2(null);
  27.             log.info("{}", userModelList1);
  28.         }
  29.     }
  30.  
  31.     //二级缓存中没有getList1需要查找的数据了，所以这次访问getList1会去访问db
  32.     log.info("getList1查询");
  33.     try (SqlSession sqlSession = this.sqlSessionFactory.openSession(true);) {
  34.         UserMapper mapper = sqlSession.getMapper(UserMapper.class);
  35.         List<UserModel> userModelList1 = mapper.getList1(null);
  36.         log.info("{}", userModelList1);
  37.     }
  38. }
运行输出
  1. 02:51.560 [main] INFO  c.j.chat05.demo9.Demo9Test - getList1查询
  2. 02:51.842 [main] DEBUG c.j.c.d.mapper.UserMapper.getList1 - ==>  Preparing: SELECT id,name,age FROM t_user 
  3. 02:51.871 [main] DEBUG c.j.c.d.mapper.UserMapper.getList1 - ==> Parameters: 
  4. 02:51.891 [main] DEBUG c.j.c.d.mapper.UserMapper.getList1 - <==      Total: 4
  5. 02:51.892 [main] INFO  c.j.chat05.demo9.Demo9Test - [UserModel(id=1, name=路人甲Java, age=30), UserModel(id=2, name=张学友, age=50), UserModel(id=3, name=刘德华, age=50), UserModel(id=5100, name=路人, age=30)]
  6. 02:51.905 [main] DEBUG c.j.chat05.demo9.mapper.UserMapper - Cache Hit Ratio [com.javacode2018.chat05.demo9.mapper.UserMapper]: 0.5
  7. 02:51.906 [main] INFO  c.j.chat05.demo9.Demo9Test - [UserModel(id=1, name=路人甲Java, age=30), UserModel(id=2, name=张学友, age=50), UserModel(id=3, name=刘德华, age=50), UserModel(id=5100, name=路人, age=30)]
  8. 02:51.906 [main] INFO  c.j.chat05.demo9.Demo9Test - getList2查询
  9. 02:51.906 [main] DEBUG c.j.chat05.demo9.mapper.UserMapper - Cache Hit Ratio [com.javacode2018.chat05.demo9.mapper.UserMapper]: 0.3333333333333333
  10. 02:51.907 [main] DEBUG c.j.c.d.mapper.UserMapper.getList2 - ==>  Preparing: SELECT id,name,age FROM t_user 
  11. 02:51.907 [main] DEBUG c.j.c.d.mapper.UserMapper.getList2 - ==> Parameters: 
  12. 02:51.909 [main] DEBUG c.j.c.d.mapper.UserMapper.getList2 - <==      Total: 4
  13. 02:51.909 [main] INFO  c.j.chat05.demo9.Demo9Test - [UserModel(id=1, name=路人甲Java, age=30), UserModel(id=2, name=张学友, age=50), UserModel(id=3, name=刘德华, age=50), UserModel(id=5100, name=路人, age=30)]
  14. 02:51.910 [main] DEBUG c.j.chat05.demo9.mapper.UserMapper - Cache Hit Ratio [com.javacode2018.chat05.demo9.mapper.UserMapper]: 0.5
  15. 02:51.913 [main] DEBUG c.j.c.d.mapper.UserMapper.getList2 - ==>  Preparing: SELECT id,name,age FROM t_user 
  16. 02:51.913 [main] DEBUG c.j.c.d.mapper.UserMapper.getList2 - ==> Parameters: 
  17. 02:51.914 [main] DEBUG c.j.c.d.mapper.UserMapper.getList2 - <==      Total: 4
  18. 02:51.914 [main] INFO  c.j.chat05.demo9.Demo9Test - [UserModel(id=1, name=路人甲Java, age=30), UserModel(id=2, name=张学友, age=50), UserModel(id=3, name=刘德华, age=50), UserModel(id=5100, name=路人, age=30)]
  19. 02:51.915 [main] INFO  c.j.chat05.demo9.Demo9Test - getList1查询
  20. 02:51.915 [main] DEBUG c.j.chat05.demo9.mapper.UserMapper - Cache Hit Ratio [com.javacode2018.chat05.demo9.mapper.UserMapper]: 0.4
  21. 02:51.915 [main] DEBUG c.j.c.d.mapper.UserMapper.getList1 - ==>  Preparing: SELECT id,name,age FROM t_user 
  22. 02:51.915 [main] DEBUG c.j.c.d.mapper.UserMapper.getList1 - ==> Parameters: 
  23. 02:51.917 [main] DEBUG c.j.c.d.mapper.UserMapper.getList1 - <==      Total: 4
  24. 02:51.917 [main] INFO  c.j.chat05.demo9.Demo9Test - [UserModel(id=1, name=路人甲Java, age=30), UserModel(id=2, name=张学友, age=50), UserModel(id=3, name=刘德华, age=50), UserModel(id=5100, name=路人, age=30)]

第一次查询访问db，第二次查询从二级缓存中获取了数据，第3和第4查询访问的是getList2，这个查询会清空二级缓存中的数据，直接去db中查询，查询4执行完毕之后，二级缓存中只有第四次查询的数据，第5次查询去getList1中获取数据，此时二级缓存中没有，所以直接去db中获取了。

方式3：select元素的useCache置为false跳过二级缓存，但是不会情况二级缓存数据

新增一个select3查询，将useCache置为false，如下：

  1. <select id="getList3" useCache="false" resultType="com.javacode2018.chat05.demo9.model.UserModel"
  2.         parameterType="map">
  3.     SELECT id,name,age FROM t_user
  4.     <where>
  5.         <if test="id!=null">
  6.             AND id = #{id}
  7.         </if>
  8.         <if test="name!=null and name.toString()!=''">
  9.             AND name = #{name}
  10.         </if>
  11.         <if test="age!=null">
  12.             AND age = #{age}
  13.         </if>
  14.     </where>
  15. </select>

对应的用例代码

  1. /**
  2.  * select元素的useCache置为false跳过二级缓存，但是不会情况二级缓存数据
  3.  *
  4.  * @throws IOException
  5.  */
  6. @Test
  7. public void level2CacheTest4() throws IOException {
  8.     String mybatisConfig = "demo9/mybatis-config1.xml";
  9.     this.before(mybatisConfig);
  10.     //第一次查询访问getList1，会将数据丢到二级缓存中
  11.     try (SqlSession sqlSession = this.sqlSessionFactory.openSession(true);) {
  12.         UserMapper mapper = sqlSession.getMapper(UserMapper.class);
  13.         List<UserModel> userModelList1 = mapper.getList1(null);
  14.         log.info("{}", userModelList1);
  15.     }
  16.  
  17.     //getList3对应的select的useCache为false，会跳过二级缓存，所以会直接去访问db
  18.     for (int i = 0; i < 2; i++) {
  19.         try (SqlSession sqlSession = this.sqlSessionFactory.openSession(true);) {
  20.             UserMapper mapper = sqlSession.getMapper(UserMapper.class);
  21.             List<UserModel> userModelList1 = mapper.getList3(null);
  22.             log.info("{}", userModelList1);
  23.         }
  24.     }
  25.  
  26.     //下面的查询又去执行了getList1，由于上面的第一次查询也是访问getList1会将数据放在二级缓存中，所以下面的查询会从二级缓存中获取到数据
  27.     try (SqlSession sqlSession = this.sqlSessionFactory.openSession(true);) {
  28.         UserMapper mapper = sqlSession.getMapper(UserMapper.class);
  29.         List<UserModel> userModelList1 = mapper.getList1(null);
  30.         log.info("{}", userModelList1);
  31.     }
  32. }

注意上面有4次查询，第一次查询访问getList1，会将数据丢到二级缓存中，而第二三次查询访问的是getList3，getList3对应的select的useCache为false，会跳过二级缓存，所以会直接去访问db，第四次查询也是访问getList1，由于第一次查询也是访问getList1会将数据放在二级缓存中，所以第4次查询直接从二级缓存中获取到了数据，运行输出：

  1. 13:38.454 [main] DEBUG c.j.chat05.demo9.mapper.UserMapper - Cache Hit Ratio [com.javacode2018.chat05.demo9.mapper.UserMapper]: 0.0
  2. 13:38.852 [main] DEBUG c.j.c.d.mapper.UserMapper.getList1 - ==>  Preparing: SELECT id,name,age FROM t_user 
  3. 13:38.898 [main] DEBUG c.j.c.d.mapper.UserMapper.getList1 - ==> Parameters: 
  4. 13:38.929 [main] DEBUG c.j.c.d.mapper.UserMapper.getList1 - <==      Total: 4
  5. 13:38.930 [main] INFO  c.j.chat05.demo9.Demo9Test - [UserModel(id=1, name=路人甲Java, age=30), UserModel(id=2, name=张学友, age=50), UserModel(id=3, name=刘德华, age=50), UserModel(id=5100, name=路人, age=30)]
  6. 13:38.941 [main] DEBUG c.j.c.d.mapper.UserMapper.getList3 - ==>  Preparing: SELECT id,name,age FROM t_user 
  7. 13:38.942 [main] DEBUG c.j.c.d.mapper.UserMapper.getList3 - ==> Parameters: 
  8. 13:38.945 [main] DEBUG c.j.c.d.mapper.UserMapper.getList3 - <==      Total: 4
  9. 13:38.945 [main] INFO  c.j.chat05.demo9.Demo9Test - [UserModel(id=1, name=路人甲Java, age=30), UserModel(id=2, name=张学友, age=50), UserModel(id=3, name=刘德华, age=50), UserModel(id=5100, name=路人, age=30)]
  10. 13:38.946 [main] DEBUG c.j.c.d.mapper.UserMapper.getList3 - ==>  Preparing: SELECT id,name,age FROM t_user 
  11. 13:38.946 [main] DEBUG c.j.c.d.mapper.UserMapper.getList3 - ==> Parameters: 
  12. 13:38.952 [main] DEBUG c.j.c.d.mapper.UserMapper.getList3 - <==      Total: 4
  13. 13:38.952 [main] INFO  c.j.chat05.demo9.Demo9Test - [UserModel(id=1, name=路人甲Java, age=30), UserModel(id=2, name=张学友, age=50), UserModel(id=3, name=刘德华, age=50), UserModel(id=5100, name=路人, age=30)]
  14. 13:38.957 [main] DEBUG c.j.chat05.demo9.mapper.UserMapper - Cache Hit Ratio [com.javacode2018.chat05.demo9.mapper.UserMapper]: 0.5
  15. 13:38.957 [main] INFO  c.j.chat05.demo9.Demo9Test - [UserModel(id=1, name=路人甲Java, age=30), UserModel(id=2, name=张学友, age=50), UserModel(id=3, name=刘德华, age=50), UserModel(id=5100, name=路人, age=30)]

从输出中可以看出前面3次查询都访问db了，最后一次查询访问的是二级缓存命中了数据。4次查询，第1次和第4次会访问二级缓存，中间2次跳过了二级缓存，二级缓存命中了1次，所以最后一次输出的命中率是0.5

总结

  1. 一二级缓存访问顺序：一二级缓存都存在的情况下，会先访问二级缓存，然后再访问一级缓存，最后才会访问db，这个顺序大家理解一下

  2. 将mapper xml中select元素的flushCache属性置为false，最终会清除一级缓存所有数据，同时会清除这个select所在的namespace对应的二级缓存中所有的数据

  3. 将mapper xml中select元素的useCache置为false，会使这个查询跳过二级缓存

  4. 总体上来说使用缓存可以提升查询效率，这块知识掌握了，大家可以根据业务自行选择

案例代码 

  1. 链接：https://pan.baidu.com/s/1vt-MAX3oJOu9gyxZAhKkbg 
  2. 提取码：i8op

MyBatis系列

  1. MyBatis系列第1篇：MyBatis未出世之前我们那些痛苦的经历

  2. MyBatis系列第2篇：入门篇，带你感受一下mybatis独特的魅力！

  3. MyBatis系列第3篇：Mybatis使用详解（1）

  4. MyBatis系列第4篇：Mybatis使用详解（2）

  5. Mybatis系列第5篇：Mapper接口多种方式传参详解、原理、源码解析

  6. Mybatis系列第6篇：恕我直言，mybatis增删改你未必玩得转!

  7. Mybatis系列第7篇：各种查询详解

  8. Mybatis系列第8篇：自动映射，使用需谨慎！

  9. Mybatis系列第9篇：延迟加载、鉴别器、继承怎么玩？

  10. Mybatis系列第10篇：动态SQL，这么多种你都会？

  11. Mybatis系列第11篇：类型处理器，这个你得会玩

更多好文章

  1. Java高并发系列（共34篇）

  2. MySql高手系列（共27篇）

  3. Maven高手系列（共10篇）

  4. 聊聊db和缓存一致性常见的实现方式

  5. 接口幂等性这么重要，它是什么？怎么实现？

感谢大家的阅读，也欢迎您把这篇文章分享给更多的朋友一起阅读！谢谢！

路人甲java

▲长按图片识别二维码关注

路人甲Java：工作10年的前阿里P7分享Java、算法、数据库方面的技术干货！坚信用技术改变命运，让家人过上更体面的生活！来源：https://itsoku.blog.csdn.net/article/details/103982277

posted @ 2022-04-23 03:19  程序员小明1024  阅读(99)  评论(0)  编辑  收藏  举报