AI专业者开发社区 1 号成员
  •  0 回帖  •  2 浏览  •  5 个月前
 

SpringBoot 下 mybatis 的缓存

背景：

　　说起 mybatis，作为 Java 程序员应该是无人不知，它是常用的数据库访问框架。与 Spring 和 Struts 组成了 Java Web 开发的三剑客 --- SSM。当然随着 Spring Boot 的发展，现在越来越多的企业采用的是 SpringBoot + mybatis 的模式开发，我们公司也不例外。而 mybatis 对于我也仅仅停留在会用而已，没想过怎么去了解它，更不知道它的缓存机制了，直到那个生死难忘的 BUG。故事的背景比较长，但并不是啰嗦，只是让读者知道这个 BUG 触发的场景，加深记忆。在遇到类似问题时，可以迅速定位。

　　先说下故事的前提，为了防止用户在动态中输入特殊字符，用户的动态都是编码后发到后台，而后台在存入到 DB 表之前会解码以方便在 DB 中查看以及上报到搜索引擎。而在查询用户动态的时候先从 DB 表中读取并在后台做一次编码再传到前端，前端再解码既可以正常展示了。流程如下图：

​

　　有一天后端预发环境发布完毕后，用户的动态页面有的动态显示正常，而有的动态却是被编码过的。看到现象后的第一个反应就是部分被编码了两次，但是编码操作只会在 service 层的 findById 中有。理论不会在上层犯这种低级错误，于是开始排查新增加的代码。发现只要进入了新增加代码中的某个 if 分支则被编码了两次。分支中除了再次调用 findById（必要性不讨论），也无其他特殊代码了。百思不得其解后请教了旁边的老司机，老司机说可能是 mybatis 缓存。于是看了下我代码，将编码的操作从 findById 中移出来后再次发布到预发，正常了，心想老司机不愧是老司机。本次 BUG 触发的有两个条件需要注意：

  •  整个操作过程都在一个函数中，而函数上面加了 @Transactional 的注解（对 mybatis 来说是在同一个 SESSION 中）
  •  一般只会调用 findByIdy 一次，如果进入分支则会调用两次 （第一次调用后做了编码后被缓存，第二次从缓存读后继续被编码）

　　于是，便开始谷歌 mybatis 的缓存机制，搜到了一篇非常不错的文章《聊聊 mybatis 的缓存机制》，推荐大家看一下，特别是里面的流程图。同时关注下美团技术官方公众号，上面有很多干货（这不是广告）。但是这篇文章讲到了源码，涉及的比较深。而且并没讲 SpringBoot 下 mybatis 下的一些缓存知识点，遂作此篇，以作补充。

缓存的配置

　　SpringBoot + mybatis 环境搭建很简单而且网上一堆教程，这里不班门弄斧了，记得在项目中将 mytatis 的源码下载下来即可。mybaits 一共有两级缓存：一级缓存的配置 key 是 localCacheScope，而二级缓存的配置 key 是 cacheEnabled，从名字上可以得出以下信息：

  •  一级缓存是本地或者说局部缓存，它不能被关闭，只能配置缓存范围。SESSION 或者 STATEMENT。
  •  二级缓存才是 mybatis 的正统，功能应该会更强大些。

　　先来看下在 SpringBoot 中 如何配置 mybatis 缓存的相关信息。默认情况下 SpringBoot 下的 mybatis 一级缓存为 SESSION 级别，二级缓存也是打开的，可以在 mybatis 源码中的 org.apache.ibatis.session.Configuration.class 文件中看到（idea 中打开），如下图：

​

　　也可以通过以下测试程序查看缓存开启情况

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@RunWith(SpringRunner.class)
@SpringBootTest
public class LearnApplicationTests {
    private SqlSessionFactory factory;
    @Before
    public void setUp() throws Exception {
 
        InputStream inputStream = Resources.getResourceAsStream("mybatis/mybatis-config.xml");
        factory = new SqlSessionFactoryBuilder().build(inputStream);
    }
    @Test
    public void showDefaultCacheConfiguration() {
        System.out.println("一级缓存范围: " + factory.getConfiguration().getLocalCacheScope());
        System.out.println("二级缓存是否被启用: " + factory.getConfiguration().isCacheEnabled());
    }
}

　　

　　如果要设置一级缓存的缓存级别和开关二级缓存，在 mybatis-config.xml （当然也可以在 application.xml/yml 中配置）加入如下配置即可：
?
1
2
3
4
<settings>
  <setting name="cacheEnabled" value="true/false"/>
  <setting name="localCacheScope" value="SESSION/STATEMENT"/>
</settings>

　　但需要注意的是二级缓存 cacheEnabled 只是个总开关，如果要让二级缓存真正生效还需要在 mapper xml 文件中加入 <cache /> 。一级缓存只在同一 SESSION 或者 STATEMENT 之间共享，二级缓存可以跨 SESSION，开启后它们默认具有如下特性：

  •  映射文件中所有的 select 语句将被缓存
  •  映射文件中所有的 insert、update 和 delete 语句将刷新缓存 

　　一二级缓存同时开启的情况下，数据的查询顺序是 二级缓存 -> 一级缓存 -> 数据库。一级缓存比较简单，而二级缓存可以设置更多的属性，只需要在 mapper 的 xml 文件中的 <cache /> 配置即可，具体如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
<cache
        type = "org.mybatis.caches.ehcache.LoggingEhcache"  //指定使用的缓存类，mybatis默认使用HashMap进行缓存,可以指定第三方缓存
        eviction = "LRU"  //默认是 LRU 淘汰缓存的算法，有如下几种：
                          //1.LRU – 最近最少使用的:移除最长时间不被使用的对象。
                          //2.FIFO – 先进先出:按对象进入缓存的顺序来移除它们。 
                          //3.SOFT – 软引用:移除基于垃圾回收器状态和软引用规则的对象。 
                          //4.WEAK – 弱引用:更积极地移除基于垃圾收集器状态和弱引用规则的对象
        flushInterval = "1000"  //清空缓存的时间间隔，单位毫秒，可以被设置为任意的正整数。  默认情况是不设置，也就是没有刷新间隔，缓存仅仅调用语句时刷新。
        size = "100"      //缓存对象的个数，任意正整数，默认值是1024。
       readOnly  = "true"  //缓存是否只读，提高读取效率
       blocking = "true"   //是否使用阻塞缓存，默认为false，当指定为true时将采用BlockingCache进行封装，blocking，
                           //阻塞的意思，使用BlockingCache会在查询缓存时锁住对应的Key，如果缓存命中了则会释放对应的锁，
                           //否则会在查询数据库以后再释放锁这样可以阻止并发情况下多个线程同时查询数据，详情可参考BlockingCache的源码。 
/>

　　

触发 mybatis 缓存

　　（1）配置一级缓存为 SESSION 级别

　　Controller 中做两次调用，代码如下：

?
1
2
3
4
5
6
7
8
@RequestMapping("/getUser")
public UserEntity getUser(Long id) {
    //第一次调用
    UserEntity user1=userMapper.getOne(id);
    //第二次调用
    UserEntity user2=userMapper.getOne(id);
    return user1;
}
　　调用：http://localhost:8080/getUser?id=1，打印结果如下：

​

　　从图中的 1/2/3/4 可以看出每次 mapper 层的一次接口调用如 getOne 就会创建一个 session，并且在执行完毕后关闭 session。所以两次调用并不在一个 session 中，一级缓存并没有发生作用。开启事务，Controller 层代码如下：

?
1
2
3
4
5
6
7
8
9
@RequestMapping("/getUser")
@Transactional(rollbackFor = Throwable.class)
public UserEntity getUser(Long id) {
    //第一次调用
    UserEntity user1=userMapper.getOne(id);
    //第二次调用
    UserEntity user2=userMapper.getOne(id);
    return user1;
}

　　

　　打印结果如下：

​

　　由于在同一个事务中，虽然调用了 select 操作两次但是只执行了一次 sql ，缓存发挥了作用。这就跟一开始我遇到的那个 BUG 场景一样：同一 session 且 select 调用 > 1 次。如果在两次调用中间插入 update 操作，缓存会立即失效。只要 session 中有 insert、update 和 delete 语句，该 session 中的缓存会立即被刷新。但是注意这只是在同一 session 之间。不同 session 之间如 session1 和 session2，session1 里的 insert/update/delete 并不会影响 session 2 下的缓存，这在高并发或者分布式的情况下会产生脏数据。所以建议将一级缓存级别调成 statement。

　　（2）配置一级缓存为 STATEMENT 级别

　　再次将（1）中的无事务和有事务的代码分别执行一遍，打印结果始终如下：

​

　　配置成 SATEMENT 后，一级缓存相当于被关闭了。STATEMENT 级别暂时不好模拟，但是我猜测 STATEMENT 级别即在同一执行 sql 的接口中（如上面的 getOne 中）缓存，出了 getOne 缓存即失效。

　　（3）二级缓存，同时为了避免一级缓存的干扰，将一级缓存设置为 STATEMENT

　　Controller 中去掉 @Transactional 注解代码如下：

?
1
2
3
4
5
6
@RequestMapping("/getUser")
public UserEntity getUser(Long id) {
    UserEntity user1=userMapper.getOne(id);
    UserEntity user2=userMapper.getOne(id);
    return user1;
}

　　二级缓存开关保证打开，在 mapper xml 文件中加入 <cache />，整个文件代码如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.binggle.learn.dao.mapper.UserMapper" >
<resultMap id="BaseResultMap" type="com.binggle.learn.dao.entity.UserEntity" >
    <id column="id" property="id" jdbcType="BIGINT" />
    <result column="name" property="name" jdbcType="VARCHAR" />
    <result column="sex" property="sex"/>
</resultMap>
<sql id="Base_Column_List" >
        id, name, sex
</sql>
<select id="getOne" parameterType="java.lang.Long" resultMap="BaseResultMap" >
    SELECT
    <include refid="Base_Column_List" />
    FROM users
    WHERE id = #{id};
</select>
<cache />
</mapper>

　　执行 http://localhost:8080/getUser?id=1，打印结果如下：

 

​

　　从图中红框可以看出第二次查询命中缓存，0.5 是命中率，

　　再次执行 http://localhost:8080/getUser?id=1 打印结果如下：

​

　　这次一次 sql 也没执行了，所以说二级缓存全局缓存。但它的缓存范围也是有限的，一级缓存在同一个 session 中。二级缓存可以跨 session 但也只能在同一 namespace 中，所谓 namespace 即 mapper xml 文件中。具体实验请看《聊聊 mybatis 的缓存机制》中的关于二级缓存的实验 4 和 5。再看下二级缓存配置对二级缓存的影响，为了明显的看出效果，只改如下配置：

?
1
2
3
4
<cache
        size="1"             //一次只能缓存一个对象
        flushInterval="5000" //刷新时间为 5s
/>

　　controller 代码：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
@RequestMapping("/getUser")
public UserEntity getUser(Long id, Long id2) {
    //第一个对象 1
    System.out.println("================缓存对象 1=================");
    UserEntity user1 = userMapper.getOne(id);
 
    //另一个对象 2
    System.out.println("========缓存对象 2，剔除缓存中的对象 1=======");
    UserEntity user2=userMapper.getOne(id2);
    user2 = userMapper.getOne(id2);
 
    //再次读取第一个对象
    System.out.println("==========缓存被剔除，执行查询 sql===========");
    user1 = userMapper.getOne(id);
 
    //暂停 5s
    try {
        sleep(5000);
    }catch (Exception e){
        e.printStackTrace();
    }
 
    System.out.println("============5s 后再次查询对象 2=============");
    user2 = userMapper.getOne(id2);
 
    return user1;
}

　　http://localhost:8080/getUser?id=1&id2=2 最后打印的结果如下：

　　太长了，拼接下：

​

　　可以看出二级缓存只能缓存一个对象且 5s 后就失效了，缓存失效。

总结：

　　我推荐的文章中总结的已经非常好了，直接引用下：

1、MyBatis 一级缓存的生命周期和 SqlSession 一致。

2、MyBatis 一级缓存内部设计简单，只是一个没有容量限定的 HashMap，在缓存的功能性上有所欠缺。

3、MyBatis 的一级缓存最大范围是 SqlSession 内部，有多个 SqlSession 或者分布式的环境下，数据库写操作会引起脏数据，建议设定缓存级别为 Statement。

4、MyBatis 的二级缓存相对于一级缓存来说，实现了 SqlSession 之间缓存数据的共享，同时粒度更加的细，能够到 namespace 级别，通过 Cache 接口实现类不同的组合，对 Cache 的可控性也更强。

5、MyBatis 在多表查询时，极大可能会出现脏数据，有设计上的缺陷，安全使用二级缓存的条件比较苛刻。

6、在分布式环境下，由于默认的 MyBatis Cache 实现都是基于本地的，分布式环境下必然会出现读取到脏数据，需要使用集中式缓存将 MyBatis 的 Cache 接口实现，有一定的开发成本，直接使用 Redis、Memcached 等分布式缓存可能成本更低，安全性也更高。

7. 个人建议 MyBatis 缓存特性在生产环境中进行关闭，单纯作为一个 ORM 框架使用可能更为合适。