Redis缓存穿透的几种解决方案

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
</dependency>

2.配置Redis参数

spring:
  data:
    redis:
      host: 127.0.0.1
      port: 6379
      password: 123456

3.配置布隆过滤器：

import org.redisson.api.RBloomFilter;
import org.redisson.api.RedissonClient;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 布隆过滤器配置
 */
@Configuration
public class RBloomFilterConfiguration {

    /**
     * 防止用户注册查询数据库的布隆过滤器
     */
    @Bean
    public RBloomFilter<String> userRegisterCachePenetrationBloomFilter(RedissonClient redissonClient) {
        RBloomFilter<String> cachePenetrationBloomFilter = redissonClient.getBloomFilter("userRegisterCachePenetrationBloomFilter");
        cachePenetrationBloomFilter.tryInit(10000000L, 0.001);
        return cachePenetrationBloomFilter;
    }
}

注意：

tryInit 有两个核心参数：

expectedInsertions：预估布隆过滤器存储的元素长度。
falseProbability：运行的误判率。

错误率越低，位数组越长，布隆过滤器的内存占用越大。

错误率越低，散列 Hash 函数越多，计算耗时较长。

4.使用：

4.1先注入：private final RBloomFilter<String> userRegisterCachePenetrationBloomFilter;

4.2

userRegisterCachePenetrationBloomFilter.contains(xxx) 这个判断元素是否存在布隆过滤器

userRegisterCachePenetrationBloomFilter.add(xxx) 把元素加入布隆过滤器

4.组合方案

上面的这些方案或多或少都会有些问题，应该用三者进行组合用来解决缓存穿透问题。如果说缓存不存在，那么就通过布隆过滤器进行初步筛选，然后判断是否存在缓存空值，如果存在直接返回失败。如果不存在缓存空值，使用锁机制避免多个相同请求同时访问数据库。最后，如果请求数据库为空，那么将为空的 Key 进行空对象值缓存。

1.当我们生成短链接的时候，因为完整短链接是唯一的，我们用布隆过滤器判断，不存在才生成。



    private String generateSuffix(ShortLinkCreateReqDTO shortLinkCreateReqDTO) {
        int count = 0;
        String shortUri;
        while (true) {
            if (count > 10) {
                throw new ServiceException("短链接创造频繁，请稍后再试！");
            }
            //加上当前毫秒数，减少重复可能
            shortUri = HashUtil.hashToBase62(shortLinkCreateReqDTO.getOriginUrl() + System.currentTimeMillis());
            if (!shortUriCreateCachePenetrationBloomFilter.contains(shortLinkCreateReqDTO.getDomain() + "/" + shortUri)) {
                break;
            }
            count++;
        }
        return shortUri;
    }

2.当上一步的布隆过滤器误判了，明明存在但判断不存在。当我们插入短链接的时候，去查一次数据库。如果存在数据，证明布隆过滤器误判。

        try {
            baseMapper.insert(shortLinkDO);
            shortLinkGotoMapper.insert(shortLinkGotoDO);
            //   basemapper的插入： 这个异常是 插入mysql 是 key重复了 因为布隆过滤器误判才会如此
            //    存在的 判断为 不存在
        } catch (DuplicateKeyException ex) {
            // TODO 布隆过滤器误判咋办
            // 那就去数据库查在判断一次
            ShortLinkDO ifExit = this.baseMapper.selectOne(Wrappers.lambdaQuery(ShortLinkDO.class)
                    .eq(ShortLinkDO::getFullShortUrl, full_short_link));
            if (ifExit != null) {
                log.warn("短链接：{} 重复入库", full_short_link);
                throw new ServiceException("短链接存在了！！");
            }

        }

3.成功插入之后，把完整短链接加入布隆过滤器。同时缓存预热，key为原始连接

        stringRedisTemplate.opsForValue().set(
                String.format(GOTO_SHORT_LINK_KEY,full_short_link),
                shortLinkCreateReqDTO.getOriginUrl(),
                LinkUtil.getLinCacheValidDate(shortLinkCreateReqDTO.getValidDate()),
                TimeUnit.MILLISECONDS
        );
        shortUriCreateCachePenetrationBloomFilter.add(full_short_link);

以上是插入一条短链接的判断大致流程

那么当我们高并发的访问短链接或者人为的去穿透的时候呢？

比如下面有人恶意请求毫秒级触发大量请求去一个插入的短链接

1.先从缓存中拿原始链接（这个访问当时是之前我们已经通过插入mysql时候，预热到缓存中的），拿到就跳转，（这里跳转不了）

2.布隆过滤器判断是否包含完整的短链接（明显没有，如果误判的话，逻辑下走）

3.这个要调回头再看，第一次明显不走

4.分布式锁，双检加锁策略。

5.因为数据本就不存在，所以shortLinkGotoDO == null，存入信息到，IS_NO_SHORK_LINK，对应了第3步

以上步骤，我们判断了布隆过滤器，查看了是否为空值，加了分布式锁。

6.一直向向下乃至释放锁是正常访问的流程。

    @SneakyThrows
    @Override
    public void restoreUrl(String shortUri, ServletRequest request, ServletResponse response) {
        String serverName = request.getServerName();
        String full_short_url = serverName + "/" + shortUri;
        //1.先从缓存中那 跳转的原始链接 拿到的话直接跳转
        String origin_url = stringRedisTemplate.opsForValue().get(String.format(GOTO_SHORT_LINK_KEY, full_short_url));
        if (StrUtil.isNotBlank(origin_url)) {
            HttpServletResponse response1 = (HttpServletResponse) response;
            response1.sendRedirect(origin_url);
            return;
        }
        // 判断布隆过滤器是否存在 完整短连接， 这个full_short_url 在添加短连接的时候就添加到布隆过滤器里面了
        // 这个避免了 穿透 乱输入的链接地址 PS : 误判的话，逻辑向下走 通过redis的路由表 在判断一次
        boolean contains = shortUriCreateCachePenetrationBloomFilter.contains(full_short_url);
        if(!contains) {
            ((HttpServletResponse) response).sendRedirect("/page/notfound");
            return;
        }
        //缓存的路由信息 存在
        String isNoShortGotoLink = stringRedisTemplate.opsForValue().get(String.format(GOTO_IS_NOLL_SHORT_LINK_KEY, full_short_url));
        if(StrUtil.isNotBlank(isNoShortGotoLink)) {
            ((HttpServletResponse) response).sendRedirect("/page/notfound");
            return;
        }
        //分布式锁
        RLock lock = redissonClient.getLock(String.format(LOCK_GOTO_SHORT_LINK_KEY, full_short_url));
        lock.lock();
        try {
            origin_url = stringRedisTemplate.opsForValue().get(String.format(GOTO_SHORT_LINK_KEY, full_short_url));
            if(StrUtil.isNotBlank(origin_url)) {
                HttpServletResponse response1 = (HttpServletResponse) response;
                response1.sendRedirect(origin_url);
                return;
            }
            //根据 full_short_url 查找路由表
            ShortLinkGotoDO shortLinkGotoDO = shortLinkGotoMapper.selectOne(Wrappers.lambdaQuery(ShortLinkGotoDO.class)
                    .eq(ShortLinkGotoDO::getFullShortUrl, full_short_url));
            if (shortLinkGotoDO == null) {
                //    这个旨在解决布隆过滤器误判
                stringRedisTemplate.opsForValue().set(String.format(GOTO_IS_NOLL_SHORT_LINK_KEY, full_short_url),"-",30, TimeUnit.MINUTES);
                ((HttpServletResponse) response).sendRedirect("/page/notfound");
                return;
            }
            //根据路由表的Gid 和 full_short_url 查找 shortLinkDO
            ShortLinkDO shortLinkDO = baseMapper.selectOne(Wrappers.lambdaQuery(ShortLinkDO.class)
                    .eq(ShortLinkDO::getGid, shortLinkGotoDO.getGid())
                    .eq(ShortLinkDO::getEnableStatus, 0)
                    .eq(ShortLinkDO::getDelFlag, 0)
                    .eq(ShortLinkDO::getFullShortUrl, shortLinkGotoDO.getFullShortUrl()));
            if (shortLinkDO != null) {
                //这是解决短链接 已经过期的问题
                if(shortLinkDO.getValidDate() !=null && shortLinkDO.getValidDate().before(new Date())) {
                stringRedisTemplate.opsForValue().set(String.format(GOTO_IS_NOLL_SHORT_LINK_KEY, full_short_url),"-",30, TimeUnit.MINUTES);
                ((HttpServletResponse) response).sendRedirect("/page/notfound");
                return;
                }
                stringRedisTemplate.opsForValue().set(
                        String.format(GOTO_SHORT_LINK_KEY, full_short_url),
                        shortLinkDO.getOriginUrl(),
                        LinkUtil.getLinCacheValidDate(shortLinkDO.getValidDate()),
                        TimeUnit.MILLISECONDS
                );
                HttpServletResponse response1 = (HttpServletResponse) response;
                response1.sendRedirect(shortLinkDO.getOriginUrl());
            }
        } finally {
            lock.unlock();
        }
    }

原文地址:https://blog.csdn.net/m0_66532138/article/details/136824211 本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：https://www.suanlizi.com/kf/1770390332232568832.html 如若内容造成侵权/违法违规/事实不符，请联系《酸梨子》网邮箱：1419361763@qq.com进行投诉反馈，一经查实，立即删除！

阅读全部