MyBati-缓存机制

最新推荐文章于 2023-10-12 00:16:56 发布

WYFVV

最新推荐文章于 2023-10-12 00:16:56 发布

阅读量159

点赞数

分类专栏： MyBatis

本文链接：https://blog.csdn.net/WYFVV/article/details/104396359

版权

MyBatis 专栏收录该内容

8 篇文章 1 订阅

订阅专栏

一.概述

MyBatis包含一个非常强大的查询缓存特性，它可以非常方便地配置和定制。缓存可以极大的提升查询效率。

MyBatis系统中默认定义了两级缓存：一级缓存和二级缓存

默认情况下，只有一级缓存（SqlSession级别的缓存，也称为本地缓存）开启。
二级缓存需要手动开启和配置，他是基于namespace级别的缓存。
为了提高扩展性。MyBatis定义了缓存接口Cache。我们可以通过实现Cache接口来自定义二级缓存

MyBatis 跟缓存相关的类都在cache 包里面，其中有一个Cache 接口，只有一个默认的实现类 PerpetualCache，它是用HashMap 实现的。

二.一级缓存

2.1 概述

MyBatis的一级查询缓存（也叫作本地缓存）是基于org.apache.ibatis.cache.impl.PerpetualCache 类的 HashMap本地缓存，其作用域是SqlSession。当Session flush或close后，该Session中的所有Cache都将被清空。

本地缓存不能被关闭，但是可以调用clearCache()来清空本地缓存，或者改变缓存的作用域。

在mybatis3.1之后, 可以配置本地缓存的作用域. 在 mybatis.xml 中配置

2.2 一级缓存生效情况

同一次会话期间只要查询过的数据都会保存在当前SqlSesison的一个Map中。

MyBatis会在一次会话的表示----一个SqlSession对象中创建一个本地缓存(local cache)，对于每一次查询，都会尝试根据查询的条件去本地缓存中查找是否在缓存中，如果在缓存中，就直接从缓存中取出，然后返回给用户；否则，从数据库读取数据，将查询结果存入缓存并返回给用户。

一级缓存的生命周期：

MyBatis在开启一个数据库会话时，会创建一个新的SqlSession对象，SqlSession对象中会有一个新的Executor对象，Executor对象中持有一个新的PerpetualCache对象；当会话结束时，SqlSession对象及其内部的Executor对象还有PerpetualCache对象也一并释放掉。
如果SqlSession调用了close()方法，会释放掉一级缓存PerpetualCache对象，一级缓存将不可用；
如果SqlSession调用了clearCache()，会清空PerpetualCache对象中的数据，但是该对象仍可使用；
SqlSession中执行了任何一个update操作(update()、delete()、insert()) ，都会清空PerpetualCache对象的数据，但是该对象可以继续使用；

一级缓存的工作流程：

对于某个查询，根据statementId,params,rowBounds来构建一个key值，根据这个key值去缓存Cache中取出对应的key值存储的缓存结果
判断从Cache中根据特定的key值取的数据数据是否为空，即是否命中；
如果命中，则直接将缓存结果返回；
如果没命中： 1）去数据库中查询数据，得到查询结果；2）将key和查询到的结果分别作为key,value对存储到Cache中；3）将查询结果返回；

2.3 一级缓存失效情况

　　接下来来验证一下，MyBatis 的一级缓存到底是不是只能在一个会话里面共享，以及跨会话（不同session）操作相同的数据会产生什么问题。判断是否命中缓存：如果再次发送SQL 到数据库执行，说明没有命中缓存；如果直接打印对象，说明是从内存缓存中取到了结果。

一级缓存失效的四种情况：

1.不同的SqlSession对应不同的一级缓存

    /*   1.不同的SqlSession：使用不同的一级缓存
	 *      只有在当前的同一个SqlSession期间查到的数据就会保存在这个SqlSession中，下次使用这个SqlSession查询会从缓冲中拿
	 */
	@Test
	public void test01() throws IOException {
		
		//第一次会话
	     SqlSession session1=sqlSessionFcatory.openSession();
	     TeacherDao teacherDao1=session1.getMapper(TeacherDao.class);
	     Teacher teacher1=teacherDao1.getTeacherById(1);
	     System.out.println(teacher1);
	
	    //第二个会话
	     SqlSession session2=sqlSessionFcatory.openSession();
	     TeacherDao teacherDao2=session2.getMapper(TeacherDao.class);
	     Teacher teacher2=teacherDao2.getTeacherById(1);
	     System.out.println(teacher2);
	     session1.close();
	     session2.close();
	}

执行以上的SQL，我们可以看到如下的控制台打印的信息，发现两次查询发送了两次数据库的操作，说明缓存没有起作用，验证了不同的SqlSession对应不同的一级缓存。

2.同一个SqlSession但是查询条件不同

@Test
	public void test01() throws IOException {
		
		//第一次会话
	     SqlSession session1=sqlSessionFcatory.openSession();
	     TeacherDao teacherDao1=session1.getMapper(TeacherDao.class);
	     Teacher teacher1=teacherDao1.getTeacherById(1);
	     System.out.println(teacher1);
	     Teacher teacher2=teacherDao1.getTeacherById(2);
	     System.out.println(teacher2);
	     session1.close();
	}

3.同一个SqlSession两次查询期间执行了任何一次增删改操作，因为增删改操作会把缓存清空

	@Test
	public void test01() throws IOException {
		
		//第一次会话
	     SqlSession session1=sqlSessionFcatory.openSession();
	     TeacherDao teacherDao1=session1.getMapper(TeacherDao.class);
	     Teacher teacher1=teacherDao1.getTeacherById(1);
	     System.out.println(teacher1);
	     System.out.println("===================");
	     //执行任何一个增删改操作
	     Teacher teacher=new Teacher();
	     teacher.setId(2);
	     teacher.setName("你好");
	     teacherDao1.updateTeacher(teacher);
	     System.out.println("===================");
	     Teacher teacher2=teacherDao1.getTeacherById(1);
	     System.out.println(teacher2);
	     session1.commit();
	     session1.close();
	}

执行以上的SQL，我们可以看到如下的控制台打印的信息，发现即使使用同一个SqlSession进行两次相同的查询，还是发送了两次数据库的操作，说明在同一个会话中，增删改操作会清空Cache。

4.同一个SqlSession两次查询期间手动清空了缓存

@Test
	public void test01() throws IOException {
		
		//第一次会话
	     SqlSession session1=sqlSessionFcatory.openSession();
	     TeacherDao teacherDao1=session1.getMapper(TeacherDao.class);
	     Teacher teacher1=teacherDao1.getTeacherById(1);
	     System.out.println(teacher1);
	     System.out.println("===================");
	     System.out.println("手动清空缓存");
	     //清空当前SqlSession的一级缓存
	     session1.clearCache();
	     System.out.println("===================");
	     Teacher teacher2=teacherDao1.getTeacherById(1);
	     System.out.println(teacher2);
	     session1.commit();
	     session1.close();
	}

执行以上的SQL，我们可以看到如下的控制台打印的信息，发现两次查询发送了两次数据库的操作，说明手动清空缓存起了作用。

三.二级缓存

3.1 概述

二级缓存是用来解决一级缓存不能跨会话共享的问题的，范围是namespace 级别的，可以被多个SqlSession 共享（只要是同一个接口里面的相同方法，都可以共享），生命周期和应用同步。二级缓存，全局作用域缓存。二级缓存默认不开启，需要手动配置。

MyBatis提供二级缓存的接口以及实现，缓存实现需要POJO实现Serializable接口。

二级缓存在SqlSession关闭或提交之后才会生效。

3.2 步骤

1.全局配置文件中开启二级缓存

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

2.需要使用二级缓存的映射文件中使用Cache配置缓存

<cache />

3.注意，POJO需要实现Serializable接口

3.3 缓存的相关属性（<cache/>）

• eviction=“FIFO”： 缓存回收策略：

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

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

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

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

• 默认的是 LRU 。

• flushInterval： 刷新间隔，单位毫秒

• 默认情况是不设置，也就是没有刷新间隔，缓存仅仅调用语句时刷新

• size： 引用数目，正整数

• 代表缓存最多可以存储多少个对象，太大容易导致内存溢出

• readOnly： 只读， true/false

•true：只读缓存；会给所有调用者返回缓存对象的相同实例。因此这些对象不能被修改。这提供了很重要的性能优势。

•false：读写缓存；会返回缓存对象的拷贝（通过序列化）。这会慢一些，但是安全，因此默认是 false 。

3.4 缓存有关设置

1.全局setting的cacheEnable：配置二级缓存的开关。一级缓存一直是打开的。

2.select标签的useCache属性：配置这个select是否使用二级缓存。一级缓存一直是使用的

3.sql标签的flushCache属性：增删改默认flushCache=true。sql执行以后，会同时清空一级和二级缓存。查询默认flushCache=false。

4.sqlSession.clearCache()：只是用来清除一级缓存。

5、当在某一个作用域 (一级缓存Session/二级缓存Namespaces) 进行了 C/U/D 操作后，默认该作用域下所有 select 中的缓存将被clear。

3.5 二级缓存生效测试

@Test
	public void test02(){
		  SqlSession session1=sqlSessionFcatory.openSession();
		  SqlSession session2=sqlSessionFcatory.openSession();
		  
		  TeacherDao teacherDao1=session1.getMapper(TeacherDao.class);
		  TeacherDao teacherDao2=session2.getMapper(TeacherDao.class);
		  
		  //1.第一个Dao查询1号teacher
		  Teacher teacher1=teacherDao1.getTeacherById(1);
		  System.out.println(teacher1);
		  session1.close();
		  
		  //2.第二个Dao查询2号teacher
		  Teacher teacher2=teacherDao2.getTeacherById(1);
		  System.out.println(teacher2);
		  session2.close();
		  
	}

执行以上的SQL，我们可以看到如下的控制台打印的信息，两次查询只发送了一次数据库操作，且命中率增加了，说明二级缓存起了作用。

四.缓存的细节

4.1 什么时候使用二级缓存

一级缓存默认是打开的，二级缓存需要配置才可以开启。那么我们必须思考一个问题，在什么情况下才有必要去开启二级缓存？

因为所有的增删改都会刷新二级缓存，导致二级缓存失效，所以适合在查询为主的应用中使用，比如历史交易、历史订单的查询。否则缓存就失去了意义。
如果多个namespace 中有针对于同一个表的操作，比如Blog 表，如果在一个namespace 中刷新了缓存，另一个namespace 中没有刷新，就会出现读到脏数据的情况。所以，推荐在一个Mapper 里面只操作单表的情况使用。

　　如果要让多个namespace 共享一个二级缓存，应该怎么做？跨namespace 的缓存共享的问题，可以使用<cache-ref>来解决：

<cache-ref namespace="com.test.Dao.TeacherDao" />

　　cache-ref 代表引用别的命名空间的Cache 配置，两个命名空间的操作使用的是同一个Cache。在关联的表比较少，或者按照业务可以对表进行分组的时候可以使用。

4.2 缓存的执行顺序

1.不会出现一级缓存和二级缓存中有同一个数据。原因是：

二级缓存中有数据：一级缓存关闭了就有
一级缓存中有数据：二级缓存中没有此数据，就会看一级缓存，一级缓存没有就去查数据库，数据库查询的结果就会放在一级缓存中。

2.如果你的MyBatis使用了二级缓存，并且你的Mapper和select语句也配置使用了二级缓存，那么在执行select查询的时候，MyBatis会先从二级缓存中取输入，其次才是一级缓存，即MyBatis查询数据的顺序是：二级缓存 —> 一级缓存 —> 数据库。

4.3 缓存流程图

4.4 缓存执行顺序的测试

@Test
	public void test02(){
		  SqlSession session1=sqlSessionFcatory.openSession();
		  SqlSession session2=sqlSessionFcatory.openSession();
		  
		  TeacherDao teacherDao1=session1.getMapper(TeacherDao.class);
           //1.第一个Dao查询1号teacher
		  Teacher teacher1=teacherDao1.getTeacherById(1);
		  System.out.println(teacher1);
		  session1.close();
           System.out.println("=============");
     
		  TeacherDao teacherDao2=session2.getMapper(TeacherDao.class);
		  Teacher teacher2=teacherDao2.getTeacherById(1);
		  System.out.println(teacher2);
		  System.out.println("=============");

		  Teacher teacher3=teacherDao2.getTeacherById(1);
		  System.out.println(teacher2);		  
		  System.out.println("=============");
		  
		  
		 //查询第二个老师
		  Teacher teacher4=teacherDao2.getTeacherById(2);
		  System.out.println(teacher4);
		  Teacher teacher5=teacherDao2.getTeacherById(2);
		  System.out.println(teacher5);
		  session2.close();
		  
	}

执行以上的SQL，我们可以看到如下的控制台打印的信息，第一次查询发送了数据库的操作，然后关闭了SqlSession，将查询的数据放在了二级缓存中。第二次查询虽然是一个新的会话，但是没有进行数据库的操作，而是从二级缓存中拿出了数据。第三次查询还是从二级缓存中拿到了数据。第四次查询用的同一个会话，但是查询的数据不同，还是进行了数据库的操作。第五次查询和第四次查询相同的数据，但是第四次查询的时候没有关闭SqlSession，所以第五次查询是从一级缓存中拿出数据，明显可见命中率减少了。

五.整合第三方缓存

5.1 概述

除了MyBatis 自带的二级缓存之外，我们也可以通过实现Cache 接口来自定义二级缓存。MyBatis 官方提供了一些第三方缓存集成方式，比如ehcache 和redis。

EhCache 是一个纯Java的进程内缓存框架，具有快速、精干等特点，是Hibernate中默认的CacheProvider。MyBatis定义了Cache接口方便我们进行自定义扩展。

5.2 步骤

1.导入ehcache包，以及整合包，日志包

ehcache-core-2.6.8.jar
mybatis-ehcache-1.0.3.jar
slf4j-api-1.6.1.jar
slf4j-log4j12-1.6.2.jar

2.编写ehcache.xml配置文件，放在类路径的根目录下

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">
 <!-- 磁盘保存路径 -->
 <diskStore path="D:\44\ehcache" />
 
 <defaultCache 
   maxElementsInMemory="1" 
   maxElementsOnDisk="10000000"
   eternal="false" 
   overflowToDisk="true" 
   timeToIdleSeconds="120"
   timeToLiveSeconds="120" 
   diskExpiryThreadIntervalSeconds="120"
   memoryStoreEvictionPolicy="LRU">
 </defaultCache>
</ehcache>
 
<!-- 
属性说明：
l diskStore：指定数据在磁盘中的存储位置。
l defaultCache：当借助CacheManager.add("demoCache")创建Cache时，EhCache便会采用<defalutCache/>指定的的管理策略
 
以下属性是必须的：
l maxElementsInMemory - 在内存中缓存的element的最大数目 
l maxElementsOnDisk - 在磁盘上缓存的element的最大数目，若是0表示无穷大
l eternal - 设定缓存的elements是否永远不过期。如果为true，则缓存的数据始终有效，如果为false那么还要根据timeToIdleSeconds，timeToLiveSeconds判断
l overflowToDisk - 设定当内存缓存溢出的时候是否将过期的element缓存到磁盘上
 
以下属性是可选的：
l timeToIdleSeconds - 当缓存在EhCache中的数据前后两次访问的时间超过timeToIdleSeconds的属性取值时，这些数据便会删除，默认值是0,也就是可闲置时间无穷大
l timeToLiveSeconds - 缓存element的有效生命期，默认是0.,也就是element存活时间无穷大
 diskSpoolBufferSizeMB 这个参数设置DiskStore(磁盘缓存)的缓存区大小.默认是30MB.每个Cache都应该有自己的一个缓冲区.
l diskPersistent - 在VM重启的时候是否启用磁盘保存EhCache中的数据，默认是false。
l diskExpiryThreadIntervalSeconds - 磁盘缓存的清理线程运行间隔，默认是120秒。每个120s，相应的线程会进行一次EhCache中数据的清理工作
l memoryStoreEvictionPolicy - 当内存缓存达到最大，有新的element加入的时候， 移除缓存中element的策略。默认是LRU（最近最少使用），可选的有LFU（最不常使用）和FIFO（先进先出）
 -->

3.配置cache标签

<cache type="org.mybatis.caches.ehcache.EhcacheCache"></cache>

5.3 流程图

WYFVV

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
MyBati-缓存机制

一级缓存：1）只要之前查询过的数据，MyBatis就会保存在一个缓存中（Map），下次获取直接从缓存拿一级缓存失效的四种情况：1.不同的SqlSession对应不同的一级缓存 /* 1.不同的SqlSession：使用不同的一级缓存 * 只有在当前的同一个SqlSession期间查到的数据就会保存在这个SqlSession中，下次使用这个SqlSes...
复制链接

扫一扫