2021-08-23

13、缓存（了解）

13.1、简介

• 每次查询都要从数据库中查询出来，很耗资源
• 我们可以将一次查询的结果给它暂存在一个可以直接取到的地方！内存中，内存中的这些查询的数据就叫缓存，我们在次查询相同数据的时候，直接走缓存，就不用走数据库了
• 只有读走缓存，写是不走缓存的

1. 什么是缓存【Cache】？
   • 存在内存中的数据放在缓存（内存）中，用户去查询数据就不用从磁盘上（关系型数据库数据文件）查询，从缓存中查询，解决了高并发系统的性能问题。
2. 为什么使用缓存？
   • 减少和数据库的交互次数，减少系统开销，提高系统效率
3. 什么样的数据库能使用缓存？
   • 经常查询并且不经常改变的数据

13.2、Mybatis缓存

• MyBatis 内置了一个强大的事务性查询缓存机制，它可以非常方便地配置和定制缓存。缓存可以极大额提升查询的效率。
• Mybatis系统中默认定义了两级缓存：一级缓存和二级缓存
  • 默认情况下，只有一级缓存开启（Sqlsession级别的缓存，也称本地缓存）
  • 二级缓存需要手动开启和配置，它是基于namespace级别的缓存。
  • 为了提高扩展性，Mybatis定义了缓存接口Cache，我们可以通过实现Cache接口来自定义二级缓存

13.3、一级缓存

• 一级缓存也叫本地缓存：Sqlsession级别的缓存
  • 与数据库同一次会话期间查询到的数据会放在本地缓存中。
  • 以后如果需要获取相同的数据，直接从缓存中拿，没必要再去查询数据库；

测试一级缓存步骤：

1. 开启日志！

2. 测试在一个Session中查询两次相同记录

     @Test
       public void test(){
           SqlSession sqlSession = MybatisUtils.getSqlSession();
           UserMapper mapper = sqlSession.getMapper(UserMapper.class);
   
           User user = mapper.queryUser(1);
           System.out.println(user);
           System.out.println("===========================");
           User user1 = mapper.queryUser(1);
           System.out.println(user1);
   
           sqlSession.close();
       }
   

3. 分析查询结果

缓存失效：

测试缓存失效：

在上面的两次查询语句中间进行一次插入数据，分析结果

• 增删改，可能会改变原来的数据，所以必定会刷新缓存

从结果可以看出：这次的查询语句执行了两次，说明缓存确实是失效了。

• 手动清除缓存: sqlSession.clearCache();//手动清除缓存

 @Test
    public void test(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        User user1 = mapper.queryUser(1);
        System.out.println(user1);
        System.out.println("===========================");
//        //在两次查询中间进行一次插入，就能使查询失效
//        User user = new User(6, "safd", "123123123");
        sqlSession.clearCache();//手动清除缓存
        System.out.println("==========================");
        User user2 = mapper.queryUser(1);
        System.out.println(user2);

        sqlSession.close();
    }

小结：一级缓存是默认开启的，并且是关不掉的，只在一次Sqlsession中有效，也就是从拿到连接到关闭连接之间！

13.4、二级缓存

• 二级缓存也叫全局缓存，一级缓存作用域太低了，所以就诞生了二级缓存
• 基于namespace级别（一个Mapper的作用域）的缓存，一个名称空间，对应一个二级缓存；
• 工作机制
  • 一个会话查询一条数据，这个数据就会被放在当前会话的一级缓存中；
  • 如果当前会话关闭了，这个会话对应的一级缓存就没了；但是我们想要的是，会话关闭了，一级缓存中的数据被保存到二级缓存中获取内容；

• 二级缓存是事务性的。这意味着，当 SqlSession 完成并提交时，或是完成并回滚，但没有执行 flushCache=true 的 insert/delete/update 语句时，缓存会获得更新。

步骤：

1. 开启全局缓存

   <!--显示的开启全局缓存-->
   <setting name="cacheEnabled" value="true"/>
   

2. 在要使用二级缓存的Mapper中开启

   <!--在当前Mapper.xml中使用二级缓存-->
   <cache/>
   

   同时可以对它进行设置

   <!--在当前Mapper.xml中使用二级缓存-->
       <cache
            eviction="FIFO"
            flushInterval="60000" // 60秒刷新
            size="512"
            readOnly="true"/>
   

3. 测试：

@Test
    public void test01(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        SqlSession sqlSession2 = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        UserMapper mapper2 = sqlSession2.getMapper(UserMapper.class);

        User user1 = mapper.queryUser(1);
        System.out.println(user1);
        System.out.println("===========================");
        User user2 = mapper2.queryUser(1);
        System.out.println(user2);
        //当第一次sqlSession执行完还没有关闭时，接着执行sqlSession2
        sqlSession.close();
        sqlSession2.close();
    }

结果为：

可以看出sql语句执行了两次，说明第二次不是在二级缓存中查的，也说明当第一个sqlsessiion没有关闭连接时，它是不会将数据放到二级缓存中的，只有一级缓存关闭了或者崩塌了，他就会将数据放入二级缓存中。

在次测试：

 @Test
    public void test01(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        SqlSession sqlSession2 = MybatisUtils.getSqlSession();
        
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user1 = mapper.queryUser(1);
        System.out.println(user1);

        sqlSession.close();//先关闭第一个sqlSession
        System.out.println("===========================");
        
        UserMapper mapper2 = sqlSession2.getMapper(UserMapper.class);
        User user2 = mapper2.queryUser(1);
        System.out.println(user2);

        sqlSession2.close();
    }

结果为：

sql语句只执行了一次，确实开启了二级缓存；

这里遇到了两个情况：

• 情况一：
  • 你调用的接口中的方法必须要在开启二级缓存的mapper中注册，从mapper中实现，不能子啊接口的方法中用注解实现。
• 情况二：实体类要继承Serializable接口实现序列化，不然会报
  • java.io.NotSerializableException: com.kuang.pojo.User 没有将实体类序列化

小结：

• 只要开启了二级缓存，在同一个Mapper下就有效
• 所有的数据都会先放在一级缓存中；
• 只有当会话提交，或者关闭的时候，才会提交到二级缓存中！这里有转存的概念

13.5、缓存原理

用户查询数据时，会先在二级缓存中找，看有没有数据，没有在找一级缓存中，在没有就找数据库！

13.6、自定义缓存-ehcache

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

• Ehcache是一种广泛使用的开源Java分布式缓存。主要面向通用缓存,Java EE和轻量级容器。

要在程序中使用ehcache，先要导包

<!-- https://mvnrepository.com/artifact/org.mybatis.caches/mybatis-ehcache -->
<dependency>
    <groupId>org.mybatis.caches</groupId>
    <artifactId>mybatis-ehcache</artifactId>
    <version>1.2.1</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="./tmpdir/Tmp_EhCache"/>

<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>

        <!--
              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，最近最少使用的，缓存的元素有一个时间戳，当缓存容量满了，而又需要腾出地方来缓存新的元素的时候，那么现有缓存元素中时间戳离当前时间最远的元素将被清出缓存。
       -->

在Mapper中配置：

    <!--使用 ehcache 的自定义的缓存-->
    <cache type="org.mybatis.caches.ehcache.EhcacheCache"/>

但目前使用Redis数据库来做缓存，实战中不会用这个来做缓存，效率太低了。