MyBatis缓存机制

最新推荐文章于 2023-05-19 17:14:29 发布

蒟蒻...

最新推荐文章于 2023-05-19 17:14:29 发布

阅读量159

点赞数

分类专栏： MyBatis笔记

本文链接：https://blog.csdn.net/weixin_44159306/article/details/89074261

版权

MyBatis笔记专栏收录该内容

15 篇文章 0 订阅

订阅专栏

MyBatis中有两级缓存

①一级缓存（本地缓存）

sqlSession级别的缓存，一直开启，无法关闭

就是一个sqlSession的Map

在与数据库同一次会话期间，查询到的数据会放到本地查询中

以后如果需要获取相同的数据，直接从缓存中拿，不需要再次去查询数据库

一级缓存的体验：

测试代码：
	@Test
	void cache_1() throws IOException {
		SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
		SqlSession openSession = sqlSessionFactory.openSession();

		try {
			EmployeeMapperDynamicSQL mapper = openSession.getMapper(EmployeeMapperDynamicSQL.class);

			// 第一次获取id为3的员工信息
			List<Employee> emps = mapper.getEmpsByIf(new Employee(3, null, null, null));
			for (Employee employee : emps) {
				System.out.println(employee);
			}

			// 第二次获取id为3的员工信息
			List<Employee> emps2 = mapper.getEmpsByIf(new Employee(3, null, null, null));
			for (Employee employee : emps2) {
				System.out.println(employee);
			}

			System.out.println("emp == emps吗？：" + (emps == emps2));
		} finally {
			openSession.close();
		}
	}
在代码中，在同一次会话里获取了2次id为3的员工信息，查询打印结果

可以看出，第二次查询是MyBatis直接将第一次查询封装的对象再次赋值给第二次查询，而没有再次去数据库查询。

一级缓存的失效情况

1、sqlSession不同，一级缓存失效。

测试代码：
	@Test
	void cache_1() throws IOException {
		SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
		SqlSession openSession = sqlSessionFactory.openSession();

		try {
			EmployeeMapperDynamicSQL mapper = openSession.getMapper(EmployeeMapperDynamicSQL.class);

			// 第一次获取id为3的员工信息
			List<Employee> emps = mapper.getEmpsByIf(new Employee(3, null, null, null));
			for (Employee employee : emps) {
				System.out.println(employee);
			}

			// 开启一个新的sqlSession
			SqlSession openSession2 = sqlSessionFactory.openSession();
			EmployeeMapperDynamicSQL mapper2 = openSession2.getMapper(EmployeeMapperDynamicSQL.class);
			// 第二次获取id为3的员工信息
			List<Employee> emps2 = mapper2.getEmpsByIf(new Employee(3, null, null, null));
			for (Employee employee : emps2) {
				System.out.println(employee);
			}

			System.out.println("emp == emps吗？：" + (emps == emps2));
		} finally {
			openSession.close();
		}
	}
第二次查询id为3的员工，使用的是sqlSession2这个sqlSession，查看打印结果：

2、sqlSession相同，但是查询条件不同，一级缓存失效。

这个显而易见，因为查询条件不同肯定会发起一条新的sql，因为当前一级缓存中没有缓存。

3、sqlSession相同，两次查询之间执行了增删改操作，一级缓存失效。

这次增删改可能对当前数据有影响（解释：如果这次操作删除了要查询的数据，那么下一次查询就不应该再次使用上次查询的结果）

测试代码：
	@Test
	void cache_1() throws IOException {
		SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
		SqlSession openSession = sqlSessionFactory.openSession();

		try {
			EmployeeMapperDynamicSQL mapper = openSession.getMapper(EmployeeMapperDynamicSQL.class);

			// 第一次获取id为3的员工信息
			List<Employee> emps = mapper.getEmpsByIf(new Employee(3, null, null, null));
			for (Employee employee : emps) {
				System.out.println(employee);
			}

			// 添加一个员工
			ArrayList<Employee> arrayList = new ArrayList<Employee>();
			arrayList.add(new Employee(null, "wangwu", "wangwu@qq.com", "1", new Department(1)));
			mapper.addEmps(arrayList);
			System.out.println("员工信息添加成功！");

			// 第二次获取id为3的员工信息
			List<Employee> emps2 = mapper.getEmpsByIf(new Employee(3, null, null, null));
			for (Employee employee : emps2) {
				System.out.println(employee);
			}

			System.out.println("emp == emps吗？：" + (emps == emps2));
		} finally {
			openSession.close();
		}
	}
在两次查询之间执行了一次添加员工的方法，执行结果：

4、 sqlSession相同，手动清空了一级缓存，自然一级缓存失效

清空缓存的代码：
openSession.clearCache();

②二级缓存（全局缓存）

基于namespace级别的缓存，一个namespace对应一个二级缓存

工作机制：

1、一个会话，查询一条数据，这个数据就会放在这个会话的一级缓存中

2、如果会话关闭，那么一级缓存中的数据就会被保存到二级缓存中。新的会话查询信息，可以参照二级缓存中的内容

3、不同的namespace查出的数据会放在自己对应的缓存中

使用二级缓存的步骤：

1、开启全局二级缓存的配置：

<setting name="cacheEnabled" value="true"/>

2、去mapper.xml中配置使用二级缓存：

cache：

 <cache eviction="" flushInterval="" readOnly="" size="" type=""></cache>

eviction:缓存的回收策略：

        • LRU – 最近最少使用的：移除最长时间不被使用的对象。

        • FIFO – 先进先出：按对象进入缓存的顺序来移除它们。

        • SOFT – 软引用：移除基于垃圾回收器状态和软引用规则的对象。

        • WEAK – 弱引用：更积极地移除基于垃圾收集器状态和弱引用规则的对象。

        • 默认的是 LRU。

 flushInterval：缓存刷新间隔

        缓存多长时间清空一次，默认不清空，设置一个毫秒值

 readOnly:是否只读：

        true：只读，mybatis认为所有从缓存中获取数据的操作都是只读操作，不会修改数据。

                 mybatis为了加快获取速度，直接就会将数据在缓存中的引用交给用户。不安全，速度快

        false：非只读，mybatis觉得获取的数据可能会被修改。

                mybatis会利用序列化&反序列的技术克隆一份新的数据给你。安全，速度慢

 size：缓存存放多少元素

 type=""：指定自定义缓存的全类名

            实现Cache接口即可

3.POJO实现序列化接口

测试二级缓存：

测试代码：

	@Test
	void cache_2() throws IOException {
		SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
		SqlSession openSession = sqlSessionFactory.openSession();
		SqlSession openSession2 = sqlSessionFactory.openSession();
		try {
			EmployeeMapperDynamicSQL mapper = openSession.getMapper(EmployeeMapperDynamicSQL.class);
			EmployeeMapperDynamicSQL mapper2 = openSession2.getMapper(EmployeeMapperDynamicSQL.class);

			// 第一个mapper
			List<Employee> emps = mapper.getEmpsByIf(new Employee(3, null, null, null));
			System.out.println(emps);
			openSession.close();

			// 第二个mapper
			List<Employee> emps2 = mapper2.getEmpsByIf(new Employee(3, null, null, null));
			System.out.println(emps2);
			openSession2.close();
		} finally {

		}
	}

打印信息：

注意：必须是第一次会话关闭或者提交后，一级缓存中的数据才会转移到二级缓存中

和缓存有关的设置项：

1）、cacheEnabled=true：false：关闭缓存（二级缓存关闭）(一级缓存一直可用的)

2）、每个select标签都有useCache="true"：
  false：不使用缓存（一级缓存依然使用，二级缓存不使用）

3）、每个增删改标签的：flushCache="true"：（一级二级都会清除）
   增删改执行完成后就会清楚缓存；
测试：flushCache="true"：一级缓存就清空了；二级也会被清除；
查询标签：flushCache="false"：
如果flushCache=true;每次查询之后都会清空缓存；缓存是没有被使用的；

4）、sqlSession.clearCache();只是清楚当前session的一级缓存；

5）、localCacheScope：本地缓存作用域：（一级缓存)

默认SESSION；当前会话的所有数据保存在会话缓存中；

STATEMENT：可以禁用一级缓存；

第三方缓存整合：
   1）、导入第三方缓存包即可；
   2）、导入与第三方缓存整合的适配包；官方有；
   3）、mapper.xml中使用自定义缓存
 <cache type="org.mybatis.caches.ehcache.EhcacheCache"></cache>
引用缓存：
<cache-ref namespace=""/>
namespace:指定和那个名称空间用的缓存一样