在我们使用redis时，也会存在一些问题，导致请求直接打到数据库上，导致数据库挂掉。下面我们来说说这些问题及解决方案。

1、缓存穿透

1.1 场景

一个请求进来后，先去redis进行查找，redis存在，则返回，不存在则查询数据数据库，数据存在则放到redis中，但是key对应的数据有可能在数据库中也不存在，每次从缓存中获取不到数据，请求就会压到数据库，可能导致压垮数据库。

1.2 解决方案

1.2.1 对空值缓存

即将不存在的数据的值设置成null，进行缓存，并设置过期时间，到时间后自动删除缓存（时间不要超过5分钟）

实现代码：

java复制代码    private static final Logger log = LoggerFactory.getLogger(SolveBreakDown.class);

    @Autowired
    private RedisTemplate<String,String> redisTemplate;
    private static final Map<String,String> DATA_MAP = new HashMap<>(1);
    static {
        DATA_MAP.put("key","模拟数据库查询数据");
    };

    @GetMapping("/solve.do")
    public ResultUtil<String> solveBreakDown(){
        String val = redisTemplate.opsForValue().get("key");
        if (StringUtils.isBlank(val)){
            log.info("模拟查询数据库");
            //模拟数据库查询
            String selVal = DATA_MAP.get("key");
            redisTemplate.opsForValue().set("key",selVal,1L, TimeUnit.MINUTES);
        }
        return ResultUtil.success(val);
    }

执行结果：

第一次执行时控制台打印日志:

一分钟内再次访问时，不会在进入模拟数据库查询数据这段代码。

1.2.2 设置访问白名单

在redis中bitmaps中保存可以访问的名单，名单id作为bitmaps的偏移量，每次访问都和bitmaps中的id进行比较，id不存在时进行拦截，不允许访问。

实现步骤：

1.2.2.1 加载白名单

模拟将数据库数据加载到redis中。

java复制代码@Component
public class RedisWhiteNameLoad implements CommandLineRunner {
    private static final List<String> WHITE_NAMES = Arrays.asList("10000001","10000002");
    private static final Logger log = LoggerFactory.getLogger(RedisWhiteNameLoad.class);

    @Autowired
    private RedisTemplate redisTemplate;


    @Override
    public void run(String... args) throws Exception {
        WHITE_NAMES.forEach(name -> {
            log.info("加载白名单");
            redisTemplate.opsForValue().setBit("white_"+name,1,true);
        });
    }
}

1.2.2.2 校验

java复制代码/**
 * @author: jiangjs
 * @description: redis缓存击穿解决方案
 * @date: 2023/5/25 15:29
 **/
@RestController
@RequestMapping("/breakdown")
public class SolveBreakDown {

    private static final Logger log = LoggerFactory.getLogger(SolveBreakDown.class);

    @Autowired
    private RedisTemplate<String,String> redisTemplate;

    @GetMapping("/white.do/{id}")
    public ResultUtil<String> whiteName(@PathVariable("id") String id){
        Boolean bit = redisTemplate.opsForValue().getBit(id, 1);
        String result = bit ? "白名单，可以继续访问" : "不符合，不能访问";
        return ResultUtil.success(result);
    }
}

执行结果:

1.2.3 布隆过滤器

布隆过滤器，用于检测一个元素是否在一个集合，优点是空间效率和查询时间远超一般的算法，缺点是有一定的误识别率和删除困难。 （存在可能存在，不存在一定不存在）

将所有可能存在的数据哈希到一个足够大的bitmaps中，一个一定不存在的数据会被这个bitmaps拦截掉，从而避免对底层存储系统的查询压力。

1.2.4 实时监控

当发现redis的命中率开始急速降低，需要排查访问对象和访问的数据，和运维人员配置，可以设置黑名单限制其提供服务。

2、缓存击穿

2.1 场景

redis中某个热点key过期了，此时大量请求同时进行访问，未获取到缓存数据，这些请求全部打到DB上，导致数据库瞬间压力大增，可能打垮数据库。

2.2 解决方案

2.2.1 预先设置热门数据，适时调整过期时间

在redis高峰之前，把一些热门数据提前存入到redis里面，对缓存中的这些热门数据进行监控，试试调整过期时间。

2.2.1.1 获取热门数据，设置过期时间

java复制代码    /**
     * @author: jiangjs
     * @description: 设置热门数据
     * @date: 2023/5/29 11:13
     **/
    @Component
    public class HotData implements CommandLineRunner {
        private static final Logger log = LoggerFactory.getLogger(HotData.class);
        @Autowired
        private RedisTemplate<String,String> redisTemplate;

        @Override
        public void run(String... args) throws Exception {
            //RedisData.DATA_MAP是设置的模拟数据，读者自行设置
            Map<String, String> dataMap = RedisData.DATA_MAP;
            dataMap.forEach((k,v) ->{
                double random = Math.ceil(10 * Math.random());
                long outTime = 10L + new Double(random).longValue();
                log.info("用户："+k+"，过期时间："+outTime);
                redisTemplate.opsForValue().set(k,v,outTime, TimeUnit.SECONDS);
            });
        }
    }

2.2.1.2 监控数据，过期时重新设置过期时间

1、redis支持监听过期时间

redis默认是关闭监听过期时间的，因此需要进行启动。

命令 ： config set notify-keyspace-events Ex

或直接在redis.conf中添加：notify-keyspace-events "Ex"

2、设置监听

java复制代码    /**
     * @author: jiangjs
     * @description: redis配置类
     * @date: 2023/4/7 11:16
     **/
    @Configuration
    public class RedisConfig {
        
        @Bean
        public RedisMessageListenerContainer listenerContainer(RedisConnectionFactory factory){
            RedisMessageListenerContainer listenerContainer = new RedisMessageListenerContainer();
            listenerContainer.setConnectionFactory(factory);
            return listenerContainer;
        }
    }

3、重新设置过期时间

集成
KeyExpirationEventMessageListener，获取过期的key，重新设置过期时间

java复制代码    /**
     * @author: jiangjs
     * @description:
     * @date: 2023/5/29 15:24
     **/
    @Component
    public class RedisKeyExpirationListener extends KeyExpirationEventMessageListener {

        private final static Logger log = LoggerFactory.getLogger(RedisKeyExpirationListener.class);
        @Autowired
        private RedisTemplate<String,String> redisTemplate;
        
        public RedisKeyExpirationListener(RedisMessageListenerContainer listenerContainer) {
            super(listenerContainer);
        }

        @Override
        public void onMessage(Message message, byte[] pattern) {
            String key = message.toString();
            log.info("key：" + key + "过期，重新加载数据，设置过期时间");
            String val = RedisData.DATA_MAP.get(key);
            double random = Math.ceil(10 * Math.random());
            long outTime = 10L + new Double(random).longValue();
            log.info("设置用户："+key+"，过期时间："+outTime);
            redisTemplate.opsForValue().set(key,val,outTime, TimeUnit.SECONDS);
            super.onMessage(message, pattern);
        }
    }

执行结果：

2.2.2 使用锁

缓存中拿不到数据后，此时不能立即去数据库查询，而是去获取分布式锁，拿到锁后再去数据库中查询数据，拿不到锁线程休眠一段时间后再重试整个获取数据的方法。

2.2.2.1 创建锁工具

java复制代码    /**
     * @author: jiangjs
     * @description:
     * @date: 2023/5/31 9:33
     **/
    public class Locked {
        private final RedisTemplate<String,String> redisTemplate;

        public Locked(RedisTemplate<String,String> redisTemplate){
            this.redisTemplate = redisTemplate;
        }

        private final static String HOT_KEY_LOCKED = "locked_hot_key";
        /**
         * 获取锁
         * @return 返回加锁状态
         */
        public boolean getLock(){
            Boolean absent = redisTemplate.opsForValue().setIfAbsent(HOT_KEY_LOCKED, "locking", 30L, TimeUnit.SECONDS);
            return Objects.nonNull(absent) ? absent : false;
        }

        /**
         * 释放锁
         */
        public void releaseLock(){
            redisTemplate.delete(HOT_KEY_LOCKED);
        }
    }

2.2.2.2 获取锁，查询数据

先获取锁，如果获取失败则过10s后再继续。

java复制代码    public ResultUtil<String> lockedData(@PathVariable("key") String key){
            String val = redisTemplate.opsForValue().get(key);
            if (StringUtils.isBlank(val)){
                Locked locked = new Locked(redisTemplate);
                while (true){
                    boolean lock = locked.getLock();
                    if (lock){
                        log.info("获取到锁，拿去数据......");
                        val = DATA_MAP.get(key);
                       // locked.releaseLock();
                        break;
                    } else {
                        try {
                            log.info("未获取到锁，10s后再试......");
                            Thread.sleep(10000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
            return ResultUtil.success(val);
        }

ResultUtil：是封装的统一返回数据类。

执行结果：

上述代码中，只是简单地加了锁，如果在分布式系统中，请使用分布式锁。

3、缓存雪崩

3.1 场景

redis中大量key集中过期，此时大量并发进行请求，缓存中没有数据，请求只能落到DB上去加载数据，导致DB击穿，服务崩溃

缓存雪崩与缓存击穿区别：前者是大量key过期，后者是某个key过期。

3.2 解决方案

3.2.1 多级缓存

nginx缓存 + redis缓存 + 其他缓存（ehcache等）

3.2.2 锁或队列

加锁或队列的方式来保证不会有大量的线程对数据库一次性进行读写，从而避免失效时大量的并发请求落到底层存储系统上，不适用高并发情况

3.3.3 监控缓存过期，提前更新

监控缓存，发现缓存快过期时，提前对缓存更新。可以参见：缓存击穿中的【2.2.1】解决方案

3.3.4 错开缓存失效时间

即将key的过期时间设置成不同时间段，避免同一时间失效，例如在失效时间上加上1-5分钟随机数

java复制代码    /**
     * @author: jiangjs
     * @description: 设置热门数据
     * @date: 2023/5/29 11:13
     **/
    @Component
    public class HotData implements CommandLineRunner {
        private static final Logger log = LoggerFactory.getLogger(HotData.class);
        @Autowired
        private RedisTemplate<String,String> redisTemplate;

        @Override
        public void run(String... args) throws Exception {
            //RedisData.DATA_MAP是设置的模拟数据，读者自行设置
            Map<String, String> dataMap = RedisData.DATA_MAP;
            dataMap.forEach((k,v) ->{
                double random = Math.ceil(10 * Math.random());
                long outTime = 10L + new Double(random).longValue();
                log.info("用户："+k+"，过期时间："+outTime);
                redisTemplate.opsForValue().set(k,v,outTime, TimeUnit.SECONDS);
            });
        }
    }

上述就是我总结redis应用问题的解决方案，希望对大家工作中有所帮助。后期我也会补上布隆过滤器解决方案，谢谢！