当前位置： 首页 > news >正文

Redis-商品缓存

news 2025/5/9 7:07:49

什么是缓存

缓存就是数据交换的缓冲区（称作Cache [ kæʃ ] ），是存贮数据的临时地方，一般读写性能较高。

引入了数据库，也带了一些问题

添加Redis缓存

流程图

查询商铺

  @Resourceprivate StringRedisTemplate stringRedisTemplate;@Overridepublic Result queryById(Long id) {//1.从redis查询商铺缓存String key=CACHE_SHOP_KEY+id;String shopJson = stringRedisTemplate.opsForValue().get(key);//2.判断是否存在if(!StrUtil.isBlank(shopJson)){//3.存在，直接返回Shop shop = JSONUtil.toBean(shopJson, Shop.class);return Result.ok(shop);}//4.不存在，根据id查询数据库Shop shop = getById(id);//5.不存在，返回错误if(shop==null){return Result.fail("店铺不存在");}//6.存在，返回redisstringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shop));//7.返回return Result.ok(shop);}

练习：给店铺类型查询业务添加缓存

@GetMapping("list")public Result queryTypeList() {//1.从redis查询店铺类别进行缓存List<String> shopTypeRedisKey = stringRedisTemplate.opsForList().range(CACHE_SHOP_TYPE_KEY, 0, -1);//2.判断是否命中缓存if (!CollectionUtils.isEmpty(shopTypeRedisKey)) {//3.存在，直接返回，即命中缓存//使用stream流将json集合转为ListList<ShopType> shopTypeList = shopTypeRedisKey.stream().map(item -> JSONUtil.toBean(item, ShopType.class)).sorted(Comparator.comparingInt(ShopType::getSort)).collect(Collectors.toList());return Result.ok(shopTypeList);}//4.不存在，查询数据库List<ShopType> shopTypes = typeService.query().orderByAsc("sort").list();//判断数据库中是否有数据if (CollectionUtils.isEmpty(shopTypes)) {//不存在则缓存一个空集合，解决缓存穿透stringRedisTemplate.opsForValue().set(CACHE_SHOP_TYPE_KEY, Collections.emptyList().toString(),RedisConstants.CACHE_NULL_TTL, TimeUnit.MINUTES);return Result.fail("商品分类信息为空");}//5.存在，写入redis，再返回List<String> shopTypeCache = shopTypes.stream().sorted(Comparator.comparingInt(ShopType::getSort)).map(item -> JSONUtil.toJsonStr(item)).collect(Collectors.toList());stringRedisTemplate.opsForList().rightPushAll(RedisConstants.CACHE_SHOP_TYPE_KEY,shopTypeCache);stringRedisTemplate.expire(RedisConstants.CACHE_SHOP_TYPE_KEY,RedisConstants.CACHE_SHOP_TYPE_TTL, TimeUnit.MINUTES);// 6. 返回（按类别升序排序)return Result.ok(shopTypes);}

缓存更新策略

业务场.景：

  • 低一致性需求：使用内存淘汰机制。例如店铺类型的查询缓存
  • 高一致性需求：主动更新，并以超时剔除作为兜底方案。例如店铺详情查询的缓存。

主动更新策略：

  1. 由缓存的调用者，在更新数据库的同时更新缓存
  2. 缓存与数据库整合为一个服务，由服务来维护一致性，调用者调用该服务，无需关心缓存一致性的问题。
  3. 调用者只操作缓存，由其它线程异步的将缓存数据持久化到数据库，保证最终一致。

操作缓存和数据库时有三个问题需要考虑：

1.删除缓存还是更新缓存

  • 更新缓存：每次更新数据库中都更新缓存，无效写操作较多
  • 删除缓存：更新数据库时让缓存失效，查询时再更新缓存

2.如何保证缓存与数据库的操作的同时成功或失败？

  • 单体系统，将缓存与数据库操作放在一个事务
  • 分布式系统，利用TCC等分布式事务方案

3.先操作缓存还是先操作数据库？

这两种方案都会出现意外。总的来说，还是选择，先操作数据库，再删除缓存。

读操作：

        缓存命中则直接返回，

        缓存未命中则查询数据库，并写入缓存，设定超时时间

写操作：

        先写数据库，然后再删除缓存

        要确保数据库与缓存操作的原子性

案例：给查询商铺的缓存添加超时剔除和主动更新的策略

① 根据 id 查询店铺时，如果缓存未命中，则查询数据库，将数据库结果写入缓存，并设置超时时间
② 根据 id 修改店铺时，先修改数据库，再删除缓存

设置过期时间

先修改再删除缓存

    @Overridepublic Result update(Shop shop) {Long id = shop.getId();if(id==null){return Result.fail("店铺id不能为空");}//1.更新数据库updateById(shop);//2.删除缓存stringRedisTemplate.delete(CACHE_SHOP_KEY+id);return Result.ok();}

缓存穿透

缓存穿透是指客户端请求的数据在缓存中和数据库中都不存在，这样缓存永远不会生效，这些请求都会打到数据库。

常见的解决方案有两种：

        缓存空对象

  •                 优点：实现简单，维护方便
  •                 缺点：
  • 额外的内存消耗
  • 可能造成短期的不一致
布隆过滤
  •  优点：内存占用较少，没有多余key
  •  缺点：
  • 实现复杂
  • 存在误判可能

避免缓存穿透问题，在查询商铺时，数据库中商铺不存在时，将空值写入Redis，同时，如果缓存命中，要先判定该值是否为空。

  //2.判断是否存在if(StrUtil.isNotBlank(shopJson)){//3.存在，直接返回Shop shop = JSONUtil.toBean(shopJson, Shop.class);return Result.ok(shop);}/*如果是空字符串也是false所以需要判断是否为空*///判断命中的是否是空值if(shopJson !=null){//不是null那就是空值//返回一个错误信息return Result.fail("店铺信息不存在！");}//4.不存在，根据id查询数据库Shop shop = getById(id);//5.不存在，返回错误if(shop==null){//将空值写入redisstringRedisTemplate.opsForValue().set(key,"",CACHE_NULL_TTL,TimeUnit.MINUTES);//返回错误信息return Result.fail("店铺不存在");}

关键部分就在于，如果商铺不存在，就在redis中写入空字符串，而且要在redis命中时判断是否为空。

1.缓存穿透产生的原因是什么？

用户请求的数据在缓存中和数据库中都不存在，不断发起这样的请求，给数据库带来压力。

2.缓存穿透的解决方案有哪些？

  • 缓存null值
  • 布隆过滤
  • 增强id的复杂度，避免被猜测id规律
  • 做好数据的基础格式校验
  • 加强用户校验权限
  • 做好热点参数的限流

缓存雪崩

缓存雪崩是指在同一时段大量的缓存key同时失效或者Redis服务宕机，导致大量请求到达数据库，带来巨大压力。

解决方案：

  • 给不同的Key的TTL添加随机值
  • 利用Redis集群提高服务的可用性
  • 给缓存业务添加降级限流策略
  • 给业务添加多级缓存

缓存击穿 

缓存击穿问题也叫热点Key问题，就是一个被高并发访问并且缓存重建业务较复杂的key突然失效了，无数的请求访问会在瞬间给数据库带来巨大的冲击。

常见的解决方法有两种：

  •         互斥锁
  •         逻辑过期

 互斥锁逻辑，直到有一个线程正在构建，其他线程都需要等待。直到该线程结束，才行。

逻辑过期，此时线程查询缓存，发现是过期数据，获取互斥锁失败，说明有其他线程帮忙在更新，那就返回旧数据。直到负责重建缓存数据的线程结束，才能获得更新后的数据

两种方式对比

案例：基于互斥锁解决缓存击穿问题

需求：修改根据id查询商铺的业务，基于互斥锁方式来解决缓存击穿问题

         /**
         *注意，获取锁成功应该再次检测redis缓存是否过期，做DoubleCheck，如果存在则无需重建缓存。
         */

 /*** 缓存击穿* @param id* @return*/public Shop queryWithMutex(Long id) {//1.从redis查询商铺缓存String key=CACHE_SHOP_KEY+id;String shopJson = stringRedisTemplate.opsForValue().get(key);//2.判断是否存在if(StrUtil.isNotBlank(shopJson)){//3.存在，直接返回return JSONUtil.toBean(shopJson, Shop.class);}/*如果是空字符串也是false所以需要判断是否为空*///判断命中的是否是空值if(shopJson !=null){//不是null那就是空值//返回一个错误信息return null;}//4.实现缓存重建//4.1 获取互斥锁String lockKey="lock:shop:"+id;Shop shop = null;try {boolean isLock = tryLock(lockKey);//4.2 判断是否获取成功if(!isLock){//4.3 失败，休眠并重试Thread.sleep(50);return queryWithMutex(id);}//4.4成功，根据id查询数据库shop = getById(id);//模拟重建的延时Thread.sleep(200);//5.不存在，返回错误if(shop==null){//将空值写入redisstringRedisTemplate.opsForValue().set(key,"",CACHE_NULL_TTL,TimeUnit.MINUTES);//返回错误信息return null;}//6.存在，返回redis,设置超时时间stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shop),CACHE_SHOP_TTL, TimeUnit.MINUTES);} catch (InterruptedException e) {throw new RuntimeException(e);} finally {//7.释放互斥锁unLock(lockKey);}//8.返回return shop;}

案例：基于逻辑过期方式解决缓存击穿问题

需求：修改根据id查询商铺的业务，基于逻辑过期方式来解决缓存击穿问题

 //线程池private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);public Shop queryWithLogicalExpire(Long id){//1.从redis查询商铺缓存String key=CACHE_SHOP_KEY+id;String shopJson = stringRedisTemplate.opsForValue().get(key);//2.判断是否存在if(StrUtil.isBlank(shopJson)){//3.不存在，直接返回return null;}//4.命中，需要先把json反序列化为对象RedisData redisData = JSONUtil.toBean(shopJson, RedisData.class);Shop shop = JSONUtil.toBean((JSONObject) redisData.getData(), Shop.class);//取出过期时间LocalDateTime expireTime = redisData.getExpireTime();//5.判断是否过期if(expireTime.isAfter(LocalDateTime.now())){//5.1未过期，直接返回店铺信息return shop;}//5.2已过期，需要缓存重建//6.缓存重建//6.1获取互斥锁String lockKey=LOCK_SHOP_KEY+id;boolean isLock = tryLock(lockKey);//6.2判断是否获取锁成功if(isLock){// 6.3成功，开启独立线程，实现缓存重建。CACHE_REBUILD_EXECUTOR.submit(() -> {try {//重建缓存this.saveShop2Redis(id,20L);} catch (Exception e) {throw new RuntimeException(e);}finally {//释放锁unLock(lockKey);}});}/*** 注意，获取锁成功应该再次检测redis缓存是否过期，做DoubleCheck，如果存在则无需重建缓存。*///6.4 返回过期的商城信息数据return shop;}
 public void saveShop2Redis(Long id,Long expireSeconds) throws InterruptedException {//1.查询店铺数据Shop shop=getById(id);Thread.sleep(200);//2.封装逻辑过期时间RedisData redisData=new RedisData();redisData.setData(shop);redisData.setExpireTime(LocalDateTime.now().plusMinutes(expireSeconds));//3.写入redisstringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY+id,JSONUtil.toJsonStr(redisData));}

缓存工具封装

基于StringRedisTemplate封装一个缓存工具类，满足下列需求：

  • 方法1：将任意Java对象序列化为json并存储在string类型的key中，并且可以设置TTL过期时间
  • 方法2：将任意Java对象序列化为json并存储在string类型的key中，并且可以设置逻辑过期时间，用于处理缓存击穿问题
  • 方法3：根据指定的key查询缓存，并反序列化为指定类型，利用缓存空值的方式解决缓存穿透问题
  • 方法4：根据指定的key查询缓存，并反序列化为指定类型，需要利用逻辑过期解决缓存击穿问题

定义了一个工具类，将方法转为泛型。

package com.hmdp.utils;import cn.hutool.core.util.BooleanUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import com.hmdp.entity.Shop;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;import java.time.LocalDateTime;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;import static com.hmdp.utils.RedisConstants.*;@Component
@Slf4j
public class CacheClient {private StringRedisTemplate stringRedisTemplate;//使用构造函数，也可以使用@Autowired注解public CacheClient(StringRedisTemplate stringRedisTemplate) {this.stringRedisTemplate = stringRedisTemplate;}public void set(String key, Object value, Long time, TimeUnit unit) {stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(value),time,unit);}public void setWithLogicalExpire(String key, Object value, Long time, TimeUnit unit) {//设置逻辑过期RedisData redisData=new RedisData();redisData.setData(value);redisData.setExpireTime(LocalDateTime.now().plusSeconds(unit.toSeconds(time)));//写入redisstringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(value));}//Fuction传递函数，函数的参数是id，返回值是R/*缓存穿透*/public <R,ID> R queryWithThrough(String keyPrefix, ID id, Class<R> type,Function<ID,R> dbFallback,Long time,TimeUnit unit){//1.从redis查询商铺缓存String key=keyPrefix + id ;String json = stringRedisTemplate.opsForValue().get(key);//2.判断是否存在if(StrUtil.isNotBlank(json)){//3.存在，直接返回return JSONUtil.toBean(json,type);}/*如果是空字符串也是false所以需要判断是否为空*///判断命中的是否是空值if(json !=null){//不是null那就是空值//返回一个错误信息return null;}//4.不存在，根据id查询数据库R r = dbFallback.apply(id);//5.不存在，返回错误if(r==null){//将空值写入redisstringRedisTemplate.opsForValue().set(key,"",CACHE_NULL_TTL,TimeUnit.MINUTES);//返回错误信息return null;}//6.存在，返回redis,设置超时时间this.set(key,r,time,unit);//7.返回return r;}/*** 缓存击穿————逻辑过期*///线程池private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);public <R,ID> R queryWithLogicalExpire(String keyPrefix,ID id,Class<R> type,Function<ID,R> dbFallback,Long time,TimeUnit unit){//1.从redis查询商铺缓存String key=keyPrefix+id;String json = stringRedisTemplate.opsForValue().get(key);//2.判断是否存在if(StrUtil.isBlank(json)){//3.不存在，直接返回return null;}//4.命中，需要先把json反序列化为对象RedisData redisData = JSONUtil.toBean(json, RedisData.class);R r = JSONUtil.toBean((JSONObject) redisData.getData(),type);//取出过期时间LocalDateTime expireTime = redisData.getExpireTime();//5.判断是否过期if(expireTime.isAfter(LocalDateTime.now())){//5.1未过期，直接返回店铺信息return r;}//5.2已过期，需要缓存重建//6.缓存重建//6.1获取互斥锁String lockKey=LOCK_SHOP_KEY+id;boolean isLock = tryLock(lockKey);//6.2判断是否获取锁成功if(isLock){// 6.3成功，开启独立线程，实现缓存重建。CACHE_REBUILD_EXECUTOR.submit(() -> {try {//重建缓存//查询数据库R rl=dbFallback.apply(id);//写入redisthis.setWithLogicalExpire(key,rl,time,unit);} catch (Exception e) {throw new RuntimeException(e);}finally {//释放锁unLock(lockKey);}});}/*** 注意，获取锁成功应该再次检测redis缓存是否过期，做DoubleCheck，如果存在则无需重建缓存。*///6.4 返回过期的商城信息数据return r;}private boolean tryLock(String key){Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);return BooleanUtil.isTrue(flag);}/*释放锁*/private void unLock(String key){stringRedisTemplate.delete(key);}//互斥锁解决缓存击穿public <R,ID> R queryWithMutex(String keyPrefix,ID id,Class<R> type,Function<ID,R> dbFallback,Long time,TimeUnit unit) {//1.从redis查询商铺缓存String key=keyPrefix+id;String shopJson = stringRedisTemplate.opsForValue().get(key);//2.判断是否存在if(StrUtil.isNotBlank(shopJson)){//3.存在，直接返回return  JSONUtil.toBean(shopJson, type);}/*如果是空字符串也是false所以需要判断是否为空*///判断命中的是否是空值if(shopJson !=null){//不是null那就是空值//返回一个错误信息return null;}//4.实现缓存重建//4.1 获取互斥锁String lockKey=LOCK_SHOP_KEY+id;R r=null;try {boolean isLock = tryLock(lockKey);//4.2 判断是否获取成功if(!isLock){//4.3 失败，休眠并重试Thread.sleep(50);return queryWithMutex(keyPrefix,id,type,dbFallback,time,unit);}//4.4成功，根据id查询数据库r= dbFallback.apply(id);//模拟重建的延时Thread.sleep(200);//5.不存在，返回错误if(r==null){//将空值写入redisstringRedisTemplate.opsForValue().set(key,"",CACHE_NULL_TTL,TimeUnit.MINUTES);//返回错误信息return null;}//6.存在，返回redis,设置超时时间this.set(key,r,time,unit);} catch (InterruptedException e) {throw new RuntimeException(e);} finally {//7.释放互斥锁unLock(lockKey);}//8.返回return r;}}
http://www.xdnf.cn/news/339589.html

相关文章：

  • pycharm无法导入相对路径下其它文件
  • 性能远超SAM系模型，苏黎世大学等开发通用3D血管分割基础模型
  • 【造包工具】【Xcap】精讲Xcap构造分片包（IPv4、ipv6、4G\5G等pcap均可），图解超赞超详细！！！
  • 开发者如何优雅应对HTTPS抓包难题
  • 智能量化策略开发全流程：数据准备，因子计算，因子分析，模型训练，策略构建（附python代码）
  • 硬件选型：工控机的选择要素
  • 00 Ansible简介和安装
  • ubuntu 22.04 换源
  • 【Linux】FreeRTOS与Linux：实时与通用的终极对比
  • LeetCode热题100--54.螺旋矩阵--中等
  • Hutool的`BeanUtil.toBean`方法详解
  • Navee滑板车强势登陆中国，以智能科技重塑城市出行新风尚
  • 使用 Cesium 构建 3D 地图应用的实践
  • C++ 算法学习之旅：从入门到精通的秘籍
  • AWS之存储服务
  • 蓝桥杯FPGA赛道第二次模拟题代码
  • 如何从播放器构造角度研究 Media3 源码
  • 六、Hadoop初始化与启动
  • KAXA凯莎科技AGV通信方案如何赋能智能仓储高效运作？
  • 数据结构--红黑树
  • XML简单介绍
  • IBM BAW（原BPM升级版）使用教程第五讲
  • MyBatis 动态 SQL 详细指南【完整示例】
  • Python+ffmpeg 实现给视频添加字幕
  • Android ImageView 加载 Base64编码图片
  • vscode如何使用 GitHub Copilot
  • Windows ABBYY FineReader 16 Corporate 文档转换、PDF编辑和文档比较
  • 文件操作和IO（下）
  • 基础编程题目集 6-8 简单阶乘计算
  • 【Rust错误处理】Rust错误处理机制详解与应用实战