一、什么是缓存穿透、缓存击穿、缓存雪崩

1、为啥使用缓存？

在程序内部使用缓存，将经常使用的数据存储在缓存中，可以减少对数据库的频繁访问，从而提高系统的响应速度和性能。缓存可以将数据保存在内存中，读取速度更快，能够大大缩短数据访问的时间，提升用户体验。
缓存不仅可以提高系统的性能和吞吐量，还可以提高系统的可靠性和稳定性。还可以减少网络传输的负载，特别是在分布式系统中。能够节省网络带宽和服务器的资源消耗。
使用缓存可以优化系统的性能、提高响应速度、降低数据库负载、节省网络传输和服务器资源，从而提升用户体验和系统的可靠性
其实就是以空间换时间

2、名词解析

词语解析	说明	redis中是否存在	数据库中是否存在
缓存穿透	查询一个不存在的数据，缓存中没有数据直接穿透缓存，查询数据库，造成数据库的压力。	不存在	不存在
缓存击穿	缓存中的某个热点数据过期，大量的并发请求访问这个数据。导致请求在瞬间直接请求数据库，数据库压力过大甚至崩溃。	不存在	存在
缓存雪崩	指在同一时段大量的缓存失效，导致数据查询直接打到数据库，可能会使数据库崩溃	不存在	存在

3、原因分析

词语解析	可能的原因
缓存穿透	被攻击。小可爱通过构造恶意请求，使得缓存层无法命中任何数据
缓存击穿	缓存中的热点数据设置了过期时间，数据失效了
缓存雪崩	大量的数据在同一时间失效

4、缓存穿透

4.1、缓存穿透示意图

在这里插入图片描述
如上图，小可爱发送一个亿的请求，因为数据本身不存在，如果逻辑没有处理好。一亿的请求都会命中数据库。那该怎么解决嘞？

4.2、解决方案

4.2.1、缓存空对象

判断数据库查询结果

1、存在，将数据缓存起来[key,结果]

2、不存在，将空对象一般是null或者空数组[]缓存起来[key,null]或[key,[]]

下面的代码，如果ID在数据库中不存在，则直接查询数据库，返回的是空数组，后续再查询的话，redis认为有数据，有效解决缓存穿透

public DictBO queryDictById(Long id) {
    DictBO dictBO = redisUtil.get(String.valueOf(id));
    if(!ObjectUtils.isEmpty(dictBO)){
        return dictBO;
    }else{
        dictBO = this.getById(id);
        redisUtil.setEx(String.valueOf(dictBO.getId()), dictBO, Duration.ofHours(1L));
        return dictBO;
    }
}

4.2.1.1、优点

实现简单

4.2.1.2、缺点

内存消耗（一亿的数据量还是挺大的），因此要设置过期时间TTL

4.2.2、布隆过滤器

4.2.2.1、布隆过滤器示例代码

package com.toto.redis.filter;

import java.util.BitSet;

/**
 * @Description: MyBloomFilter
 * @Package: com.toto.redis.filter
 * @Author gufanbiao
 * @CreateTime 2024-06-21 21:06
 */
public class MyBloomFilter {
    /** 一个长度为10 亿的比特位 */
    private static final int DEFAULT_SIZE = 256 << 22;
    /** 为了降低错误率，使用加法hash算法，所以定义一个8个元素的质数数组 */
    private static final int[] seeds = {3, 5, 7, 11, 13, 31, 37, 61};
    /** 相当于构建 8 个不同的hash算法 */
    private static HashFunction[] functions = new HashFunction[seeds.length];
    /** 初始化布隆过滤器的 bitmap */
    private static BitSet bitset = new BitSet(DEFAULT_SIZE);

    /**
     * 添加数据
     * @param value 需要加入的值
     */
    public static void add(String value) {
        if (value != null) {
            for (HashFunction f : functions) {
                //计算 hash 值并修改 bitmap 中相应位置为 true
                bitset.set(f.hash(value), true);
            }
        }
    }

    /**
     * 判断相应元素是否存在
     * @param value 需要判断的元素
     * @return 结果
     */
    public static boolean contains(String value) {
        if (value == null) {
            return false;
        }
        boolean ret = true;
        for (HashFunction f : functions) {
            ret = bitset.get(f.hash(value));
            //一个 hash 函数返回 false 则跳出循环
            if (!ret) {
                break;
            }
        }
        return ret;
    }

    public static void main(String[] args) {
        for (int i = 0; i < seeds.length; i++) {
            functions[i] = new HashFunction(DEFAULT_SIZE, seeds[i]);
        }
        // 添加1亿数据
        for (int i = 0; i < 100000000; i++) {
            add(String.valueOf(i));
        }
        String id = "123456789";
        add(id);
        System.out.println(contains(id));   // true
        System.out.println("" + contains("234567890"));  //false
    }
}

class HashFunction {
    private int size;
    private int seed;
    public HashFunction(int size, int seed) {
        this.size = size;
        this.seed = seed;
    }
    public int hash(String value) {
        int result = 0;
        int len = value.length();
        for (int i = 0; i < len; i++) {
            result = seed * result + value.charAt(i);
        }
        int r = (size - 1) & result;
        return (size - 1) & result;
    }
}

4.2.2.2、布隆过滤器示例代码使用

相当于是在redis前加了一层过滤
在这里插入图片描述

public DictBO queryDictById(Long id) {
	// 使用布隆过滤器
    boolean contains = MyBloomFilter.contains(String.valueOf(id));
    if(!contains){
        return null;
    }
    DictBO dictBO = redisUtil.get(String.valueOf(id));
    if(!ObjectUtils.isEmpty(dictBO)){
        return dictBO;
    }else{
        dictBO = this.getById(id);
        redisUtil.setEx(String.valueOf(dictBO.getId()), dictBO, Duration.ofHours(1L));
        return dictBO;
    }
}