Mybatis系列（六）缓存机制

最新推荐文章于 2024-01-09 13:31:52 发布
最新推荐文章于 2024-01-09 13:31:52 发布
阅读量179 收藏
点赞数
分类专栏： mybatis 文章标签： mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40469302/article/details/115352101
版权

Mybatis系列（六）缓存机制

文章目录

一、Mybatis缓存机制

思想:从数据中读取数据时,先去缓存中拿,如果缓存中有,直接从缓存中拿，如果没有,就去查数据库,然后同步到缓存中一份,下次查询的时候直接从缓存中拿就可以了。

  1. 一级缓存:线程级别的缓存;本地缓存；SqlSession(与数据库的一次会话)级别的缓存
  2. 二级缓存:全局范围的缓存,除过当前线程,Sqlsession能用外,其它的线程都可以使用

二、一级缓存

一级缓存,mybatis默认是开启的

一级缓存初体验:

Test.java：

	@Test
    public void testMybatisSelect03(){
        //获取与数据库的一次会话
        SqlSession sqlSession = sqlSessionFactory.openSession();
        KeyDao keyDao = sqlSession.getMapper(KeyDao.class);
        Key key = keyDao.getKeyById(1);
        System.out.println(key);
        System.out.println("----------------------------------------->");
        Key key2 = keyDao.getKeyById(1);
        System.out.println(key2);
        sqlSession.close();
    }

输出结果:

DEBUG 02-18 12:46:55,002 ==>  Preparing: SELECT * FROM t_key k, t_lock l WHERE k.l_id = l.lid AND k.kid = ?   (BaseJdbcLogger.java:145) 
DEBUG 02-18 12:46:55,055 ==> Parameters: 1(Integer)  (BaseJdbcLogger.java:145) 
DEBUG 02-18 12:46:55,086 <==      Total: 1  (BaseJdbcLogger.java:145) 
Key(id=1, keyName=钥匙1, lock=Lock(id=1, lockName=锁1, keyList=null))
----------------------------------------->
Key(id=1, keyName=钥匙1, lock=Lock(id=1, lockName=锁1, keyList=null))

缓存失效的几种情况:

  1. 不同的SqlSession

Test.java：

	@Test
    public void testMybatisSelect03(){
        //获取与数据库的一次会话
        SqlSession sqlSession = sqlSessionFactory.openSession();
        KeyDao keyDao = sqlSession.getMapper(KeyDao.class);
        Key key = keyDao.getKeyById(1);
        System.out.println(key);
        System.out.println("----------------------------------------->");
        //打开新的SqlSession
        SqlSession sqlSession2 = sqlSessionFactory.openSession();
        KeyDao keyDao2 = sqlSession2.getMapper(KeyDao.class);
        Key key2 = keyDao2.getKeyById(1);
        System.out.println(key2);
        sqlSession.close();
        sqlSession2.close();
    }

测试结果:

DEBUG 02-18 12:58:56,376 ==>  Preparing: SELECT * FROM t_key k, t_lock l WHERE k.l_id = l.lid AND k.kid = ?   (BaseJdbcLogger.java:145) 
DEBUG 02-18 12:58:56,425 ==> Parameters: 1(Integer)  (BaseJdbcLogger.java:145) 
DEBUG 02-18 12:58:56,458 <==      Total: 1  (BaseJdbcLogger.java:145) 
Key(id=1, keyName=钥匙1, lock=Lock(id=1, lockName=锁1, keyList=null))
----------------------------------------->
DEBUG 02-18 12:58:56,467 ==>  Preparing: SELECT * FROM t_key k, t_lock l WHERE k.l_id = l.lid AND k.kid = ?   (BaseJdbcLogger.java:145) 
DEBUG 02-18 12:58:56,468 ==> Parameters: 1(Integer)  (BaseJdbcLogger.java:145) 
DEBUG 02-18 12:58:56,470 <==      Total: 1  (BaseJdbcLogger.java:145) 
Key(id=1, keyName=钥匙1, lock=Lock(id=1, lockName=锁1, keyList=null))
  1. 同一个SqlSession，不同的参数

Test.java：

@Test
    public void testMybatisSelect03(){
        //获取与数据库的一次会话
        SqlSession sqlSession = sqlSessionFactory.openSession();
        KeyDao keyDao = sqlSession.getMapper(KeyDao.class);
        Key key = keyDao.getKeyById(1);
        System.out.println(key);
        System.out.println("----------------------------------------->");
        //预编译Sql相同,但是参数不同
        Key key2 = keyDao.getKeyById(2);
        System.out.println(key2);
        sqlSession.close();
    }

测试结果:

DEBUG 02-18 13:02:00,224 ==>  Preparing: SELECT * FROM t_key k, t_lock l WHERE k.l_id = l.lid AND k.kid = ?   (BaseJdbcLogger.java:145) 
DEBUG 02-18 13:02:00,304 ==> Parameters: 1(Integer)  (BaseJdbcLogger.java:145) 
DEBUG 02-18 13:02:00,340 <==      Total: 1  (BaseJdbcLogger.java:145) 
Key(id=1, keyName=钥匙1, lock=Lock(id=1, lockName=锁1, keyList=null))
----------------------------------------->
DEBUG 02-18 13:02:00,343 ==>  Preparing: SELECT * FROM t_key k, t_lock l WHERE k.l_id = l.lid AND k.kid = ?   (BaseJdbcLogger.java:145) 
DEBUG 02-18 13:02:00,344 ==> Parameters: 2(Integer)  (BaseJdbcLogger.java:145) 
DEBUG 02-18 13:02:00,346 <==      Total: 1  (BaseJdbcLogger.java:145) 
Key(id=2, keyName=钥匙2, lock=Lock(id=2, lockName=锁2, keyList=null))
  1. 在同一个SqlSession期间执行了一次增删改操作

由于增删改操作会改变表中的数据,可能造成缓存中已存在的缓存数据与数据库中的数据不一致,因此mybatis默认执行增删改操作时清空了一下缓存，下次需要的时候再去数据库中查询

Test.java：

	@Test
    public void testMybatisSelect03(){
        //获取与数据库的一次会话
        SqlSession sqlSession = sqlSessionFactory.openSession();
        KeyDao keyDao = sqlSession.getMapper(KeyDao.class);
        Key key = keyDao.getKeyById(1);
        System.out.println(key);

        //执行一次增删改的任意一次操作
        System.out.println("-------开始执行修改操作-------------------->");
        Key k = new Key();
        k.setId(1);
        k.setKeyName("钥匙n");
        keyDao.updateKeyById(k);
        System.out.println("----------------------------------------->");

        Key key2 = keyDao.getKeyById(1);
        System.out.println(key2);
        sqlSession.commit();
        sqlSession.close();
    }

测试结果

DEBUG 02-18 13:10:15,525 ==>  Preparing: SELECT * FROM t_key k, t_lock l WHERE k.l_id = l.lid AND k.kid = ?   (BaseJdbcLogger.java:145) 
DEBUG 02-18 13:10:15,599 ==> Parameters: 1(Integer)  (BaseJdbcLogger.java:145) 
DEBUG 02-18 13:10:15,628 <==      Total: 1  (BaseJdbcLogger.java:145) 
Key(id=1, keyName=钥匙1, lock=Lock(id=1, lockName=锁1, keyList=null))
-------开始执行修改操作-------------------->
DEBUG 02-18 13:10:15,630 ==>  Preparing: update t_key set kname = ? where kid = ?   (BaseJdbcLogger.java:145) 
DEBUG 02-18 13:10:15,636 ==> Parameters: 钥匙n(String), 1(Integer)  (BaseJdbcLogger.java:145) 
DEBUG 02-18 13:10:15,640 <==    Updates: 1  (BaseJdbcLogger.java:145) 
----------------------------------------->
DEBUG 02-18 13:10:15,641 ==>  Preparing: SELECT * FROM t_key k, t_lock l WHERE k.l_id = l.lid AND k.kid = ?   (BaseJdbcLogger.java:145) 
DEBUG 02-18 13:10:15,644 ==> Parameters: 1(Integer)  (BaseJdbcLogger.java:145) 
DEBUG 02-18 13:10:15,646 <==      Total: 1  (BaseJdbcLogger.java:145) 
Key(id=1, keyName=钥匙n, lock=Lock(id=1, lockName=锁1, keyList=null))
  1. 手动清空了缓存

Test.java:

@Test
    public void testMybatisSelect03(){
        //获取与数据库的一次会话
        SqlSession sqlSession = sqlSessionFactory.openSession();
        KeyDao keyDao = sqlSession.getMapper(KeyDao.class);
        Key key = keyDao.getKeyById(1);
        System.out.println(key);

        //手动清空缓存
        sqlSession.clearCache();
        System.out.println("----------------------------------------->");

        Key key2 = keyDao.getKeyById(1);
        System.out.println(key2);
        sqlSession.commit();
        sqlSession.close();
    }

测试结果:

DEBUG 02-18 13:14:02,715 ==>  Preparing: SELECT * FROM t_key k, t_lock l WHERE k.l_id = l.lid AND k.kid = ?   (BaseJdbcLogger.java:145) 
DEBUG 02-18 13:14:02,790 ==> Parameters: 1(Integer)  (BaseJdbcLogger.java:145) 
DEBUG 02-18 13:14:02,814 <==      Total: 1  (BaseJdbcLogger.java:145) 
Key(id=1, keyName=钥匙n, lock=Lock(id=1, lockName=锁1, keyList=null))
----------------------------------------->
DEBUG 02-18 13:14:02,816 ==>  Preparing: SELECT * FROM t_key k, t_lock l WHERE k.l_id = l.lid AND k.kid = ?   (BaseJdbcLogger.java:145) 
DEBUG 02-18 13:14:02,817 ==> Parameters: 1(Integer)  (BaseJdbcLogger.java:145) 
DEBUG 02-18 13:14:02,821 <==      Total: 1  (BaseJdbcLogger.java:145) 
Key(id=1, keyName=钥匙n, lock=Lock(id=1, lockName=锁1, keyList=null))

三、二级缓存

二级缓存(second level cache)，全局作用域缓存
二级缓存默认不开启，需要手动配置
MyBatis提供二级缓存的接口以及实现，缓存实现要求POJO实现Serializable接口
二级缓存在 SqlSession 关闭或提交之后才会生效

使用步骤
1、全局配置文件中开启二级缓存

2、需要使用二级缓存的映射文件处使用cache配置缓存

3、注意：POJO需要实现Serializable接口

二级缓存初体验

mybatis-config.xml:

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

KeyDao.xml

<mapper namespace="com.cetc.dao.KeyDao">
    <!--开启二级缓存-->
    <cache></cache>
    ........
</mapper>

Test.java:

@Test
    public void testMybatisSelect04(){
        //获取与数据库的一次会话
        SqlSession sqlSession = sqlSessionFactory.openSession();
        KeyDao keyDao = sqlSession.getMapper(KeyDao.class);
        Key key = keyDao.getKeyById(1);
        System.out.println(key);
        sqlSession.close();

        System.out.println("----------------------------------------->");

        SqlSession sqlSession2 = sqlSessionFactory.openSession();
        KeyDao keyDao2 = sqlSession2.getMapper(KeyDao.class);
        Key key2 = keyDao2.getKeyById(1);
        sqlSession2.close();
        System.out.println(key2);
    }

测试结果:

DEBUG 02-18 15:46:19,961 Cache Hit Ratio [com.cetc.dao.KeyDao]: 0.0  (LoggingCache.java:62)  //缓存命中率
DEBUG 02-18 15:46:20,361 ==>  Preparing: SELECT * FROM t_key k, t_lock l WHERE k.l_id = l.lid AND k.kid = ?   (BaseJdbcLogger.java:145) 
DEBUG 02-18 15:46:20,432 ==> Parameters: 1(Integer)  (BaseJdbcLogger.java:145) 
DEBUG 02-18 15:46:20,460 <==      Total: 1  (BaseJdbcLogger.java:145) 
Key(id=1, keyName=钥匙n, lock=Lock(id=1, lockName=锁1, keyList=null))
----------------------------------------->
DEBUG 02-18 15:46:20,594 Cache Hit Ratio [com.cetc.dao.KeyDao]: 0.5  (LoggingCache.java:62) 
Key(id=1, keyName=钥匙n, lock=Lock(id=1, lockName=锁1, keyList=null))

四、缓存的查询顺序

一级缓存与二级缓存不会存在同样的数据

  1. 如果二级缓存中存在,直接从二级缓存中查
  2. 如果二级缓存中没有,去一级缓存中查
  3. 如果一、二级缓存中都没有,就去数据库中查询

Test.java:

@Test
    public void testMybatisSelect05(){
        //获取与数据库的一次会话
        SqlSession sqlSession = sqlSessionFactory.openSession();
        KeyDao keyDao = sqlSession.getMapper(KeyDao.class);
        Key key = keyDao.getKeyById(1);
        System.out.println(key);
        sqlSession.close();

        System.out.println("----------------------------------------->");

        SqlSession sqlSession2 = sqlSessionFactory.openSession();
        KeyDao keyDao2 = sqlSession2.getMapper(KeyDao.class);
        Key key2 = keyDao2.getKeyById(1);
        sqlSession2.close();
        System.out.println(key2);
    }

    @Test
    public void testMybatisSelect04(){
        //获取与数据库的一次会话
        SqlSession sqlSession = sqlSessionFactory.openSession();
        KeyDao keyDao = sqlSession.getMapper(KeyDao.class);
        Key key = keyDao.getKeyById(1);
        System.out.println(key);
        //一级缓存关闭,将数据放到二级缓存
        sqlSession.close();

        System.out.println("----------------------------------------->");

        SqlSession sqlSession2 = sqlSessionFactory.openSession();
        KeyDao keyDao2 = sqlSession2.getMapper(KeyDao.class);
        //从二级缓存中获取数据
        Key key2 = keyDao2.getKeyById(1);
        System.out.println(key2);

        //sqlSession2此时还未关闭,显示的查询结果还是直接从二级缓存中直接查询的,
        //说明以及二级缓存如果存在,会从二级缓存中直接查询到,不会再放到以及缓存中去
        Key key3= keyDao2.getKeyById(1);
        System.out.println(key3);


        System.out.println("---------------------->以下是查询id=2的钥匙");

        sqlSession2.close();

        /**
         * 一级缓存和二级缓存此时都还没有ID=2的钥匙信息，
         * 1.首先当前会话没有关闭,会在一级缓存中存放ID=2的数据
         * 2.其次二级缓存中没有ID=2的数据
         * 3.首先查询二级缓存,二级缓存中没有,则去查询一级缓存,一级缓存如果没有,则查询数据库
         */
        //此次是第四次从二级缓存中查询,之前已经命中了2次
        SqlSession sqlSession3 = sqlSessionFactory.openSession();
        KeyDao keyDao3 = sqlSession3.getMapper(KeyDao.class);
        Key key4 = keyDao3.getKeyById(3);
        System.out.println(key4);

        //此次是第5次查询,之前命中了2次,此次二级缓存中没有,查询的是一级缓存
        Key key5 = keyDao3.getKeyById(3);
        System.out.println(key5);
        sqlSession3.close();

    }

测试结果:

DEBUG 02-18 16:30:48,748 Cache Hit Ratio [com.cetc.dao.KeyDao]: 0.0  (LoggingCache.java:62) 
DEBUG 02-18 16:30:49,171 ==>  Preparing: SELECT * FROM t_key k, t_lock l WHERE k.l_id = l.lid AND k.kid = ?   (BaseJdbcLogger.java:145) 
DEBUG 02-18 16:30:49,247 ==> Parameters: 1(Integer)  (BaseJdbcLogger.java:145) 
DEBUG 02-18 16:30:49,270 <==      Total: 1  (BaseJdbcLogger.java:145) 
Key(id=1, keyName=钥匙n, lock=null)
----------------------------------------->
DEBUG 02-18 16:30:49,363 Cache Hit Ratio [com.cetc.dao.KeyDao]: 0.5  (LoggingCache.java:62) 
Key(id=1, keyName=钥匙n, lock=null)
DEBUG 02-18 16:30:49,364 Cache Hit Ratio [com.cetc.dao.KeyDao]: 0.6666666666666666  (LoggingCache.java:62) 
Key(id=1, keyName=钥匙n, lock=null)
---------------------->以下是查询id=2的钥匙
DEBUG 02-18 16:30:49,365 Cache Hit Ratio [com.cetc.dao.KeyDao]: 0.5  (LoggingCache.java:62) 
DEBUG 02-18 16:30:49,366 ==>  Preparing: SELECT * FROM t_key k, t_lock l WHERE k.l_id = l.lid AND k.kid = ?   (BaseJdbcLogger.java:145) 
DEBUG 02-18 16:30:49,367 ==> Parameters: 3(Integer)  (BaseJdbcLogger.java:145) 
DEBUG 02-18 16:30:49,369 <==      Total: 1  (BaseJdbcLogger.java:145) 
Key(id=3, keyName=钥匙3, lock=null)
DEBUG 02-18 16:30:49,369 Cache Hit Ratio [com.cetc.dao.KeyDao]: 0.4  (LoggingCache.java:62) 
Key(id=3, keyName=钥匙3, lock=null)

五、缓存原理以及配置

缓存原理图:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sDdfH7PZ-1617176397720)(C:\Users\86173\Desktop\自我总结\images\mybatis\8.png)]

缓存有关设置:

  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。

六、整合ehcache

EhCache是一个纯Java的进程内缓存框架，具有快速、精干等特点，是Hibernate中默认的CacheProvider。

MyBatis定义了Cache接口方便我们进行自定义扩展。

使用步骤:

  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:\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（先进先出）
 -->
  1. 配置cache标签

KeyDao.xml:

<!--开启EhcacheCache二级缓存-->
    <cache type="org.mybatis.caches.ehcache.EhcacheCache"></cache>

补充:

若想在命名空间中共享相同的缓存配置和实例。可以使用 cache-ref 元素来引用另外一个缓存。

LockDao.xml:

<!--与KeyDao共用一个二级缓存-->
    <cache-ref namespace="com.cetc.dao.KeyDao"/>
《雨过天晴》
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot 配置mybatis的二级缓存机制，使用redis配置二级缓存demo代码
闲走天涯的博客
08-25 620
springboot 配置mybatis的二级缓存机制 一级缓存 是sqlSession级别的缓存，面向单个访问用户 二级缓存 是namespace级别的缓存，同一个namespace内查询会缓存，一旦发生增删改操作则会清空该namespace缓存，二级缓存面向所有访问用户；二级缓存默认使用hashMap缓存，支持自定义缓存：mybatis支持encache和redis mybatis 开启二级缓存的两种方式 首先配置 开启MyBatis的全局二级缓存 .properties文件或.yml 文件 增加配置
mybatis配置自带缓存和第三方缓存
grhlove123的专栏
08-20 2万+
参考：https://mybatis.github.io/mybatis-3/zh/sqlmap-xml.html， http://www.yihaomen.com/article/java/428.htm 许多应用程序，为了提高性能而增加缓存, 特别是从数据库中获取的数据. 在默认情况下，mybatis 的一级缓存是默认开启的。类似于hibernate, 所谓一级缓存，也就是基于
mybatis缓存的使用
wangin1013的专栏
12-18 114
mybatis的缓存是在mapper文件中配置的 <cache type="com.***.mybatis.cache.MyCache"/> 框架默认提供了几种缓存类型： LRU：最近最少使用 FIFO：先进先出 SOFT：软引用 WEAK：弱引用 以上方式，基本上都是使用JAVA的Deque，HashMap，SoftReference，WeakReference存储，因...
cache二级缓存增加性能
最新发布
易雁的博客
01-09 491
【代码】缓存增加性能。
【MyBatis系列8】给我五分钟，带你彻底掌握MyBatis的缓存工作原理
zwx900102的博客
09-28 9161
MyBatis中一级缓存和二级缓存分析前言总结 前言 MyBatis中一级缓存和二级缓存分析 总结 MyBatis中一级缓存和二级缓存分析 请关注我，和孤狼一起学习进步。
Mybatis系列教程Mybatis缓存共17页.pdf
11-19
本教程“Mybatis系列教程Mybatis缓存共17页”旨在深入解析Mybatis的缓存功能。 在Mybatis中，缓存分为一级缓存和二级缓存。一级缓存是SqlSession级别的，同一个SqlSession内的多次相同查询会复用第一次查询的结果，...
mybatis二级缓存的实现代码
08-29
MyBatis提供了三级缓存机制，一级缓存是Session级别的缓存，二级缓存是namespace级别的缓存，三级缓存是Application级别的缓存。今天，我们将详细介绍MyBatis二级缓存的实现代码。 MyBatis二级缓存的实现代码主要是...
MyBatis系列操作资源
04-11
这个压缩包文件"MyBatis系列操作资源"显然包含了与MyBatis相关的各种教程、示例代码或者项目实践，特别是涉及到一对一查询的实践。 首先，我们要理解MyBatis的核心概念。MyBatis抛弃了传统的基于JDBC的繁琐数据操作...
Mybatis系列教程Mybatis源码剖析共15页.pd
11-19
8. **缓存机制**：Mybatis内置了第一级和第二级缓存，可以提高数据访问效率。开发者可以根据需求自定义缓存策略。 9. **事务管理**：Mybatis支持手动和自动事务管理，通过SqlSession的beginTransaction、commit和...
Mybatis系列教程Mybatis注解开发共9页.pdf
11-19
Mybatis的标签可能还包括Mapper接口、动态SQL、事务管理、结果映射、缓存机制等核心概念。 在Mybatis的注解开发中，主要涉及以下知识点： 1. **@Mapper**: 这个注解用于标记Mapper接口，表明这个接口是Mybatis的...
Mybatis二级缓存原理
曹金桂
10-27 624
记录是一种精神，是加深理解最好的方式之一。 最近看了下Mybatis的源码，分析了二级缓存的实现方式，在这里把他记下来。虽然这不复杂，对这方面的博客也有很多，写的也很好。但我坚信看懂了是其一，能够教别人或者描述清楚记下来才能真正的掌握。 曹金桂 cao_jingui@163.com (如有欠缺还请指教) 时间：2016年10月11日16:00 这篇文章能够帮你 学会对Myba
深入了解MyBatis二级缓存
热门推荐
偶尔记一下 - mybatis.io
03-30 8万+
MyBatis深入了解二级缓存
MyBatis缓存策略之二级缓存
零度的博客专栏
09-15 2万+
1. 二级缓存的原理 　　前面介绍了，mybatis中的二级缓存是mapper级别的缓存，值得注意的是，不同的mapper通常情况下有不同的namespace，就都有一个二级缓存，也就是说，不同的mapper之间的二级缓存是互不影响的。为了更加清楚的描述二级缓存，先来看一个示意图：    　　从图中可以看出： sqlSession1去查询用户id为1的用户信息，查询到用户信息会
Mybatis入门系列之（十二）——一对多查询
guo20082200的博客
04-30 418
一对多查询 第一种解决方案 这里假定一个用户对应多个角色，在SysUser.java中添加如下字段： /** * 一个用户对应多个角色 */ private List&lt;SysRole&gt; roleList; public List&lt;SysRole&gt; getRoleList() { return roleList; } public void setR...
记一个坑 mybatis 二级缓存失效(X)
Edwel的博客
01-13 1793
用easypoi 导出的时候,mybatis二级缓存失效(内容缺失?), 原因暂时未知
delphi7 记录集locate如何提交到缓存_Spring Boot（七）：你不能不知道的Mybatis缓存机制
weixin_39941262的博客
11-26 221
缓存的重要性是不言而喻的。使用缓存， 我们可以避免频繁的与数据库进行交互， 尤其是在查询越多、缓存命中率越高的情况下， 使用缓存对性能的提高更明显。同样地，mybatis作为ORM框架，也必然会支持缓存它分别支持一级缓存和二级缓存。其中一级缓存是sqlSession级的缓存，而二级缓存则可以实现多个sqlSession间的缓存什么意思？往下看喽~一 一级缓存01. 什么是一级缓存之所以说mybat...
MyBatis - 日志 - 一二级缓存
weixin_44130043的博客
10-13 355
日志： a，Log4j（需要log4j.jar）： b，开启日志；conf.xml <settings> <!--开启日志，并指定使用的具体日志--> <setting name="logImpl" value="LOG4J"/> </settings> 如果不指定，Mybatis就会根据以下顺序 寻找日志 SLF4J - Apache Co...
mybatis关系映射和缓存机制
09-09
MyBatis关联映射是指通过MyBatis框架实现对象之间的关系映射，包括一对一、一对多、多对一和多对多等关系。关联映射可以通过配置文件和注解的方式来实现。 MyBatis缓存机制是指MyBatis框架自带的缓存功能，可以提高数据库查询的性能。MyBatis缓存可以分为一级缓存和二级缓存。一级缓存是指在同一个SqlSession中，对于相同的查询语句，MyBatis会将查询结果缓存起来，下次再执行相同的查询时，直接从缓存中获取结果，而不需要再次访问数据库。二级缓存是指在多个SqlSession中，对于相同的查询语句，MyBatis会将查询结果缓存起来，当其他SqlSession执行相同的查询时，可以直接从缓存中获取结果，而不需要再次访问数据库。 关于Spring JdbcTemplate类中几个常用方法的作用，我无法在提供的引用内容中找到明确的回答。但是一般来说，Spring JdbcTemplate类提供了一系列方法来执行数据库的增删改查操作。常用的方法包括：execute()方法用于执行SQL语句，query()方法用于执行查询操作并返回结果集，update()方法用于执行更新操作并返回受影响的行数，batchUpdate()方法用于执行批处理操作等。这些方法可以帮助开发人员简化数据库操作的代码，并提高开发效率。 但是，如果您对Spring JdbcTemplate类中具体方法的作用有进一步的疑问，我建议您参考《Java EE企业级应用开发教程 第2版（Spring Spring MVC MyBatis）》这本书，其中可能会有更详细的解释和示例。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值