阅读 1521

MyBatis的缓存 | MyBatis系列(十)

这是我参与8月更文挑战的第4天,活动详情查看:8月更文挑战


相关文章

MyBatis系列汇总:MyBatis系列


前言

  • 震惊!MyBaits竟然有缓存?不知道落伍了哦~
  • 虽然在我们平时开发中并不会使用,但是了解还是很有必要的嘛!
  • 实际工作中,我们使用的缓存一般都是Redis,有兴趣的同学可以去看看先前我写的Redis系列文章,十分火热哦~并且已经完结了!
  • 点击跳转:Redis系列

一、一级缓存

  • 其实Mybatis默认开启的就是一级缓存,我们可以来测试一下。

  • xml和mapper随便写一个即可,为了省略篇幅,我这里就不贴代码了。

  • 我们在一个session中执行两次查询语句,看它会执行几次sql。

  • Junit Test

    •     @Test
          public void getMyBlog(){
              SqlSession session = MybatisUtils.getSession();
              MyBlogMapper mapper = session.getMapper(MyBlogMapper.class);
              Map<String,Object> map = new HashMap<>();
              map.put("title","Mybatis");
              //第一次查询
              List<Blog> myBlogMappers = mapper.getBlogInfo(map);
              for (Blog myBlogMapper : myBlogMappers) {
                  System.out.println(myBlogMapper);
              }
              System.out.println("========================");
              //第二次查询
              List<Blog> myBlogMappers1 = mapper.getBlogInfo(map);
              for (Blog myBlogMapper : myBlogMappers1) {
                  System.out.println(myBlogMapper);
              }
              session.close();
          }
      
      复制代码
  • 执行结果

    • image-20210731231427019.png
  • 结果很明显的告诉我们,在同一个session作用域下,我们执行同样的操作,MyBatis会帮我们将数据存储在缓存中,第二次查询会优先从缓存中查询数据,查不到才会再次执行sql。

  • 当然,一级缓存可以说是只有在查询中才是有效的。如果中间进行了增删改立马会刷新一级缓存。

  • Junit Test

    •     @Test
          public void getMyBlog(){
              SqlSession session = MybatisUtils.getSession();
              MyBlogMapper mapper = session.getMapper(MyBlogMapper.class);
              Map<String,Object> map = new HashMap<>();
              map.put("title","Mybatis");
              //第一次查询
              List<Blog> myBlogMappers = mapper.getBlogInfo(map);
              for (Blog myBlogMapper : myBlogMappers) {
                  System.out.println(myBlogMapper);
              }
              System.out.println("=========================");
              Map<String,Object> map1 = new HashMap<>();
              map1.put("id","3");
              map1.put("title","富婆让我陪她逛街2");
              map1.put("autor","大大大大鱼");
      //        map.put("reads","100000");
              Integer num = mapper.updateBlogName(map1);
              System.out.println("一共更新了:"+num+"条数据");
              session.commit();//更新不要忘记提交事务哦
              System.out.println("========================");
              //第二次查询
              List<Blog> myBlogMappers1 = mapper.getBlogInfo(map);
              for (Blog myBlogMapper : myBlogMappers1) {
                  System.out.println(myBlogMapper);
              }
              session.close();
          }
      复制代码
  • 执行结果

    • image-20210731231841679.png
  • 总结一下一级缓存

    • 一级缓存又称为局部缓存。
    • 映射语句文件中的所有 insert、update 和 delete 语句会刷新缓存。
    • 查询不同的mapper.xml,缓存是没用的。
    • 手动清除缓存。
      • flushCache: 将其设置为 true 后,只要语句被调用,都会导致本地缓存和二级缓存被清空,默认值:(对 insert、update 和 delete 语句)true。
      • image-20210731232427195.png
      • image-20210731232358942.png
      • 执行了两遍sql,证明一级缓存失效了。当然,只有当前的mapper的select下是失效的,默认值是false。

二、二级缓存

  • 二级缓存又被称为全局缓存。作用域是当前mapper下。

  • 开启二级缓存

    • 核心配置文件

    •     <settings>
              <setting name="logImpl" value="LOG4J"/>
              <setting name="cacheEnabled" value="true"/>
          </settings>
      复制代码
    • xml

    • image-20210731232725659.png

  • Junit Test

    • 我们开启两个session,证明当前有两个局部作用域

    •     @Test
          public void getMyBlog(){
              SqlSession session = MybatisUtils.getSession();
              MyBlogMapper mapper = session.getMapper(MyBlogMapper.class);
              Map<String,Object> map = new HashMap<>();
              map.put("title","Mybatis");
              //第一次查询
              List<Blog> myBlogMappers = mapper.getBlogInfo(map);
              for (Blog myBlogMapper : myBlogMappers) {
                  System.out.println(myBlogMapper);
              }
              session.commit();//这里需要提交事务,不然缓存还是一级缓存,提交事务后,才会存到全局缓存当中
              System.out.println("========================");
              SqlSession session1 = MybatisUtils.getSession();
              MyBlogMapper mapper1 = session1.getMapper(MyBlogMapper.class);
              //第二次查询
              List<Blog> myBlogMappers1 = mapper1.getBlogInfo(map);
              for (Blog myBlogMapper : myBlogMappers1) {
                  System.out.println(myBlogMapper);
              }
              session.close();
          }
      复制代码
    • 当然,这个时候普通的实体类没用了,需要进行序列化。

    • 报错信息如下

    • image-20210731233628882.png

    • @Data
      @AllArgsConstructor
      @NoArgsConstructor
      @Alias("Blog")
      public class Blog  implements Serializable{
          private Integer id;
          private String title;
          private String autor;
          private Date creat_time;
          private Integer reads;
      }
      复制代码
  • 执行看结果

    • image-20210731234142547.png
  • 参数说明

    • <cache eviction="FIFO"
             flushInterval="60000"
             size="512"
             readOnly="true"/>
      复制代码
    • eviction :缓存的回收策略

      • LRU - 最近最少使用,移除最长时间不被使用的对象。
      • FIFO - 先进先出,按对象进入缓存的顺序来移除它们。
      • SOFT - 软引用,移除基于垃圾回收器状态和软 引用规则的对象。
      • WEAK - 弱引用,更积极地移除基于垃圾收集器和弱引用规则的对象。
    • flushInterval : 缓存刷新间隔,缓存多长时间清空一次,默认不清空,设置一个毫秒值。

    • size : 缓存存放多少个元素。

    • readOnly : 是否只读。

      • true:只读:mybatis认为所有从缓存中获取数据的操作都是只读操作,不会修改数据。
      • mybatis为了加快获取数据,直接就会将数据在缓存中的引用交给用户 。不安全,速度快。
      • false:读写(默认):mybatis觉得获取的数据可能会被修改。
      • mybatis会利用序列化&反序列化的技术克隆一份新的数据给你。安全,速度相对慢。
  • 总结

    • 开启了二级缓存,在Mapper下有效。
    • 所有数据都会先放在一级缓存。
    • 只有当回话提交,或者关闭的时候,才会提交到二级缓存。

三、自定义缓存

  • 同样的,除了MyBatis提供的一、二级缓存外,我们也可以自定义缓存。

  • pom引入

    •     <!-- https://mvnrepository.com/artifact/org.mybatis.caches/mybatis-ehcache -->
          <dependency>
              <groupId>org.mybatis.caches</groupId>
              <artifactId>mybatis-ehcache</artifactId>
              <version>1.2.0</version>
          </dependency>
      复制代码
  • ehcache.xml

    • <?xml version="1.0" encoding="UTF-8"?>
      <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
               xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
               updateCheck="false">
          <!--
             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"/>
      
          <cache
                  name="cloud_user"
                  eternal="false"
                  maxElementsInMemory="5000"
                  overflowToDisk="false"
                  diskPersistent="false"
                  timeToIdleSeconds="1800"
                  timeToLiveSeconds="1800"
                  memoryStoreEvictionPolicy="LRU"/>
      
      </ehcache>
      复制代码
    • 可能会报错

      • image-20210801110719196.png
      • 解决办法如下
      • image-20210801110809627.png
  • 实现Catch的类

    • /** * 实现cache的类 *@author DingYongJun *@date 2021/08/01 *@return Map<String, Object> */public class BatisCache implements Cache {    private ReadWriteLock lock = new ReentrantReadWriteLock();    private ConcurrentHashMap<Object,Object> cache = new ConcurrentHashMap<Object, Object>();    private String id;    public  BatisCache(){        System.out.println("初始化-1!");    }  //必须有该构造函数    public BatisCache(String id){        System.out.println("初始化-2!");        this.id = id;    }    // 获取缓存编号    public String getId() {        System.out.println("得到ID:" + id);        return id;    }    //获取缓存对象的大小    public int getSize() {        System.out.println("获取缓存大小!");        return 0;    }    // 保存key值缓存对象    public void putObject(Object key, Object value) {        System.out.println("往缓存中添加元素:key=" + key+",value=" + value);        cache.put(key,value);    }    //通过KEY    public Object getObject(Object key) {        System.out.println("通过kEY获取值:" + key);        System.out.println("OVER");        System.out.println("=======================================================");        System.out.println("值为:" + cache.get(key));        System.out.println("=====================OVER==============================");        return cache.get(key);    }    // 通过key删除缓存对象    public Object removeObject(Object key) {        System.out.println("移除缓存对象:" + key);        return null;    }    // 清空缓存    public void clear() {        System.out.println("清除缓存!");        cache.clear();    }    // 获取缓存的读写锁    public ReadWriteLock getReadWriteLock() {        System.out.println("获取锁对象!!!");        return lock;    }}
      复制代码
  • Junit Test

    •     @Test    public void TestCache(){        SqlSession session = MybatisUtils.getSession();        MyBlogMapper mapper = session.getMapper(MyBlogMapper.class);        Map<String,Object> map = new HashMap<>();        map.put("title","Mybatis");        //第一次查询        List<Blog> myBlogMappers = mapper.getBlogInfo(map);        for (Blog myBlogMapper : myBlogMappers) {            System.out.println(myBlogMapper);        }        //第二次查询        List<Blog> myBlogMappers1 = mapper.getBlogInfo(map);        for (Blog myBlogMapper : myBlogMappers1) {            System.out.println(myBlogMapper);        }        //如果我们使用二级缓存,需要提交事务        session.commit();        System.out.println("=============================================================");        //获取新的session        SqlSession session1 = MybatisUtils.getSession();        MyBlogMapper mapper1 = session1.getMapper(MyBlogMapper.class);        List<Blog> myBlogMappers2 = mapper.getBlogInfo(map);        session1.commit();    }
      复制代码
  • 执行结果

    • image-20210801111500893.png
    • image-20210801111514792.png
  • 总结

    • 所以在mybatis默认的缓存中,缓存的id值是namespace命名空间。
    • 数据类型是map类型的,key为namespace+sql语句等等,value为SQL语句查询的数据。

四、完结语

  • MyBatis系列到此就告一段落了。基础的东西基本上已经写完了。
  • 下面大家可以看我写的Spring系列,已经完结了,并且十分详细哦~
  • 点击跳转Spring系列汇总
  • 接下来我会不定期的更新MyBatis的源码文章,也是放在这个专栏里面,希望大家可以点个关注加点赞!
  • 谢谢支持!

路漫漫其修远兮,吾必将上下求索~

如果你认为i博主写的不错!写作不易,请点赞、关注、评论给博主一个鼓励吧~hahah

文章分类
后端
文章标签