Redis缓存在项目中的使用升级

已于 2024-08-09 15:26:02 修改
阅读量997 收藏 10
点赞数 11
分类专栏： spring 文章标签： 缓存 redis spring boot
于 2024-08-09 15:25:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54925172/article/details/140890468
版权

对于redis在项目中的使用与介绍这里就不展开描述，与进行基本的代码构造了。

这里针对redis的代码使用进行介绍

一，最简单阶段（一）--简单使用redis缓存

思想：拿数据先从缓存中拿去，如果缓存中没有再从数据库获取。

package com.luojie.test.catchs;

import com.luojie.dao.mapper2.Mapper2;
import com.luojie.util.RedisServiceUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.concurrent.TimeUnit;

/**
 * 简单使用redis缓存
 */
@Component
@Slf4j
public class RedisCatch1 {

    @Autowired
    Mapper2 mapper2;

    @Autowired
    RedisServiceUtil redisUtil;
    public String test1() {
        // 先从redis中找数据，没有才去查数据库
        String value = redisUtil.get("uuid");
        if (StringUtils.isNotEmpty(value)) {
            return value;
        } else {
            String dbValue = mapper2.getuuid("uuid");
            log.info("get data form db dbValue:{}", dbValue);
            if (StringUtils.isNotEmpty(dbValue)) {
                // 缓存数据
                redisUtil.setWithExpire("uuid", dbValue, 3, TimeUnit.DAYS);
            }
            return dbValue;
        }
    }
}

缺点：

无法避免缓存穿透，缓存击穿，缓存雪崩，并发写入的问题。

简单介绍问题名词：

  • 缓存穿透： 多个线程同时请求一个缓存中没有的数据时，可能会导致多个线程同时去查询数据库，这会给数据库带来较大的负载。

  • 缓存雪崩： 当缓存中的某个热数据在同一时间失效时，大量请求会同时击中数据库，导致数据库压力骤增。

  • 缓存击穿： 当缓存中某个热数据失效的瞬间，大量请求直接击中数据库，导致数据库瞬间负载过大。

  • 并发写入： 多个线程同时执行redisUtil.set("key", dbValue);，可能会导致一些不必要的重复操作。

二，优化上一步（二）--解决redis缓存常见问题

思想：

1，空结果缓存：解决缓存穿透

2，设置（随机过期时间）：解决缓存雪崩

3，加锁：解决缓存击穿与并发写入问题

package com.luojie.test.catchs;

import com.luojie.dao.mapper2.Mapper2;
import com.luojie.util.RedisServiceUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.concurrent.TimeUnit;

/**
 * 简单使用redis缓存2
 */
@Component
@Slf4j
public class RedisCatch2 {

    @Autowired
    Mapper2 mapper2;

    @Autowired
    RedisServiceUtil redisUtil;

    public String test1() {
        // 先从redis中找数据，没有才去查数据库
        String value = redisUtil.get("uuid");
        if (StringUtils.isNotEmpty(value)) {
            return value;
        }
        synchronized (this) {
            // 双重检查，以防止在获取锁之后，缓存已经被其他线程更新
            value = redisUtil.get("uuid");
            if (StringUtils.isNotEmpty(value)) {
                return value;
            }
            // 缓存空结果的前提是该方法如果出错应抛出异常，而不是被catch后返回空
            String dbValue = mapper2.getuuid("uuid");
            log.info("get data form db dbValue:{}", dbValue);
            // 缓存数据
            redisUtil.setWithExpire("uuid", dbValue, 1 + (int) Math.ceil(Math.random() * 10), TimeUnit.DAYS);
            return dbValue;
        }

    }

}

缺点

锁的力度大，范围广。高并发环境下，可能重复获取锁

三，优化上一步（三）--使用最小粒度锁

思想：使用最小粒度锁。采用轮询的方式，避免锁被重复获取

package com.luojie.test.catchs;

import com.luojie.dao.mapper2.Mapper2;
import com.luojie.util.RedisServiceUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 简单使用redis缓存3
 */
@Component
@Slf4j
public class RedisCatch3 {

    @Autowired
    Mapper2 mapper2;

    @Autowired
    RedisServiceUtil redisUtil;

    Lock lock = new ReentrantLock(false);

    public String test1() throws InterruptedException {
        // 先从redis中找数据，没有才去查数据库
        String value = redisUtil.get("uuid");
        if (StringUtils.isNotEmpty(value)) {
            return value;
        }
        try {
            if (lock.tryLock(300, TimeUnit.MILLISECONDS)) {
                // 双重检查，以防止在获取锁之后，缓存已经被其他线程更新
                value = redisUtil.get("uuid");
                if (StringUtils.isNotEmpty(value)) {
                    return value;
                }
                // 缓存空结果的前提是该方法如果出错应抛出异常，而不是被catch后返回空
                String dbValue = mapper2.getuuid("uuid");
                log.info("get data form db dbValue:{}", dbValue);
                // 缓存数据
                redisUtil.setWithExpire("uuid", dbValue, 1 + (int) Math.ceil(Math.random() * 10), TimeUnit.DAYS);
                return dbValue;
            } else {
                // 如果未获取到锁，则等待一段时间再从缓存中获取数据
                Thread.sleep(100);
                return test1();
            }
        } finally {
            lock.unlock();
        }

    }

}

缺点：

  • 本地锁局限性： ReentrantLock 是 JVM 级别的锁，只能在单个应用实例内有效。如果应用部署在多个实例（比如微服务架构或分布式系统）中，本地锁无法保证全局唯一性。

  • 潜在的死锁风险： 在尝试获取锁和释放锁时，如果发生异常而未能正确释放锁，可能会导致死锁。

四，优化上一步（四）--使用分布式锁

思想：

在集群部署情况下保证同一时间只有一个请求能打到数据库获取数据。

package com.luojie.test.catchs;

import com.luojie.dao.mapper2.Mapper2;
import com.luojie.util.RedisServiceUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 简单使用redis缓存3
 */
@Component
@Slf4j
public class RedisCatch4 {

    @Autowired
    Mapper2 mapper2;

    @Autowired
    RedisServiceUtil redisUtil;

    public String test1() throws InterruptedException {
        // 先从redis中找数据，没有才去查数据库
        String value = redisUtil.get("uuid");
        if (StringUtils.isNotEmpty(value)) {
            return value;
        }
        try {
            if (redisUtil.setIfAbsent("lock", "doneLock")) {
                // 双重检查，以防止在获取锁之后，缓存已经被其他线程更新
                value = redisUtil.get("uuid");
                if (StringUtils.isNotEmpty(value)) {
                    return value;
                }
                // 缓存空结果的前提是该方法如果出错应抛出异常，而不是被catch后返回空
                String dbValue = mapper2.getuuid("uuid");
                log.info("get data form db dbValue:{}", dbValue);
                // 缓存数据
                redisUtil.setWithExpire("uuid", dbValue, 1 + (int) Math.ceil(Math.random() * 10), TimeUnit.DAYS);
                return dbValue;
            } else {
                // 如果未获取到锁，则等待一段时间再从缓存中获取数据
                Thread.sleep(100);
                // 自旋获取
                return test1();
            }
        } finally {
            // 删除锁
            redisUtil.delete("lock");
        }

    }

}

缺点：

若加锁成功但系统故障则会导致锁永久存在，进入死锁。

方法在未获取到锁时递归调用自身。如果长时间未获取到锁，这可能导致StackOverflowError。

五，优化上一步（五）--优化分布式锁

思想：

redis加锁增加超时时间已经独特vule设定--防止释放掉别人的锁

使用递归时增加次数循环次数判定

package com.luojie.test.catchs;

import com.luojie.dao.mapper2.Mapper2;
import com.luojie.util.RedisServiceUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.UUID;
import java.util.concurrent.TimeUnit;

/**
 * 简单使用redis缓存3
 */
@Component
@Slf4j
public class RedisCatch5 {

    @Autowired
    Mapper2 mapper2;

    @Autowired
    RedisServiceUtil redisUtil;

    private static final int MAX_RETRIES = 5;
    private static final long RETRY_DELAY_MS = 100;

    public String test1() throws InterruptedException {
        // 先从redis中找数据，没有才去查数据库
        String value = redisUtil.get("uuid");
        if (StringUtils.isNotEmpty(value)) {
            return value;
        }
        String uuid = UUID.randomUUID().toString();
        int retryCount = 0;
        boolean lockAcquired = false;
        // 循环代替迭代
        while (retryCount < MAX_RETRIES && !lockAcquired) {
            lockAcquired = redisUtil.setIfAbsentWithExpire("lock", uuid, 300, TimeUnit.SECONDS);
            if (!lockAcquired) {
                Thread.sleep(RETRY_DELAY_MS);
                ++retryCount;
            }
        }

        try {
            if (lockAcquired) {
                // 双重检查，以防止在获取锁之后，缓存已经被其他线程更新
                value = redisUtil.get("uuid");
                if (StringUtils.isNotEmpty(value)) {
                    return value;
                }
                // 缓存空结果的前提是该方法如果出错应抛出异常，而不是被catch后返回空
                String dbValue = mapper2.getuuid("uuid");
                log.info("get data form db dbValue:{}", dbValue);
                // 缓存数据
                redisUtil.setWithExpire("uuid", dbValue, 1 + (int) Math.ceil(Math.random() * 10), TimeUnit.DAYS);
                return dbValue;
            } else {
                // 如果未能获取到锁，重试从缓存获取数据
                return redisUtil.get("uuid");
            }
        } finally {
            // 获取锁值
            String lock = redisUtil.get("lock");
            if (StringUtils.isNotEmpty(lock) && lock.equals(uuid)) {
                // 删除锁
                redisUtil.delete("lock");
            }
        }
    }

}

缺点：

redis并没有跟服务进行脱钩，是强绑定的状态，当redis出现异常会导致服务也发生异常。

六，优化上一步（六） --最终 

思想：

对set，delete操作与主线程，主业务脱钩。使用多线程 + 监听器进行解耦操作

具体多线程 + 监听器的实现请参考：

SpringBoot使用Redis（事务异步add + 更新）_spring redis 异步处理-CSDN博客

成都被卷死的程序员
关注
专栏目录
使用Redis实现分布式缓存 （转载）
u011385246的博客
07-07 1245
分布式缓存描述： 分布式缓存重点是在分布式上，相信大家接触过的分布式有很多中，像分布式开发，分布式部署，分布式锁、事物、系统 等有很多。使我们对分布式本身就有一个很明确的认识，分布式就是有多个应用程序组成，可能分布在不同的服务器上，最终都是在为web端提供服务。 分布式缓存有以下几点优点：传统的单体应用架构因为用户的访问量的不高，缓存的存在大多数都是存储用户的信息，以及一些页面，大多数的操作都是直接和DB进行读写交互，这种架构简单，也称为简单架构， 传统的OA项目比如ERP,SCM,CRM等系统因为用户量不
「中间件系列二」redis缓存
qq_35789269的博客
12-05 1106
Redis(Remote Dictionary Server) 是一个使用 C 语言编写的，开源的（BSD许可）高性能非关系型（NoSQL）的键值对数据库。 Redis 可以存储键和五种不同类型的值之间的映射。键的类型只能为字符串，值支持五种数据类型：字符串、列表、集合、散列表、有序集合。 与传统数据库不同的是 Redis 的数据是存在内存中的，所以读写速度非常快，因此 redis 被广泛应用于缓存方向，每秒可以处理超过 10万次读写操作，是已知性能最快的Key-Value DB。另外，Redis...
redis在项目中的应用
墨浅
02-02 544
redis缓存在项目中的应用，jsonRedisTemplate、reidsCacheManager、cacheManager，spring缓存管理器
【Redis】缓存更新策略
qq_39921135的博客
08-05 1129
这三种都有可能出现线程不安全的问题，但是方案二相对来讲出现的可能性更低。就算方案二的特殊情况真的发生了，我们将来加上一个超时时间就行了，万一写了旧数据也没关系，过一段时间就会清除。先操作数据库，再删除缓存。内存淘汰超时剔除主动更新，具体如何选择，需要看业务需求：1、低一致性需求：使用Redis自带的内存淘汰机制，最多加一个超时更新2、高一致性需求：主动更新，并以超时剔除作为兜底方案，这样才能在发生意外的时候保证数据的恢复。写回。
实战派 | Java项目中玩转Redis6.0客户端缓存
05-17 877
原创：微信公众号 码农参上，欢迎分享，转载请保留出处。 哈喽大家好啊，我是Hydra。 在前面的文章中，我们介绍了Redis6.0中的新特性客户端缓存client-side caching，通过telnet连接模拟客户端，测试了三种客户端缓存的工作模式，这篇文章我们就来点硬核实战，看看客户端缓存在java项目中应该如何落地。 铺垫 首先介绍一下今天要使用到的工具Lettuce，它是一个可伸缩线程安全的redis客户端。多个线程可以共享同一个RedisConnection，利用nio框架Netty来高效地.
浅谈一下Redis缓存失效问题
liuyuii的博客
02-22 492
Redis缓存失效问题
redis缓存更新策略
teternity的博客
10-06 3038
redis缓存更新策略
redis的使用
suiyishiguang的博客
07-08 916
redis的使用
redis 分布式缓存 详解
共勉
12-17 3453
Redis命令操作、Redis持久化、Spring整合Redis、Redis的分布式缓存、主从复制、哨兵监测、集群搭建、分布式Session实现
Django如何使用redis作为缓存
12-17
在Django中使用Redis作为缓存系统是一种高效且灵活的选择，因为Redis是一个内存数据库，能够提供高速的数据存储和检索。以下是如何在已有Django项目中配置和使用Redis作为缓存的详细步骤： 1. **安装**： 首先，你...
Springboot默认缓存+Redis缓存（使用详解）
程序员资料站
08-09 1705
Springboot环境搭建 一个实体类Comment： package com.lagou.pojo; import javax.persistence.*; import java.io.Serializable; @Entity @Table(name = "t_comment") public class Comment implements Serializable { @Id @GeneratedValue(strategy = GenerationType.IDENT
【Redis】缓存预热、雪崩、击穿、穿透、过期删除策略、内存淘汰策略
最新发布
Stringzhua的博客
10-13 852
Redis缓存预热“宕机”服务器启动后迅速宕机，指的是服务刚上线由于Redis中没有任何数据，导致大量请求访问数据库，主从之间数据吞吐量较大，数据同步操作频度较高。而缓存预热解决的就是，在系统启动前，提前将相关的数据直接加载到缓存系统。避免用户在请求的时候，先查询数据库，再将数据库的查询到的数据缓存到Redis的问题。用户可以直接查询事先被预热的缓存数据。解决方案：准备工作：日常例行统计数据访问记录，统计访问频度较高的热点数据。
Redis 高可用方案
ArchManual 分布式技术架构手册
10-10 1367
SDOWN（主观下线）：这是 Sentinel 单个实例对 Redis 节点的主观判断。即某个 Sentinel 认为该 Redis 节点不可用，但这种判断仅仅是该 Sentinel 的“个人观点”。ODOWN（客观下线）：这是 Sentinel 集群的共同判断。即多个 Sentinel 一致认为该 Redis 节点不可用，这时该节点被标记为客观下线，触发故障转移机制。
SpringBoot日常：redission的接入使用和源码解析
qq_32590535的博客
10-08 1179
Redisson 是一个在 Redis 的基础上实现的 Java 驻内存数据网格客户端（In-Memory Data Grid）。它不仅提供了一系列的 redis 常用数据结构命令服务，还提供了许多分布式服务，例如分布式锁、分布式对象、分布式集合、分布式远程服务、分布式调度任务服务等等。本文会介绍如何将redission集成到springboot和如何使用 Redisson 操作 Redis 中的字符串、哈希、列表、集合、有序集合，以及布隆过滤器和分布式锁等功能，并解析源码中其最大亮点的看门狗机制。
redis与springBoot整合
hang_sa_mu的博客
10-11 801
设置一个没有登录异常类即可​/*** --- 天道酬勤 ---* @desc 未登录异常*/​// 为了接收状态码​​​。
滚雪球学Redis[1.3讲]：Redis的安装与配置
**My Coding Family**
10-09 763
在前几期文章中，我们探讨了什么是 Redis以及Redis 的基本架构，从宏观上理解了 Redis 是一个高性能的内存数据库，并学习了其客户端-服务器模型、单线程与多线程设计、内存存储与持久化机制等关键概念。这些知识为我们打下了理论基础。然而，理论与实践结合，才能真正掌握 Redis。本期，我们将深入探讨 Redis 的安装与配置过程，包括在多种操作系统上的安装方法、Redis 配置文件的重要选项以及安装过程中常见的错误与解决方案。这些内容将帮助你顺利地在本地或生产环境中部署和配置 Redis。
Redis 实现 查找附近的人 功能
分享技术，分享经验
10-09 671
使用 Redis 实现“查找附近的人”功能，通常会依赖 Redis 的Geo（地理位置）数据类型来存储用户的经纬度，并基于此进行地理范围查询。Redis 通过GEOADDGEORADIUS等命令来存储用户位置和查找一定范围内的用户。存储用户的地理位置：我们需要存储用户的经纬度信息，以便后续可以基于此进行地理查询。Redis 提供了GEOADD命令，允许将用户的经纬度信息存储在 Redis 中的有序集合中（底层基于ZSet实现）。根据当前用户的位置查找附近的用户：使用GEORADIUS或。
简单认识redis-5 jdbc 与 jedis 使用的区别
m0_68274160的博客
10-08 698
【代码】简单认识redis-5 jdbc 与 jedis 使用的区别。
redis单线程为什么这么快
Lxn2zh的博客
10-10 1206
多个 socket 可能会并发产生不同的操作，每个操作对应不同的文件事件，但是 IO 多路复用程序会监听多个 socket，会将产生事件的 socket 放入队列中排队，事件分派器每次从队列中取出一个 socket，根据 socket 的事件类型交给对应的事件处理器进行处理。它采用 IO 多路复用机制同时监听多个 socket，将产生事件的 socket 压入内存队列中，事件分派器根据 socket 上的事件类型来选择对应的事件处理器进行处理。事件处理器（连接应答处理器、命令请求处理器、命令回复处理器）
Redis分布式缓存系统：高效数据存储解决方案
本项目中的"缓存的使用与设计.md"文档可能详细介绍了如何合理设计和使用缓存，包括缓存的粒度、失效策略、一致性问题等。 通过以上内容，可以理解基于Redis的分布式缓存系统项目的主要概念、关键特性、安装与配置...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值