AI 助理
备案控制台
开发者社区 数据库 文章 正文

Mybatis 缓存失效的几种情况

2017-08-09 892
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
云数据库 RDS MySQL，集群系列 2核4GB
推荐场景：
搭建个人博客
RDS MySQL Serverless 基础系列，0.5-2RCU 50GB
推荐场景：
学生管理系统数据库设计 搭建个人博客
云数据库 RDS MySQL，高可用系列 2核4GB
简介： 1　不在同一个sqlSession对象中下面比较下载同一个sqlSession和不在同一sqlSession下面的两种情况：同一sqlSession:@Test public final void testQueryClazzById() { SqlSession session = sqlSessionFactory.

1　不在同一个sqlSession对象中

下面比较下载同一个sqlSession和不在同一sqlSession下面的两种情况：

同一sqlSession:

@Test
    public final void testQueryClazzById() {
        SqlSession session = sqlSessionFactory.openSession();
        try {
            ClazzMapper clazzMapper = session.getMapper(ClazzMapper.class);
            Clazz clazz1 = clazzMapper.queryClazzById(1);
            System.out.println("clazz1 = "+clazz1);
            
            Clazz clazz2 = clazzMapper.queryClazzById(1);
            System.out.println("clazz2 = "+clazz2);
        } finally {
            session.close();
        }

如下sql执行了一次，第二次queryClazzById没有执行sql,直接从缓存里面获取。

DEBUG [main] - ==>  Preparing: select c.*,s.id stu_id,s.name stu_name from t_clazz c left join t_student s on c.id = s.clazz_id where c.id = ? 
DEBUG [main] - ==> Parameters: 1(Integer)
DEBUG [main] - <==      Total: 3
clazz1 = Clazz [id=1, name=javaEE20170228, stus=[Student [id=1, name=stu0228_张三, clazz=null], Student [id=2, name=stu0228_李四, clazz=null], Student [id=3, name=stu0228_王五, clazz=null]]]
clazz2 = Clazz [id=1, name=javaEE20170228, stus=[Student [id=1, name=stu0228_张三, clazz=null], Student [id=2, name=stu0228_李四, clazz=null], Student [id=3, name=stu0228_王五, clazz=null]]]

不在同一sqlSession:

@Test
    public final void testQueryClazzById() {
        SqlSession session = sqlSessionFactory.openSession();
        try {
            ClazzMapper clazzMapper = session.getMapper(ClazzMapper.class);
            Clazz clazz1 = clazzMapper.queryClazzById(1);
            System.out.println("clazz1 = "+clazz1);
        } finally {
            session.close();
        }
        //緩存失效的四種情況
        //不在同一個對象中
        SqlSession session2 = sqlSessionFactory.openSession();
        try {
            ClazzMapper clazzMapper2 = session2.getMapper(ClazzMapper.class);
            Clazz clazz2 = clazzMapper2.queryClazzById(1);
            System.out.println("clazz2 = "+clazz2);
        } finally {
            session2.close();
        }
    }
  看下结果：
DEBUG [main] - ==>  Preparing: select c.*,s.id stu_id,s.name stu_name from t_clazz c left join t_student s on c.id = s.clazz_id where c.id = ? 
DEBUG [main] - ==> Parameters: 1(Integer)
DEBUG [main] - <==      Total: 3
clazz1 = Clazz [id=1, name=javaEE20170228, stus=[Student [id=1, name=stu0228_张三, clazz=null], Student [id=2, name=stu0228_李四, clazz=null], Student [id=3, name=stu0228_王五, clazz=null]]]
DEBUG [main] - Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@6895a785]
DEBUG [main] - Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@6895a785]
DEBUG [main] - Returned connection 1754638213 to pool.
DEBUG [main] - Opening JDBC Connection
DEBUG [main] - Checked out connection 1754638213 from pool.
DEBUG [main] - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@6895a785]
DEBUG [main] - ==>  Preparing: select c.*,s.id stu_id,s.name stu_name from t_clazz c left join t_student s on c.id = s.clazz_id where c.id = ? 
DEBUG [main] - ==> Parameters: 1(Integer)
DEBUG [main] - <==      Total: 3
clazz2 = Clazz [id=1, name=javaEE20170228, stus=[Student [id=1, name=stu0228_张三, clazz=null], Student [id=2, name=stu0228_李四, clazz=null], Student [id=3, name=stu0228_王五, clazz=null]]]
DEBUG [main] - Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@6895a785]
DEBUG [main] - Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@6895a785]
DEBUG [main] - Returned connection 1754638213 to pool. 
分别调用两次sql,没用使用缓存。
 

2    执行语句的参数不同。缓存中也不存在数据 

@Test
    public void testfirstCacheFail2() {
        //一级缓存必须存在于同一个SqlSession中
        SqlSession session = sqlSessionFactory.openSession();
        ClazzMapper clazzMapper2 = session.getMapper(ClazzMapper.class);
        Clazz user1 = clazzMapper2.queryClazzById(1);
        System.out.println(user1);
        
        Clazz user2 = clazzMapper2.queryClazzById(2);
        System.out.println( user2 );
        session.close();
    }
看结果：
DEBUG [main] - ==>  Preparing: select c.*,s.id stu_id,s.name stu_name from t_clazz c left join t_student s on c.id = s.clazz_id where c.id = ? 
DEBUG [main] - ==> Parameters: 1(Integer)
DEBUG [main] - <==      Total: 3
Clazz [id=1, name=javaEE20170228, stus=[Student [id=1, name=stu0228_张三, clazz=null], Student [id=2, name=stu0228_李四, clazz=null], Student [id=3, name=stu0228_王五, clazz=null]]]
DEBUG [main] - ==>  Preparing: select c.*,s.id stu_id,s.name stu_name from t_clazz c left join t_student s on c.id = s.clazz_id where c.id = ? 
DEBUG [main] - ==> Parameters: 2(Integer)
DEBUG [main] - <==      Total: 2
Clazz [id=2, name=javaEE20170325, stus=[Student [id=4, name=stu0325_马云, clazz=null], Student [id=5, name=stu0325_任正非, clazz=null]]]
分别调用两次sql,没有使用到缓存。
 

3、执行增，删，改，语句，会清空掉缓存

 @Test
    public void testfirstCacheFail3() {
        //一级缓存必须存在于同一个SqlSession中
        SqlSession session = sqlSessionFactory.openSession();
        ClazzMapper clazzMapper2 = session.getMapper(ClazzMapper.class);
        Clazz user1 = clazzMapper2.queryClazzById(2);
        System.out.println(user1);
        
        Clazz clazz = new Clazz();
        clazz.setId(2);
        clazz.setName("電影放映班");
        clazzMapper2.updateClazz(clazz);
        session.commit();
        
        System.out.println(clazzMapper2.queryClazzById(2));
        session.close();
    }

看结果：

DEBUG [main] - ==>  Preparing: select c.*,s.id stu_id,s.name stu_name from t_clazz c left join t_student s on c.id = s.clazz_id where c.id = ? 
DEBUG [main] - ==> Parameters: 2(Integer)
DEBUG [main] - <==      Total: 2
Clazz [id=2, name=javaEE20170325, stus=[Student [id=4, name=stu0325_马云, clazz=null], Student [id=5, name=stu0325_任正非, clazz=null]]]
DEBUG [main] - ==>  Preparing: update t_clazz set name = ? where id = ? 
DEBUG [main] - ==> Parameters: 電影放映班(String), 2(Integer)
DEBUG [main] - <==    Updates: 1
DEBUG [main] - Committing JDBC Connection [com.mysql.jdbc.JDBC4Connection@6895a785]
DEBUG [main] - ==>  Preparing: select c.*,s.id stu_id,s.name stu_name from t_clazz c left join t_student s on c.id = s.clazz_id where c.id = ? 
DEBUG [main] - ==> Parameters: 2(Integer)
DEBUG [main] - <==      Total: 2
Clazz [id=2, name=電影放映班, stus=[Student [id=4, name=stu0325_马云, clazz=null], Student [id=5, name=stu0325_任正非, clazz=null]]]
查询执行两次，更新执行一次，也没使用到缓存

4、手动清空缓存数据

@Test
    public  void testfirstCacheFail4() {
        SqlSession session = sqlSessionFactory.openSession();
        try {
            ClazzMapper clazzMapper = session.getMapper(ClazzMapper.class);
            Clazz clazz1 = clazzMapper.queryClazzById(1);
            System.out.println("clazz1 = "+clazz1);
            //清空緩存
            session.clearCache();
            Clazz clazz2 = clazzMapper.queryClazzById(1);
            System.out.println("clazz2 = "+clazz2);
        } finally {
            session.close();
        }
    }

看结果：

DEBUG [main] - ==>  Preparing: select c.*,s.id stu_id,s.name stu_name from t_clazz c left join t_student s on c.id = s.clazz_id where c.id = ? 
DEBUG [main] - ==> Parameters: 1(Integer)
DEBUG [main] - <==      Total: 3
clazz1 = Clazz [id=1, name=javaEE20170228, stus=[Student [id=1, name=stu0228_张三, clazz=null], Student [id=2, name=stu0228_李四, clazz=null], Student [id=3, name=stu0228_王五, clazz=null]]]
DEBUG [main] - ==>  Preparing: select c.*,s.id stu_id,s.name stu_name from t_clazz c left join t_student s on c.id = s.clazz_id where c.id = ? 
DEBUG [main] - ==> Parameters: 1(Integer)
DEBUG [main] - <==      Total: 3
clazz2 = Clazz [id=1, name=javaEE20170228, stus=[Student [id=1, name=stu0228_张三, clazz=null], Student [id=2, name=stu0228_李四, clazz=null], Student [id=3, name=stu0228_王五, clazz=null]]]
执行了两次sql,没有使用到缓存

1    不在同一个sqlSession对象中

下面比较下载同一个sqlSession和不在同一sqlSession下面的两种情况
<wiz_code_mirror>
 
 
1 
@Test
2 
    public final void testQueryClazzById() {
3 
        SqlSession session = sqlSessionFactory.openSession();
4 
        try {
5 
            ClazzMapper clazzMapper = session.getMapper(ClazzMapper.class);
6 
            Clazz clazz1 = clazzMapper.queryClazzById(1);
7 
            System.out.println("clazz1 = "+clazz1);
8 
            
9 
            Clazz clazz2 = clazzMapper.queryClazzById(1);
10 
            System.out.println("clazz2 = "+clazz2);
11 
        } finally {
12 
            session.close();
13 
        }
 
 
如下sql执行了一次，第二次queryClazzById没有执行sql,直接从缓存里面获取。
DEBUG [main] - ==>  Preparing: select c.*,s.id stu_id,s.name stu_name from t_clazz c left join t_student s on c.id = s.clazz_id where c.id = ? 
DEBUG [main] - ==> Parameters: 1(Integer)
DEBUG [main] - <==      Total: 3
clazz1 = Clazz [id=1, name=javaEE20170228, stus=[Student [id=1, name=stu0228_张三, clazz=null], Student [id=2, name=stu0228_李四, clazz=null], Student [id=3, name=stu0228_王五, clazz=null]]]
clazz2 = Clazz [id=1, name=javaEE20170228, stus=[Student [id=1, name=stu0228_张三, clazz=null], Student [id=2, name=stu0228_李四, clazz=null], Student [id=3, name=stu0228_王五, clazz=null]]]
 
<wiz_code_mirror>
 
 
1 
@Test
2 
    public final void testQueryClazzById() {
3 
        SqlSession session = sqlSessionFactory.openSession();
4 
        try {
5 
            ClazzMapper clazzMapper = session.getMapper(ClazzMapper.class);
6 
            Clazz clazz1 = clazzMapper.queryClazzById(1);
7 
            System.out.println("clazz1 = "+clazz1);
8 
        } finally {
9 
            session.close();
10 
        }
11 
        //緩存失效的四種情況
12 
        //不在同一個對象中
13 
        SqlSession session2 = sqlSessionFactory.openSession();
14 
        try {
15 
            ClazzMapper clazzMapper2 = session2.getMapper(ClazzMapper.class);
16 
            Clazz clazz2 = clazzMapper2.queryClazzById(1);
17 
            System.out.println("clazz2 = "+clazz2);
18 
        } finally {
19 
            session2.close();
20 
        }
21 
    }
 
 
  看下结果：
DEBUG [main] - ==>  Preparing: select c.*,s.id stu_id,s.name stu_name from t_clazz c left join t_student s on c.id = s.clazz_id where c.id = ? 
DEBUG [main] - ==> Parameters: 1(Integer)
DEBUG [main] - <==      Total: 3
clazz1 = Clazz [id=1, name=javaEE20170228, stus=[Student [id=1, name=stu0228_张三, clazz=null], Student [id=2, name=stu0228_李四, clazz=null], Student [id=3, name=stu0228_王五, clazz=null]]]
DEBUG [main] - Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@6895a785]
DEBUG [main] - Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@6895a785]
DEBUG [main] - Returned connection 1754638213 to pool.
DEBUG [main] - Opening JDBC Connection
DEBUG [main] - Checked out connection 1754638213 from pool.
DEBUG [main] - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@6895a785]
DEBUG [main] - ==>  Preparing: select c.*,s.id stu_id,s.name stu_name from t_clazz c left join t_student s on c.id = s.clazz_id where c.id = ? 
DEBUG [main] - ==> Parameters: 1(Integer)
DEBUG [main] - <==      Total: 3
clazz2 = Clazz [id=1, name=javaEE20170228, stus=[Student [id=1, name=stu0228_张三, clazz=null], Student [id=2, name=stu0228_李四, clazz=null], Student [id=3, name=stu0228_王五, clazz=null]]]
DEBUG [main] - Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@6895a785]
DEBUG [main] - Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@6895a785]
DEBUG [main] - Returned connection 1754638213 to pool. 
分别调用两次sql,没用使用缓存

2    执行语句的参数不同。缓存中也不存在数据

<wiz_code_mirror>
 
 
1 
@Test
2 
    public void testfirstCacheFail2() {
3 
        //一级缓存必须存在于同一个SqlSession中
4 
        SqlSession session = sqlSessionFactory.openSession();
5 
        ClazzMapper clazzMapper2 = session.getMapper(ClazzMapper.class);
6 
        Clazz user1 = clazzMapper2.queryClazzById(1);
7 
        System.out.println(user1);
8 
        
9 
        Clazz user2 = clazzMapper2.queryClazzById(2);
10 
        System.out.println( user2 );
11 
        session.close();
12 
    }
 
 
看结果：
DEBUG [main] - ==>  Preparing: select c.*,s.id stu_id,s.name stu_name from t_clazz c left join t_student s on c.id = s.clazz_id where c.id = ? 
DEBUG [main] - ==> Parameters: 1(Integer)
DEBUG [main] - <==      Total: 3
Clazz [id=1, name=javaEE20170228, stus=[Student [id=1, name=stu0228_张三, clazz=null], Student [id=2, name=stu0228_李四, clazz=null], Student [id=3, name=stu0228_王五, clazz=null]]]
DEBUG [main] - ==>  Preparing: select c.*,s.id stu_id,s.name stu_name from t_clazz c left join t_student s on c.id = s.clazz_id where c.id = ? 
DEBUG [main] - ==> Parameters: 2(Integer)
DEBUG [main] - <==      Total: 2
Clazz [id=2, name=javaEE20170325, stus=[Student [id=4, name=stu0325_马云, clazz=null], Student [id=5, name=stu0325_任正非, clazz=null]]]
分别调用两次sql,没有使用到缓存

3、执行增，删，改，语句，会清空掉缓存

   
<wiz_code_mirror>
 
 
1 
 @Test
2 
    public void testfirstCacheFail3() {
3 
        //一级缓存必须存在于同一个SqlSession中
4 
        SqlSession session = sqlSessionFactory.openSession();
5 
        ClazzMapper clazzMapper2 = session.getMapper(ClazzMapper.class);
6 
        Clazz user1 = clazzMapper2.queryClazzById(2);
7 
        System.out.println(user1);
8 
        
9 
        Clazz clazz = new Clazz();
10 
        clazz.setId(2);
11 
        clazz.setName("電影放映班");
12 
        clazzMapper2.updateClazz(clazz);
13 
        session.commit();
14 
        
15 
        System.out.println(clazzMapper2.queryClazzById(2));
16 
        session.close();
17 
    }
 
 
DEBUG [main] - ==>  Preparing: select c.*,s.id stu_id,s.name stu_name from t_clazz c left join t_student s on c.id = s.clazz_id where c.id = ? 
DEBUG [main] - ==> Parameters: 2(Integer)
DEBUG [main] - <==      Total: 2
Clazz [id=2, name=javaEE20170325, stus=[Student [id=4, name=stu0325_马云, clazz=null], Student [id=5, name=stu0325_任正非, clazz=null]]]
DEBUG [main] - ==>  Preparing: update t_clazz set name = ? where id = ? 
DEBUG [main] - ==> Parameters: 電影放映班(String), 2(Integer)
DEBUG [main] - <==    Updates: 1
DEBUG [main] - Committing JDBC Connection [com.mysql.jdbc.JDBC4Connection@6895a785]
DEBUG [main] - ==>  Preparing: select c.*,s.id stu_id,s.name stu_name from t_clazz c left join t_student s on c.id = s.clazz_id where c.id = ? 
DEBUG [main] - ==> Parameters: 2(Integer)
DEBUG [main] - <==      Total: 2
Clazz [id=2, name=電影放映班, stus=[Student [id=4, name=stu0325_马云, clazz=null], Student [id=5, name=stu0325_任正非, clazz=null]]]
查询执行两次，更新执行一次，也没使用到缓存
4 、手动清空缓存数据
<wiz_code_mirror>
 
 
1 
@Test
2 
    public  void testfirstCacheFail4() {
3 
        SqlSession session = sqlSessionFactory.openSession();
4 
        try {
5 
            ClazzMapper clazzMapper = session.getMapper(ClazzMapper.class);
6 
            Clazz clazz1 = clazzMapper.queryClazzById(1);
7 
            System.out.println("clazz1 = "+clazz1);
8 
            //清空緩存
9 
            session.clearCache();
10 
            Clazz clazz2 = clazzMapper.queryClazzById(1);
11 
            System.out.println("clazz2 = "+clazz2);
12 
        } finally {
13 
            session.close();
14 
        }
15 
    }
 
 
 
看下结果：
DEBUG [main] - ==>  Preparing: select c.*,s.id stu_id,s.name stu_name from t_clazz c left join t_student s on c.id = s.clazz_id where c.id = ? 
DEBUG [main] - ==> Parameters: 1(Integer)
DEBUG [main] - <==      Total: 3
clazz1 = Clazz [id=1, name=javaEE20170228, stus=[Student [id=1, name=stu0228_张三, clazz=null], Student [id=2, name=stu0228_李四, clazz=null], Student [id=3, name=stu0228_王五, clazz=null]]]
DEBUG [main] - ==>  Preparing: select c.*,s.id stu_id,s.name stu_name from t_clazz c left join t_student s on c.id = s.clazz_id where c.id = ? 
DEBUG [main] - ==> Parameters: 1(Integer)
DEBUG [main] - <==      Total: 3
clazz2 = Clazz [id=1, name=javaEE20170228, stus=[Student [id=1, name=stu0228_张三, clazz=null], Student [id=2, name=stu0228_李四, clazz=null], Student [id=3, name=stu0228_王五, clazz=null]]]
执行了两次sql,没有使用到缓存
文章标签：
云数据库 RDS MySQL 版
缓存
Java
数据库连接
SQL
mybatis
关键词：
MyBatis缓存
缓存mybatis
相关实践学习
如何在云端创建MySQL数据库
开始实验后，系统会自动创建一台自建MySQL的 源数据库 ECS 实例和一台 目标数据库 RDS。
全面了解阿里云能为你做什么
阿里云在全球各地部署高效节能的绿色数据中心，利用清洁计算为万物互联的新世界提供源源不断的能源动力，目前开服的区域包括中国（华北、华东、华南、香港）、新加坡、美国（美东、美西）、欧洲、中东、澳大利亚、日本。目前阿里云的产品涵盖弹性计算、数据库、存储与CDN、分析与搜索、云通信、网络、管理与监控、应用服务、互联网中间件、移动服务、视频服务等。通过本课程，来了解阿里云能够为你的业务带来哪些帮助 &nbsp; &nbsp; 相关的阿里云产品：云服务器ECS 云服务器 ECS（Elastic Compute Service）是一种弹性可伸缩的计算服务，助您降低 IT 成本，提升运维效率，使您更专注于核心业务创新。产品详情: https://www.aliyun.com/product/ecs
西北野狼
目录
相关文章
杀死一只知更鸟debug
|
3月前
|
缓存 Java 数据库连接
mybatis复习05,mybatis的缓存机制（一级缓存和二级缓存及第三方缓存）
文章介绍了MyBatis的缓存机制，包括一级缓存和二级缓存的配置和使用，以及如何整合第三方缓存EHCache。详细解释了一级缓存的生命周期、二级缓存的开启条件和配置属性，以及如何通过ehcache.xml配置文件和logback.xml日志配置文件来实现EHCache的整合。
杀死一只知更鸟debug
48 1
mybatis复习05,mybatis的缓存机制（一级缓存和二级缓存及第三方缓存）
WangBai
|
16天前
|
缓存 Java 数据库连接
MyBatis缓存机制
MyBatis提供两级缓存机制：一级缓存（Local Cache）默认开启，作用范围为SqlSession，重复查询时直接从缓存读取；二级缓存（Second Level Cache）需手动开启，作用于Mapper级别，支持跨SqlSession共享数据，减少数据库访问，提升性能。
WangBai
27 1
蓝易云
|
20天前
|
缓存 Java 数据库连接
深入探讨：Spring与MyBatis中的连接池与缓存机制
Spring 与 MyBatis 提供了强大的连接池和缓存机制，通过合理配置和使用这些机制，可以显著提升应用的性能和可扩展性。连接池通过复用数据库连接减少了连接创建和销毁的开销，而 MyBatis 的一级缓存和二级缓存则通过缓存查询结果减少了数据库访问次数。在实际应用中，结合具体的业务需求和系统架构，优化连接池和缓存的配置，是提升系统性能的重要手段。
蓝易云
35 4
蓝染-惣右介
|
1月前
|
SQL 缓存 Java
【详细实用のMyBatis教程】获取参数值和结果的各种情况、自定义映射、动态SQL、多级缓存、逆向工程、分页插件
本文详细介绍了MyBatis的各种常见用法MyBatis多级缓存、逆向工程、分页插件 包括获取参数值和结果的各种情况、自定义映射resultMap、动态SQL
蓝染-惣右介
122 1
【详细实用のMyBatis教程】获取参数值和结果的各种情况、自定义映射、动态SQL、多级缓存、逆向工程、分页插件
刘大猫.
|
1月前
|
SQL 缓存 Java
MyBatis如何关闭一级缓存(分注解和xml两种方式)
MyBatis如何关闭一级缓存(分注解和xml两种方式)
刘大猫.
69 5
智商低情商凑
|
6月前
|
SQL 缓存 Java
MYBATIS缓存
MYBATIS缓存
智商低情商凑
47 1
2G冲浪词条
|
2月前
|
缓存 Java 数据库连接
使用MyBatis缓存的简单案例
MyBatis 是一种流行的持久层框架，支持自定义 SQL 执行、映射及复杂查询。本文介绍了如何在 Spring Boot 项目中集成 MyBatis 并实现一级和二级缓存，以提高查询性能，减少数据库访问。通过具体的电商系统案例，详细讲解了项目搭建、缓存配置、实体类创建、Mapper 编写、Service 层实现及缓存测试等步骤。
2G冲浪词条
30 2
JavaSouth南哥
|
5月前
|
SQL 缓存 Java
【面试官】Mybatis缓存有什么问题吗？
面试官：你说下对MyBatis的理解？面试官：那SqlSession知道吧？面试官：Mybatis的缓存有哪几种？面试官：那Mybatis缓存有什么问题吗？面试官：Mybatis分页插件是怎么
JavaSouth南哥
72 5
【面试官】Mybatis缓存有什么问题吗？
威哥爱编程
|
5月前
|
缓存 算法 Java
关于MyBatis的缓存详解
MyBatis 的缓存机制非常灵活，可以通过简单的配置来满足不同的性能需求。合理地使用缓存可以显著提高应用程序的性能，尤其是在处理大量数据库查询时。然而，开发者需要注意缓存的一致性和并发问题，特别是在使用可读写缓存时。
威哥爱编程
75 3
众所周知
|
6月前
|
缓存 NoSQL Java
在 SSM 架构（Spring + SpringMVC + MyBatis）中，可以通过 Spring 的注解式缓存来实现 Redis 缓存功能
【6月更文挑战第18天】在SSM（Spring+SpringMVC+MyBatis）中集成Redis缓存，涉及以下步骤：添加Spring Boot的`spring-boot-starter-data-redis`依赖；配置Redis连接池（如JedisPoolConfig）和连接工厂；在Service层使用`@Cacheable`注解标记缓存方法，指定缓存名和键生成策略；最后，在主配置类启用缓存注解。通过这些步骤，可以利用Spring的注解实现Redis缓存。
众所周知
83 2

热门文章

最新文章

  • 1
    SpringMvc+Spring+MyBatis 基于注解整合
  • 2
    还在使用MyBatis Generator？试试这个工具
  • 3
    05_MyBatis基于注解的开发
  • 4
    全栈开发实战｜​人事管理系统的设计与实现（Spring Boot + Vue 3 + MyBatis）
  • 5
    MyBatis Plus 解决大数据量查询慢问题
  • 6
    MyBatis快速入门（四） MyBatis和Spring集成
  • 7
    【MyBatis框架点滴】——mybatis插入数据返回主键（mysql、oracle）
  • 8
    mybatis insert 返回主键
  • 9
    Spring Boot + Mybatis Plus + ClickHouse 轻松实现增删改查，看了必懂。。
  • 10
    Mybatis源码分析系列之第二篇：Mybatis的数据存储对象
  • 1
    中间件Write-Through Cache（直写缓存）策略
    111
  • 2
    中间件Read-Through Cache（直读缓存）策略
    69
  • 3
    中间件Cache-Aside（旁路缓存）策略中间件Cache-Aside（旁路缓存）策略
    199
  • 4
    【后端面经】【缓存】33｜缓存模式：缓存模式能不能解决缓存一致性问题？-03 Refresh Ahead + SingleFlight + 删除缓存 + 延迟双删
    137
  • 5
    【后端面经】【缓存】33｜缓存模式：缓存模式能不能解决缓存一致性问题？-02 Write Through + Write Back
    96
  • 6
    Redis经典问题：缓存击穿
    645
  • 7
    中间件缓存一致性
    59
  • 8
    中间件缓存失效策略
    45
  • 9
    中间件缓存策略类型
    54
  • 10
    缓存处理的主要步骤
    55

    • 相关课程

    更多
  • MyBatis持久层框架入门

    • 相关电子书

    更多
  • 基于英特尔 SSD 的虚拟机缓存解决SSD
  • Java Spring Boot开发实战系列课程【第6讲】：Spring Boot 2.0实战MyBatis与优化(Java面试题)
  • 高性能Web架构之缓存体系
    • 下一篇
    DataWorks