devbox
羊村懒王
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

RuoYi-Vue-Plus （SpringCache、CacheManager、@Cacheable、缓存雪崩、击穿、穿透）

作者：羊村懒王 | 2024-05-14 10:23:05

赞

踩

RuoYi-Vue-Plus （SpringCache、CacheManager、@Cacheable、缓存雪崩、击穿、穿透）

一、概述

        1、SpringCache是Spring提供的一个缓存框架，在Spring3.1版本开始支持将缓存添加到现有的spring应用程序中，在4.1开始，缓存已支持JSR-107注释和更多自定义的选项。

        2、SpringCache利用了AOP，实现了基于注解的缓存功能，只需要简单地加一个注解，就能实现缓存功能了，做到了对代码侵入性做小。

        3、SpringCache框架还提供了CacheManager接口，可以实现降低对各种缓存框架的耦合。它不是具体的缓存实现，它只提供一整套的接口和代码规范、配置、注解等，用于整合各种缓存方案，比如Caffeine、Guava Cache、Ehcache。

二、SpringCache概念

接口：


1、Cache接口:缓存接口，定义缓存操作。实现有 如RedisCache、EhCacheCache、ConcurrentMapCache等

2、cacheResolver：指定获取解析器

3、CacheManager：缓存管理器，管理各种缓存（Cache）组件；如：RedisCacheManager，使用redis作为缓存。指定缓存管理器

注解：

1- @Cacheable：在方法执行前查看是否有缓存对应的数据，如果有直接返回数据，如果没有调用方法获取数据返回，并缓存起来。

2- @CacheEvict：将一条或多条数据从缓存中删除。

3- @CachePut：将方法的返回值放到缓存中

4- @EnableCaching：开启缓存注解功能

5- @Caching：组合多个缓存注解；

6- @CacheConfig：统一配置@Cacheable中的value值

三、spring缓存整合redis 

RedisConfig 
类路径： com.ruoyi.framework.config.RedisConfig
1- spring 自动管理缓存机制
@EnableCaching //开启spring缓存，提升性能
  1. @Slf4j
  2. @Configuration
  3. @EnableCaching //1- spring 自动管理缓存机制 ，，提升性能
  4. @EnableConfigurationProperties(RedissonProperties.class)
  5. public class RedisConfig {
 2- 整合自定义缓存管理器
  1.  /**
  2.      * 2-自定义缓存管理器 整合spring-cache
  3.      */
  4.     @Bean
  5.     public CacheManager cacheManager() {
  6.         return new PlusSpringCacheManager();
  7.     }

自定义 管理器：PlusSpringCacheManager，实现CacheManager 接口，基于redssion操作缓存

  1. /**
  2.  * Copyright (c) 2013-2021 Nikita Koksharov
  3.  *
  4.  * Licensed under the Apache License, Version 2.0 (the "License");
  5.  * you may not use this file except in compliance with the License.
  6.  * You may obtain a copy of the License at
  7.  *
  8.  *    http://www.apache.org/licenses/LICENSE-2.0
  9.  *
  10.  * Unless required by applicable law or agreed to in writing, software
  11.  * distributed under the License is distributed on an "AS IS" BASIS,
  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13.  * See the License for the specific language governing permissions and
  14.  * limitations under the License.
  15.  */
  16. package com.ruoyi.framework.manager;
  17.  
  18. import com.ruoyi.common.utils.redis.RedisUtils;
  19. import org.redisson.api.RMap;
  20. import org.redisson.api.RMapCache;
  21. import org.redisson.spring.cache.CacheConfig;
  22. import org.redisson.spring.cache.RedissonCache;
  23. import org.springframework.boot.convert.DurationStyle;
  24. import org.springframework.cache.Cache;
  25. import org.springframework.cache.CacheManager;
  26. import org.springframework.cache.transaction.TransactionAwareCacheDecorator;
  27. import org.springframework.util.StringUtils;
  28.  
  29. import java.util.Collection;
  30. import java.util.Collections;
  31. import java.util.Map;
  32. import java.util.concurrent.ConcurrentHashMap;
  33. import java.util.concurrent.ConcurrentMap;
  34.  
  35. /**
  36.  * A {@link org.springframework.cache.CacheManager} implementation
  37.  * backed by Redisson instance.
  38.  * <p>
  39.  * 修改 RedissonSpringCacheManager 源码
  40.  * 重写 cacheName 处理方法 支持多参数
  41.  *
  42.  * @author Nikita Koksharov
  43.  *
  44.  */
  45. @SuppressWarnings("unchecked")
  46. public class PlusSpringCacheManager implements CacheManager {
  47.  
  48.     //是否自动配置name
  49.     private boolean dynamic = true;
  50.  
  51.     //是否允许null
  52.     private boolean allowNullValues = true;
  53.  
  54.     //事务提交之后执行
  55.     private boolean transactionAware = true;
  56.  
  57.     // 常用缓存配置 ttl;  maxIdleTime; maxSize; 等
  58.     Map<String, CacheConfig> configMap = new ConcurrentHashMap<>();
  59.     // 缓存实例
  60.     ConcurrentMap<String, Cache> instanceMap = new ConcurrentHashMap<>();
  61.  
  62.     /**
  63.      * Creates CacheManager supplied by Redisson instance
  64.      */
  65.     public PlusSpringCacheManager() {
  66.     }
  67.  
  68.  
  69.     /**
  70.      * Defines possibility of storing {@code null} values.
  71.      * <p>
  72.      * Default is <code>true</code>
  73.      *
  74.      * @param allowNullValues stores if <code>true</code>
  75.      */
  76.     public void setAllowNullValues(boolean allowNullValues) {
  77.         this.allowNullValues = allowNullValues;
  78.     }
  79.  
  80.     /**
  81.      * Defines if cache aware of Spring-managed transactions.
  82.      * If {@code true} put/evict operations are executed only for successful transaction in after-commit phase.
  83.      * <p>
  84.      * Default is <code>false</code>
  85.      *
  86.      * @param transactionAware cache is transaction aware if <code>true</code>
  87.      */
  88.     public void setTransactionAware(boolean transactionAware) {
  89.         this.transactionAware = transactionAware;
  90.     }
  91.  
  92.     /**
  93.      * Defines 'fixed' cache names.
  94.      * A new cache instance will not be created in dynamic for non-defined names.
  95.      * <p>
  96.      * `null` parameter setups dynamic mode
  97.      *
  98.      * @param names of caches
  99.      */
  100.     public void setCacheNames(Collection<String> names) {
  101.         if (names != null) {
  102.             for (String name : names) {
  103.                 getCache(name);
  104.             }
  105.             dynamic = false;
  106.         } else {
  107.             dynamic = true;
  108.         }
  109.     }
  110.  
  111.     /**
  112.      * Set cache config mapped by cache name
  113.      *
  114.      * @param config object
  115.      */
  116.     public void setConfig(Map<String, ? extends CacheConfig> config) {
  117.         this.configMap = (Map<String, CacheConfig>) config;
  118.     }
  119.  
  120.     protected CacheConfig createDefaultConfig() {
  121.         return new CacheConfig();
  122.     }
  123.  
  124.     @Override
  125.     public Cache getCache(String name) {
  126.         // 重写 cacheName 支持多参数
  127.         /**
  128.          * 演示案例   ：  String DEMO_CACHE = "demo:cache#60s#10m#20";
  129.          */
  130.         String[] array = StringUtils.delimitedListToStringArray(name, "#");
  131.         name = array[0];
  132.  
  133.         Cache cache = instanceMap.get(name);
  134.         if (cache != null) {
  135.             return cache;
  136.         }
  137.         //2- dynamic=false 不会动态生成
  138.         if (!dynamic) {
  139.             //return cache;
  140.             return null;
  141.         }
  142.  
  143.         CacheConfig config = configMap.get(name);
  144.         if (config == null) {
  145.             config = createDefaultConfig();
  146.             configMap.put(name, config);
  147.         }
  148.  
  149.         //setTTL
  150.         if (array.length > 1) {
  151.             config.setTTL(DurationStyle.detectAndParse(array[1]).toMillis());
  152.         }
  153.         //setMaxIdleTime
  154.         if (array.length > 2) {
  155.             config.setMaxIdleTime(DurationStyle.detectAndParse(array[2]).toMillis());
  156.         }
  157.         //setMaxSize
  158.         if (array.length > 3) {
  159.             config.setMaxSize(Integer.parseInt(array[3]));
  160.         }
  161.  
  162.         if (config.getMaxIdleTime() == 0 && config.getTTL() == 0 && config.getMaxSize() == 0) {
  163.             return createMap(name, config);
  164.         }
  165.  
  166.         return createMapCache(name, config);
  167.     }
  168.  
  169.     private Cache createMap(String name, CacheConfig config) {
  170.         //1-获取缓存
  171.         RMap<Object, Object> map = RedisUtils.getClient().getMap(name);
  172.         //2-没有过期时间传2个参数
  173.         Cache cache = new RedissonCache(map, allowNullValues);
  174.         // 3-事务提交 之后执行
  175.         if (transactionAware) {
  176.             cache = new TransactionAwareCacheDecorator(cache);
  177.         }
  178.         //4-不存在就添加
  179.         Cache oldCache = instanceMap.putIfAbsent(name, cache);
  180.         if (oldCache != null) {
  181.             cache = oldCache;
  182.         }
  183.         return cache;
  184.     }
  185.  
  186.     private Cache createMapCache(String name, CacheConfig config) {
  187.         //1-获取缓存
  188.         RMapCache<Object, Object> map = RedisUtils.getClient().getMapCache(name);
  189.         //2-有过期时间传3个参数 ，config 里面有  ttl、maxIdleTime、maxSize
  190.         Cache cache = new RedissonCache(map, config, allowNullValues);
  191.         // 3-事务提交 之后执行
  192.         if (transactionAware) {
  193.             cache = new TransactionAwareCacheDecorator(cache);
  194.         }
  195.         //4-不存在就添加
  196.         Cache oldCache = instanceMap.putIfAbsent(name, cache);
  197.         if (oldCache != null) {
  198.             cache = oldCache;
  199.         } else {
  200.             map.setMaxSize(config.getMaxSize());
  201.         }
  202.         return cache;
  203.     }
  204.  
  205. //返回不可修改的集合
  206.     @Override
  207.     public Collection<String> getCacheNames() {
  208.         return Collections.unmodifiableSet(configMap.keySet());
  209.     }
  210.  
  211.  
  212. }
3-@Cacheable

以下Cacheable几个属性分别演示了如何使用：（支持SPEL表达式）

  • cacheNames 
  • key 
  • sync
  • condition 
  • sync 
  1. /**
  2.      * <简述>cacheNames： 指定名称 可以是数组
  3.      *        key： 支持spel表达式，可以获取参数
  4.      * @author syf
  5.      * @date 2024/5/7 11:03
  6.      * @param id
  7.      * @param pageQuery
  8.      * @return java.lang.String
  9.      */
  10.     @Cacheable(cacheNames = "cache1", key = "#id + '_cache' + #pageQuery.pageNum")
  11.     @GetMapping("test1")
  12.     public  String test1(String id, PageQuery pageQuery){
  13.  
  14.         return "ok";
  15.     }
  16.  
  17.     /**
  18.      * <简述> condition :符合条件进行缓存
  19.      *        #id != null ：表示传入 id不为空才会缓存进入redis，id为空则不缓存
  20.      * @author syf
  21.      * @date 2024/5/7 11:03
  22.      * @param id
  23.      * @return java.lang.String
  24.      */
  25.     @Cacheable(cacheNames = "cache2", key = "#id + '_cache'" , condition = "#id != null")
  26.     @GetMapping("test2")
  27.     public  String test2(String id){
  28.  
  29.         return "ok";
  30.     }
  31.  
  32.     /**
  33.      * <简述> unless 符合条件不缓存
  34.      *        #result == null ：接口返回结果为空则不进行缓存
  35.      * @author syf
  36.      * @date 2024/5/7 11:03
  37.      * @param id
  38.      * @return java.lang.String
  39.      */
  40.     @Cacheable(cacheNames = "cache3", key = "#id + '_cache'" , unless = "#result == null")
  41.     @GetMapping("test3")
  42.     public  String test3(String id){
  43.         return null;
  44.     }
  45.  
  46.     /**
  47.      * <简述> sync = true
  48.      *       同步阻塞：同时进来多个请求， 等待前面调用返回并缓存，才能回进入下个请求
  49.      *       作用：防止缓存积存
  50.      * @author syf
  51.      * @date 2024/5/7 11:03
  52.      * @param id
  53.      * @return java.lang.String
  54.      */
  55.     @Cacheable(cacheNames = "cache4", key = "#id + '_cache'", sync = true)
  56.     @GetMapping("test4")
  57.     public  String test4(String id){
  58.         return null;
  59.     }
  60.  
  61.     /**
  62.      * <简述> 获取类中参数
  63.      *         比较繁琐，一般是在实现类中传递登录参数，用spel获取
  64.      * @author syf
  65.      * @date 2024/5/7 11:03
  66.      * @return java.lang.String
  67.      */
  68.     @Cacheable(cacheNames = "cache5", key = "T(com.ruoyi.common.helper.LoginHelper).getLoginUser().getLoginId()")
  69.     @GetMapping("test5")
  70.     public  String test5(){
  71.         LoginUser loginUser = LoginHelper.getLoginUser();
  72.         return "ok";
  73.     }
4- @CachePut

缓存更新

执行该方法，并将执行结果以键值对的形式存入指定的缓存中。

  1.   /**
  2.      * <简述> 结果不为空进行更新
  3.      * @author syf
  4.      * @date 2024/5/7 11:03
  5.      * @param id
  6.      * @return java.lang.String
  7.      */
  8.     @CachePut(cacheNames = "cache2", key = "#id + '_cache'" , condition = "#result != null")
  9.     @GetMapping("test2")
  10.     public  String test2(String id){
  11.         boolean flag = doUpdate();
  12.         return flag  ? "ok" : null;
  13.     }
5- @CacheEvict

缓存删除

执行该方法，并将缓存中结果删除。

allEntries  删除所有cacheNames = "cache4"，下面缓存
beforeInvocation  默认false，方法执行之后有异常不执行。true：方法执行之后有异常，也执行
  1.   /**
  2.      * <简述> 删除缓存
  3.      * @author syf
  4.      * @date 2024/5/7 11:03
  5.      * @param id
  6.      * @return java.lang.String
  7.      */
  8.     @CacheEvict(cacheNames = "cache4", key = "#id + '_cache'")
  9.     @GetMapping("test7")
  10.     public  String test7(String id){
  11.         boolean flag = doDelete();
  12.         return flag  ? "ok" : null;
  13.     }
  14.  
  15.  
  16.   /**
  17.      * <简述> 删除所有缓存
  18.      * @author syf
  19.      * @date 2024/5/7 11:03
  20.      * @param id
  21.      * @return java.lang.String
  22.      */
  23.     @CacheEvict(cacheNames = "cache4", allEntries = true)
  24.     @GetMapping("test8")
  25.     public  String test8(String id){
  26.         return null;
  27.     }
  28.  
  29.    /**
  30.      * <简述> beforeInvocation 无论是否有异常都执行操作
  31.      * @author syf
  32.      * @date 2024/5/7 11:03
  33.      * @param id
  34.      * @return java.lang.String
  35.      */
  36.     @CacheEvict(cacheNames = "cache4", beforeInvocation = true)
  37.     @GetMapping("test9")
  38.     public  String test9(String id){
  39.         return null;
  40.     }
 6-@Caching：

指定多个Spring Cache相关的注解

三个属性：cacheable、put和evict，分别用于指定@Cacheable、@CachePut和@CacheEvict。

  1.     @Caching(
  2.             cacheable = {@Cacheable(value = "uer1",key = "#userName")},
  3.             put = {@CachePut(value = "uer1", key = "#result.id"),
  4.                     @CachePut(value = "uer1", key = "#result.age")
  5.             }
  6.     )
  7.     public User getStuByStr(String userName) {
  8.       
  9.         List<User> users= listMapper.selectByList(studentExample);
  10.         return Optional.ofNullable(users).orElse(null).get(0);
  11.     }

四、若依框架中缓存使用（自定义SpringCache 源码解读）、

CacheNames 缓存名称配置类：
类位置：com.ruoyi.common.constant.CacheNames
key 格式为： cacheNames#ttl#maxIdleTime#maxSize
/**
 * 缓存组名称常量
 * <p>
 * key 格式为 cacheNames#ttl#maxIdleTime#maxSize
 * <p>
 * ttl 过期时间 如果设置为0则不过期 默认为0
 * maxIdleTime 最大空闲时间 根据LRU算法清理空闲数据 如果设置为0则不检测 默认为0   （超过maxIdleTime LRU算法自动清理）
 * maxSize 组最大长度 根据LRU算法清理溢出数据 如果设置为0则无限长 默认为0
 * <p>
 * 例子: test#60s、test#0#60s、test#0#1m#1000、test#1h#0#500
 */

PlusSpringCacheManager 实现 CacheManager 接口，重写 getCache 方法，

就是配置了  ：ttl、maxIdleTime、maxSize  三个参数吗，如下：

  1. @Override
  2.     public Cache getCache(String name) {
  3.         // 重写 cacheName 支持多参数
  4.         /**
  5.          * 1-演示案例   ：  String DEMO_CACHE = "demo:cache#60s#10m#20";
  6.          */
  7.         String[] array = StringUtils.delimitedListToStringArray(name, "#");
  8.         name = array[0];
  9.  
  10.         Cache cache = instanceMap.get(name);
  11.         if (cache != null) {
  12.             return cache;
  13.         }
  14.         //2- dynamic=false 不会动态生成
  15.         if (!dynamic) {
  16.             //return cache;
  17.             return null;
  18.         }
  19.  
  20.         CacheConfig config = configMap.get(name);
  21.         if (config == null) {
  22.             config = createDefaultConfig();
  23.             configMap.put(name, config);
  24.         }
  25.         
  26.         //setTTL
  27.         if (array.length > 1) {
  28.             config.setTTL(DurationStyle.detectAndParse(array[1]).toMillis());
  29.         }
  30.         //setMaxIdleTime
  31.         if (array.length > 2) {
  32.             config.setMaxIdleTime(DurationStyle.detectAndParse(array[2]).toMillis());
  33.         }
  34.         //setMaxSize
  35.         if (array.length > 3) {
  36.             config.setMaxSize(Integer.parseInt(array[3]));
  37.         }
  38.  
  39.         if (config.getMaxIdleTime() == 0 && config.getTTL() == 0 && config.getMaxSize() == 0) {
  40.             return createMap(name, config);
  41.         }
  42.  
  43.         return createMapCache(name, config);
  44.     }

 重点：下面就是PlusSpringCacheManager ，操作缓存的地方

上面调用了：createMap、createMapCache 2个方法对比:

1-逻辑：

createMapCache 多了个 setMaxSize判断，其他都一样

  1. else {
  2.             map.setMaxSize(config.getMaxSize());
  3.         }

2- 返回类型 

createMap 返回  RMap

createMapCache 返回 RMapCache

对比： RMapCache 继承了 RMap 多了对于ttl、maxIdleTime、maxSize 的配置

相同 ：都是基于redisson，缓存到redis

  1. private Cache createMap(String name, CacheConfig config) {
  2.         //1-获取缓存
  3.         RMap<Object, Object> map = RedisUtils.getClient().getMap(name);
  4.         //2-没有过期时间传2个参数
  5.         Cache cache = new RedissonCache(map, allowNullValues);
  6.         // 3-事务提交 之后执行
  7.         if (transactionAware) {
  8.             cache = new TransactionAwareCacheDecorator(cache);
  9.         }
  10.         //4-不存在就添加
  11.         Cache oldCache = instanceMap.putIfAbsent(name, cache);
  12.         if (oldCache != null) {
  13.             cache = oldCache;
  14.         }
  15.         return cache;
  16.     }
  17.  
  18.     private Cache createMapCache(String name, CacheConfig config) {
  19.         //1-获取缓存
  20.         RMapCache<Object, Object> map = RedisUtils.getClient().getMapCache(name);
  21.         //2-有过期时间传3个参数 ，config 里面有  ttl、maxIdleTime、maxSize
  22.         Cache cache = new RedissonCache(map, config, allowNullValues);
  23.         // 3-事务提交 之后执行
  24.         if (transactionAware) {
  25.             cache = new TransactionAwareCacheDecorator(cache);
  26.         }
  27.         //4-不存在就添加
  28.         Cache oldCache = instanceMap.putIfAbsent(name, cache);
  29.         if (oldCache != null) {
  30.             cache = oldCache;
  31.         } else {
  32.             map.setMaxSize(config.getMaxSize());
  33.         }
  34.         return cache;
  35.     }

 上面  TransactionAwareCacheDecorator：

所执行的put操作，是在事务提交之后执行

  1.  public void put(final Object key, @Nullable final Object value) {
  2.         if (TransactionSynchronizationManager.isSynchronizationActive()) {
  3.             TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
  4.                 public void afterCommit() {
  5.                     TransactionAwareCacheDecorator.this.targetCache.put(key, value);
  6.                 }
  7.             });
  8.         } else {
  9.             this.targetCache.put(key, value);
  10.         }
  11.  
  12.     }

 五、缓存工具类

private static final CacheManager CACHE_MANAGER = SpringUtils.getBean(CacheManager.class);

主要是获取 CacheManager 接口，提供对缓存CRUD操作 ：

  1. public interface CacheManager {
  2.     @Nullable
  3.     Cache getCache(String name);
  4.  
  5.     Collection<String> getCacheNames();
  6. }
 

 

  1. package com.ruoyi.common.utils.redis;
  2.  
  3. import com.ruoyi.common.utils.spring.SpringUtils;
  4. import lombok.AccessLevel;
  5. import lombok.NoArgsConstructor;
  6. import org.redisson.api.RMap;
  7. import org.springframework.cache.Cache;
  8. import org.springframework.cache.CacheManager;
  9.  
  10. import java.util.Set;
  11.  
  12. /**
  13.  * 缓存操作工具类 {@link }
  14.  *
  15.  * @author Michelle.Chung
  16.  * @date 2022/8/13
  17.  */
  18. @NoArgsConstructor(access = AccessLevel.PRIVATE)
  19. @SuppressWarnings(value = {"unchecked"})
  20. public class CacheUtils {
  21.  
  22.     private static final CacheManager CACHE_MANAGER = SpringUtils.getBean(CacheManager.class);
  23.  
  24.     /**
  25.      * 获取缓存组内所有的KEY
  26.      *
  27.      * @param cacheNames 缓存组名称
  28.      */
  29.     public static Set<Object> keys(String cacheNames) {
  30.         RMap<Object, Object> rmap = (RMap<Object, Object>) CACHE_MANAGER.getCache(cacheNames).getNativeCache();
  31.         return rmap.keySet();
  32.     }
  33.  
  34.     /**
  35.      * 获取缓存值
  36.      *
  37.      * @param cacheNames 缓存组名称
  38.      * @param key        缓存key
  39.      */
  40.     public static <T> T get(String cacheNames, Object key) {
  41.         Cache.ValueWrapper wrapper = CACHE_MANAGER.getCache(cacheNames).get(key);
  42.         return wrapper != null ? (T) wrapper.get() : null;
  43.     }
  44.  
  45.     /**
  46.      * 保存缓存值
  47.      *
  48.      * @param cacheNames 缓存组名称
  49.      * @param key        缓存key
  50.      * @param value      缓存值
  51.      */
  52.     public static void put(String cacheNames, Object key, Object value) {
  53.         CACHE_MANAGER.getCache(cacheNames).put(key, value);
  54.     }
  55.  
  56.     /**
  57.      * 删除缓存值
  58.      *
  59.      * @param cacheNames 缓存组名称
  60.      * @param key        缓存key
  61.      */
  62.     public static void evict(String cacheNames, Object key) {
  63.         CACHE_MANAGER.getCache(cacheNames).evict(key);
  64.     }
  65.  
  66.     /**
  67.      * 清空缓存值
  68.      *
  69.      * @param cacheNames 缓存组名称
  70.      */
  71.     public static void clear(String cacheNames) {
  72.         CACHE_MANAGER.getCache(cacheNames).clear();
  73.     }
  74.  
  75. }
 

 
 

六、缓存雪崩
 

 
 
概念：
 
 
        缓存集中过期失效（大量key失效）。所有请求直接查询数据库了，而对数据库造成巨大压力，严重可能的会导致数据库宕机。从而形成一系列连锁反应，造成整个系统崩溃。
 

 

 
 
解决：
 
 
  • 1、实现Redis的高可用、改为主从+哨兵集群模式
  • 2、允许的话，也可以设置热点数据不过期（或者不同业务设置不同过期时间 例子: test#60s、test#0#60s、test#0#1m#1000、test#1h#0#500）
  • 3、开启Redis的RDB+AOF组合持久化策略，以便快速恢复
 

 

 
 

七、缓存击穿 
 

 
 
概念：
 
 
缓存击穿指的是热点key在某个特殊的场景时间内恰好失效了，恰好有大量并发请求过来了，导致大量的请求都打到数据库上，造成数据库极大的压力，这就是缓存击穿问题。
 
 
 
 
对比缓存雪崩：        
 
 
        雪崩大量key失效，击穿 某几个热点key失效
 

 

 
 
 解决：
 
 
互斥锁方案，保证同一时间只有一个业务线程去数据库获取数据填充到Redis中，更新缓存，未能获取互斥锁的请求，需要等待锁释放后重新读取缓存。获取成功，直接返回结果；获取失败，则再次尝试获取锁，重复上述流程。
 

 

 
 
若依框架中的实现：简单举例
 
 
        sync = true  同步阻塞：同时进来多个请求， 等待前面调用返回并缓存，才能回进入下个请求
   
 

 

  1.    /**
  2.      * <简述> sync = true
  3.      *       同步阻塞：同时进来多个请求， 等待前面调用返回并缓存，才能回进入下个请求
  4.      *   
  5.      * @author syf
  6.      * @date 2024/5/7 11:03
  7.      * @param id
  8.      * @return java.lang.String
  9.      */
  10.     @Cacheable(cacheNames = "cache4", key = "#id + '_cache'", sync = true)
  11.     @GetMapping("test4")
  12.     public  String test4(String id){
  13.         return null;
  14.     }
 

四、缓存穿透
 

 
 
概念：
 
 
用户在不断访问一个在缓存和数据库中都没有的数据，缓存无法命中,从而导致一直请求数据库,流量过大就会导致数据库的崩溃，这就是缓存穿透问题。
 

 

 解决：
 

 
 
  • 接口层增加校验，如用户鉴权等；
  • 使用布隆过滤器快速判断数据是否存在，避免通过查询数据库来判断数据是否存在；
  • 将空结果(NULL)或默认查询结果存入到缓存中，并设置值过期时间。
 

 

布隆过滤器可以参考文章：
 

redis中布隆过滤器使用详解_redis布隆过滤器使用-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/w1014074794/article/details/129750865 

                

        
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/羊村懒王/article/detail/568370
推荐阅读
相关标签
Copyright ©  2003-2013 www.wpsshop.cn  版权所有，并保留所有权利。

  
闽ICP备14008679号