常见算法

FIFO-先进先出

先进先出，在这种淘汰算法中，先进入缓存的会先被淘汰，会导致命中率很低。

LRU-最近最少使用（处理突发流量）

最近最少使用算法，每次访问数据都会将其放在我们的队尾，如果需要淘汰数据，就只需要淘汰队首即可。仍然有个问题，如果有个数据在 1 分钟访问了 1000次，再后 1 分钟没有访问这个数据，但是有其他的数据访问，就导致了我们这个热点数据被淘汰。

LFU-最近最少频率使用（应对大多数场景）

最近最少频率使用，利用额外的空间记录每个数据的使用频率，然后选出频率最低进行淘汰。这样就避免了 LRU 不能处理时间段的问题。

Window TinyLFU-基于滑动窗口的时间衰减设计机制

**

回收策略

基于大小回收（基于缓存大小maximumSize、基于权重maximumWeight）

maximumWeight与maximumSize不可以同时使用

基于时间回收

expireAfterAccess-基于固定的到期策略进行退出
expireAfterWrite-基于固定的到期策略进行退出
expireAfter-基于不同的到期策略进行退出

基于引用回收

AsyncLoadingCache不支持弱引用和软引用。
Caffeine.weakValues()和Caffeine.softValues()不可以一起使用
Java中四种引用类型

引用类型 被垃圾回收时间 用途 生存时间
强引用 Strong Reference 从来不会 对象的一般状态 JVM停止运行时终止
软引用 Soft Reference 在内存不足时 对象缓存 内存不足时终止
弱引用 Weak Reference 在垃圾回收时 对象缓存 gc运行后终止
虚引用 Phantom Reference 从来不会 可以用虚引用来跟踪对象被垃圾回收器回收的活动，当一个虚引用关联的对象被垃圾收集器回收之前会收到一条系统通知 JVM停止运行时终止

weakKeys().weakValues() - 当key和value都没有引用时驱逐缓存
softValues() - 当垃圾收集器需要释放内存时驱逐

基本用法

  1. @Configuration
  2. public class CacheConfig {
  5.     /**
  6.      * 创建基于Caffeine的Cache Manager
  7.      * 初始化一些key存入
  8.      * @return
  9.      */
  10.     @Bean
  11.     @Primary
  12.     public CacheManager caffeineCacheManager() {
  13.         SimpleCacheManager cacheManager = new SimpleCacheManager();
  14.         ArrayList<CaffeineCache> caches = Lists.newArrayList();
  15.         List<CacheBean> list = setCacheBean();
  16.         for(CacheBean cacheBean : list){
  17.             caches.add(new CaffeineCache(cacheBean.getKey(),
  18.                     Caffeine.newBuilder().recordStats()
  19.                             .expireAfterWrite(cacheBean.getTtl(), TimeUnit.SECONDS)
  20.                             .maximumSize(cacheBean.getMaximumSize())
  21.                             .build()));
  22.         }
  23.         cacheManager.setCaches(caches);
  24.         return cacheManager;
  25.     }
  28.     /**
  29.      * 初始化一些缓存的 key
  30.      * @return
  31.      */
  32.     private List<CacheBean> setCacheBean(){
  33.         List<CacheBean> list = Lists.newArrayList();
  34.         CacheBean userCache = new CacheBean();
  35.         userCache.setKey("userCache");
  36.         userCache.setTtl(60);
  37.         userCache.setMaximumSize(10000);
  39.         CacheBean deptCache = new CacheBean();
  40.         deptCache.setKey("userCache");
  41.         deptCache.setTtl(60);
  42.         deptCache.setMaximumSize(10000);
  44.         list.add(userCache);
  45.         list.add(deptCache);
  47.         return list;
  48.     }
  50.     class CacheBean {
  51.         private String key;
  52.         private long ttl;
  53.         private long maximumSize;
  55.         public String getKey() {
  56.             return key;
  57.         }
  59.         public void setKey(String key) {
  60.             this.key = key;
  61.         }
  63.         public long getTtl() {
  64.             return ttl;
  65.         }
  67.         public void setTtl(long ttl) {
  68.             this.ttl = ttl;
  69.         }
  71.         public long getMaximumSize() {
  72.             return maximumSize;
  73.         }
  75.         public void setMaximumSize(long maximumSize) {
  76.             this.maximumSize = maximumSize;
  77.         }
  78.     }
  1. 使用缓存
  2. @Cacheable(value = "key:config", key = "#appId+#thirdType", unless = "#result == null")
  3. 更新缓存
  4. @CacheEvict(value = "key:config", key = "#result.appId+#result.type")
  7. Caffeine.weakKeys()： 使用弱引用存储key。如果没有其他地方对该key有强引用，那么该缓存就会被垃圾回收器回收。由于垃圾回收器只依赖于身份(identity)相等，因此这会导致整个缓存使用身份 (==) 相等来比较 key，而不是使用 equals()。
  9. Caffeine.weakValues() ：使用弱引用存储value。如果没有其他地方对该value有强引用，那么该缓存就会被垃圾回收器回收。由于垃圾回收器只依赖于身份(identity)相等，因此这会导致整个缓存使用身份 (==) 相等来比较 key，而不是使用 equals()。
  11. Caffeine.softValues() ：使用软引用存储value。当内存满了过后，软引用的对象以将使用最近最少使用(least-recently-used ) 的方式进行垃圾回收。由于使用软引用是需要等到内存满了才进行回收，所以我们通常建议给缓存配置一个使用内存的最大值。 softValues() 将使用身份相等(identity) (==) 而不是equals() 来比较值。
  13. Caffeine.weakValues()和Caffeine.softValues()不可以一起使用。
  15. expireAfterWrite和expireAfterAccess同时存在时，以expireAfterWrite为准。
  17. maximumSize和maximumWeight不可以同时使用
  19. weakValues和softValues不可以同时使用

主要注解

@Cacheable 主要针对方法配置，能够根据方法的请求参数对其进行缓存
@CacheEvict 清空缓存
@CachePut 保证方法被调用，又希望结果被缓存。与@Cacheable区别在于是否每次都调用方法，常用于更新
@EnableCaching 开启基于注解的缓存
keyGenerator 缓存数据时key生成策略
serialize 缓存数据时value序列化策略
@CacheConfig 统一配置本类的缓存注解的属性

注解主要参数

**

名称 解释
value 缓存的名称，在 spring 配置文件中定义，必须指定至少一个
例如：
@Cacheable(value=”mycache”) 或者
@Cacheable(value={”cache1”,”cache2”}
key 缓存的 key，可以为空，如果指定要按照 SpEL 表达式编写，
如果不指定，则缺省按照方法的所有参数进行组合
例如：
@Cacheable(value=”testcache”,key=”#id”)
condition 缓存的条件，可以为空，使用 SpEL 编写，返回 true 或者 false，
只有为 true 才进行缓存/清除缓存
例如：@Cacheable(value=”testcache”,condition=”#userName.length()>2”)
unless 否定缓存。当条件结果为TRUE时，就不会缓存。
@Cacheable(value=”testcache”,unless=”#userName.length()>2”)
allEntries
(@CacheEvict )		 是否清空所有缓存内容，缺省为 false，如果指定为 true，
则方法调用后将立即清空所有缓存
例如：
@CachEvict(value=”testcache”,allEntries=true)
beforeInvocation
(@CacheEvict)		 是否在方法执行前就清空，缺省为 false，如果指定为 true，
则在方法还没有执行的时候就清空缓存，缺省情况下，如果方法
执行抛出异常，则不会清空缓存
例如：
@CachEvict(value=”testcache”，beforeInvocation=true)

SpEL上下文数据

名称 位置 描述 示例
methodName root对象 当前被调用的方法名 #root.methodname
method root对象 当前被调用的方法 #root.method.name
target root对象 当前被调用的目标对象实例 #root.target
targetClass root对象 当前被调用的目标对象的类 #root.targetClass
args root对象 当前被调用的方法的参数列表 #root.args[0]
caches root对象 当前方法调用使用的缓存列表 #root.caches[0].name
Argument Name 执行上下文 当前被调用的方法的参数，如findArtisan(Artisan artisan),可以通过#artsian.id获得参数 #artsian.id
result 执行上下文 方法执行后的返回值（仅当方法执行后的判断有效，如 unless cacheEvict的beforeInvocation=false） #result

注意：
1.当我们要使用root对象的属性作为key时我们也可以将“#root”省略，因为Spring默认使用的就是root对象的属性。 如
@Cacheable(key = "targetClass + methodName +#p0")
2.使用方法参数时我们可以直接使用“#参数名”或者“#p参数index”。 如：
@Cacheable(value="users", key="#id")
@Cacheable(value="users", key="#p0")
SpEL提供了多种运算符

类型 运算符
关系 <，>，<=，>=，==，!=，lt，gt，le，ge，eq，ne
算术 +，- ，* ，/，%，^
逻辑 &&，||，!，and，or，not，between，instanceof
条件 ?: (ternary)，?: (elvis)
正则表达式 matches
其他类型 ?.，?[…]，![…]，^[…]，$[…]

https://www.cnblogs.com/yueshutong/p/9381540.html