MyBatis缓存机制（一级缓存，二级缓存）

最新推荐文章于 2024-09-22 14:31:22 发布
最新推荐文章于 2024-09-22 14:31:22 发布
阅读量4.7k 收藏 131
点赞数 15
分类专栏： 程序员 JAVA 面向对象编程 文章标签： java mybatis mysql 数据库 spring
原文链接：https://www.tuicool.com/articles/AVnUNvn
版权
JAVA 同时被 3 个专栏收录
281 篇文章 2 订阅
订阅专栏
程序员
279 篇文章 1 订阅
订阅专栏
面向对象编程
162 篇文章 1 订阅
订阅专栏

写在前面：2020年面试必备的Java后端进阶面试题总结了一份复习指南在Github上，内容详细，图文并茂，有需要学习的朋友可以Star一下！
GitHub地址：https://github.com/abel-max/Java-Study-Note/
一，MyBatis一级缓存（本地缓存）
My Batis 一级缓存存在于 SqlSession 的生命周期中，是SqlSession级别的缓存。在操作数据库时需要构造SqlSession对象，在对象中有一个数据结构用来存储缓存数据。不同的SqlSession之间的数据缓存是不能共享的。

在同一个SqlSession 中查询数据时，sqlSession会先在一级缓存中查找，如果有，直接读取，如果没有，则从数据库中查询， 接着把执行的方法和参数通过算法生成缓存的键值，将键值和查询结果存入一级缓存中（以Map对象的形式）。如果后面再次执行相同方法，SqlSession通过算法会生成相同的键值，然后在一级缓存中查找，由于一级缓存中己经存在该键值，所以会返回缓存中的对象。与执行select不同的是，执行update，insert，delect操作后会清空一级缓存中的数据，而不是通过算法生成缓存的键值存入一级缓存，之所以有这种差别是因为 select的flushCache（清空缓存）默认为false，而update，insert，delect的flushCache（清空缓存）默认为true。

当然也可以使用下面的方法对select操作进行设置，

select * from student where sid=#{Sid} and s_name=#{Sname} 就是在原来方法的基础上增加了 flushCache= true ，这个属性配置为 true 后，在查询数据后会清空当前的一级缓存，因此调用该方法后每次都会重新从数据库中查询数据，但是由于这个方法清空了一级缓存，会影响当前 SqlSession 中所有缓存的查询，因此在需要反复查询获取只读数据的情况下，会增加数据库的查询次数，所以要避免这么使用。

除了上面讲的将 flushCache赋值为true的情况外，还会导致一级缓存清空的情况就是关闭第一个 SqlSession，然后重新开启一个SqlSession，由于一级缓存是和 SqlSession 绑定的，只存在于 SqlSession的生命周期中，所以在新的SqlSession中调用刚才的方法，在缓存中就查不到，必须去数据库中查询，当然之后在调用过该方法并不清除的情况下就可以在缓存中取到了。

一级缓存原理图：
在这里插入图片描述
代码：

public class MyBatisTest {
    public static void main( String[] args ) {
        SqlSession openSession = null;
        try {
            //mybatis配置文件
            String resourse="mybatis-cfg.xml";
            //通过 Resources 工具类将 ti -config.xm 配置文件读入 Reader
            InputStream inputStream=Resources.getResourceAsStream(resourse);
            //通过 SqlSessionFactoryBuilder 建造类使用 Reader 创建 SqlSessionFactory工厂对象
            SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(inputStream);
            //通过SqlSessionFactory工厂得到SqlSession
            openSession = sqlSessionFactory.openSession();
            //通过反射机制来获取对应的Mapper实例
            StudentMapper mapper=openSession.getMapper(StudentMapper.class);
            Student student1=mapper.selectStudentByIdAndName(2,"danghh");
            Student student2=mapper.selectStudentByIdAndName(2,"danghh");
            System.out.println(student1);
            openSession.commit();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //最后一定不要忘记关闭 SqlSession ，否则会因为连接没有关闭导致数据库连接数过多，造成系统崩旗
            openSession.close();
        }
    }
}

运行结果：

[DEBUG] - Setting autocommit to false on JDBC Connection[com.mysql.jdbc.JDBC4Connection@dfd3711]
[DEBUG] - ==>  Preparing: select * from student where sid=? and s_name=? 
[DEBUG] - ==> Parameters: 2(Integer), danghh(String)
[DEBUG] - <==      Total: 1
 Student{SID=2, Sname='danghh', Sage=22, Ssex='nv', course=null}
 Student{SID=2, Sname='danghh', Sage=22, Ssex='nv', course=null}

通过结果可以看出，由于代码中查询是在一个SqlSession，且两次查询过程中没有更新信息，不会导致一级缓存失效，所以结果只进行了一次数据库查询。

那如果是在两个SqlSession中分别进行查询呢？

代码：
在这里插入图片描述结果：

[DEBUG] - Opening JDBC Connection
[DEBUG] - Checked out connection 234698513 from pool.
[DEBUG] - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@dfd3711]
[DEBUG] - ==>  Preparing: select * from student where sid=? and s_name=? 
[DEBUG] - ==> Parameters: 2(Integer), danghh(String)
[DEBUG] - <==      Total: 1
[DEBUG] - Opening JDBC Connection
[DEBUG] - Created connection 1836797772.
[DEBUG] - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@6d7b4f4c]
[DEBUG] - ==>  Preparing: select * from student where sid=? and s_name=? 
[DEBUG] - ==> Parameters: 2(Integer), danghh(String)
[DEBUG] - <==      Total: 1
Student{SID=2, Sname='danghh', Sage=22, Ssex='nv', course=null}
Student{SID=2, Sname='danghh', Sage=22, Ssex='nv', course=null}

可以看出在使用了两个SqlSession进行查询后，在数据库进行了两次查询，也验证了SqlSession的一级缓存是和SqlSession的生命周期绑定的，作用范围也只在当前SqlSession中。

另外在演示下如果在进行查询之前进行了一次update操作会不会使一级缓存清空呢？

代码：
在这里插入图片描述运行结果：

 [DEBUG] - ==>  Preparing: select * from student where sid=? and s_name=? 
 [DEBUG] - ==> Parameters: 2(Integer), hjj(String)
 [DEBUG] - <==      Total: 1
 [DEBUG] - ==>  Preparing: update student set S_name=?,Sage=?,Ssex=? where Sid=? 
 [DEBUG] - ==> Parameters: hjj(String), 23(Integer), null, 2(Integer)
 [DEBUG] - <==    Updates: 1
 [DEBUG] - ==>  Preparing: select * from student where sid=? and s_name=? 
 [DEBUG] - ==> Parameters: 2(Integer), hjj(String)
 [DEBUG] - <==      Total: 1
  Student{SID=2, Sname='hjj', Sage=23, Ssex='null', course=null}
  Student{SID=2, Sname='hjj', Sage=23, Ssex='null', course=null}

二，MyBatis二级缓存（全局缓存）

MyBatis二级缓存非常强大，它不同于一级缓存只存在于 SqlSession 的生命周期中， 而是可以理解为存在于 SqlSessionFactory 的生命周期中 ，是Mapper（studentMapper） 级别的缓存，一个Mapper对应一个二级缓存，当Mapper中的多个SqlSession共同操作同一个方法时，多个SqlSession是可以共用二级缓存的中的数据的，所以二级缓存是跨SqlSession的。

在开启二级缓存时，查出来的数据默认先存储在一级缓存中，当有 SqlSession关闭 时，它里面一级缓存中的数据就会被存储到Mapper的二级缓存中，这样该Mapper中的其他会话执行了相同方法时，就会在二级缓存中找到匹配的数据，如果没有找到，才会去数据库中查找。注意只有在该会话关闭时，它一级缓存中的数据才会被刷到二级缓存中。另外如果只是开启二级缓存的全局（config）开关，而会话（student）没有开启二级缓存，查询时也不会在二级缓存中查询。

一级缓存（ 也叫本地缓存）一般默认会启开，不需要进行配置，但要使用二级缓存就需要进行配置。 那如何配置呢？

第一步 ：在全局配置文件中添加

在这里插入图片描述
（这个参数是二级缓存的全局开关，默认值是 true ，初始状态为启用状态，所以也可忽略此步的配置）

（由于MyBatis二级缓存和命名空间namespace是绑定的 ，即二级缓存还需要在 Mapper.xml 映射文件中配置或者在 Mapper.java 接口中配置。）

第二步 ：在Sql映射文件中添加元素。

在这里插入图片描述
上面的配置创建了一个 FIFO 缓存，并每隔6秒刷新一次，存储集合或对象的1024个引用，而且返回的对象被认为是非只读的。

eviction ：缓存的收回策略

LRU （最近最少使用的） 移除最长时间不被使用的对象，这是默认值
FIFO （先进先出〉 按对象进入缓存的顺序来移除它们
SOFT （软引用） 移除基于垃圾回收器状态和软引用规则的对象
WEAK （弱引用） 更积极地移除基于垃圾收集器状态和弱引用规则的对象
flushinterval ：刷新间隔

设置缓存多长时间清空一次，单位为毫秒值，默认不清空。

readOnly：是否只读

true：只读，设置为true后，mybatis认为所有从缓存中获取数据的操作都是只读操作，不会修改数据，因此为了加快获取速度，一般会直接将数据在缓存中的引用交给用户，虽然速度快，但不安全。

false：非只读，设置为false后，mybatis认为获取的数据可能会被修改，因此会利用序列化和反序列化的技术克隆一份新的数据给你，虽然速度慢，但安全。

默认是 false

size ：引用数目

设置缓存可以存放的引用数目，可以被设置为任意正整数 。默认值是 1024。

第三步 ：给POJO类实现序列化接口
在这里插入图片描述
代码：

public class MyBatisTest {
    public static void main( String[] args ) {
        SqlSession openSession1 = null;
        SqlSession openSession2 = null;
        try {
            //mybatis配置文件
            String resourse="mybatis-cfg.xml";
            //通过 Resources 工具类将 ti -config.xm 配置文件读入 Reader
            InputStream inputStream=Resources.getResourceAsStream(resourse);
            //通过 SqlSessionFactoryBuilder 建造类使用 Reader 创建 SqlSessionFactory工厂对象
            SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(inputStream);
            //通过SqlSessionFactory工厂得到SqlSession1
            openSession1 = sqlSessionFactory.openSession();
            StudentMapper mapper1=openSession1.getMapper(StudentMapper.class);
            //通过SqlSessionFactory工厂得到SqlSession2
            openSession2 = sqlSessionFactory.openSession();
            StudentMapper mapper2=openSession2.getMapper(StudentMapper.class);
            //使用会话1进行查询,此次查询结果只会存储在一级缓存中
            Student student1=mapper1.selectStudentByIdAndName(2,"hjj");
            System.out.println(student1);
            //使用会话2进行查询，前面会话未关闭，数据不会被刷到二级缓存中，所以本次仍会执行sql
            Student student2=mapper2.selectStudentByIdAndName(2,"hjj");
            System.out.println(student2);
            //使用会话2进行查询，由于前面已执行过该方法，所以可在一级缓存中查到
            Student student3=mapper2.selectStudentByIdAndName(2,"hjj");
            System.out.println(student3);
            openSession1.commit();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //最后一定不要忘记关闭 SqlSession ，否则会因为连接没有关闭导致数据库连接数过多，造成系统崩旗
            openSession1.close();
        }
    }
}

运行结果：

[DEBUG] - Cache Hit Ratio [MyBatisDemo.StudentMapper]: 0.0
[DEBUG] - Opening JDBC Connection
[DEBUG] - Checked out connection 234698513 from pool.
[DEBUG] - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@dfd3711]
[DEBUG] - ==>  Preparing: select * from student where sid=? and s_name=? 
[DEBUG] - ==> Parameters: 2(Integer), hjj(String)
[DEBUG] - <==      Total: 1
     Student{SID=2, Sname='hjj', Sage=23, Ssex='null', course=null}
[DEBUG] - Cache Hit Ratio [MyBatisDemo.StudentMapper]: 0.0
[DEBUG] - Opening JDBC Connection
[DEBUG] - Created connection 1843368112.
[DEBUG] - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@6ddf90b0]
[DEBUG] - ==>  Preparing: select * from student where sid=? and s_name=? 
[DEBUG] - ==> Parameters: 2(Integer), hjj(String)
[DEBUG] - <==      Total: 1
     Student{SID=2, Sname='hjj', Sage=23, Ssex='null', course=null}
[DEBUG] - Cache Hit Ratio [MyBatisDemo.StudentMapper]: 0.0
      Student{SID=2, Sname='hjj', Sage=23, Ssex='null', course=null}
[DEBUG] - Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@dfd3711]
[DEBUG] - Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@dfd3711]
[DEBUG] - Returned connection 234698513 to pool.

该颜色： 表示会话1第一次查询的结果，由于第一次查询，一级缓存和二级缓存中都没有数据，所以Mapper命中率为0.0，且进行了数据库查询，并将结果存储到会话1一级缓存中。

该颜色： 表示会话2第一次查询的结果，由于会话1没有关闭，所以会话1的一级缓存不会刷到Mapper的二级缓存中，并且是在会话2中第一次查询该方法，所以Mapper命中率为0.0，且进行了数据库查询，并将结果存储到会话2的一级缓存中。

该颜色： 表示会话2第二次查询的结果，虽然会话1没有关闭，会话1的一级缓存不会刷到Mapper的二级缓存中，但是在会话2中查询过该方法，在会话2的一级缓存中已存在该数据，所以Mapper命中率为0.0，没有进行数据库查询。

接下来就验证下会话中一级缓存的数据是不是只有在该会话关闭后才会被刷新到mapper的二级缓存！

代码：（仅截取部分）

在这里插入图片描述运行结果：

[DEBUG] - Cache Hit Ratio [MyBatisDemo.StudentMapper]: 0.0
[DEBUG] - Opening JDBC Connection
[DEBUG] - Checked out connection 234698513 from pool.
[DEBUG] - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@dfd3711]
[DEBUG] - ==>  Preparing: select * from student where sid=? and s_name=? 
[DEBUG] - ==> Parameters: 2(Integer), hjj(String)
[DEBUG] - <==      Total: 1
  Student{SID=2, Sname='hjj', Sage=23, Ssex='null', course=null}
[DEBUG] - Cache Hit Ratio [MyBatisDemo.StudentMapper]: 0.0
  Student{SID=2, Sname='hjj', Sage=23, Ssex='null', course=null}
[DEBUG] - Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@dfd3711]
[DEBUG] - Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@dfd3711]
[DEBUG] - Returned connection 234698513 to pool.
[DEBUG] - Cache Hit Ratio [MyBatisDemo.StudentMapper]: 0.3333333333333333
  Student{SID=2, Sname='hjj', Sage=23, Ssex='null', course=null}
[DEBUG] - Cache Hit Ratio [MyBatisDemo.StudentMapper]: 0.5
  Student{SID=2, Sname='hjj', Sage=23, Ssex='null', course=null}

来源：https://www.tuicool.com/articles/AVnUNvn

毛发旺盛的程序员
关注
专栏目录
MyBatis之缓存机制
yandao的博客
05-18 1479
缓存即为存在内存中的临时数据.将用户经常查询的数据存放在缓存(内存)中,用户去查询数据就不用去每次去数据库中查询,而是去缓存中查询,从而提高了查询的效率,解决了高并发系统的性能问题.MyBatis提供了两种缓存机制：一级缓存（本地）和二级缓存（全局）1、默认情况下，只有一级缓存( SqlSession级别的缓存也称为本地缓存)开启。2、二级缓存需要手动开启和配置，他是基于namespace级别的缓存。3、为了提高扩展性。MyBatis定义了缓存接口Cache。
MyBatis缓存（一级缓存和二级缓存）机制
muweichang的博客
10-17 733
缓存可以将数据保存在内存中，是互联网系统常常用到的。目前流行的缓存服务器有 MongoDB、**Redis**、Ehcache 等。 一级缓存的作用域是同一个 SqlSession，在同一个 sqlSession 中两次执行相同的 sql语句，第一次执行完毕会将数据库中查询的数据写到缓存（内存），**第二次会从缓存中获取，数据将不再从数据库查询，从而提高查询效率**。当一个 sqlSession 结束后该 s 缓存是在计算机内存上保存的数据，读取时无需再从磁盘读入，因此具备**快速读取和使用**的特点。
Mybatis的缓存机制
m0_72106802的博客
09-16 1318
Mybatis框架内置了一级缓存机制和二级缓存机制，一级缓存机制又称为会话（Session）缓存，默认是开启的，且无法关闭；二级缓存机制又成为namespace缓存，作用于某个namespace，可以理解为是接口。Mybatis框架自带两者缓存机制：一级缓存机制和二级缓存机制，但是这种机制我们了解即可，在实际缓存使用中应为局限性（执行任意一种增删改数据的操作，缓存就会失效）的原因，还是不推荐大家使用！
MyBatis一级缓存和二级缓存全面详解
最新发布
2401_87299389的博客
09-22 1754
一级缓存的内容不能跨sqlsession。由MyBatis自动维护。，缓存范围比一级缓存更大。不同的sqlsession可以访问二级缓存的内容。哪些数据放入二级缓存需要自己指定。
mybatis一级缓存二级缓存
weixin_34395205的博客
10-11 128
一级缓存 　　Mybatis对缓存提供支持，但是在没有配置的默认情况下，它只开启一级缓存，一级缓存只是相对于同一个SqlSession而言。所以在参数和SQL完全一样的情况下，我们使用同一个SqlSession对象调用一个Mapper方法，往往只执行一次SQL，因为使用SelSession第一次查询后，MyBatis会将其放在缓存中，以后再查询的时候，如...
MyBatis的缓存机制
私は悪い人ですか的博客
11-05 774
缓存机制简介 MyBatis 包含一个非常强大的查询缓存特性,它可以非常方便地配置和定制。缓存可以极大的提升查询效率 MyBatis系统中默认定义了两级缓存 一级缓存 二级缓存 默认情况下，只有一级缓存（SqlSession级别的缓存，也称为本地缓存）开启。 二级缓存需要手动开启和配置，他是基于namespace级别的缓存。 为了提高扩展性。MyBatis定义了缓存接口Cache。我...
Mybatis 一级缓存、二级缓存（转）
qq_39809613的博客
06-11 151
查询缓存 首先，我们先看一下这个标题“查询缓存”，那就说明跟增、删、改是没有任何关联的，只有在查询时，才会遇到缓存，增删改不涉及！ 查询缓存目前Mybatis中提供了两个，分别是：一级缓存、二级缓存； 一级缓存 先说一下一级缓存的范围：同一个SqlSession对象，也就说，我们是同一个SqlSession对象，又要进行同样的查询操作，那么，我们就可以去缓存中获取； 所以，SqlSess...
深入理解MyBatis中的一级缓存与二级缓存
08-30
一级缓存和二级缓存都是MyBatis提供的缓存机制，它们可以帮助提高应用程序的性能。但是，二级缓存的作用范围更大，可以被多个SqlSession共用，是一种更强大的一种缓存机制。 在实际开发中，MyBatis通常和Spring进行...
mybatis一级缓存和二级缓存简单示例
01-01
本文将深入讲解 MyBatis 的一级缓存和二级缓存，并通过一个简单的示例进行说明。 ### 一级缓存 一级缓存是 Session 级别的缓存，也称为本地缓存（Local Cache）。每当我们在一个 SqlSession 中执行了 CRUD 操作，...
【MyBatis源码全面解析】MyBatis一二级缓存介绍
08-30
CacheKey是MyBatis缓存机制中的一个重要概念，它用于标识缓存中的键。CacheKey是根据MappedStatement、参数、RowBounds和BoundSql等信息生成的。 CachingExecutor CachingExecutor是MyBatis中的一个执行器，它负责...
Mybatis笔记13（完结）--缓存
weixin_47324424的博客
07-02 373
13、缓存 查询：要连接数据库---耗资源 优化：把一次查询的结果，给暂存一个可以直接取到的地方！-->内存：缓存 当我们再次查询相同的数据时，直接走缓存，就不用走数据库了 1、简介 什么是缓存[Cache]? 存在内存中的临时数据 将用户经常查询的数据放在缓存（内存）中，用户去查询数据就不用从磁盘上（关系型数据数据文件）查询，从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题。 为什么使用缓存？ 减少和数据库的交互次数，减少系统开销，提高系统效率 什么样的数据能使用缓存
mybatis的缓存机制
卷心菜投手
09-16 1万+
一、mybatis和同是持久层的hibernate一样，都存在着缓存机制，今天来说一下mybatis的缓存机制。 查询缓存来缓存数据，从而达到提高查询性能的要求，以提高我们项目的效率！！ 二、mybatis的缓存机制有两级：              （1）一级缓存：一级缓存mybatsi已近为我们自动开启，不用我们手动操作，而且我们是关闭不了的！！但是我们可以手动清除缓存。（SqlSess...
MyBatis之缓存（一级缓存、二级缓存）
tomoto_zh的博客
05-12 1014
1，        MyBatis的解析 MyBatis的解析工作由XmlConfiguraBuilder类来实现的，它将MyBatis的所有配置信息解析到Configuration中，为之后的使用提供支持。 2，        MyBatis的一级缓存 MyBatis的一级缓存是SqlSession级别的缓存，每个SqlSession都有一个以及缓存。 我们在对数据库进行操作时，会创建一
mybatis中的缓存（一级缓存、二级缓存）
m0_62943934的博客
07-23 5792
在计算机的世界中，缓存无处不在，重要性不言而喻。作为一款优秀的ORM框架，MyBatis中又岂能少得了缓存，本博客基于mybatis 3.5.11版本，全面介绍mybatis一级缓存、二级缓存以及自定义缓存的使用方法、实现原理、应用场景、优缺点等，并进行验证，带你彻底掌握MyBatis缓存。
mybatis缓存
热门推荐
Mr. Wu's blog
05-24 1万+
mybatis一级缓存二级缓存机制
mybatis缓存机制
qq_44286009的博客
06-09 4477
  学习了mybatis缓存机制，现对其进行总结。
理解MyBatis一二级缓存机制
"MyBatis的一级和二级缓存机制是其优化数据库操作的重要特性，能够显著提高查询效率，减少对数据库的访问。一级缓存基于SqlSession，而二级缓存则跨越多个Mapper，实现了Mapper级别的数据共享。" MyBatis缓存系统是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值