Redis之商品缓存

已于 2024-08-05 22:57:24 修改
阅读量879 收藏 25
点赞数 22
分类专栏： Redis 文章标签： 缓存 redis spring
于 2024-06-25 09:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/apple_74262176/article/details/139866334
版权

文章目录

什么是缓存

缓存就是数据交换的缓冲区( Cache ), 是存储数据的临时地方, 一般读写性能较高

缓存的作用:

  • 降低后端负载
  • 提高读写效率, 降低响应时间

缓存的成本:

  • 数据一致性成本
  • 代码维护成本
  • 运维成本

添加Redis缓存

一图胜过千言万语~
image.png

/**
 * 根据id查询商铺信息
 * @param id 商铺id
 * @return 商铺详情数据
 */
@GetMapping("/{id}")
public Result queryShopById(@PathVariable("id") Long id) {
    return Result.ok(shopService.queryById(id));
}

@Override
public Object queryById(Long id) {
	String shopKey = CACHE_SHOP_KEY + id;
	// 从redis查询商店缓存
	String shopJson = stringRedisTemplate.opsForValue().get(shopKey);
	// 判断缓存是否存在
	if(StrUtil.isNotBlank(shopJson)){
		// 缓存存在，直接返回
		Shop shop = JSONUtil.toBean(shopJson, Shop.class);
		return Result.ok(shop);
	}
	// 缓存不存在，查询数据库
	Shop shop = getById(id);
	// 店铺不存在, 返回错误
	if(shop == null){
		return Result.fail("商铺不存在");
	}
	// 店铺存在, 写入redus
	stringRedisTemplate.opsForValue().set(shopKey, JSONUtil.toJsonStr(shop));
	// 返回
	return Result.ok(shop);
}
  1. 从redis中查询是否存在商铺缓存
  • stringRedisTemplate.opsForValue().get(shopKey)
  1. 缓存存在, 将数据转换成Java对象并返回
  • Shop shop = JSONUtil.toBean(shopJson, Shop.class)
  1. 缓存不存在, 先查库看商铺是否存在
  • Shop shop = getById(id)
  1. 商铺不存在, 直接返回错误提示
  • return Result.fail("商铺不存在")
  1. 商铺存在, 写入redis再返回商铺信息
  • stringRedisTemplate.opsForValue().set(shopKey, JSONUtil.toJsonStr(shop))
  • return Result.ok(shop)

缓存更新策略

image.png

业务场景:

  • 低一致性要求: 使用内存淘汰机制. 例如店铺类型的查询缓存
  • 高一致性要求: 主动更新, 并以超时剔除作为兜底方案. 例如店铺详情查询的缓存
  • 读操作:
    • 缓存命中则直接返回
    • 缓存未命中则查数据库, 并写入缓存, 设定超时时间
  • 写操作:
    • 先写数据库, 然后再删除缓存
    • 要确保数据库与缓存操作的原子性

更新商铺信息

/**
 * 更新商铺信息
 * @param shop 商铺数据
 * @return 无
 */
@PutMapping
public Result updateShop(@RequestBody Shop shop) {
    // 写入数据库
    return shopService.updateShop(shop);
}

@Override
@Transactional
public Result updateShop(Shop shop) {
	Long id = shop.getId();
	if(id == null){
		return Result.fail("商铺ID不能为空");
	}
	// 更新数据库
	updateById(shop);
	// 删除缓存
	stringRedisTemplate.delete(CACHE_SHOP_KEY + id);
	return Result.ok();
}
  1. 判断商铺ID是否为空, 防止NPE
  2. 更新数据库, 直接调用MP的方法, 最后在删除缓存
  3. 添加@Transactional注解, 保持事务一致性, 防止缓存与数据库不一致

缓存穿透

缓存穿透:
指客户端请求的数据在缓存中和数据库都不存在,
这样缓存永远不会生效, 这些请求都会发送到数据库

image.png

解决方案:

缓存空对象

  • 优点: 实现简单 维护方便
  • 缺点: 额外内存消耗 可能造成短期数据不一致

布隆过滤器

  • 优点: 内存占用较少 没有多余key
  • 缺点: 实现复杂 存在误判可能

image.png

@Override
public Object queryById(Long id) {
	String shopKey = CACHE_SHOP_KEY + id;
	// 从redis查询商店缓存
	String shopJson = stringRedisTemplate.opsForValue().get(shopKey);
	// 判断缓存是否存在
	if(StrUtil.isNotBlank(shopJson)){
		// 缓存存在，直接返回
		Shop shop = JSONUtil.toBean(shopJson, Shop.class);
		return Result.ok(shop);
	}
	// 判断命中的是否是空值
***	if(shopJson != null){							<***为多加的代码,防止缓存穿透>
***		// 命中空值，直接返回
***		return Result.fail("商铺不存在");
***	}
	// 缓存不存在，查询数据库
	Shop shop = getById(id);
	// 店铺不存在, 返回错误
	if(shop == null){
		// 将空值写入redis
***		stringRedisTemplate.opsForValue().set(shopKey, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
		// 返回错误信息
		return Result.fail("商铺不存在");
	}
	// 店铺存在, 写入redus
	stringRedisTemplate.opsForValue().set(shopKey, JSONUtil.toJsonStr(shop), CACHE_SHOP_TTL, TimeUnit.MINUTES);
	// 返回
	return Result.ok(shop);
}

缓存雪崩

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

image.png

解决方案:

给不同的key的TTL添加随机值

利用Redis集群提高服务的可用性

给缓存业务添加降级限流策略

给业务添加多级缓存

缓存击穿

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

image.png

解决方案:

互斥锁

  • 优点:
    • 没有额外的内存消耗
    • 保证一致性
    • 实现简单
  • 缺点:
    • 线程需要等待 性能受到影响
    • 可能有死锁的风险

逻辑过期

  • 优点:
    • 现成无需等待
    • 性能较好
  • 缺点:
    • 不保证一致性
    • 有额外的内存消耗
    • 实现复杂

互斥锁解决缓存击穿
image.png

互斥锁解决缓存击穿

// 缓存击穿
public Shop queryWithMutex(Long id){
	String shopKey = CACHE_SHOP_KEY + id;
	// 从redis查询商店缓存
	String shopJson = stringRedisTemplate.opsForValue().get(shopKey);
	// 判断缓存是否存在
	if(StrUtil.isNotBlank(shopJson)){
		// 缓存存在，直接返回
		return JSONUtil.toBean(shopJson, Shop.class);
	}
	// 判断命中的是否是空值
	if(shopJson != null){
		// 命中空值，直接返回
		return null;
	}
	// 实现缓存重建
	// 1. 获取互斥锁
	String lockKey = "lock:shop:" + id;
	Shop shop = null;
	try{
		boolean isLock = tryLock(lockKey);
		// 2. 判断是否获取成功
		if(!isLock){
			// 3. 失败 则休眠并重试
			Thread.sleep(50);
			return queryWithMutex(id);
		}
		// 4. 成功 根据id查询数据库
		shop = getById(id);
		// 模拟重建延时
		Thread.sleep(1000);
		// 店铺不存在, 返回错误
		if(shop == null){
			// 将空值写入redis
			stringRedisTemplate.opsForValue().set(shopKey, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
			// 返回错误信息
			return null;
		}
		// 店铺存在, 写入redus
		stringRedisTemplate.opsForValue().set(shopKey, JSONUtil.toJsonStr(shop), CACHE_SHOP_TTL, TimeUnit.MINUTES);
	}catch(InterruptedException e){
		throw new RuntimeException(e);
	}finally{
		// 释放互斥锁
		unLock(lockKey);
	}
	// 返回
	return shop;
}

// 获取锁
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);
}
  1. 判断缓存是否存在, 存在直接返回, 不存在先判断是否为空值, 空值返回null, 不是空值则继续
  2. 实现缓存重建, 尝试拿到锁, 失败则休眠一段时间之后再次尝试拿锁~
  3. 成功拿到锁之后查询数据库, 判断数据是否存在, 不存在则写入空字符串到redis, 防止缓存穿透
  4. 数据存在则将数据写入redis, 下次查询直接命中缓存, 无需抢锁再查库, 最后缓存重建成功, 释放锁

使用逻辑过期解决缓存击穿问题
image.png

使用逻辑过期解决缓存击穿问题

// 数据预热 / 缓存重建
public void saveShopRedis(Long id, Long expireSeconds){
	// 1. 查询店铺数据
	Shop shop = getById(id);
	// 2. 封装逻辑过期时间
	RedisData redisData = new RedisData();
	redisData.setData(shop);
	redisData.setExpireTime(LocalDateTime.now().plusSeconds(expireSeconds));
	// 3. 写入Redis
	stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(redisData));
}

// 独立线程重建缓存(线程池)
private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);
// 逻辑过期解决缓存击穿
public Shop queryWithLogicalExpire(Long id){
	String shopKey = CACHE_SHOP_KEY + id;
	// 1. 从redis查询商店缓存
	String shopJson = stringRedisTemplate.opsForValue().get(shopKey);
	// 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.saveShopRedis(id, 20L);
			} catch (Exception e) {
				throw new RuntimeException(e);
			} finally {
				// 释放互斥锁
				unLock(lockKey);
			}
		});
	}
	// 6.4 返回过期的商铺信息
	return shop;
}
  1. 判断redis是否存在缓存数据
  • stringRedisTemplate.opsForValue().get(shopKey)
  1. 判断缓存是否存在 if(StrUtil.isBlank(shopJson))
  2. 缓存不存在, 返回 null
  3. 缓存存在, 将缓存反序列化为Java对象
  • RedisData redisData = JSONUtil.toBean(shopJson, RedisData.class)
  • Shop shop = JSONUtil.toBean((JSONObject) redisData.getData(), Shop.class)
  • LocalDateTime expireTime = redisData.getExpireTime() -> 逻辑过期时间
  1. 判断逻辑时间是否过期 if(expireTime.isAfter(LocalDateTime.now()))
  2. 未过期直接返回缓存信息 return shop
  3. 过期则进行缓存重建, 要获取锁, boolean isLock = tryLock(lockKey)
  4. 抢锁成功则进行缓存重建
  • Shop shop = getById(id)
  • RedisData redisData = new RedisData()
  • String cacheKey = CACHE_SHOP_KEY + id
  • redisData.setData(shop)
  • redisData.setExpireTime(LocalDateTime.now().plusSeconds(expireSeconds))
  • stringRedisTemplate.opsForValue().set(cacheKey, JSONUtil.toJsonStr(redisData))
  1. 缓存重建成功之后释放锁, unLock(), 最后返回信息 return shop

缓存工具封装

缓存工具封装
image.png

方法1 写入redis

// 写入缓存
public void set(String key, Object value, Long time, TimeUnit unit){
	stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(value), time, unit);
}

方法2 设置逻辑过期

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)));
	// 写入Redis
	stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(redisData));
}
  1. 拿到缓存的key, 缓存的数据value, 缓存时间time, 缓存时间单位unit
  2. 分别设置数据和过期时间, 过期时间是以当前时间加上缓存时间time
  • redisData.setExpireTime(LocalDateTime.now().plusSeconds(unit.toSeconds(time)))
  1. 最后写入Redis, 缓存数据转换成String类型

方法3 解决缓存穿透

// 解决缓存穿透
public <R, ID> R queryWithPassThrough(
		String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit unit){
	String key = keyPrefix + id;
	// 从redis查询商店缓存
	String json = stringRedisTemplate.opsForValue().get(key);
	// 判断缓存是否存在
	if(StrUtil.isNotBlank(json)){
		// 缓存存在，直接返回
		return JSONUtil.toBean(json, type);
	}
	// 判断命中的是否是空值
	if(json != null){
		// 命中空值，直接返回
		return null;
	}
	// 缓存不存在，查询数据库
	R r = dbFallback.apply(id);
	// 店铺不存在, 返回错误
	if(r == null){
		// 将空值写入redis
		stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
		// 返回错误信息
		return null;
	}
	// 店铺存在, 写入redus
	this.set(key, r, time, unit);
	// 返回
	return r;
}

方法4 解决缓存击穿

// 解决缓存击穿
// 独立线程重建缓存(线程池)
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){
	String key = keyPrefix + id;
	// 1. 从redis查询商店缓存
	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 r1 = dbFallback.apply(id);
				// 写入Redis
				this.setWithLogicalExpire(key, r1, time, unit);
			} catch (Exception e) {
				throw new RuntimeException(e);
			} finally {
				// 释放互斥锁
				unLock(lockKey);
			}
		});
	}
	// 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);
}
水蓝烟雨
关注
  • 22
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深入学习 Redis - 如何使用 Redis 作缓存？缓存更新策略？使用需要注意哪些问题（工作/重点）
CYK_byte的博客
09-19 4601
缓存可以理解为，将常用的数据从放到一个访问速度更快的的地方，方便更快的随时读取. 也就是说，速度快的设备，可以作为速度慢的设备的缓存，加快读取速度。
Redis 缓存雪崩如何处理?
Web3 & Basketball
07-31 928
在实际应用中，需要根据具体的业务场景和数据更新频率来选择合适的缓存过期时间和容量，以避免缓存雪崩的发生。例如，对于一个高频访问的页面，可以将缓存过期时间设置为较短的时间，如 30 秒或 1 分钟，而对于一个低频访问的页面，可以将缓存过期时间设置为较长的时间，如 1 小时或 1 天。在这个示例中，我们假设商品库存为商品 ID 的两倍。这样，当用户连续购买商品时，缓存中的商品库存会不断更新，并且过期时间会重新设置。在函数中，我们首先从缓存中读取商品库存，如果缓存中没有商品库存，则更新库存并设置缓存过期时间。
商品详情优化——利用redis进行缓存
weixin_58153822的博客
11-05 944
商品优化详情，利用redis进行缓存，以及解决缓存击穿、缓存穿透、缓存雪崩问题。
redis商品详情的缓存
qq_25881443的博客
10-17 741
商品详情redis缓存更新方案
流氓要吹口哨了
09-30 388
redis缓存如何更新，如何删除 商品详情缓存场景： 概述： 比如一个商品下聚合多个相关数据的缓存， 将商品的整个聚合信息按商品的ID当作key，value等于各种聚合信息(父对象包含并组合各个子对象结构，使用json转换成字符串对象)。 何时将聚合的信息放入缓存： 查询商品详情时，将各个组合完成后的对象放入缓存 聚合的信息变更时缓存如何更新，更新方案：先删除-后添加： 先删除： 商品对象和聚合的子对象发生变更时，找到子对象关联的商品ID，对redis中的商品Id的key 进行删除。 (在存入子表信息时尽量
商店类型缓存redis实现
qq_57294711的博客
10-28 545
redis实现基本的商品列表缓存
Redis：黑马点评项目之商品缓存
m0_49569564的博客
03-27 2144
一、缓存更新策略 缓存可以减轻数据库压力，但也会存在数据库与缓存不一致的问题； 如果数据库数据更新，缓存没有更新，那查到的就是缓存中的旧数据； 内存淘汰：不用自己维护，利用redis内存淘汰机制，当内存不足时淘汰部分数据，下次查询时更新缓存；在一定程度上可以保证一致性；但是这种一致性不是我们能控制的，淘汰哪一部分数据，什么时候淘汰，不确定；好处是没有维护成本； 超时剔除：给缓存数据添加过期时间TTL,到期自动删除缓存，下次查询更新缓存；这个一致性的强度取决于时间长短；一致性一般，维护成本也低； 主动更
redis页面缓存html使用redis实现页面缓存.docx
07-06
如果商品被访问过且访问的排名在 10000 之内，就可以缓存返回 true。 缓存实现代码：在缓存实现中，我们使用了 Jedis 连接 Redis 服务器，并使用了 zadd、zremrangeByRank、zincrby 等方法来操作缓存。缓存的实现...
redis多级缓存搭建资料
05-31
结合实际业务场景，例如电商网站的商品详情页，可以先从本地缓存（如JVM内存）查找商品信息，未命中再查询Redis一级缓存，最后若仍无结果，则访问数据库并将数据存入二级缓存。 总结，Redis多级缓存的搭建涉及到多...
网上商城项目总结（七）使用Redis 缓存 + 单点登陆系统模拟session
CCCCC_SSSSS的博客
07-31 1453
Redis：C语言开发的一种开源的高性能键值对数据库，是单线程的，不适合保存内容大的数据，会影响性能。NoSQL数据库，基于特殊的结构，将数据存到内存中的数据库（持久化数据方式RDB，AOF稍后写），性能更优，适合高并发读写，存储，访问需求。具有高扩展性，高可用性。 Redis五种数据类型： ①、字符串类型：最基础，最重要。key-value形式，用作缓存。主要方法，get/set，incr（...
基于Redis缓存商城分类以及商品信息Demo
10-15
基于Redis缓存商城分类以及商品信息，实现商城数据高速精确访问，源码，jar包
【商城】redis分布式多级缓存应用(瓶颈之殇)
一个人的人生
05-11 737
缓存 发发发 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客： 全新的界面设计 ，将会带来全新的写作体验； 在创作中心设置你喜爱的代码高亮样式，Markdown 将代码片显示选择的高亮样式 进行展示； 增加了 图片拖拽 功能，你可以
商城项目_Redis中央缓存_页面静态化
布谷鸟
05-11 1031
因为商城项目使用的是微服务的架构，比如产品服务、订单服务、物流服务等等，不同的服务可能会部署在不同的电脑上，以前我们优化查询是用过缓存实现的，即将用户所需要访问的数据，在用户第一次查询的时候，就进入数据库进行查询，然后将所有的数据存放到缓存中，之后用户若再次访问就直接从内存中进行获取，不需要再访问数据库，这在性能上面优化了。并且当出现并发的情况时，比如：几千个用户同时访问同一个资源，这会给数据库或...
Redis实现商品信息对象缓存
最新发布
jakelihua
12-13 407
在秒杀系统的开发中，为了提高系统性能和降低数据库压力，使用Redis进行对象缓存是一种常见的优化策略。本文将详细介绍如何在Spring Boot项目中，通过Redis缓存实现商品信息的对象缓存，以提高系统性能和响应速度。
springboot整合Redis，保存商品和商品库存信息
Xmi2599的博客
05-24 646
（1）Redis配置类，防止存到Redis的数据是二进制或者乱码。（2）使用FastJson序列化。
电商项目缓存问题的解决方案（初步）
pshdhx的博客
11-15 1109
电商项目的三级缓存解决方案1、nginx+lua利用OpenResty实现前端缓存2、JVM缓存3、redis缓存
Spring 集成 Redis 实现商品信息内存缓存（Redis 数据缓存分析）
Coder Yang
09-03 3520
一、Redis 内存数据库简介 Redis is an open source (BSD licensed), in-memory data structure store, used as a database, cache and message broker. It supports data structures such as strings, hashes, lists, sets...
缓存与分布式锁实战：Redis 整合与缓存策略解析
例如，电商类应用的商品分类和商品列表可以缓存并设置适当的失效时间，确保后台更新后能在一段时间内反映到前端。 2. 缓存逻辑：在代码实现中，通常采用“缓存-数据库”双查策略，当缓存为空时，从数据库中加载数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值