MyBatis的缓存 | MyBatis系列（十）

文章目录

- 相关文章

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();
    }

执行结果
结果很明显的告诉我们，在同一个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();
    }

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

二、二级缓存

二级缓存又被称为全局缓存。作用域是当前mapper下。
开启二级缓存
- 核心配置文件
- ```
    <settings>
        <setting name="logImpl" value="LOG4J"/>
        <setting name="cacheEnabled" value="true"/>
    </settings>
```
- xml

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();
    }

当然，这个时候普通的实体类没用了，需要进行序列化。
报错信息如下

@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;
}

执行看结果
参数说明
- ```
<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>

可能会报错
- 解决办法如下

实现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();    }