缓存-提高检索效率的利器
2023年11月16日大约 18 分钟约 3520 字
官方文档
https://mybatis.org/mybatis-3/zh/sqlmap-xml.html#cache
一级缓存
基本介绍
- 默认情况下，mybatis 是启用一级缓存的/本地缓存/local Cache，它是 SqlSession 级别的。
- 同一个 SqlSession 接口对象调用了相同的 select 语句，会直接从缓存里面获取，而不是再去查询数据库。
快速入门
当我们第 1 次查询 id=1 的 Monster 后，再次查询 id=1 的 monster 对象，就会直接 从一级缓存获取,不会再次发出 sql。
创建新的module
必要的文件和配置直接从mybatis_quickstart module 拷贝即可
使用 MonsterMapperTest.java，运行 getMonsterById() 看看是否可以看到日志输出，结论我们多次运行，总是会发出 SQL。
package com.lzw.mapper;
import com.lzw.entity.Monster;
import com.lzw.util.MyBatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Before;
import org.junit.Test;
import java.util.List;
/**
* @author LiAng
*/
public class MonsterMapperTest {
private SqlSession sqlSession;
private MonsterMapper monsterMapper;
@Before
public void init(){
//获取到 sqlSession
sqlSession = MyBatisUtils.getSqlSession();
//获取到到MonsterMapper对象 class com.sun.proxy.$Proxy7 代理对象
//, 底层是使用了动态代理机制
monsterMapper = sqlSession.getMapper(MonsterMapper.class);
System.out.println("monsterMapper = " + monsterMapper.getClass());
}
@Test
public void getMonsterById(){
Monster monster = monsterMapper.getMonsterById(3);
System.out.println(monster);
if(sqlSession != null){
sqlSession.close();
}
System.out.println("查询成功");
}
@Test
public void findAllMonster(){
List<Monster> monsters = monsterMapper.findAllMonster();
for (Monster monster : monsters) {
System.out.println(monster);
}
if(sqlSession != null){
sqlSession.close();
}
System.out.println("查询成功");
}
}
修改MonsterMapperTest.java
@Test
public void level1CacheTest(){
//查询id=3的monster
Monster monster = monsterMapper.getMonsterById(3);
System.out.println("monster=" + monster);
//再次查询id=3的monster
System.out.println("=======因为一级缓存默认是打开的，再次查询相同的id时，不会再发出sql=======");
Monster monster2 = monsterMapper.getMonsterById(3);
System.out.println("monster2=" + monster);
if(sqlSession != null){
sqlSession.close();
}
}
一级缓存失效分析
- 关闭 sqlSession 会话后，再次查询，会到数据库查询，修改 MonsterMapperTest.java，测试一级缓存失效情况。
//测试一级缓存,失效
//关闭sqlSession会话后 , 一级缓存失效
@Test
public void level1CacheTest2() {
//查询id=3的monster
Monster monster = monsterMapper.getMonsterById(3);
System.out.println("monster=" + monster);
//关闭sqlSession, 一级缓存失效
if (sqlSession != null) {
sqlSession.close();
}
//因为关闭了sqlSession,所以需要重新初始化sqlSession和 monsterMapper
sqlSession = MyBatisUtils.getSqlSession();
monsterMapper = sqlSession.getMapper(MonsterMapper.class);
//再次查询id=3的monster
System.out.println("--如果你关闭了sqlSession,当你再次查询相同的id时, 仍然会发出sql----");
Monster monster2 = monsterMapper.getMonsterById(3);
System.out.println("monster2=" + monster2);
if (sqlSession != null) {
sqlSession.close();
}
}- 当执行 sqlSession.clearCache() 会使一级缓存失效，修改 MonsterMapperTest.java，测试一级缓存失效情况。
修改 MonsterMapperTest.java
//测试一级缓存,失效
//如果执行sqlSession.clearCache() , 会导致一级缓存失效
@Test
public void level1CacheTest3() {
//查询id=3的monster
Monster monster = monsterMapper.getMonsterById(3);
System.out.println("monster=" + monster);
//执行clearCache
/**
* @Override
* public void clearCache() {
* executor.clearLocalCache();
* }
*/
sqlSession.clearCache();
//再次查询id=3的monster
System.out.println("--如果你执行sqlSession.clearCache(),当你再次查询相同的id时, 仍然会发出sql----");
Monster monster2 = monsterMapper.getMonsterById(3);
System.out.println("monster2=" + monster2);
if (sqlSession != null) {
sqlSession.close();
}
}- 当对同一个 monster 修改，该对象在一级缓存会失效，修改 MonsterMapperTest.java，测试。
修改 MonsterMapper.java
package com.lzw.mapper;
import com.lzw.entity.Monster;
import java.util.List;
/**
* @author LiAng
*/
public interface MonsterMapper {
//查询-根据id
public Monster getMonsterById(Integer id);
//查询所有的Monster
public List<Monster> findAllMonster();
//修改Monster
public void updateMonster(Monster monster);
}修改 MonsterMapper.xml
<!--配置updateMonster方法-->
<update id="updateMonster" parameterType="Monster">
UPDATE `monster`
SET `age`=#{age} , `birthday`= #{birthday}, `email` = #{email},
`gender` = #{gender} , `name`= #{name}, `salary` = #{salary}
WHERE id = #{id}
</update>修改 MonsterMapperTest.java
//测试一级缓存,失效
//如果修改了同一个对象 , 会导致一级缓存[对象数据]失效
@Test
public void level1CacheTest4() {
//查询id=3的monster
Monster monster = monsterMapper.getMonsterById(3);
System.out.println("monster=" + monster);
//如果修改了同一个对象 , 会导致一级缓存[对象数据]失效
monster.setName("蚂蚱精");
monsterMapper.updateMonster(monster);
//再次查询id=3的monster
System.out.println("--如果你修改了同一个对象,当你再次查询相同的id时, 仍然会发出sql----");
Monster monster2 = monsterMapper.getMonsterById(3);
System.out.println("monster2=" + monster2);
if (sqlSession != null) {
sqlSession.commit();//这里需要commit
sqlSession.close();
}
}二级缓存
基本介绍
- 二级缓存和一级缓存都是为了提高检索效率的技术。
- 最大的区别就是作用域的范围不一样，一级缓存的作用域是 sqlSession 会话级别，在一次会话有效，而二级缓存作用域是全局范围，针对不同的会话都有效。
快速入门
修改 mybatis-config.xml
<setting name="cacheEnabled" value="true"/>使用二级缓存时 entity 类实现序列化接口 (serializable)
因为二级缓存可能使用到序列化技术。
在对应的 MonsterMapper.xml 中设置二级缓存的策略
<!--
1、配置二级缓存： 是mybatis自带
2、FIFO – 先进先出：按对象进入缓存的顺序来移除它们。
3. flushInterval 刷新间隔 是毫秒单位 60000 表示 60s
4. size="512": 引用数目, 属性可以被设置为任意正整数, 默认1024
5. readOnly="true": (只读）属性可以被设置为 true 或 false: 如果我们只是用于读操作,
建议设置成 true, 这样可以提示效率, 如果有修改操作，设置成 false, 默认就是false
-->
<cache eviction="FIFO" flushInterval="60000" size="512" readOnly="true"/>修改MonsterMapperTest.java
//测试二级缓存的使用
@Test
public void level2CacheTest() {
//查询id=3的monster
Monster monster = monsterMapper.getMonsterById(3);
System.out.println("monster=" + monster);
//这里关闭sqlSession
if (sqlSession != null) {
sqlSession.close();
}
//重新获取sqlSession
sqlSession = MyBatisUtils.getSqlSession();
//重新获取了monsterMapper
monsterMapper = sqlSession.getMapper(MonsterMapper.class);
//再次查询id=3的monster
System.out.println("--虽然前面关闭了sqlSession,因为配置二级缓存, " +
"当你再次查询相同的id时, 依然不会再发出sql, 而是从二级缓存获取数据----");
Monster monster2 = monsterMapper.getMonsterById(3);
System.out.println("monster2=" + monster2);
Monster monster3 = monsterMapper.getMonsterById(3);
System.out.println("monster3=" + monster3);
if (sqlSession != null) {
sqlSession.close();
}
}
注意事项和使用细节
- 理解二级缓存策略的参数
<cache eviction="FIFO" flushInterval="30000" size="360" readOnly="true"/>上面的配置意思如下：
创建了 FIFO 的策略，每隔 30 秒刷新一次，最多存放 360 个对象而且返回的对象被认为是只读的。
eviction：缓存的回收策略。
flushInterval：时间间隔，单位是毫秒。
size：引用数目，内存大就多配置点，要记住你缓存的对象数目和你运行环境的可用内存资源数目。默认值是1024。
readOnly：true，只读。
- 四大策略
（1）LRU – 最近最少使用的：移除最长时间不被使用的对象，它是默认。
（2）FIFO – 先进先出：按对象进入缓存的顺序来移除它们。
（3）SOFT – 软引用：移除基于垃圾回收器状态和软引用规则的对象。
（4）WEAK – 弱引用：更积极地移除基于垃圾收集器状态和弱引用规则的对象。
- 如何禁用二级缓存
（1）mybatis-config文件中
<!--全局性地开启或关闭所有映射器配置文件中已配置的任何缓存, 默认就是 true-->
<setting name="cacheEnabled" value="false"/>（2）MonsterMapper.xml文件中
<!--<cache eviction="FIFO" flushInterval="60000" size="512" readOnly="true"/>-->（3）配置方法上指定
<!--配置getMonsterById-->
<select id="getMonsterById" resultType="Monster" useCache="false">
SELECT * FROM `monster` WHERE id = #{id}
</select>- mybatis 刷新二级缓存的设置
<!--配置updateMonster方法-->
<update id="updateMonster" parameterType="Monster" flushCache="true">
UPDATE `monster`
SET `age`=#{age} , `birthday`= #{birthday}, `email` = #{email},
`gender` = #{gender} , `name`= #{name}, `salary` = #{salary}
WHERE id = #{id}
</update>insert、update、delete 操作数据后需要刷新缓存，如果不执行刷新缓存会出现脏读，默认为 true，默认情况下为 true 即刷新缓存，一般不用修改。
一级缓存和二级缓存执行顺序
缓存执行顺序是：二级缓存-->一级缓存-->数据库。
代码演示
修改 MonsterMapperTest.java
//演示二级缓存->一级缓存->DB执行的顺序
@Test
public void cacheSeqTest() {
System.out.println("查询第1次");
//DB, 会发出SQL, 分析cache hit ratio 0.0
Monster monster1 = monsterMapper.getMonsterById(3);
System.out.println(monster1);
//这里关闭sqlSession, 一级缓存数据没有
//当我们关闭一级缓存的时候，如果你配置二级缓存,那么一级缓存的数据，会放入到二级缓存
sqlSession.close();
sqlSession = MyBatisUtils.getSqlSession();
monsterMapper = sqlSession.getMapper(MonsterMapper.class);
System.out.println("查询第2次");
//从二级缓存获取id=3 monster , 就不会发出SQL, 分析cache hit ratio 0.5
Monster monster2 = monsterMapper.getMonsterById(3);
System.out.println(monster2);
System.out.println("查询第3次");
//从二级缓存获取id=3 monster, 不会发出SQL, 分析cache hit ratio 0.6666
Monster monster3 = monsterMapper.getMonsterById(3);
System.out.println(monster3);
if (sqlSession != null) {
sqlSession.close();
}
System.out.println("操作成功");
}结果
查询第1次
Cache Hit Ratio [com.lzw.mapper.MonsterMapper]: 0.0
Opening JDBC Connection
Created connection 611563982.
Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@2473b9ce]
==> Preparing: SELECT * FROM `monster` WHERE id = ?
==> Parameters: 3(Integer)
<== Columns: id, age, birthday, email, gender, name, salary
<== Row: 3, 66, 2000-12-12, nmw@sohu.com, 1, 蚂蚱精, 9999
<== Total: 1
Monster{id=3, age=66, name='蚂蚱精', email='nmw@sohu.com', birthday=Tue Dec 12 00:00:00 CST 2000, salary=9999.0, gender=1}
Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@2473b9ce]
Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@2473b9ce]
Returned connection 611563982 to pool.
查询第2次
Cache Hit Ratio [com.lzw.mapper.MonsterMapper]: 0.5
Monster{id=3, age=66, name='蚂蚱精', email='nmw@sohu.com', birthday=Tue Dec 12 00:00:00 CST 2000, salary=9999.0, gender=1}
查询第3次
Cache Hit Ratio [com.lzw.mapper.MonsterMapper]: 0.6666666666666666
Monster{id=3, age=66, name='蚂蚱精', email='nmw@sohu.com', birthday=Tue Dec 12 00:00:00 CST 2000, salary=9999.0, gender=1}细节说明
不会出现一级缓存和二级缓存中有同一个数据。因为二级缓存(数据)是在一级缓存关闭之后才有的。
EHCache 缓存
配置文档
https://www.cnblogs.com/zqyanywn/p/10861103.html
基本介绍
- EHCache 是一个纯 Java 的缓存框架，具有快速、精干等特点 。
- MyBatis 有自己默认的二级缓存(前面我们已经使用过了)，但是在实际项目中，往往使用的是更加专业的第三方缓存产品作为 MyBatis 的二级缓存，EHCache 就是非常优秀的缓存产品。
配置和使用 EhCache
加入相关依赖，修改 pom.xml
<dependencies>
<!--引入ehcache核心库/jar-->
<dependency>
<groupId>net.sf.ehcache</groupId>
<artifactId>ehcache-core</artifactId>
<version>2.6.11</version>
</dependency>
<!--引入需要使用的slf4j-->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.7.25</version>
</dependency>
<!--引入mybatis整合ehcache库/jar-->
<dependency>
<groupId>org.mybatis.caches</groupId>
<artifactId>mybatis-ehcache</artifactId>
<version>1.2.1</version>
</dependency>
</dependencies>mybatis-config.xml 打开二级缓存
<settings>
<!--默认是打开的-->
<setting name="cacheEnabled" value="true"/>
</settings>加入 resources\ehcache.xml 配置文件
文档说明：https://www.taobye.com/f/view-11-23.html
<?xml version="1.0" encoding="UTF-8"?>
<ehcache>
<!--
diskStore：为缓存路径，ehcache分为内存和磁盘两级，此属性定义磁盘的缓存位置。参数解释如下：
user.home – 用户主目录
user.dir – 用户当前工作目录
java.io.tmpdir – 默认临时文件路径
-->
<diskStore path="java.io.tmpdir/Tmp_EhCache"/>
<!--
defaultCache：默认缓存策略，当ehcache找不到定义的缓存时，则使用这个缓存策略。只能定义一个。
-->
<!--
name:缓存名称。
maxElementsInMemory:缓存最大数目
maxElementsOnDisk：硬盘最大缓存个数。
eternal:对象是否永久有效，一但设置了，timeout将不起作用。
overflowToDisk:是否保存到磁盘，当系统宕机时
timeToIdleSeconds:设置对象在失效前的允许闲置时间（单位：秒）。仅当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大。
timeToLiveSeconds:设置对象在失效前允许存活时间（单位：秒）。最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用，默认是0.，也就是对象存活时间无穷大。
diskPersistent：是否缓存虚拟机重启期数据 Whether the disk store persists between restarts of the Virtual Machine. The default value is false.
diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。
diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认是120秒。
memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。默认策略是LRU（最近最少使用）。你可以设置为FIFO（先进先出）或是LFU（较少使用）。
clearOnFlush：内存数量最大时是否清除。
memoryStoreEvictionPolicy:可选策略(清除策略)有：LRU（最近最少使用，默认策略）、FIFO（先进先出）、LFU（最少访问次数）。
FIFO，first in first out，这个是大家最熟的，先进先出。
LFU， Less Frequently Used，就是上面例子中使用的策略，直白一点就是讲一直以来最少被使用的。如上面所讲，缓存的元素有一个hit属性，hit值最小的将会被清出缓存。
LRU，Least Recently Used，最近最少使用的，缓存的元素有一个时间戳，当缓存容量满了，而又需要腾出地方来缓存新的元素的时候，那么现有缓存元素中时间戳离当前时间最远的元素将被清出缓存。
-->
<defaultCache
eternal="false"
maxElementsInMemory="10000"
overflowToDisk="false"
diskPersistent="false"
timeToIdleSeconds="1800"
timeToLiveSeconds="259200"
memoryStoreEvictionPolicy="LRU"/>
</ehcache>在 MonsterMapper.xml 中启用 EhCache
当然原来 MyBatis 自带的缓存配置就注销了
<!--<cache eviction="FIFO" flushInterval="60000" size="512" readOnly="true"/>-->
<!--配置/启用ehcache-->
<cache type="org.mybatis.caches.ehcache.EhcacheCache"/>修改 MonsterMapperTest.java
@Test
public void ehCacheTest(){
//查询id=3的monster
Monster monster = monsterMapper.getMonsterById(3);
//会发出SQL，到DB查询
System.out.println("monster=" + monster);
//这里关闭sqlSession，一级缓存[数据]失效 -> 将数据放入到二级缓存(ehcache)
if (sqlSession != null) {
sqlSession.close();
}
//重新获取sqlSession
sqlSession = MyBatisUtils.getSqlSession();
//重新获取了monsterMapper
monsterMapper = sqlSession.getMapper(MonsterMapper.class);
//再次查询id=3的monster
System.out.println("--虽然前面关闭了sqlSession,因为配置二级缓存(ehcache), " +
"当你再次查询相同的id时, 依然不会再发出sql, 而是从二级缓存(ehcache)获取数据----");
Monster monster2 = monsterMapper.getMonsterById(3);
System.out.println("monster2=" + monster2);
//再次查询id=3的monster，仍然到二级缓存(ehcache)，获取数据，不会发出sql
Monster monster3 = monsterMapper.getMonsterById(3);
System.out.println("monster3=" + monster3);
if (sqlSession != null) {
sqlSession.close();
}
}
细节说明
如何理解 EhCache 和 MyBatis 缓存的关系
- MyBatis 提供了一个接口 Cache，如下图：
只要实现了该 Cache 接口，就可以作为二级缓存产品和 MyBatis 整合使用，Ehcache 就 是实现了该接口。
MyBatis 默认情况(即一级缓存)是使用的 PerpetualCache 类实现 Cache 接口的，是核心类。
当我们使用了 Ehcahce 后，就是 EhcacheCache 类实现 Cache 接口的，是核心类。
- 缓存的本质就是 Map<Object，Object>。
