SpringBoot中的缓存穿透、击穿、雪崩解决方案

添加Redis依赖

RedisTemplate底层使用lettuce的话，进行压力测试时，会抛内存溢出异常，因此去掉lettuce依赖，底层使用jedis连接Redis

       <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <version>2.4.1</version>
            <exclusions>
                <exclusion>
                    <groupId>io.lettuce</groupId>
                    <artifactId>lettuce-core</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.3.0</version>
        </dependency>

新建RedisTest测试类

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.util.StringUtils;

import java.util.Random;
import java.util.concurrent.TimeUnit;

/**
 * @author ZhaoBW
 * @version 1.0
 * @date 2021/1/24 16:39
 */
@SpringBootTest
public class RedisTest {

    @Autowired
    StringRedisTemplate redisTemplate;
}

1、缓存穿透

缓存穿透是指用户查询数据，在数据库没有，自然在缓存中也不会有。这样就导致用户查询的时候， 在缓存中找不到对应key的value，每次都要去数据库再查询一遍，然后返回空(相当于进行了两次 无用的查询)。这样请求就绕过缓存直接查数据库。

解决方案：缓存空值，如果一个查询返回的数据为空(不管是数据不存在，还是系统故障)我们仍然把这个空结果进行缓存，但它的过期时间会很短，最长不超过五分钟。 通过这个直接设置的默认值存放到缓存，这样第二次到缓冲中获取就有值了，而不会继续访问数据库。

新建redisTest1方法，解决缓存穿透

    /**
     * 缓存穿透
     */
    @Test
    void redisTest1(){
        ValueOperations<String, String> ops = redisTemplate.opsForValue();
        //1、从缓存中读取数据
        String s = ops.get("Jessie");
        if(StringUtils.isEmpty(s)){
            //2、模拟从数据库中读取数据
            String sFromDB = queryFromDB();
            if(StringUtils.isEmpty(sFromDB)){
                //库中没有此数据，存入一个空值,过期时间为5分钟
                ops.set("Jessie","",5, TimeUnit.MINUTES);
                //返回数据，我这里是测试方法，所以返回空，
                return;
            }else{
                ops.set("Jessie",sFromDB);
                return;
            }
        }
        //缓存中有数据，直接返回
        return;
    }

2、缓存雪崩

如果缓存集中在一段时间内失效，发生大量的缓存穿透，所有的查询都落在数据库上，造成了缓存雪崩。 由于原有缓存失效，新缓存未存储，期间所有原本应该访问缓存的请求都去查询数据库了，而对数据库CPU 和内存造成巨大压力，严重的会造成数据库宕机。

解决方案：设置不同的过期时间，让缓存失效的时间点尽量均匀。

    @Test
    void redisTest1(){
        ValueOperations<String, String> ops = redisTemplate.opsForValue();
        //1、从缓存中读取数据
        String s = ops.get("Jessie");
        if(StringUtils.isEmpty(s)){
            //2、模拟从数据库中读取数据
            String sFromDB = queryFromDB();
            if(StringUtils.isEmpty(sFromDB)){
                //库中没有此数据，解决缓存穿透问题,存入一个空值,过期时间为5分钟
                ops.set("Jessie","",5, TimeUnit.MINUTES);
                //返回数据，我这里是测试方法，所以返回空，
                return;
            }else{
                //将数据写入缓存，并设置一个随机的过期时间，解决缓存雪崩问题
                //生成5-15之间的一个随机数,设置缓存随机在5-15个小时内过期
                Random random = new Random();
                int randomNum = random.nextInt(10)+5;
                ops.set("Jessie",sFromDB,randomNum,TimeUnit.HOURS);
                return;
            }
        }
        //缓存中有数据，直接返回
        return;
    }

3、缓存击穿

缓存击穿是指缓存中没有但数据库中有的数据（一般是缓存时间到期），这时由于并发用户特别多，同时读缓存没读到数据，又同时去数据库去取数据，引起数据库压力瞬间增大，造成过大压力。

解决方案：加互斥锁，保证同一时刻，只能有一个线程去访问数据库。类似线程安全的懒汉单例模式实现。

    @Test
    void testRedis(){
        ValueOperations<String, String> ops = redisTemplate.opsForValue();
        //1、从缓存中读取数据
        String s = ops.get("Jessie");
        if(StringUtils.isEmpty(s)){
            //2、缓存中没有，读取数据库加锁
            synchronized (this){
                //获取到锁之后，第一个进来的线程，把数据存入缓存，后面得到锁的线程需要判断缓存中有没有数据
                // 避免缓存击穿时，大量请求访问数据库
                String sFormCache = ops.get("Jessie");
                if(!StringUtils.isEmpty(sFormCache)){
                    //缓存中有数据,直接返回数据，我这里是测试方法，就返回null了。
                    return ;
                }else{
                    //缓存中没有时，再去数据库中读取数据，模拟从数据库中读取数据
                    String sFromDB = queryFromDB();
                    if(StringUtils.isEmpty(sFromDB)){
                        //库中没有此数据，解决缓存穿透问题,存入一个空值,过期时间为5分钟
                        ops.set("Jessie","",5, TimeUnit.MINUTES);
                        return;
                    }else{
                        //将数据写入缓存，并设置一个随机的过期时间，避免缓存雪崩问题
                        //生成5-15之间的一个随机数,设置缓存随机在5-15个小时内过期
                        Random random = new Random();
                        int randomNum = random.nextInt(10)+5;
                        ops.set("Jessie",sFromDB,randomNum,TimeUnit.HOURS);
                        return;
                    }
                }
            }
        }
        return;
    }