MyBatis缓存原来是这么一回事儿

其他 2020-05-24 15:44:22 阅读次数: 0

文章目录

什么是缓存

缓存就是存储数据的一个地方（称作：Cache），当程序要读取数据时，会首先从缓存中获取，有则直接返回，否则从其他存储设备中获取。

缓存的特点：缓存最重要的一点就是从其内部获取数据的速度是非常快的，通过缓存可以加快数据的访问速度。

mybatis中的缓存

通常情况下mybatis会访问数据库获取数据，中间涉及到网络通信，数据库从磁盘中读取数据，然后将数据返回给mybatis，总的来说耗时还是挺长的，mybatis为了加快数据查询的速度，在其内部引入了缓存来加快数据的查询速度。

mybatis中分为一级缓存和二级缓存:

一级缓存是SqlSession级别的缓存，在操作数据库时需要构造 sqlSession对象，在对象中有一个数据结构（HashMap）用于存储缓存数据，不同的sqlSession之间的缓存数据区域是互相不影响的。

二级缓存是mapper级别的缓存，多个SqlSession去操作同一个Mapper的sql语句，多个SqlSession可以共用二级缓存，二级缓存是跨SqlSession的。

mybatis一级缓存

一级缓存是SqlSession级别的缓存，每个SqlSession都有自己单独的一级缓存，多个SqlSession之间的一级缓存是相互隔离的，互不影响，mybatis中一级缓存是默认自动开启的。

一级缓存工作原理：在同一个SqlSession中去多次去执行同样的查询，每次执行的时候会先到一级缓存中查找，如果缓存中有就直接返回，如果一级缓存中没有相关数据，mybatis就会去db中进行查找，然后将查找到的数据放入一级缓存中，第二次执行同样的查询的时候，会发现缓存中已经存在了，会直接返回。一级缓存的存储介质是内存，是用一个HashMap来存储数据的，所以访问速度是非常快的。

一级缓存案例

sql源文件如下：

DROP TABLE IF EXISTS `t_student`;
CREATE TABLE `t_student`  (
  `id` int(32) NOT NULL AUTO_INCREMENT,
  `student_id` int(32) NOT NULL,
  `student_name` varchar(32) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `age` int(32) NOT NULL,
  `gender` varchar(32) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `class_name` varchar(32) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 6 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
INSERT INTO `t_student` VALUES (1, 2018013001, '张三', 18, '男', '301');
INSERT INTO `t_student` VALUES (2, 2018013002, '李四', 19, '男', '301');
INSERT INTO `t_student` VALUES (3, 2018013003, '王芳', 18, '女', '302');
INSERT INTO `t_student` VALUES (4, 2018013004, '李娟', 19, '女', '301');

下面是查询用户信息mapper文件内容

 <!--查询单个-->
 <select id="queryById" resultMap="StudentMap">
     select
       id, student_id, student_name, age, gender, class_name
     from mybatis.t_student
     where id = #{id}
 </select>

测试用例

@Test
    public void testStudentDao() {
        // 通过工具类生成SqlSession对象
        SqlSession session = MybatisUtils.getSession();
        // 测试查询方法
        Student stu1 = session.selectOne("com.lwz.mapper.StudentDao.queryById", 1);
        System.out.println(stu1.getStudentName());
        Student stu2 = session.selectOne("com.lwz.mapper.StudentDao.queryById", 1);
        System.out.println(stu2.getStudentName());

		System.out.println(stu1 == stu2);

        session.commit();
        session.close();
    }

上面的代码在同一个SqlSession中去执行了2次获取用户列表信息，2次查询结果分别放在stu1和stu2，最终代码中也会判断这两个结果是否相等，下面我们运行一下看看会访问几次db？

运行输出：
在这里插入图片描述
从输出中可以看出看到，sql只输出了一次，说明第一次会访问数据库，第二次直接从缓存中获取的，最后输出了一个true，也说明两次返回结果是同一个对象，第二次直接从缓存中获取数据的，加快了查询的速度。

清空一级缓存的3种方式

同一个SqlSession中查询同样的数据，mybatis默认会从一级缓存中获取，如果缓存中没有，才会访问db，那么我们如何去清除一级缓存呢，强制让查询去访问db呢？

  1. SqlSession中执行增、删、改操作，此时sqlsession会自动清理其内部的一级缓存
  2. 调用SqlSession中的clearCache方法清理其内部的一级缓存
  3. 设置Mapper xml中select元素的flushCache属性值为true，那么执行查询的时候会先清空一级缓存中的所有数据，然后去db中获取数据

下面我们来分别演示这3种情况

方式1：增删操作让一级缓存失效

当执行增删改操时，mybatis会将当前SqlSession一级缓存中的所有数据都清除。

案例代码：

@Test
    public void testStudentDao() {
        // 通过工具类生成SqlSession对象
        SqlSession session = MybatisUtils.getSession();

        //第一次查询
        Student stu1 = session.selectOne("com.lwz.mapper.StudentDao.queryById", 1);
        System.out.println(stu1.getStudentName());

        int i = session.delete("com.lwz.mapper.StudentDao.deleteById", 4);
        System.out.println(i);

        //第二次查询
        Student stu2 = session.selectOne("com.lwz.mapper.StudentDao.queryById", 1);
        System.out.println(stu2.getStudentName());

        System.out.println(stu1 == stu2);

        session.commit();
        session.close();

    }

运行输出：
在这里插入图片描述
从输出中可以看出2次查询都访问了db，并且两次查询的结果集(false)是不一样的。删除数据让缓存失效是可以理解的，删除操作可能会改变数据库中的数据，所以如果再从缓存中去获取，可能获取到的数据和db中的数据不一致的情况，mybatis为了避免这种情况，在执行删除操作的时候，会将SqlSession中的一级缓存清空。插入和修改也是一样的。

方式2：SqlSession.clearCache清理一级缓存

SqlSession.clearCache()方法会将当前SqlSession一级缓存中的所有数据清除。

案例代码：

@Test
    public void testStudentDao() {
        // 通过工具类生成SqlSession对象
        SqlSession session = MybatisUtils.getSession();

        //第一次查询
        Student stu1 = session.selectOne("com.lwz.mapper.StudentDao.queryById", 1);
        System.out.println(stu1.getStudentName());

        //调用clearCache方法清理当前SqlSession中的缓存
        session.clearCache();

        //第二次查询
        Student stu2 = session.selectOne("com.lwz.mapper.StudentDao.queryById", 1);
        System.out.println(stu2.getStudentName());

        System.out.println(stu1 == stu2);

        session.commit();
        session.close();

    }

运行输出：
在这里插入图片描述
从输出中可以看出，2次同样的查询都访问了db。

方式3：Select元素的flushCache置为true

将Mapper xml中select元素的flushCache属性置为true的时候，每次执行这个select元素对应的查询之前，mybatis会将当前SqlSession中一级缓存中的所有数据都清除。

案例代码

<!--查询单个-->
<!--新增一个select元素的查询，将flushCache元素置为true，注意：select元素这个属性的默认值是false。-->
<select id="queryById" flushCache="true" resultMap="StudentMap">
    select
      id, student_id, student_name, age, gender, class_name
    from mybatis.t_student
    where id = #{id}
</select>

对应测试用例

@Test
    public void testStudentDao() {
        // 通过工具类生成SqlSession对象
        SqlSession session = MybatisUtils.getSession();

        //第一次查询
        Student stu1 = session.selectOne("com.lwz.mapper.StudentDao.queryById", 1);
        System.out.println(stu1.getStudentName());

        //第二次查询
        Student stu2 = session.selectOne("com.lwz.mapper.StudentDao.queryById", 1);
        System.out.println(stu2.getStudentName());

        System.out.println(stu1 == stu2);

        session.commit();
        session.close();

    }

运行输出：
在这里插入图片描述
从输出中可以看出，2次同样的查询都访问了db。

一级缓存使用总结

1：一级缓存是SqlSession级别的，每个人SqlSession有自己的一级缓存，不同的SqlSession之间一级缓存是相互隔离的

2：mybatis中一级缓存默认是自动开启的

4：当在同一个SqlSession中执行同样的查询的时候，会先从一级缓存中查找，如果找到了直接返回，如果没有找到会去访问db，然后将db返回的数据丢到一级缓存中，下次查询的时候直接从缓存中获取

5：一级缓存清空的3种方式（1：SqlSession中执行增删改会使一级缓存失效；2：调用SqlSession.clearCache方法会使一级缓存失效；3：Mapper xml中的select元素的flushCache属性置为true，那么执行这个查询会使一级缓存失效）

mybatis二级缓存

二级缓存的使用

一级缓存使用上存在局限性，必须要在同一个SqlSession中执行同样的查询，一级缓存才能提升查询速度，如果想在不同的SqlSession之间使用缓存来加快查询速度，此时我们需要用到二级缓存了。

二级缓存是mapper级别的缓存，每个mapper xml有个namespace，二级缓存和namespace绑定的，每个namespace关联一个二级缓存，多个SqlSession可以共用二级缓存，二级缓存是跨SqlSession的。
在这里插入图片描述
二级缓存默认是没有开启的，需要我们在mybatis全局配置文件中进行开启：

<settings>
    <!-- 开启二级缓存 -->
    <setting name="cacheEnabled" value="true"/>
</settings>

上面配置好了以后，还需要在对应的mapper xml加上下面配置，表示这个mapper中的查询开启二级缓存：

<cache/>

经过上面两个步骤，就完成了二级缓存的开启操作。

一二级缓存共存时查询原理

一二级缓存如果都开启的情况下，数据查询过程如下：

1：当发起一个查询的时候，mybatis会先访问这个namespace对应的二级缓存，如果二级缓存中有数据则直接返回，否则继续向下
2：查询一级缓存中是否有对应的数据，如果有则直接返回，否则继续向下
3：访问db获取需要的数据，然后放在当前SqlSession对应的二级缓存中，并且在本地内存中的另外一个地方存储一份（这个地方我们就叫TransactionalCache）
4：当SqlSession关闭的时候，也就是调用SqlSession的close方法的时候，此时会将TransactionalCache中的数据放到二级缓存中，并且会清空当前SqlSession一级缓存中的数据。

二级缓存案例

mybatis全局配置文件开启二级缓存配置

<settings>
    <!-- 开启二级缓存 -->
    <setting name="cacheEnabled" value="true"/>
</settings>

映射文件中使用cache元素开启二级缓存

<!-- 启用二级缓存 -->
<cache></cache>

<!--查询单个-->
<!--新增一个select元素的查询，将flushCache元素置为true，注意：select元素这个属性的默认值是false。-->
<select id="queryById" resultMap="StudentMap">
    select
      id, student_id, student_name, age, gender, class_name
    from mybatis.t_student
    where id = #{id}
</select>

测试用例

@Test
public void testStudentDao() {

    // 通过工具类生成SqlSession对象
    SqlSession session = MybatisUtils.getSession();
    //第一次查询
    StudentDao studentDao = session.getMapper(StudentDao.class);
    Student student = studentDao.queryById(1);
    System.out.println(student.getStudentName());
    //关闭session
    session.close();

    SqlSession session1 = MybatisUtils.getSession();
    //第二次查询
    StudentDao studentDao1 = session1.getMapper(StudentDao.class);
    Student student1 = studentDao1.queryById(1);
    System.out.println(student1.getStudentName());

}

上面执行了2次查询，每次查询都是新的SqlSession，运行一下看看效果。

执行输出

DEBUG [main] - Cache Hit Ratio [com.lwz.dao.StudentDao]: 0.0
DEBUG [main] - ==>  Preparing: select id, student_id, student_name, age, gender, class_name from mybatis.t_student where id = ? 
DEBUG [main] - ==> Parameters: 1(Integer)
DEBUG [main] - <==      Total: 1
张三
DEBUG [main] - Cache Hit Ratio [com.lwz.dao.StudentDao]: 0.5
张三

注意上面第一行日志输出：

DEBUG [main] - Cache Hit Ratio [com.lwz.dao.StudentDao]: 0.0

对这行做一个解释：com.lwz.dao.StudentDao是上面查询访问的mapper xml的namesapce的值，去这个namespace对应的二级缓存中去查询数据，没有查询到，输出中的0.0表示命中率，这次没有命中，所以命中率为0

然后就去db中访问数据了，会将db中返回的数据放在一级缓存中，第一次运行完毕之后会调用SqlSession的close方法，然后db中返回的数据会被丢到二级缓存中，第二次查询的时候就直接从二级缓存中获取到数据返回了，所以第二次查询输出如下：
在这里插入图片描述
2次查询都去访问了二级缓存，第二次命中了，命中率为1/2=0.5

清空或者跳过二级缓存的3种方式

当二级缓存开启的时候，在某个mapper xml中添加cache元素之后，这个mapper xml中所有的查询都默认开启了二级缓存，那么我们如何清空或者跳过二级缓存呢？3种方式如下：

1：对应的mapper中执行增删改查会清空二级缓存中数据

2：select元素的flushCache属性置为true，会先清空二级缓存中的数据，然后再去db中查询数据，然后将数据再放到二级缓存中

3：select元素的useCache属性置为false，可以使这个查询跳过二级缓存，然后去查询数据

方式1：增删改会清除二级缓存中的数据

案例代码

@Test
    public void testStudentDao() {

        // 通过工具类生成SqlSession对象
        SqlSession session = MybatisUtils.getSession();
        //第一次查询
        StudentDao studentDao = session.getMapper(StudentDao.class);
        Student student = studentDao.queryById(1);
        System.out.println(student.getStudentName());

        SqlSession session2 = MybatisUtils.getSession();
        StudentDao studentDao2 = session2.getMapper(StudentDao.class);
        Student student3 = new Student();
        student3.setAge(10);
        student3.setStudentName("速度放缓");
        student3.setGender("女");
        student3.setClassName("303");
        student3.setStudentId(2018013456);
        int i = studentDao2.insert(student3);
        System.out.println(i);
        session2.commit();

        SqlSession session1 = MybatisUtils.getSession();
        //第二次查询
        StudentDao studentDao1 = session1.getMapper(StudentDao.class);
        Student student1 = studentDao1.queryById(1);
        System.out.println(student1.getStudentName());

    }

上面使用了3个不同的SqlSession，第一次和第三次都调用了queryById()执行查询，中间执行了一个插入操作，mybatis执行插入的时候，会先清除当前namespace对应的二级缓存中的数据，所以上面2次查询最终都会访问db，来运行一下看看效果。

运行输出
在这里插入图片描述

方式2：select元素的flushCache属性置为true

当将mapper xml中select元素的flushCache属性置为true，会先清空二级缓存中的数据，然后再去db中查询数据，然后将数据再放到二级缓存中。

<!--查询单个-->
    <select id="queryById" flushCache="true" resultMap="StudentMap">
        select
          id, student_id, student_name, age, gender, class_name
        from mybatis.t_student
        where id = #{id}
    </select>

方式3：select元素的useCache置为false跳过二级缓存，但是不会清空二级缓存数据

<!--查询单个-->
    <select id="queryById" useCache="false" resultMap="StudentMap">
        select
          id, student_id, student_name, age, gender, class_name
        from mybatis.t_student
        where id = #{id}
    </select>

二级缓存使用总结

1：一二级缓存访问顺序：一二级缓存都存在的情况下，会先访问二级缓存，然后再访问一级缓存，最后才会访问db，这个顺序大家理解一下

2：将mapper xml中select元素的flushCache属性置为false，最终会清除一级缓存所有数据，同时会清除这个select所在的namespace对应的二级缓存中所有的数据

3：将mapper xml中select元素的useCache置为false，会使这个查询跳过二级缓存

4：总体上来说使用缓存可以提升查询效率，这块知识掌握了，大家可以根据业务自行选择

猜你喜欢

转载自blog.csdn.net/weixin_43894879/article/details/106044225
今日推荐
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
Java自定义时间格式
同步整形电路
在开发中最最最常用的字符串的属性大集合
Linux 查看端口占用并杀掉
Java基础四：ArrayList
多线程之死锁就是这么简单
mysql 基础命令集
awk 命令详解
Centos6.3编译安装nginx+php步骤
OCR （Optical Character Recognition，光学字符识别）
每日归档
更多
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022