boot 版本 2.4.13 boot Caching 官方文档 其他实战笔记参考

系统的知识后面有实际再补，先看如何接入使用

Ehcache 2.x 使用

添加依赖

  1. // ~ cache==========================
  2.     // ehcache3 更规范，要求有序列化，相对来说比较难用
  3.     implementation 'org.springframework.boot:spring-boot-starter-cache:2.4.13'
  4.     implementation 'net.sf.ehcache:ehcache'

编写 ehcache.xml 文件

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <ehcache>
  3.     <!-- 当你缓存大量数据的时候，请自行创建自己的缓存配置-->
  4.     <!-- 指定一个文件目录，当 EhCache把数据写到硬盘上时，将把数据写到这个文件目录下 -->
  5.     <diskStore path="java.io.tmpdir/ehcache"/>
  7.     <!--
  8.     缓存配置
  9.        name:缓存名称。
  10.        maxElementsInMemory：缓存最大个数。
  11.        eternal:对象是否永久有效，一但设置了，timeout将不起作用。
  12.        timeToIdleSeconds：设置对象在失效前的允许闲置时间（单位：秒）。仅当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大。
  13.        timeToLiveSeconds：设置对象在失效前允许存活时间（单位：秒）。最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用，默认是0.，也就是对象存活时间无穷大。
  14.        overflowToDisk：当内存中对象数量达到maxElementsInMemory时，Ehcache将会对象写到磁盘中。
  15.        diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。
  16.        maxElementsOnDisk：硬盘最大缓存个数。
  17.        diskPersistent：是否缓存虚拟机重启期数据 Whether the disk store persists between restarts of the Virtual Machine. The default value is false.
  18.        diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认是120秒。
  19.        memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。默认策略是LRU（最近最少使用）。你可以设置为FIFO（先进先出）或是LFU（较少使用）。
  20.        clearOnFlush：内存数量最大时是否清除。
  21.     -->
  22.     <!--注意：由于是公共的缓存管理器，在使用 @Cacheable 的时候请让自己的 key 唯一，最好是类名+方法名+业务键 -->
  23.     <!-- 设定缓存的默认数据过期策略 -->
  24.     <defaultCache
  25.             maxElementsInMemory="10000"
  26.             eternal="false"
  27.             overflowToDisk="true"
  28.             timeToIdleSeconds="10"
  29.             timeToLiveSeconds="20"
  30.             diskPersistent="false"
  31.             diskExpiryThreadIntervalSeconds="120"/>
  32.     <!-- 由于本项目的场景基本上都是缓存大量全局数据，闲置和过期时间都可以变得较大 -->
  33.     <cache name="common:cache:2m"
  34.            maxElementsInMemory="100000"
  35.            eternal="false"
  36.            overflowToDisk="false"
  37.            timeToIdleSeconds="90"
  38.            timeToLiveSeconds="180"
  39.     />
  40.     <cache name="common:cache:5m"
  41.            maxElementsInMemory="100000"
  42.            eternal="false"
  43.            overflowToDisk="false"
  44.            timeToIdleSeconds="150"
  45.            timeToLiveSeconds="300"
  46.     />
  48.     <cache name="common:cache:10m"
  49.            maxElementsInMemory="100000"
  50.            eternal="false"
  51.            overflowToDisk="false"
  52.            timeToIdleSeconds="300"
  53.            timeToLiveSeconds="600"/>
  55.     <cache name="common:cache:20m"
  56.            maxElementsInMemory="100000"
  57.            eternal="false"
  58.            overflowToDisk="false"
  59.            timeToIdleSeconds="600"
  60.            timeToLiveSeconds="1200"/>
  62.     <cache name="common:cache:30m"
  63.            maxElementsInMemory="100000"
  64.            eternal="false"
  65.            overflowToDisk="false"
  66.            timeToIdleSeconds="900"
  67.            timeToLiveSeconds="1800"/>
  69.     <cache name="common:cache:1h"
  70.            maxElementsInMemory="100000"
  71.            eternal="false"
  72.            overflowToDisk="false"
  73.            timeToIdleSeconds="1800"
  74.            timeToLiveSeconds="3600"/>
  75.     <cache name="common:cache:2h"
  76.            maxElementsInMemory="100000"
  77.            eternal="false"
  78.            overflowToDisk="false"
  79.            timeToIdleSeconds="3600"
  80.            timeToLiveSeconds="7200"/>
  82.     <!-- 后面的的为单独的业务模块声明的 cache 配置 -->
  84.     <!-- token 发放缓存 -->
  85.     <cache name="accessTokenGrant:cache:30m"
  86.            maxElementsInMemory="1000000"
  87.            eternal="false"
  88.            overflowToDisk="false"
  89.            timeToIdleSeconds="900"
  90.            timeToLiveSeconds="1800"
  91.     />
  92.     <!-- 用户信息缓存 发放缓存 -->
  93.     <cache name="userinfo:cache:5m"
  94.            maxElementsInMemory="100000"
  95.            eternal="false"
  96.            overflowToDisk="false"
  97.            timeToIdleSeconds="150"
  98.            timeToLiveSeconds="300"
  99.     />
  100. </ehcache>

编写自动配置类，其实最组主要的是声明 @EnableCaching注解，关于 EhCacheNames 这是声明公用的 cache name 

  1. package cn.mrcode.autoconfig;
  3. import org.springframework.cache.annotation.EnableCaching;
  4. import org.springframework.context.annotation.Configuration;
  6. /**
  7.  * <pre>
  8.  * 全局公共缓存配置，这里只是针对一些公共的配置进行了 type 类型的配置；
  9.  *
  10.  * 如果你有大量数据进行缓存时，请创建自己的缓存
  11.  * </pre>
  12.  *
  13.  * @author mrcode
  14.  */
  15. @EnableCaching
  16. @Configuration
  17. public class CacheManagerConfig {
  18.     /**
  19.      * <pre>
  20.      * 这里的缓存都是最大存活时间，闲置时间是存活时间的一半
  21.      * 闲置不使用则自动被驱逐
  22.      * </pre>
  23.      */
  24.     public interface EhCacheNames {
  25.         /**
  26.          * 2 分钟缓存组
  27.          */
  28.         String CACHE_COMMON_2MINS = "common:cache:2m";
  29.         /**
  30.          * 5 分钟缓存组
  31.          */
  32.         String CACHE_COMMON_5MINS = "common:cache:5m";
  33.         /**
  34.          * 10 分钟缓存组
  35.          */
  36.         String CACHE_COMMON_10MINS = "common:cache:10m";
  37.         /**
  38.          * 20 分钟缓存组
  39.          */
  40.         String CACHE_COMMON_20MINS = "common:cache:20m";
  41.         /**
  42.          * 30 分钟缓存组
  43.          */
  44.         String CACHE_COMMON_30MINS = "common:cache:30m";
  45.         /**
  46.          * 1 小时缓存组
  47.          */
  48.         String CACHE_COMMON_1HOUR = "common:cache:1h";
  49.         /**
  50.          * 2 小时缓存组
  51.          */
  52.         String CACHE_COMMON_2HOUR = "common:cache:2h";
  53.     }
  54. }

applicathion.yml 指定 cache 类型和配置文件

  1. spring:
  2.   cache:
  3.     type: ehcache
  4.     ehcache:
  5.       config: classpath:/ehcache.xml

然后就可以开始使用了

  1. import org.springframework.cache.annotation.CachePut;
  2. import org.springframework.cache.annotation.Cacheable;
  3. import org.springframework.stereotype.Service;
  5. import cn.mrcode.cachepdp.eshop.cache.model.ProductInfo;
  6. import cn.mrcode.cachepdp.eshop.cache.service.CacheService;
  8. @Service
  9. public class CacheServiceImpl implements CacheService {
  10.     public static final String CACHE_NAME = "local";
  12.     /**
  13.      * 将商品信息保存到本地缓存中
  14.      */
  15.     @CachePut(value = CACHE_NAME, key = "'key_'+#productInfo.getId()")
  16.     public ProductInfo saveLocalCache(ProductInfo productInfo) {
  17.         return productInfo;
  18.     }
  20.     /**
  21.      * 从本地缓存中获取商品信息
  22.      */
  23.     @Cacheable(value = CACHE_NAME, key = "'key_'+#id")
  24.     public ProductInfo getLocalCache(Long id) {
  25.         return null;
  26.     }
  27. }
  28. m

对于这个 key 的定义来说，还可以使用 SpEL 表达式，比如下面这个

  1.     @Cacheable(cacheNames = CACHE_COMMON_2MINS, key = "#root.targetClass + '_'+ #root.method + '_' + #brand")
  2.     public MlsBrands getByNameForCache(String brand) {
  3.         return getByName(brand);
  4.     }
  • root.targetClass：表示获取当前类路径类名
  • root.method：当前方法名称，在这里是 getByNameForCache
  • 后面没有加 root 的表示从参数中获取，这里就是 brand 这个字符串的入参的值，比如传递 a，那么就是 a

key：表示存储的时候，缓存的 key 是什么。