MyBatis系列七: 一级缓存，二级缓存，EnCache缓存

缓存-提高检索效率的利器

- 官方文档
一级缓存
二级缓存
mybatis的一级缓存和二级缓存执行顺序
- 小实验
- 细节说明
EnCache缓存
MyBatis逆向工程

官方文档

官方文档: https://mybatis.org/mybatis-3/zh_CN/sqlmap-xml.html#cache

一级缓存

基本介绍

●基本说明

1.默认情况下, mybatis是启用一级缓存的/本地缓存/local Cache, 它是SqlSession级别的.

2.同一个SqlSession接口对象调用了相同的select语句, 会直接从缓存里面获取, 而不是再去查询数据库

●一级缓存原理图 [简单追一下源码, 后面再Debug]

快速入门

需求: 当我们第1次查询 id=1的Monster后, 再次查询id=1的monster对象, 就会直接从一级缓存获取, 不会再次发出sql

●代码实现

1.创建新的 module: mybatis_cache, 必要的文件和配置直接从 mybatis_quickstart module 拷贝即可 [新建子模块参考]

2.需要拷贝的文件和配置如图

3.使用MonsterMapperTest.java, 运行 getMonsterById() 看看是否可以看到日志输出, 结构我们多次执行, 总是会发出SQL

4.修改MonsterMapperTest.java, 增加测试方法, 测试一级缓存的基本使用 + Debug源码

java 复制代码

//测试一级缓存
@Test
public void level1CacheTest() {
    //查询id=7的monster
    Monster monster = monsterMapper.getMonsterById(7);
    System.out.println("monster=" + monster);

    //查询id=7的monster
    //当我们再次查询 id=7的Monster时, 直接从一级缓存获取, 不会再次发出sql
    System.out.println("---因为一级缓存默认是打开的, 当你再次查询相同的id时, 不会再发出sql---");
    Monster monster2 = monsterMapper.getMonsterById(7);
    System.out.println("monster2="  + monster);

    if (sqlSession != null) {
        sqlSession.close();
    }
}

Debug一级缓存执行流程

进入 Step Into

进入 Step Into

进入 Step Into

进入 Step Into

进入 Step Into

进入 Step Into

放行 Resume Program
第二次Debug

放行 Resume Program

进入 Step Into

进入 Step Into

进入 Step Into

进入 Step Into

进入 Step Into

进入 Step Into

放行 Resume Program

●sqlSession的结构示意图

一级缓存失效分析

1.关闭sqlSession会话后, 再次查询, 会到数据库查询, 修改MonsterMapperTest.java, 测试一级缓存失效情况

java 复制代码

//测试一级缓存,失效
//关闭sqlSession会话后, 一级缓存失效
@Test
public void level1CacheTest2() {
    //查询id=7的monster
    Monster monster = monsterMapper.getMonsterById(7);
    System.out.println("monster=" + monster);

    //关闭sqlSession, 一级缓存失效
    if (sqlSession != null) {
        sqlSession.close();
    }

    //因为关闭了sqlSession, 所以需要重新初始化sqlSession和 monsterMapper
    sqlSession = MyBatisUtils.getSqlSession();
    monsterMapper = sqlSession.getMapper(MonsterMapper.class);

    //查询id=7的monster
    //当我们再次查询 id=7的Monster时, 直接从一级缓存获取, 不会再次发出sql
    System.out.println("---如果你关闭了sqlSession, 当你再次查询相同的id时, 仍然会会发出sql---");
    Monster monster2 = monsterMapper.getMonsterById(7);
    System.out.println("monster2="  + monster);

    if (sqlSession != null) {
        sqlSession.close();
    }
}

2.当执行selSession.clearChche() 会使一级缓存失效, 修改MonsterMapperTest.java, 测试一级缓存失效情况

java 复制代码

//测试一级缓存,失效
//如果执行sqlSession.clearCache(), 会导致一级缓存失效
@Test
public void level1CacheTest3() {
    //查询id=7的monster
    Monster monster = monsterMapper.getMonsterById(7);
    System.out.println("monster=" + monster);

    //执行clearCache
    /**
     *   @Override
     *   public void clearCache() {
     *     executor.clearLocalCache();
     *   }
     */
    sqlSession.clearCache();

    //查询id=7的monster
    System.out.println("---如果你执行了sqlSession.clearCache(), 当你再次查询相同的id时, 仍然会会发出sql---");
    Monster monster2 = monsterMapper.getMonsterById(7);
    System.out.println("monster2="  + monster);

    if (sqlSession != null) {
        sqlSession.close();
    }
}

3.当对同一个monster修改, 该对象在一级缓存会失效, 修改MonsterMapperTest.java, 测试一级缓存失效情况

java 复制代码

//测试一级缓存,失效
//如果修改了同一个对象, 会导致一级缓存[对象数据]失效
@Test
public void level1CacheTest4() {
    //查询id=7的monster
    Monster monster = monsterMapper.getMonsterById(7);
    System.out.println("monster=" + monster);

    //如果修改了同一个对象, 会导致一级缓存[对象数据]失效
    monster.setName("赵志伟^_^");
    monsterMapper.updateMonster(monster);

    //查询id=7的monster
    System.out.println("---如果你修改了同一个对象, 当你再次查询相同的id时, 仍然会发出sql---");
    Monster monster2 = monsterMapper.getMonsterById(7);
    System.out.println("monster2="  + monster);

    if (sqlSession != null) {
        sqlSession.commit();//这里需要commit
        sqlSession.close();
    }
}

二级缓存

基本介绍

●基本介绍

1.二级缓存和一级缓存都是为了提高检索效率的技术

2.最大的区别就是作用域的范围不一样, 一级缓存的作用域是sqlSession会话级别, 在一次会话中有效. 而二级缓存作用域是全局范围, 针对不同的会话都有效.

●二级缓存原理图

快速入门

1.mybatis-config.xml配置中开启二级缓存

xml 复制代码

<!--配置MyBatis自带的日志输出-查看原生的sql
    DOCTYPE规定 <settings/>节点/元素 必须在前面, 放在后面会报错
-->
<settings>
    <setting name="logImpl" value="STDOUT_LOGGING"/>
    <!--
    1.全局性地开启或关闭所有映射器配置文件中已配置的任何缓存
    2.默认就是: true
    -->
    <setting name="cacheEnabled" value="true"/>
</settings>

2.使用二级缓存时entity类实现序列化接口(serialize), 因为二级缓存可能使用到序列化技术

3.在对应的XxxMapper.xml 中设置二级缓存的策略

xml 复制代码

<!--
1.配置二级缓存
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"/>

4.修改MonsterMapperTest.java, 完成测试

java 复制代码

//测试二级缓存
@Test
public void level2CacheTest() {
    //查询id=7的monster
    Monster monster = monsterMapper.getMonsterById(7);
    System.out.println("monster=" + monster);

    //这里我们关闭sqlSession
    if (sqlSession != null) {
        sqlSession.close();
    }

    //重新获取sqlSession
    sqlSession = MyBatisUtils.getSqlSession();
    //重新获取了monsterMapper
    monsterMapper = sqlSession.getMapper(MonsterMapper.class);

    //查询id=7的monster
    System.out.println("---虽然前面关闭了sqlSession, 因为配置二级缓存, " +
            "当你再次查询相同的id时, 依然不会再发出sql, 而是从二级缓存获取---");
    Monster monster2 = monsterMapper.getMonsterById(7);
    System.out.println("monster2="  + monster);

    Monster monster3 = monsterMapper.getMonsterById(7);
    System.out.println("monster3="  + monster3);

    if (sqlSession != null) {
        sqlSession.close();
    }
}

Debug二级缓存执行流程

●观察Debug二级缓存执行流程[debug主线即可]

放行 Resume Program

进入 Step Into

进入 Step Into

放行 Resume Program

放行 Resume Program

进入 Step Into

进入 Step Into

注意事项和使用细节

1.理解二级缓存策略的参数
<cache eviction="FIFO" flushInterval="60000" size="512" readOnly="true"/>

上面的配置含义如下:

创建了FIFO 的策略, 每隔60 秒刷新一次, 最多存放512个对象而且返回的对象被认为是只读的,

eviction: 缓存的回收策略

flushInterval: 时间间隔, 单位是毫秒
size: 引用数目, 内存大就多配置点, 要记住你缓存的对象数目要和你运行环境的可用内存资源数目对应. 默认值是1024
readOnly:true 只读

2.四大策略
√ LRU - 最近最少使用的: 移除最长时间不被使用的对象, 它是默认
√ FIFO - 先进先出: 按对象进入缓存的顺序来移除它们
√ SOFT - 软引用: 移除基于垃圾回收器状态和软引用规则的对象
√ WEAK - 弱引用: 更积极地移除基于垃圾回收器状态和弱引用规则的对象

3.如何禁用二级缓存

1)修改mybatis-config.xml

xml 复制代码

<settings>
    <setting name="logImpl" value="STDOUT_LOGGING"/>
    <!--
    1.全局性地开启或关闭所有映射器配置文件中已配置的任何缓存, 可以理解这是一个总开关
    2.默认就是: true
    -->
    <setting name="cacheEnabled" value="false"/>
</settings>

2)修改映射器文件MonsterMapper.xml

xml 复制代码

<!--<cache eviction="FIFO" flushInterval="60000" size="512" readOnly="true"/>-->

3)或者更加细粒度的, 直接在配置方法上指定

java 复制代码

<!--配置/实现getMonsterById-->
<select id="getMonsterById" resultType="Monster" useCache="false">
    SELECT * FROM `monster` WHERE id = #{id}
</select>

设置useCache=false 可以禁用当前select 语句的二级缓存, 即每次查询都会发出sql 去查询, 默认情况是true , 即该sql 使用二级缓存.
注意: 一般我们不需要去修改, 使用默认的即可

4.mybatis刷新二级缓存的设置

xml 复制代码

<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即刷新缓存, 一般不用修改.

mybatis的一级缓存和二级缓存执行顺序

一句话: 缓存执行顺序是: 二级缓存 --> 一级缓存 --> 数据库

小实验

1.修改MonsterMapperTest.java
这里有debug, 自己debug看看, 很有意思的

java 复制代码

//演示:二级缓存->一级缓存->DB执行的顺序
@Test
public void cacheSeqTest() {
    System.out.println("查询第1次");
    //DB, 会发出sql, 分析cache hit radio 0.0
    Monster monster1 = monsterMapper.getMonsterById(7);
    System.out.println(monster1);

    //这里我们关闭sqlSession, 一级缓存数据消失
    //当我们关闭一级缓存的时候, 如果你配置了二级缓存, 那么一级缓存的数据, 会放入到二级缓存
    sqlSession.close();

    sqlSession = MyBatisUtils.getSqlSession();
    monsterMapper = sqlSession.getMapper(MonsterMapper.class);

    System.out.println("查询第2次");
    //从二级缓存获取id=7 monster信息, 就不会发出sql, cache hit radio 0.5
    Monster monster2 = monsterMapper.getMonsterById(7);
    System.out.println(monster2);

    System.out.println("查询第3次");
    //从二级缓存获取id=7 monster信息, 就不会发出sql, cache hit radio 0.666666
    Monster monster3 = monsterMapper.getMonsterById(7);
    System.out.println(monster3);

    if (sqlSession != null) {
        sqlSession.close();
    }
}

第一次, 去数据库中查询

第二次, 从二级缓存中获取

第三次, 从二级缓存中获取

细节说明

1.不会出现一级缓存和二级缓存中有同一个数据, 因为二级缓存是在一级缓存关闭之后才有的.

2.修改MonsterMapperTest.java, 不关闭一级缓存, 看看运行效果 这里有debug, 自己debug看看, 很有意思的

java 复制代码

//分析缓存执行顺序
//二级缓存->一级缓存->DB
@Test
public void cacheSeqTest2() {
    System.out.println("查询第1次");
    //DB, 会发出sql, 分析cache hit radio 0.0
    Monster monster1 = monsterMapper.getMonsterById(7);
    System.out.println(monster1);

    //这里没有关闭sqlSession

    System.out.println("查询第2次");
    //从一级缓存获取id=7, cache hit radio 0.0, 不会发出sql
    Monster monster2 = monsterMapper.getMonsterById(7);
    System.out.println(monster2);

    System.out.println("查询第3次");
    //还是从一级缓存获取id=7, cache hit radio 0.0, 不会发出sql
    Monster monster3 = monsterMapper.getMonsterById(7);
    System.out.println(monster3);

    if (sqlSession != null) {
        sqlSession.close();
    }
}

第一次, 去数据库中查询

第二次, 去一级缓存中查询

第三次, 从一级缓存中查询

3.运行效果, 可以看到, 在一级缓存存在的情况下, 依然是先查询二级缓存, 但是因为二级缓存, 没有数据, 所以命中率都是 0.0 . 可以debug

查询第1次
Cache Hit Ratio [com.zzw.mapper.MonsterMapper]: 0.0

Opening JDBC Connection

==>Loading class com.mysql.jdbc.Driver. This is deprecated. The new driver class is com.mysql.cj.jdbc.Driver. The driver is automatically registered via the SPI and manual loading of the driver class is generally unnecessary.

Created connection 462773420.

Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@1b955cac]

==> Preparing: SELECT * FROM monster WHERE id = ?

==> Parameters: 7(Integer)

<== Columns: id, age, birthday, email, gender, name, salary

<== Row: 7, 33, 2024-02-09, 978964140@qq.com, 1, 赵志伟^_^, 1010.0

<== Total: 1

Monster{id=7, age=33, birthday=Fri Feb 09 00:00:00 CST 2024, email='978964140@qq.com', gender=1, name='赵志伟^_^', salary=1010.0}
查询第2次
Cache Hit Ratio [com.zzw.mapper.MonsterMapper]: 0.0

Monster{id=7, age=33, birthday=Fri Feb 09 00:00:00 CST 2024, email='978964140@qq.com', gender=1, name='赵志伟^_^', salary=1010.0}
查询第3次
Cache Hit Ratio [com.zzw.mapper.MonsterMapper]: 0.0

Monster{id=7, age=33, birthday=Fri Feb 09 00:00:00 CST 2024, email='978964140@qq.com', gender=1, name='赵志伟^_^', salary=1010.0}

EnCache缓存

配置文档: https://www.cnblogs.com/zqyanywn/p/10861103.html

基本介绍

1.EhCache 是一个纯Java 的缓存框架, 具有快速, 精干等特点.

2.MyBatis 有自己默认的二级缓存(前面我们已经讲过了), 但是在实际项目中, 往往使用的是更加专业的第三方缓存产品, 作为MyBatis 的二级缓存, EhCache 就是非常优秀的缓存产品.

配置和使用EhCache

1.引入相关依赖, 修改mybatis_cache\pom.xml

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.36</version>
    </dependency>
    <!--引入mybatis整合ehcache库/jar-->
    <dependency>
        <groupId>org.mybatis.caches</groupId>
        <artifactId>mybatis-ehcache</artifactId>
        <version>1.2.1</version>
    </dependency>
</dependencies>

2.mybatis-config.xml 仍然打开二级缓存

xml 复制代码

<settings>
    <!--
    1.全局性地开启或关闭所有映射器配置文件中已配置的任何缓存, 可以理解这是一个总开关
    2.默认就是: true
    -->
    <setting name="cacheEnabled" value="true"/>
</settings>

3.加入src/main/resources/ehcache.xml配置文件

文档说明: https://www.taobye.com/f/view-11-23.html

xml 复制代码

<?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>

4.在XxxMapper.xml中启用EhCache, 当然原来MyBatis自带的缓存配置就注销了

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"/>-->
<!--配置/启用ehcache-->
<cache type="org.mybatis.caches.ehcache.EhcacheCache"/>

5.修改MonsterMapperTest.java, 增加测试方法, 完成测试+简单 Debug

java 复制代码

//测试ehcache缓存的使用
@Test
public void ehCacheTest() {
    //查询id=7的monster
    Monster monster = monsterMapper.getMonsterById(7);
    //会发出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=7的monster
    System.out.println("---虽然前面关闭了sqlSession, 因为配置二级缓存[ehcache], " +
            "当你再次查询相同的id时, 不会再发出sql, 而是从二级缓存[ehcache]获取数据---");
    Monster monster2 = monsterMapper.getMonsterById(7);
    System.out.println("monster2=" + monster);

    //再次查询id=7的monster, 仍然到二级缓存(ehcache), 获取数据, 不会发出sql
    Monster monster3 = monsterMapper.getMonsterById(7);
    System.out.println("monster3=" + monster3);

    if (sqlSession != null) {
        sqlSession.close();
    }
}

细节说明

如何理解EhCache 和MyBatis 缓存的关系

1.MyBatis 提供了一个接口Cache [如右图, 找到org.apache.ibatis.cache , 关联源码包就可以看到Cache接口]

2.只要实现了该Cache 接口, 就可以作为二级缓存产品和MyBatis 整合使用, Ehcache 就是实现了该接口

3.MyBatis 默认情况(即一级缓存)是使用的PerpetualCache 类实现Cache接口的, 是核心类

4.当我们使用了Ehcache 后, 就是EhcacheCache 类实现Cache接口的, 是核心类

5.我们看一下源码, 发现缓存的本质就是 Map<Object, Object

MyBatis逆向工程

接下来我们学习, 整合SSM

💐💐💐💐💐💐💐💐给个赞, 点个关注吧, 各位大佬!💐💐💐💐💐💐💐💐

💐💐💐💐💐💐💐💐祝各位2024年大吉大运💐💐💐💐💐💐💐💐💐💐