Mybatis 一级缓存,Mybatis 二级缓存,Mybatis 缓存失效
================================
©Copyright 蕃薯耀 2021-06-24
https://blog.csdn.net/w995223851
一、SpringBoot整合Mybatis
1、pom.xml引入依赖(基于SpringBoot:2.3.12.RELEASE)
<properties>
<!-- JDK版本 -->
<java.version>1.8</java.version>
<!-- 构建时编码 -->
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<!-- 输出时编码 -->
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<!-- 5.1.49 -->
<!-- 8.0.25 -->
<mysql.version>5.1.49</mysql.version>
</properties>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- 2.2.0 -->
<!-- 2.1.4 -->
<!--
master(2.2.x) : MyBatis 3.5+, MyBatis-Spring 2.0+(2.0.6+ recommended), Java 8+ and Spring Boot 2.5+
2.1.x : MyBatis 3.5+, MyBatis-Spring 2.0+(2.0.6+ recommended), Java 8+ and Spring Boot 2.1-2.4
mybatis-spring-boot-starter自动配置:
Autodetect an existing DataSource
Will create and register an instance of a SqlSessionFactory passing that DataSource as an input using the SqlSessionFactoryBean
Will create and register an instance of a SqlSessionTemplate got out of the SqlSessionFactory
Auto-scan your mappers, link them to the SqlSessionTemplate and register them to Spring context so they can be injected into your beans
翻译:
自动检测现有数据源
将创建和注册 SqlSessionFactory 的实例,使用 SqlSessionFactoryBean 将该数据源作为输入传递
将创建并注册一个从 SqlSessionFactory 中得到的 SqlSessionTemplate 的实例
自动扫描您的映射器,将它们链接到 SqlSessionTemplate 并将它们注册到 Spring 上下文,以便它们可以注入到您的 bean 中
-->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.1.4</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
2、application.properties配置文件修改
#数据库连接配置
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.url=jdbc:mysql://localhost:3307/db?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=GMT%2B8&pinGlobalTxToPhysicalConnection=true&autoReconnect=true
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
#Mybatis配置
#详细配置项见:
#https://mybatis.org/mybatis-3/configuration.html#settings
#扫描实体包作为别名
mybatis.type-aliases-package=com.lqy.entity
#驼峰命名
mybatis.configuration.map-underscore-to-camel-case=true
#启动全局缓存,默认是true
mybatis.configuration.cache-enabled=true
#启动懒加载
mybatis.configuration.lazy-loading-enabled=true
#打印日志
mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl
3、启动类加上@MapperScan注解,自动扫描Mybatis Mapper包
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
@MapperScan("com.lqy.mapper")
public class MybatisCacheApplication {
public static void main(String[] args) {
SpringApplication.run(MybatisCacheApplication.class, args);
}
}
Mybatis使用@MapperScan注解后,Mapper文件不需要再加@Mapper注解
4、创建Mapper接口
import org.apache.ibatis.annotations.Select;
import com.lqy.entity.Student;
public interface StudentMapper {
@Select("select * from student where id = #{id}")
public Student get(Long id);
}
5、测试SpringBoot整合Mybatis
//slf4j
private Logger log = LoggerFactory.getLogger(MybatisCacheController.class);
@Resource
private StudentMapper studentMapper;
@RequestMapping("/db/{id}")
public Result db(@PathVariable("id") Long id) {
Student student = studentMapper.get(id);
log.info("student is {}", student);
return Result.ok(student);
}
二、Mybatis 一级缓存
1、Mybatis同一个会话(sqlSession),一级缓存生效
/**
* Mybatis同一个会话(sqlSession),测试一级缓存
* 结论:
* Mybatis同一个会话,两次查询同一条数据,只打印了一条sql查询语句,一级缓存生效
* @param id
* @return
*/
@RequestMapping("/sameSession/{id}")
public Result sameSession(@PathVariable("id") Long id) {
SqlSession sqlSession = sqlSessionFactory.openSession();
StudentMapper stuMapper1 =sqlSession.getMapper(StudentMapper.class);
StudentMapper stuMapper2 =sqlSession.getMapper(StudentMapper.class);
Student student1 = stuMapper1.get(id);
log.info("stuMapper1 student is {}", student1);
Student student2 = stuMapper2.get(id);
log.info("stuMapper2 student is {}", student2);
sqlSession.close();
return Result.ok(student1);
}
2021-06-23 11:13:03.125 INFO 9084 --- [io-4000-exec-10] o.a.c.c.C.[.[localhost].[/mybatisCache] : Initializing Spring DispatcherServlet 'dispatcherServlet'
2021-06-23 11:13:03.126 INFO 9084 --- [io-4000-exec-10] o.s.web.servlet.DispatcherServlet : Initializing Servlet 'dispatcherServlet'
2021-06-23 11:13:03.135 INFO 9084 --- [io-4000-exec-10] o.s.web.servlet.DispatcherServlet : Completed initialization in 9 ms
2021-06-23 11:13:03.137 INFO 9084 --- [io-4000-exec-10] com.zaxxer.hikari.HikariDataSource : HikariPool-3 - Starting...
2021-06-23 11:13:03.143 INFO 9084 --- [io-4000-exec-10] com.zaxxer.hikari.HikariDataSource : HikariPool-3 - Start completed.
==> Preparing: select * from student where id = ?
==> Parameters: 1(Long)
<== Columns: id, stu_no, stu_name, age, clazz_id, create_time, remark
<== Row: 1, 1, 学生一, null, null, 2021-04-26 19:01:29.0, null
<== Total: 1
2021-06-23 11:13:03.146 INFO 9084 --- [io-4000-exec-10] c.lqy.controller.MybatisCacheController : stuMapper1 student is com.lqy.entity.Student@2a61ea98
2021-06-23 11:13:03.146 INFO 9084 --- [io-4000-exec-10] c.lqy.controller.MybatisCacheController : stuMapper2 student is com.lqy.entity.Student@2a61ea98
2、Mybatis不是同一个会话(sqlSession),一级缓存不生效
/**
* Mybatis不是同一个会话(sqlSession),测试一级缓存
* 结论:
* Mybatis不是同一个会话,两次查询同一条数据,打印了两条sql查询语句,一级缓存不生效
* @param id
* @return
*/
@RequestMapping("/notSameSession/{id}")
public Result notSameSession(@PathVariable("id") Long id) {
SqlSession sqlSession1 = sqlSessionFactory.openSession();
SqlSession sqlSession2 = sqlSessionFactory.openSession();
StudentMapper stuMapper1 =sqlSession1.getMapper(StudentMapper.class);
StudentMapper stuMapper2 =sqlSession2.getMapper(StudentMapper.class);
Student student = stuMapper1.get(id);
log.info("stuMapper1 student is {}", student);
sqlSession1.close();
Student student2 = stuMapper2.get(id);
log.info("stuMapper2 student is {}", student2);
sqlSession2.close();
return Result.ok(student);
}
2021-06-23 11:30:31.334 INFO 188 --- [nio-4000-exec-1] com.zaxxer.hikari.HikariDataSource : HikariPool-2 - Starting...
2021-06-23 11:30:31.339 INFO 188 --- [nio-4000-exec-1] com.zaxxer.hikari.HikariDataSource : HikariPool-2 - Start completed.
JDBC Connection [HikariProxyConnection@1835684313 wrapping com.mysql.jdbc.JDBC4Connection@4d739d17] will not be managed by Spring
==> Preparing: select * from student where id = ?
==> Parameters: 1(Long)
<== Columns: id, stu_no, stu_name, age, clazz_id, create_time, remark
<== Row: 1, 1, 学生一, null, null, 2021-04-26 19:01:29.0, null
<== Total: 1
2021-06-23 11:30:31.348 INFO 188 --- [nio-4000-exec-1] c.lqy.controller.MybatisCacheController : =====stuMapper1 student is com.lqy.entity.Student@e4441a0
JDBC Connection [HikariProxyConnection@1594814042 wrapping com.mysql.jdbc.JDBC4Connection@4d739d17] will not be managed by Spring
==> Preparing: select * from student where id = ?
==> Parameters: 1(Long)
<== Columns: id, stu_no, stu_name, age, clazz_id, create_time, remark
<== Row: 1, 1, 学生一, null, null, 2021-04-26 19:01:29.0, null
<== Total: 1
2021-06-23 11:30:31.353 INFO 188 --- [nio-4000-exec-1] c.lqy.controller.MybatisCacheController : =====stuMapper2 student is com.lqy.entity.Student@4f28bd07
3、Mybatis同一个会话(sqlSession),两次查询之间做了更新操作(新增、删除、修改),一级缓存不生效(发送了2次查询sql)
/**
* Mybatis同一个会话(sqlSession),两次查询之间做了更新操作(新增、删除、修改),一级缓存不生效
* @param id
* @return
*/
@RequestMapping("/sameSessionUpdate/{id}")
public Result sameSessionUpdate(@PathVariable("id") Long id) {
SqlSession sqlSession = sqlSessionFactory.openSession();
StudentMapper stuMapper1 =sqlSession.getMapper(StudentMapper.class);
StudentMapper stuMapper2 =sqlSession.getMapper(StudentMapper.class);
StudentMapper stuMapper3 =sqlSession.getMapper(StudentMapper.class);
Student student1 = stuMapper1.get(id);
log.info(logPrefix + "stuMapper1 student is {}", student1);
//两次查询之间做了更新操作(新增、删除、修改)
stuMapper3.update(id);
Student student2 = stuMapper2.get(id);
log.info(logPrefix + "stuMapper2 student is {}", student2);
sqlSession.close();
return Result.ok(student1);
}
JDBC Connection [HikariProxyConnection@1830365917 wrapping com.mysql.jdbc.JDBC4Connection@1fa708f1] will not be managed by Spring
==> Preparing: select * from student where id = ?
==> Parameters: 1(Long)
<== Columns: id, stu_no, stu_name, age, clazz_id, create_time, remark
<== Row: 1, 1, 学生一, null, null, 2021-04-26 19:01:29.0, 1
<== Total: 1
2021-06-23 14:34:15.775 INFO 3228 --- [nio-4000-exec-2] c.lqy.controller.MybatisCacheController : =====stuMapper1 student is com.lqy.entity.Student@67e141ad
==> Preparing: update student set remark = ? where id = ?
==> Parameters: 1(Long), 1(Long)
<== Updates: 1
==> Preparing: select * from student where id = ?
==> Parameters: 1(Long)
<== Columns: id, stu_no, stu_name, age, clazz_id, create_time, remark
<== Row: 1, 1, 学生一, null, null, 2021-04-26 19:01:29.0, 1
<== Total: 1
2021-06-23 14:34:15.818 INFO 3228 --- [nio-4000-exec-2] c.lqy.controller.MybatisCacheController : =====stuMapper2 student is com.lqy.entity.Student@42cc3c7a
4、 Mybatis同一个会话(sqlSession),手动清除缓存后的一级缓存不生效。因为手动清除缓存已经没有缓存:sqlSession.clearCache()
/**
* Mybatis同一个会话(sqlSession),手动清除缓存后的一级缓存不生效。因为手动清除缓存已经没有缓存:sqlSession.clearCache()
* 结论:
* @param id
* @return
*/
@RequestMapping("/sameSessionClearCache/{id}")
public Result sameSessionClearCache(@PathVariable("id") Long id) {
SqlSession sqlSession = sqlSessionFactory.openSession();
StudentMapper stuMapper1 =sqlSession.getMapper(StudentMapper.class);
StudentMapper stuMapper2 =sqlSession.getMapper(StudentMapper.class);
Student student1 = stuMapper1.get(id);
log.info(logPrefix + "stuMapper1 student is {}", student1);
sqlSession.clearCache();
Student student2 = stuMapper2.get(id);
log.info(logPrefix + "stuMapper2 student is {}", student2);
sqlSession.close();
return Result.ok(student1);
}
2021-06-23 14:38:52.228 INFO 3228 --- [nio-4000-exec-4] com.zaxxer.hikari.HikariDataSource : HikariPool-4 - Starting...
2021-06-23 14:38:52.235 INFO 3228 --- [nio-4000-exec-4] com.zaxxer.hikari.HikariDataSource : HikariPool-4 - Start completed.
JDBC Connection [HikariProxyConnection@1539770887 wrapping com.mysql.jdbc.JDBC4Connection@3975b4fb] will not be managed by Spring
==> Preparing: select * from student where id = ?
==> Parameters: 1(Long)
<== Columns: id, stu_no, stu_name, age, clazz_id, create_time, remark
<== Row: 1, 1, 学生一, null, null, 2021-04-26 19:01:29.0, 1
<== Total: 1
2021-06-23 14:38:52.240 INFO 3228 --- [nio-4000-exec-4] c.lqy.controller.MybatisCacheController : =====stuMapper1 student is com.lqy.entity.Student@528bc92f
==> Preparing: select * from student where id = ?
==> Parameters: 1(Long)
<== Columns: id, stu_no, stu_name, age, clazz_id, create_time, remark
<== Row: 1, 1, 学生一, null, null, 2021-04-26 19:01:29.0, 1
<== Total: 1
2021-06-23 14:38:52.242 INFO 3228 --- [nio-4000-exec-4] c.lqy.controller.MybatisCacheController : =====stuMapper2 student is com.lqy.entity.Student@7dea6ddf
5、总结:
Mybatis 一级缓存(会话级别缓存:sqlSession)默认是开启的。
Mybatis 一级缓存失效的情况:
(1)、非同一个sqlSession(两个不同的sqlSession)
(2)、同一个sqlSession,查询条件不同(查询条件不同,相应的数据还没有放到缓存)
(3)、同一个sqlSession,两次查询之间做了更新操作(新增、删除、修改)
(4)、同一个sqlSession,两次查询之间做了缓存清除:sqlSession.clearCache()
三、Mybatis 二级缓存
Mybatis 二级缓存启用:
(1)、需要开启全局二级缓存:在application.properties文件配置:mybatis.configuration.cache-enabled=true,cache-enabled默认是开启的,即可以配置也可以不配置
(2)、需要在XxxMapper的接口类上加上注解:@CacheNamespace,表示该Mapper开启二级缓存
示例:
@CacheNamespace
public interface StudentMapper {}
(3)、实体bean要实现Serializable接口
1、Mybatis同一个会话(sqlSession),两次查询同一条数据,只打印了一条sql查询语句,二级缓存生效
和一级缓存的区别是:开启二级缓存后 ,会有缓存命中率的打印(Cache Hit Ratio)
/**
* Mybatis同一个会话(sqlSession),分别请求两次:
* 第一次请求,两次查询同一条数据,只打印了一条sql查询语句,一级缓存生效
* 第二次请求,两次查询同一条数据,没有打印sql查询语句,二级缓存生效
* @param id
* @return
*/
@RequestMapping("/sameSession/{id}")
public Result sameSession(@PathVariable("id") Long id) {
SqlSession sqlSession = sqlSessionFactory.openSession();
StudentMapper stuMapper1 =sqlSession.getMapper(StudentMapper.class);
StudentMapper stuMapper2 =sqlSession.getMapper(StudentMapper.class);
Student student1 = stuMapper1.get(id);
log.info(logPrefix + "stuMapper1 student is {}", student1);
Student student2 = stuMapper2.get(id);
log.info(logPrefix + "stuMapper2 student is {}", student2);
sqlSession.close();
return Result.ok(student1);
}
第一次查询(一级缓存生效,发送了一次sql查询,二级缓存未命中(还没有二级缓存数据,只有在sqlSession关闭后才放到二级缓存)):
Cache Hit Ratio [com.lqy.mapper.StudentMapper]: 0.0
2021-06-23 15:15:15.752 INFO 10808 --- [nio-4000-exec-1] com.zaxxer.hikari.HikariDataSource : HikariPool-1 - Starting...
2021-06-23 15:15:16.032 INFO 10808 --- [nio-4000-exec-1] com.zaxxer.hikari.HikariDataSource : HikariPool-1 - Start completed.
JDBC Connection [HikariProxyConnection@1253127447 wrapping com.mysql.jdbc.JDBC4Connection@3072075a] will not be managed by Spring
==> Preparing: select * from student where id = ?
==> Parameters: 1(Long)
<== Columns: id, stu_no, stu_name, age, clazz_id, create_time, remark
<== Row: 1, 1, 学生一, null, null, 2021-04-26 19:01:29.0, 1
<== Total: 1
2021-06-23 15:15:16.072 INFO 10808 --- [nio-4000-exec-1] c.lqy.controller.SecondCacheController : =====stuMapper1 student is com.lqy.entity.Student@235995b6
Cache Hit Ratio [com.lqy.mapper.StudentMapper]: 0.0
2021-06-23 15:15:16.072 INFO 10808 --- [nio-4000-exec-1] c.lqy.controller.SecondCacheController : =====stuMapper2 student is com.lqy.entity.Student@235995b6
第二次查询(二级缓存已经命中,没有发送sql查询):
As you are using functionality that deserializes object streams, it is recommended to define the JEP-290 serial filter. Please refer to https://docs.oracle.com/pls/topic/lookup?ctx=javase15&id=GUID-8296D8E8-2B93-4B9A-856E-0A65AF9B8C66
Cache Hit Ratio [com.lqy.mapper.StudentMapper]: 0.3333333333333333
2021-06-23 15:20:11.201 INFO 10808 --- [nio-4000-exec-4] c.lqy.controller.SecondCacheController : =====stuMapper1 student is com.lqy.entity.Student@3890ca0c
Cache Hit Ratio [com.lqy.mapper.StudentMapper]: 0.5
2021-06-23 15:20:11.201 INFO 10808 --- [nio-4000-exec-4] c.lqy.controller.SecondCacheController : =====stuMapper2 student is com.lqy.entity.Student@61e9e758
2、Mybatis不是一个会话(sqlSession),两次查询同一条数据,只打印了一条sql查询语句,第二次查询从二缓存命中,二级缓存生效
/**
* Mybatis不是同一个会话(sqlSession)
* 第一次请求,两次查询同一条数据,第一次查询打印了一条sql查询语句(一、二级缓存未生效),第二次查询(在第一次查询sqlSession关闭后,数据放到二级缓存),二缓存命中(一级缓存不生效),二级缓存生效
* 第二次请求,两次查询同一条数据,没有打印sql查询语句,二级缓存生效
* @param id
* @return
*/
@RequestMapping("/notSameSession/{id}")
public Result notSameSession(@PathVariable("id") Long id) {
SqlSession sqlSession1 = sqlSessionFactory.openSession();
SqlSession sqlSession2 = sqlSessionFactory.openSession();
StudentMapper stuMapper1 =sqlSession1.getMapper(StudentMapper.class);
StudentMapper stuMapper2 =sqlSession2.getMapper(StudentMapper.class);
Student student = stuMapper1.get(id);
log.info(logPrefix + "stuMapper1 student is {}", student);
sqlSession1.close();
Student student2 = stuMapper2.get(id);
log.info(logPrefix + "stuMapper2 student is {}", student2);
sqlSession2.close();
return Result.ok(student);
}
第一次请求:
Cache Hit Ratio [com.lqy.mapper.StudentMapper]: 0.0
2021-06-23 15:33:33.868 INFO 1120 --- [nio-4000-exec-5] com.zaxxer.hikari.HikariDataSource : HikariPool-1 - Starting...
2021-06-23 15:33:34.188 INFO 1120 --- [nio-4000-exec-5] com.zaxxer.hikari.HikariDataSource : HikariPool-1 - Start completed.
JDBC Connection [HikariProxyConnection@1023753071 wrapping com.mysql.jdbc.JDBC4Connection@2ca9d629] will not be managed by Spring
==> Preparing: select * from student where id = ?
==> Parameters: 1(Long)
<== Columns: id, stu_no, stu_name, age, clazz_id, create_time, remark
<== Row: 1, 1, 学生一, null, null, 2021-04-26 19:01:29.0, 1
<== Total: 1
2021-06-23 15:33:34.229 INFO 1120 --- [nio-4000-exec-5] c.lqy.controller.SecondCacheController : =====stuMapper1 student is com.lqy.entity.Student@48b64b58
As you are using functionality that deserializes object streams, it is recommended to define the JEP-290 serial filter. Please refer to https://docs.oracle.com/pls/topic/lookup?ctx=javase15&id=GUID-8296D8E8-2B93-4B9A-856E-0A65AF9B8C66
Cache Hit Ratio [com.lqy.mapper.StudentMapper]: 0.5
2021-06-23 15:33:34.238 INFO 1120 --- [nio-4000-exec-5] c.lqy.controller.SecondCacheController : =====stuMapper2 student is com.lqy.entity.Student@a654eb8
第二次请求:
Cache Hit Ratio [com.lqy.mapper.StudentMapper]: 0.6666666666666666
2021-06-23 15:36:19.272 INFO 1120 --- [nio-4000-exec-9] c.lqy.controller.SecondCacheController : =====stuMapper1 student is com.lqy.entity.Student@13a150d5
Cache Hit Ratio [com.lqy.mapper.StudentMapper]: 0.75
2021-06-23 15:36:19.273 INFO 1120 --- [nio-4000-exec-9] c.lqy.controller.SecondCacheController : =====stuMapper2 student is com.lqy.entity.Student@1d66bcd1
3、Mybatis同一个会话(sqlSession),两次查询之间做了更新操作(新增、删除、修改),一、二级缓存都不生效(发送了2次查询sql)
/**
* Mybatis同一个会话(sqlSession),两次查询之间做了更新操作(新增、删除、修改),一、二级缓存都不生效(发送了2次查询sql)
* @param id
* @return
*/
@RequestMapping("/sameSessionUpdate/{id}")
public Result sameSessionUpdate(@PathVariable("id") Long id) {
SqlSession sqlSession = sqlSessionFactory.openSession();
StudentMapper stuMapper1 =sqlSession.getMapper(StudentMapper.class);
StudentMapper stuMapper2 =sqlSession.getMapper(StudentMapper.class);
StudentMapper stuMapper3 =sqlSession.getMapper(StudentMapper.class);
Student student1 = stuMapper1.get(id);
log.info(logPrefix + "stuMapper1 student is {}", student1);
//两次查询之间做了更新操作(新增、删除、修改)
stuMapper3.update(id);
Student student2 = stuMapper2.get(id);
log.info(logPrefix + "stuMapper2 student is {}", student2);
sqlSession.close();
return Result.ok(student1);
}
Cache Hit Ratio [com.lqy.mapper.StudentMapper]: 0.0
2021-06-23 15:39:44.807 INFO 1120 --- [nio-4000-exec-6] com.zaxxer.hikari.HikariDataSource : HikariPool-2 - Starting...
2021-06-23 15:39:44.813 INFO 1120 --- [nio-4000-exec-6] com.zaxxer.hikari.HikariDataSource : HikariPool-2 - Start completed.
JDBC Connection [HikariProxyConnection@253872058 wrapping com.mysql.jdbc.JDBC4Connection@698c372c] will not be managed by Spring
==> Preparing: select * from student where id = ?
==> Parameters: 1(Long)
<== Columns: id, stu_no, stu_name, age, clazz_id, create_time, remark
<== Row: 1, 1, 学生一, null, null, 2021-04-26 19:01:29.0, 1
<== Total: 1
2021-06-23 15:39:44.817 INFO 1120 --- [nio-4000-exec-6] c.lqy.controller.SecondCacheController : =====stuMapper1 student is com.lqy.entity.Student@3a08debb
==> Preparing: update student set remark = ? where id = ?
==> Parameters: 1(Long), 1(Long)
<== Updates: 1
Cache Hit Ratio [com.lqy.mapper.StudentMapper]: 0.0
==> Preparing: select * from student where id = ?
==> Parameters: 1(Long)
<== Columns: id, stu_no, stu_name, age, clazz_id, create_time, remark
<== Row: 1, 1, 学生一, null, null, 2021-04-26 19:01:29.0, 1
<== Total: 1
2021-06-23 15:39:44.863 INFO 1120 --- [nio-4000-exec-6] c.lqy.controller.SecondCacheController : =====stuMapper2 student is com.lqy.entity.Student@2231baba
4、Mybatis不是同一个会话(sqlSession),两次查询之间做了更新操作(新增、删除、修改),二级缓存生效
第一次请求:第一次查询发送了sql,一、二级缓存不生效。第二次查询,没有发送sql,二级缓存生效。
第二次请求:两次查询都没有发送sql,二级缓存生效
/**
* Mybatis不是同一个会话(sqlSession),两次查询之间做了更新操作(新增、删除、修改),二级缓存生效
* 第一次请求:第一次查询发送了sql,一、二级缓存不生效。第二次查询,没有发送sql,二级缓存生效
* 第二次请求:两次查询都没有发送sql,二级缓存生效
* @param id
* @return
*/
@RequestMapping("/notSameSessionUpdate/{id}")
public Result notSameSessionUpdate(@PathVariable("id") Long id) {
SqlSession sqlSession1 = sqlSessionFactory.openSession();
SqlSession sqlSession2 = sqlSessionFactory.openSession();
SqlSession sqlSession3 = sqlSessionFactory.openSession();
StudentMapper stuMapper1 =sqlSession1.getMapper(StudentMapper.class);
StudentMapper stuMapper2 =sqlSession2.getMapper(StudentMapper.class);
StudentMapper stuMapper3 =sqlSession3.getMapper(StudentMapper.class);
Student student1 = stuMapper1.get(id);
log.info(logPrefix + "stuMapper1 student is {}", student1);
sqlSession1.close();
//两次查询之间做了更新操作(新增、删除、修改)
stuMapper3.update(id);
sqlSession3.close();
Student student2 = stuMapper2.get(id);
log.info(logPrefix + "stuMapper2 student is {}", student2);
sqlSession2.close();
return Result.ok(student1);
}
第一次请求:第一次查询发送了sql,一、二级缓存不生效。第二次查询,没有发送sql,二级缓存生效
Cache Hit Ratio [com.lqy.mapper.StudentMapper]: 0.0
2021-06-23 15:45:16.757 INFO 1120 --- [nio-4000-exec-1] com.zaxxer.hikari.HikariDataSource : HikariPool-4 - Starting...
2021-06-23 15:45:16.764 INFO 1120 --- [nio-4000-exec-1] com.zaxxer.hikari.HikariDataSource : HikariPool-4 - Start completed.
JDBC Connection [HikariProxyConnection@1475826374 wrapping com.mysql.jdbc.JDBC4Connection@2204d9a4] will not be managed by Spring
==> Preparing: select * from student where id = ?
==> Parameters: 1(Long)
<== Columns: id, stu_no, stu_name, age, clazz_id, create_time, remark
<== Row: 1, 1, 学生一, null, null, 2021-04-26 19:01:29.0, 1
<== Total: 1
2021-06-23 15:45:16.767 INFO 1120 --- [nio-4000-exec-1] c.lqy.controller.SecondCacheController : =====stuMapper1 student is com.lqy.entity.Student@6a3d9b01
JDBC Connection [HikariProxyConnection@1775176572 wrapping com.mysql.jdbc.JDBC4Connection@2204d9a4] will not be managed by Spring
==> Preparing: update student set remark = ? where id = ?
==> Parameters: 1(Long), 1(Long)
<== Updates: 1
Cache Hit Ratio [com.lqy.mapper.StudentMapper]: 0.5
2021-06-23 15:45:16.811 INFO 1120 --- [nio-4000-exec-1] c.lqy.controller.SecondCacheController : =====stuMapper2 student is com.lqy.entity.Student@207487b
第二次请求:两次查询都没有发送sql,二级缓存生效
Cache Hit Ratio [com.lqy.mapper.StudentMapper]: 0.6666666666666666
2021-06-23 15:45:50.022 INFO 1120 --- [nio-4000-exec-2] c.lqy.controller.SecondCacheController : =====stuMapper1 student is com.lqy.entity.Student@311e46ff
JDBC Connection [HikariProxyConnection@1071230636 wrapping com.mysql.jdbc.JDBC4Connection@2204d9a4] will not be managed by Spring
==> Preparing: update student set remark = ? where id = ?
==> Parameters: 1(Long), 1(Long)
<== Updates: 1
Cache Hit Ratio [com.lqy.mapper.StudentMapper]: 0.75
2021-06-23 15:45:50.079 INFO 1120 --- [nio-4000-exec-2] c.lqy.controller.SecondCacheController : =====stuMapper2 student is com.lqy.entity.Student@3d8e3c0a
5、Mybatis不是同一个会话(sqlSession),
第一次请求:一级缓存不生效(手动清除一级缓存:sqlSession.clearCache),二级缓存生效;
第二次请求:全部命中二级缓存,不发送sql,二级缓存生效
/**
* Mybatis不是同一个会话(sqlSession)
* 第一次请求:一级缓存不生效(手动清除一级缓存:sqlSession.clearCache),二级缓存生效
* 第二次请求:全部命中二级缓存,不发送sql,二级缓存生效
* @param id
* @return
*/
@RequestMapping("/sameSessionClearCache/{id}")
public Result sameSessionClearCache(@PathVariable("id") Long id) {
SqlSession sqlSession1 = sqlSessionFactory.openSession();
SqlSession sqlSession3 = sqlSessionFactory.openSession();
//都是sqlSession1
StudentMapper stuMapper1 =sqlSession1.getMapper(StudentMapper.class);
StudentMapper stuMapper2 =sqlSession1.getMapper(StudentMapper.class);
//sqlSession3
StudentMapper stuMapper3 =sqlSession3.getMapper(StudentMapper.class);
Student student1 = stuMapper1.get(id);
log.info(logPrefix + "stuMapper1 student is {}", student1);
//手动清除缓存
sqlSession1.clearCache();//只清除一级缓存
System.out.println(logSeparateLine);
Student student2 = stuMapper2.get(id);
log.info(logPrefix + "student2 student is {}", student2);
sqlSession1.close();
System.out.println(logSeparateLine);
Student student3 = stuMapper3.get(id);
log.info(logPrefix + "student3 student is {}", student3);
sqlSession3.close();
return Result.ok(student1);
}
第一次请求:
Cache Hit Ratio [com.lqy.mapper.StudentMapper]: 0.0
2021-06-23 16:03:26.164 INFO 1120 --- [nio-4000-exec-1] com.zaxxer.hikari.HikariDataSource : HikariPool-8 - Starting...
2021-06-23 16:03:26.170 INFO 1120 --- [nio-4000-exec-1] com.zaxxer.hikari.HikariDataSource : HikariPool-8 - Start completed.
JDBC Connection [HikariProxyConnection@276419536 wrapping com.mysql.jdbc.JDBC4Connection@20c9ed7d] will not be managed by Spring
==> Preparing: select * from student where id = ?
==> Parameters: 1(Long)
<== Columns: id, stu_no, stu_name, age, clazz_id, create_time, remark
<== Row: 1, 1, 学生一, null, null, 2021-04-26 19:01:29.0, 1
<== Total: 1
2021-06-23 16:03:26.172 INFO 1120 --- [nio-4000-exec-1] c.lqy.controller.SecondCacheController : =====stuMapper1 student is com.lqy.entity.Student@1d636554
--------------------------------------------------------------------------------------------------------------------
Cache Hit Ratio [com.lqy.mapper.StudentMapper]: 0.0
==> Preparing: select * from student where id = ?
==> Parameters: 1(Long)
<== Columns: id, stu_no, stu_name, age, clazz_id, create_time, remark
<== Row: 1, 1, 学生一, null, null, 2021-04-26 19:01:29.0, 1
<== Total: 1
2021-06-23 16:03:26.175 INFO 1120 --- [nio-4000-exec-1] c.lqy.controller.SecondCacheController : =====student2 student is com.lqy.entity.Student@3e8c7bc6
--------------------------------------------------------------------------------------------------------------------
Cache Hit Ratio [com.lqy.mapper.StudentMapper]: 0.3333333333333333
2021-06-23 16:03:26.177 INFO 1120 --- [nio-4000-exec-1] c.lqy.controller.SecondCacheController : =====student3 student is com.lqy.entity.Student@4c304786
第二次请求:
Cache Hit Ratio [com.lqy.mapper.StudentMapper]: 0.5
2021-06-23 16:04:21.256 INFO 1120 --- [nio-4000-exec-2] c.lqy.controller.SecondCacheController : =====stuMapper1 student is com.lqy.entity.Student@8dc27a9
--------------------------------------------------------------------------------------------------------------------
Cache Hit Ratio [com.lqy.mapper.StudentMapper]: 0.6
2021-06-23 16:04:21.256 INFO 1120 --- [nio-4000-exec-2] c.lqy.controller.SecondCacheController : =====student2 student is com.lqy.entity.Student@61bc8c2
--------------------------------------------------------------------------------------------------------------------
Cache Hit Ratio [com.lqy.mapper.StudentMapper]: 0.6666666666666666
2021-06-23 16:04:21.257 INFO 1120 --- [nio-4000-exec-2] c.lqy.controller.SecondCacheController : =====student3 student is com.lqy.entity.Student@2244cd9
6、查询使用flushCache、useCache清除缓存:@Options(flushCache = FlushCachePolicy.TRUE, useCache = false),二级缓存不生效
/**
* flushCache:是否清除缓存,默认是DEFAULT
* FlushCachePolicy.DEFAULT:如果是查询(select)操作,则是false,其它更新(insert、update、delete)操作则是true
*
* useCache:是否将查询数据放到二级缓存
* @param id
*/
@Select("select * from student where id = #{id}")
@Options(flushCache = FlushCachePolicy.TRUE, useCache = false)
public Student get(Long id);
方法同二级缓存的:notSameSessionUpdate,现在缓存不生效
JDBC Connection [HikariProxyConnection@806642975 wrapping com.mysql.jdbc.JDBC4Connection@7c12637c] will not be managed by Spring
==> Preparing: select * from student where id = ?
==> Parameters: 1(Long)
<== Columns: id, stu_no, stu_name, age, clazz_id, create_time, remark
<== Row: 1, 1, 学生一, null, null, 2021-04-26 19:01:29.0, 1
<== Total: 1
2021-06-23 16:28:29.394 INFO 1120 --- [nio-4000-exec-4] c.lqy.controller.SecondCacheController : =====stuMapper1 student is com.lqy.entity.Student@3aec0e6f
JDBC Connection [HikariProxyConnection@2146338646 wrapping com.mysql.jdbc.JDBC4Connection@7c12637c] will not be managed by Spring
==> Preparing: update student set remark = ? where id = ?
==> Parameters: 1(Long), 1(Long)
<== Updates: 1
JDBC Connection [HikariProxyConnection@337545723 wrapping com.mysql.jdbc.JDBC4Connection@7c12637c] will not be managed by Spring
==> Preparing: select * from student where id = ?
==> Parameters: 1(Long)
<== Columns: id, stu_no, stu_name, age, clazz_id, create_time, remark
<== Row: 1, 1, 学生一, null, null, 2021-04-26 19:01:29.0, 1
<== Total: 1
2021-06-23 16:28:29.439 INFO 1120 --- [nio-4000-exec-4] c.lqy.controller.SecondCacheController : =====stuMapper2 student is com.lqy.entity.Student@7a2c82a9
7、二级缓存结论:
当执行一条查询sql时,先从二级缓存进行查询,没有则进入一级缓存查询,再没有就执行sql进行数据库查询,在会话(sqlSession)结束前把缓存放到一级缓存,会话结束后放到二级缓存中(需要开启二级缓存)。
手动清除查询的二级缓存
@Options(flushCache = FlushCachePolicy.TRUE, useCache = false)
flushCache:是否清除缓存,默认是DEFAULT,可以直接设置FlushCachePolicy.TRUE
FlushCachePolicy.DEFAULT:如果是查询(select)操作,则是false,其它更新(insert、update、delete)操作则是true
useCache:是否将查询结果放到二级缓存
四、Mybatis整合EhCache
1、pom.xml文件引入mybatis-ehcache依赖
<!-- 使用:http://mybatis.org/ehcache-cache/ -->
<dependency>
<groupId>org.mybatis.caches</groupId>
<artifactId>mybatis-ehcache</artifactId>
<version>1.2.1</version>
</dependency>
2、Mapper类的缓存实现类改成:EhcacheCache.class
@CacheNamespace(implementation = EhcacheCache.class)
public interface StudentMapper {
}
3、增加ehcache.xml配置文件,放在classpath路径下(src/main/resources/ehcache.xml)
ehcache.xml内容如下:
<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="ehcache.xsd"
updateCheck="true" monitoring="autodetect"
dynamicConfig="true">
<!-- ehcache 文件存放路径 -->
<diskStore path="C:\mybatis-cache"/>
<!--defaultCache:默认的管理策略-->
<!--eternal:设定缓存的elements是否永远不过期。如果为true,则缓存的数据始终有效,如果为false那么还要根据timeToIdleSeconds,timeToLiveSeconds判断-->
<!--maxElementsInMemory:在内存中缓存的element的最大数目-->
<!--overflowToDisk:如果内存中数据超过内存限制,是否要缓存到磁盘上-->
<!--diskPersistent:是否在磁盘上持久化。指重启jvm后,数据是否有效。默认为false-->
<!--timeToIdleSeconds:对象空闲时间(单位:秒),指对象在多长时间没有被访问就会失效。只对eternal为false的有效。默认值0,表示一直可以访问-->
<!--timeToLiveSeconds:对象存活时间(单位:秒),指对象从创建到失效所需要的时间。只对eternal为false的有效。默认值0,表示一直可以访问-->
<!--memoryStoreEvictionPolicy:缓存的3 种清空策略-->
<!--FIFO:first in first out (先进先出)-->
<!--LFU:Less Frequently Used (最少使用).意思是一直以来最少被使用的。缓存的元素有一个hit 属性,hit 值最小的将会被清出缓存-->
<!--LRU:Least Recently Used(最近最少使用). (ehcache 默认值).缓存的元素有一个时间戳,当缓存容量满了,而又需要腾出地方来缓存新的元素的时候,那么现有缓存元素中时间戳离当前时间最远的元素将被清出缓存-->
<defaultCache
maxEntriesLocalHeap="10000"
eternal="false"
timeToIdleSeconds="120"
timeToLiveSeconds="120"
overflowToDisk=true
diskPersistent=true
diskSpoolBufferSizeMB="30"
maxEntriesLocalDisk="10000000"
diskExpiryThreadIntervalSeconds="120"
memoryStoreEvictionPolicy="LRU">
<persistence strategy="localTempSwap"/>
</defaultCache>
</ehcache>
4、启动项目测试
路径C:\mybatis-cache下会多出ehcache的文件,二级缓存同时生效。
Cache Hit Ratio [com.lqy.mapper.StudentMapper]: 0.5
Cache Hit Ratio [com.lqy.mapper.StudentMapper]: 0.6666666666666666
(时间宝贵,分享不易,捐赠回馈,^_^)
================================
©Copyright 蕃薯耀 2021-06-24