缓存就是数据交换的缓冲区,是存储数据的临时地方,一般读写性能较高。
缓存的作用:
缓存的成本:
当我们查询商铺信息时,首先先去 Redis 中查询,如果查询到了,则直接返回商铺信息,未查询到则查询数据库,将查询到的信息先写入 Redis 中,以便下次查询时可以直接命中缓存,然后再将商铺信息返回给用户。
@RestController
@RequestMapping("/shop")
public class ShopController {
@Resource
public IShopService shopService;
/**
* 根据id查询商铺信息
* @param id 商铺id
* @return 商铺详情数据
*/
@GetMapping("/{id}")
public Result queryShopById(@PathVariable("id") Long id) {
return shopService.queryById(id);
}
}
public interface IShopService extends IService<Shop> {
Result queryById(Long id);
}
@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {
@Autowired
private StringRedisTemplate stringRedisTemplate;
@Override
public Result queryById(Long id) {
// 1、根据 Id 查询 Redis
String shopJson = stringRedisTemplate.opsForValue().get(RedisConstants.CACHE_SHOP_KEY + id);
// 2、判断 shopJSON 是否为空
if (StrUtil.isNotBlank(shopJson)) {
// 3、存在,直接返回
Shop shop = JSONUtil.toBean(shopJson, Shop.class);
return Result.ok(shop);
}
// 4、不存在,查询数据库
Shop shop = getById(id);
// 5、不存在,返回错误
if(shop == null){
return Result.fail("店铺不存在!");
}
// 6、存在,写入 Redis
stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(shop));
// 7、返回
return Result.ok(shop);
}
}
Read/Writer Through Pattern 最大的问题是目前很难找到这样的服务。
Writer Behind Caching Pattern 的效率比较高,但是一致性难以保证,当缓存数据更新,还未开始异步更新数据库,如果此时 Redis 发生宕机,就会丢失数据。
Cache Aside Pattern 尽管需要自己编码,但其可控性更高,所以一般使用该种策略来进行缓存更新。
使用 Cache Aside Pattern 策略来操作缓存和数据库时有三个问题需要考虑:
更新缓存:每次更新数据库都更新缓存,无效写操作较多。
如果我们对数据库做了上百次操作,那么就需要对缓存进行上百次操作,在进行这上百次的操作过程中,如果没有任何的查询操作,也就是写多读少,那么对于缓存的上百次操作都可以看作成是无效的操作。
删除操作:更新数据库时让缓存失效,查询时再更新缓存。(一般选择此种方案)
单体系统,将缓存与数据库操作放在一个事务。
分布式事务,利用 TCC 等分布式事务方案。
(1)先删除缓存,再操作数据库:假设有两个线程:线程1 和 线程2,线程1执行更新操作,先将缓存中的数据删除,然后执行更新数据库操作,由于更新逻辑复杂,执行时间较长,此时线程2 也开始执行,线程2 执行查询操作,由于缓存中的数据被线程 1 删除了,导致查询缓存未命中,于是线程2转而去查询数据库,此时数据库并未完成更新操作,查询出的数据依旧为旧数据,接着程序就将旧数据重新写入到了缓存。这就会导致后续的所有查询操作查询到的数据依旧是旧数据。
(2)先操作数据库,再删除缓存:
情况一:假设有两个线程,线程 1 和线程 2,线程 1 执行更新操作,线程 1 先去更新数据库,然后再删除缓存,由于更新逻辑复杂,执行时间较长,此时线程2 也开始执行,线程 2 执行查询操作,由于此时数据库尚未更新完成,且缓存未被删除,线程 2 依然能从缓存中查询到旧的数据,一旦线程 1 更新数据库完成,且删除了缓存中的数据,那么其他线程再查询时就会无法命中缓存,从而去查询数据库同步缓存数据。这种情况的一个好处就是,即使线程1 未完成数据库的更新,其他线程在查询时依然能够命中缓存,哪怕是旧的缓存,也不会额外浪费时间去查询数据库。而且一旦数据库更新完成,后续的查询便都是最新的数据。
情况二:还有一种情况就是当线程 2 执行查询操作时,此时缓存中的数据恰好过期,然后线程 2 便会去数据库中查询,但是此时线程 1 未完成更新操作,所以数据库中还是原先的数据,线程 2 在将旧数据重新写入缓存的同时,恰巧线程 1 完成了数据库更新操作,并将缓存删除,这就导致缓存中的数据一直是旧数据。但实际上这种情况发生的概率极低,为了避免这种情况的发生,可以在写入缓存的时候设置过期时间。
这两种情况虽然也会存在数据不一致的情况,但在数据库更新完成后,再下一次执行查询操作时,必定查询出的是最新的数据,那么写入缓存的也就是最新数据了。
关于这两种情况的更多的分析,可以看下下面两篇文章:
删缓存,数据库更新谁先执行,及延时双删
分布式系统知识点十二:更新数据时,是先删除缓存再更新DB,还是先更新DB再删除缓存?(转载)
总结下就是双写不一致的情况是无法彻底避免的,只能选取发生概率最小的方案。
根据这个要求,很明显,“先更新数据库,再删除缓存”这一种方案胜出。
内容取自浅析数据库与缓存的双写一致性问题
缓存更新策略的最佳实践方案:
1、低一致性需求:使用 Redis 自带的内存淘汰机制
2、高一致性需求:主动更新,并以超时剔除作为兜底方案
给查询商铺的缓存添加超时剔除和主动更新的策略:
修改 ShopController 中的业务逻辑,满足下面的需求:
根据 id 查询店铺时,如果缓存未命中,则查询数据库,将数据库结果写入缓存,并设置超时时间
@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {
@Autowired
private StringRedisTemplate stringRedisTemplate;
@Override
public Result queryById(Long id) {
// 1、根据 Id 查询 Redis
String shopJson = stringRedisTemplate.opsForValue().get(RedisConstants.CACHE_SHOP_KEY + id);
// 2、判断 shopJSON 是否为空
if (StrUtil.isNotBlank(shopJson)) {
// 3、存在,直接返回
Shop shop = JSONUtil.toBean(shopJson, Shop.class);
return Result.ok(shop);
}
// 4、不存在,查询数据库
Shop shop = getById(id);
// 5、不存在,返回错误
if(shop == null){
return Result.fail("店铺不存在!");
}
// 6、存在,写入 Redis
stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(shop), RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
// 7、返回
return Result.ok(shop);
}
}
@RestController
@RequestMapping("/shop")
public class ShopController {
@Resource
public IShopService shopService;
/**
* 更新商铺信息
* @param shop 商铺数据
* @return 无
*/
@PutMapping
public Result updateShop(@RequestBody Shop shop) {
// 写入数据库
return shopService.update(shop);
}
}
public interface IShopService extends IService<Shop> {
Result update(Shop shop);
}
@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {
@Autowired
private StringRedisTemplate stringRedisTemplate;
@Override
@Transactional
public Result update(Shop shop) {
Long id = shop.getId();
if(id == null){
return Result.fail("店铺 id 不能为空!");
}
updateById(shop);
stringRedisTemplate.delete(RedisConstants.CACHE_SHOP_KEY + id);
return Result.ok();
}
}
缓存穿透是指客户端请求的数据在缓存中和数据库中都不存在,这样缓存永远不会生效,这些请求都会到达数据库。
如果有恶意用户,使用大量线程并发访问这些不存在的数据,这样所有的请求都会到达数据库,数据库顶不住访问压力,就会崩掉。
常见的解决方案有两种:
布隆过滤器判断时,如果数据不存在,就是真的不存在,如果判断数据存在,那么有可能不存在。存在一定的穿透风险。
@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {
@Autowired
private StringRedisTemplate stringRedisTemplate;
@Override
public Result queryById(Long id) {
// 1、根据 Id 查询 Redis
String shopJson = stringRedisTemplate.opsForValue().get(RedisConstants.CACHE_SHOP_KEY + id);
// 2、判断 shopJSON 是否为空
if (StrUtil.isNotBlank(shopJson)) {
// 3、存在,直接返回
Shop shop = JSONUtil.toBean(shopJson, Shop.class);
return Result.ok(shop);
}
// 增加对空字符串的判断
if(shopJson != null){
return Result.fail("店铺不存在!");
}
// 4、不存在,查询数据库
Shop shop = getById(id);
// 5、不存在,返回错误
if(shop == null){
// 店铺不存在时,缓存空值
stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, "", RedisConstants.CACHE_NULL_TTL, TimeUnit.MINUTES);
return Result.fail("店铺不存在!");
}
// 6、存在,写入 Redis
stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(shop), RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
// 7、返回
return Result.ok(shop);
}
}
缓存雪崩是指在同一时段大量的缓存 key 同时失效或者 Redis 服务宕机,导致大量请求到达数据库,给数据库带来巨大压力。
解决方案:
缓存击穿问题也叫热点 key 问题,就是一个被高并发访问并且缓存重建业务较复杂的 key 突然失效了,无效的请求访问会在瞬间给数据库带来巨大压力。
常见的解决方案:
互斥锁
假设线程 1 查询缓存未命中,那么线程 1 就需要进行缓存重建工作,为了避免其他线程重复线程1 的工作,那么线程 1 就必须要先获取互斥锁,只有获取锁成功的线程才能够重建缓存数据。重建完成后,线程 1 就会将数据写入到缓存中,并将锁释放。如果在线程 1 将数据写入缓存之前,其他线程涌入,这个时候,其他线程查询缓存依然是未命中的,那么这些线程为了重建缓存,也必须先获取到互斥锁,但是,由于此时线程 1 未释放锁,所以其他线程就会获取锁失败,一旦获取锁失败,一般程序处理是让线程休眠一会儿,然后再重试(包括查询缓存以及获取互斥锁),如果线程 1 执行缓存重建时间过长,就会导致其他线程一直处于阻塞等待重试的状态,效率过低。
逻辑过期
当我们在向 Redis 中存储数据时,不再为 key 设置过期时间(TTL),但是,需要在 value 中额外添加一个逻辑时间(以当前时间为基础,加上需要设置的过期时间),也就是说,这个 key 一旦存入到 Redis 中,就会永不过期。假设线程 1 在查询缓存时发现逻辑时间已经过期,为了避免出现多个线程重建缓存,线程 1 就会去获取互斥锁,一旦线程 1 获取互斥锁成功,线程 1 就会开启一个独立线程,由独立线程去查询数据库重建缓存数据,以及写入缓存重置逻辑过期时间等操作,一旦完成操作,独立线程就会将互斥锁释放掉。线程 1 在开启独立线程后,会直接将过期数据返回。而在独立线程释放锁之前,缓存中的数据都是过期数据。当其他线程在此之前涌入程序时,去查询缓存获取到依旧是逻辑时间过期的数据,那么这些线程就会试图获取互斥锁,此时由于独立线程还未释放锁,所以会获取锁失败,一旦失败,这些线程就会将查询到的旧数据返回。只有当独立线程执行结束,其他线程才会从缓存中获取到新数据。
需求:修改根据 id 查询商铺的业务,基于互斥锁方式来解决缓存击穿问题。业务流程如下:
我们使用 SETNX 命令来实现互斥锁。
SETNX 只有在 key 不存在的时候才能存储成功,并且返回;如果 Redis 中存在要设置的 key,则存储不成功,并且返回 0。
当有多个线程同时获取互斥锁时,根据 SETNX 的特性,那么只会有其中一个线程 SETNX 成功,其他线程在 SETNX 时,只能返回 0,而释放锁也很简单,只需要删除 key 即可。但是,这种方案会存在一个问题,当线程获取到互斥锁后,由于程序出现问题,导致锁迟迟无法释放,所以我们在获取互斥锁时,即在执行 SETNX 命令时,往往会添加上一个有效期,一般有效期时长会是业务程序执行时间10~20倍,避免异常情况。
@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {
@Autowired
private StringRedisTemplate stringRedisTemplate;
@Override
public Result queryById(Long id) {
// 解决缓存穿透
// Shop shop = queryWithPassThrough(id);
// 互斥锁解决缓存击穿
Shop shop = queryWithMetux(id);
if(shop == null){
return Result.fail("店铺不存在!");
}
// 7、返回
return Result.ok(shop);
}
/**
* 解决缓存击穿问题
* */
public Shop queryWithMetux(Long id){
// 1、根据 Id 查询 Redis
String shopJson = stringRedisTemplate.opsForValue().get(RedisConstants.CACHE_SHOP_KEY + id);
// 2、判断 shopJSON 是否为空
if (StrUtil.isNotBlank(shopJson)) {
// 3、存在,直接返回
Shop shop = JSONUtil.toBean(shopJson, Shop.class);
return shop;
}
// 增加对空字符串的判断
if(shopJson != null){
return null;
}
// 获取互斥锁
String lockKey = RedisConstants.LOCK_SHOP_KEY + id;
Shop shop = null;
try {
// 获取互斥锁
boolean isLock = tryLock(lockKey);
// 如果获取失败,则重新获取
if (!isLock) {
Thread.sleep(30);
return queryWithMetux(id);
}
// 4、不存在,查询数据库
shop = getById(id);
// 5、不存在,返回错误
if (shop == null) {
// 店铺不存在时,缓存空值
stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, "", RedisConstants.CACHE_NULL_TTL, TimeUnit.MINUTES);
return null;
}
// 6、存在,写入 Redis
stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(shop), RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
}catch (InterruptedException e){
throw new RuntimeException(e);
} finally {
// 释放互斥锁
unLock(lockKey);
}
return shop;
}
/**
* 解决缓存穿透
* */
public Shop queryWithPassThrough(Long id){
// 1、根据 Id 查询 Redis
String shopJson = stringRedisTemplate.opsForValue().get(RedisConstants.CACHE_SHOP_KEY + id);
// 2、判断 shopJSON 是否为空
if (StrUtil.isNotBlank(shopJson)) {
// 3、存在,直接返回
Shop shop = JSONUtil.toBean(shopJson, Shop.class);
return shop;
}
// 增加对空字符串的判断
if(shopJson != null){
return null;
}
// 4、不存在,查询数据库
Shop shop = getById(id);
// 5、不存在,返回错误
if(shop == null){
// 店铺不存在时,缓存空值
stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, "", RedisConstants.CACHE_NULL_TTL, TimeUnit.MINUTES);
return null;
}
// 6、存在,写入 Redis
stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(shop), RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
return shop;
}
// 获取锁
private boolean tryLock(String key){
Boolean isTrue = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", RedisConstants.LOCK_SHOP_TTL, TimeUnit.SECONDS);
return BooleanUtil.isTrue(isTrue);
}
// 释放锁
private void unLock(String key){
stringRedisTemplate.delete(key);
}
@Override
@Transactional
public Result update(Shop shop) {
Long id = shop.getId();
if(id == null){
return Result.fail("店铺 id 不能为空!");
}
updateById(shop);
stringRedisTemplate.delete(RedisConstants.CACHE_SHOP_KEY + id);
return Result.ok();
}
}
使用 Jmeter 进行并发测试,Jmeter 安装教程可以参考:MAC系统下jmeter安装教程
需求:修改根据id查询商铺的业务,基于逻辑过期方式来解决缓存击穿问题
理论上来讲,一旦热点 key 添加 Redis 中,key 就不会过期,就会永久存在,只有活动结束才会将热点 key 从缓存中删除。一般而言,热点 key 通常是参加活动的商品或者其他一些东西,这些数据会提前加入缓存,并设置逻辑过期时间,所以说,这些热点 key 理论上是一直存在的,直至活动结束删除。因此,当我们查询热点 key 时不用判断有没有命中,如果说缓存未命中,说明这个商品不在活动当中,不属于热点 key。
综上,在程序设计时,针对热点 key 可以不用进行缓存穿透的处理。
创建 RedisData,用于保存热点店铺以及设置过期时间,当然也可以使用继承方式。
@Data
public class RedisData {
private LocalDateTime expireTime;
private Object data;
}
@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {
@Autowired
private StringRedisTemplate stringRedisTemplate;
private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);
@Override
public Result queryById(Long id) {
// 解决缓存穿透
// Shop shop = queryWithPassThrough(id);
// 互斥锁解决缓存击穿
// Shop shop = queryWithMetux(id);
Shop shop = queryWithLogicalExpire(id);
if(shop == null){
return Result.fail("店铺不存在!");
}
// 7、返回
return Result.ok(shop);
}
public Shop queryWithLogicalExpire(Long id){
// 1、根据 Id 查询 Redis
String shopJson = stringRedisTemplate.opsForValue().get(RedisConstants.CACHE_SHOP_KEY + id);
// 2、判断 shopJSON 是否为空
if (StrUtil.isBlank(shopJson)) {
// 3、存在,直接返回
return null;
}
// 命中,需要先把 json 反序列化为对象
RedisData redisData = JSONUtil.toBean(shopJson, RedisData.class);
LocalDateTime expireTime = redisData.getExpireTime();
Shop shop = JSONUtil.toBean((JSONObject) redisData.getData(), Shop.class);
// 判断是否过期
if(expireTime.isAfter(LocalDateTime.now())){
return shop;
}
// 已过期,需要缓存重建
// 获取互斥锁
String lockKey = RedisConstants.LOCK_SHOP_KEY + id;
boolean isLock = tryLock(lockKey);
if (isLock) {
// 开辟独立线程
CACHE_REBUILD_EXECUTOR.submit(() -> {
try {
// 缓存重建
this.saveShop2Redis(id, 20L);
}catch (Exception e) {
throw new RuntimeException(e);
} finally {
unLock(lockKey);
}
});
}
// 6、存在,写入 Redis
stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(shop), RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
return shop;
}
/**
* 解决缓存击穿问题
* */
public Shop queryWithMetux(Long id){
// 1、根据 Id 查询 Redis
String shopJson = stringRedisTemplate.opsForValue().get(RedisConstants.CACHE_SHOP_KEY + id);
// 2、判断 shopJSON 是否为空
if (StrUtil.isNotBlank(shopJson)) {
// 3、存在,直接返回
Shop shop = JSONUtil.toBean(shopJson, Shop.class);
return shop;
}
// 增加对空字符串的判断
if(shopJson != null){
return null;
}
// 获取互斥锁
String lockKey = RedisConstants.LOCK_SHOP_KEY + id;
Shop shop = null;
try {
boolean isLock = tryLock(lockKey);
if (!isLock) {
Thread.sleep(30);
return queryWithMetux(id);
}
// 4、不存在,查询数据库
shop = getById(id);
// 5、不存在,返回错误
if (shop == null) {
// 店铺不存在时,缓存空值
stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, "", RedisConstants.CACHE_NULL_TTL, TimeUnit.MINUTES);
return null;
}
// 6、存在,写入 Redis
stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(shop), RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
}catch (InterruptedException e){
throw new RuntimeException(e);
} finally {
// 释放互斥锁
unLock(lockKey);
}
return shop;
}
/**
* 解决缓存穿透
* */
public Shop queryWithPassThrough(Long id){
// 1、根据 Id 查询 Redis
String shopJson = stringRedisTemplate.opsForValue().get(RedisConstants.CACHE_SHOP_KEY + id);
// 2、判断 shopJSON 是否为空
if (StrUtil.isNotBlank(shopJson)) {
// 3、存在,直接返回
Shop shop = JSONUtil.toBean(shopJson, Shop.class);
return shop;
}
// 增加对空字符串的判断
if(shopJson != null){
return null;
}
// 4、不存在,查询数据库
Shop shop = getById(id);
// 5、不存在,返回错误
if(shop == null){
// 店铺不存在时,缓存空值
stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, "", RedisConstants.CACHE_NULL_TTL, TimeUnit.MINUTES);
return null;
}
// 6、存在,写入 Redis
stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(shop), RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
return shop;
}
// 获取锁
private boolean tryLock(String key){
Boolean isTrue = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", RedisConstants.LOCK_SHOP_TTL, TimeUnit.SECONDS);
return BooleanUtil.isTrue(isTrue);
}
// 释放锁
private void unLock(String key){
stringRedisTemplate.delete(key);
}
public void saveShop2Redis(Long id, Long expireSeconds) throws InterruptedException {
// 查询数据库
Shop shop = getById(id);
Thread.sleep(200);
// 封装缓存过期时间
RedisData redisData = new RedisData();
redisData.setData(shop);
redisData.setExpireTime(LocalDateTime.now().plusSeconds(expireSeconds));
stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY, JSONUtil.toJsonStr(redisData));
}
@Override
@Transactional
public Result update(Shop shop) {
Long id = shop.getId();
if(id == null){
return Result.fail("店铺 id 不能为空!");
}
updateById(shop);
stringRedisTemplate.delete(RedisConstants.CACHE_SHOP_KEY + id);
return Result.ok();
}
}
@Slf4j
@Component
public class CacheClient {
@Autowired
private StringRedisTemplate stringRedisTemplate;
private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);
public CacheClient(StringRedisTemplate stringRedisTemplate) {
this.stringRedisTemplate = stringRedisTemplate;
}
/**
* 向缓存中添加 key
* */
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)));
stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(redisData));
}
/**
* 缓存穿透
* */
public <R,ID> R queryWithPassThrough(String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit unit){
String key = keyPrefix + id;
// 1、根据 Id 查询 Redis
String json = stringRedisTemplate.opsForValue().get(RedisConstants.CACHE_SHOP_KEY + id);
// 2、判断 shopJSON 是否为空
if (StrUtil.isNotBlank(json)) {
// 3、存在,直接返回
R r = JSONUtil.toBean(json, type);
return r;
}
// 增加对空字符串的判断
if(json != null){
return null;
}
// 4、不存在,查询数据库
R r = dbFallback.apply(id);
// 5、不存在,返回错误
if(r == null){
// 店铺不存在时,缓存空值
stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, "", RedisConstants.CACHE_NULL_TTL, TimeUnit.MINUTES);
return null;
}
// 6、存在,写入 Redis
this.set(key, r, time, unit);
return r;
}
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、根据 Id 查询 Redis
String json = stringRedisTemplate.opsForValue().get(key);
// 2、判断 shopJSON 是否为空
if (StrUtil.isBlank(json)) {
// 3、存在,直接返回
return null;
}
// 命中,需要先把 json 反序列化为对象
RedisData redisData = JSONUtil.toBean(json, RedisData.class);
LocalDateTime expireTime = redisData.getExpireTime();
R r = JSONUtil.toBean((JSONObject) redisData.getData(), type);
// 判断是否过期
if(expireTime.isAfter(LocalDateTime.now())){
return r;
}
// 已过期,需要缓存重建
// 获取互斥锁
String lockKey = RedisConstants.LOCK_SHOP_KEY + id;
boolean isLock = tryLock(lockKey);
if (isLock) {
// 开辟独立线程
CACHE_REBUILD_EXECUTOR.submit(() -> {
try {
// 缓存重建
R r1 = dbFallback.apply(id);
this.setWithLogicalExpire(key, r1, time, unit);
}catch (Exception e) {
throw new RuntimeException(e);
} finally {
unLock(lockKey);
}
});
}
// 6、存在,写入 Redis
this.set(key, r, time, unit);
return r;
}
// 获取锁
private boolean tryLock(String key){
Boolean isTrue = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", RedisConstants.LOCK_SHOP_TTL, TimeUnit.SECONDS);
return BooleanUtil.isTrue(isTrue);
}
// 释放锁
private void unLock(String key){
stringRedisTemplate.delete(key);
}
}
ShopServiceImpl
@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {
@Autowired
private StringRedisTemplate stringRedisTemplate;
@Autowired
private CacheClient cacheClient;
private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);
@Override
public Result queryById(Long id) {
// 解决缓存穿透
// Shop shop = cacheClient.queryWithPassThrough(CACHE_SHOP_KEY, id, Shop.class, this::getById, RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
// 互斥锁解决缓存击穿
// Shop shop = queryWithMetux(id);
// 使用逻辑过期时间解决缓存击穿问题
// Shop shop = queryWithLogicalExpire(id);
Shop shop = cacheClient.queryWithLogicalExpire(CACHE_SHOP_KEY, id, Shop.class, this::getById, RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
if(shop == null){
return Result.fail("店铺不存在!");
}
// 7、返回
return Result.ok(shop);
}
public Shop queryWithLogicalExpire(Long id){
// 1、根据 Id 查询 Redis
String shopJson = stringRedisTemplate.opsForValue().get(RedisConstants.CACHE_SHOP_KEY + id);
// 2、判断 shopJSON 是否为空
if (StrUtil.isBlank(shopJson)) {
// 3、存在,直接返回
return null;
}
// 命中,需要先把 json 反序列化为对象
RedisData redisData = JSONUtil.toBean(shopJson, RedisData.class);
LocalDateTime expireTime = redisData.getExpireTime();
Shop shop = JSONUtil.toBean((JSONObject) redisData.getData(), Shop.class);
// 判断是否过期
if(expireTime.isAfter(LocalDateTime.now())){
return shop;
}
// 已过期,需要缓存重建
// 获取互斥锁
String lockKey = RedisConstants.LOCK_SHOP_KEY + id;
boolean isLock = tryLock(lockKey);
if (isLock) {
// 开辟独立线程
CACHE_REBUILD_EXECUTOR.submit(() -> {
try {
// 缓存重建
this.saveShop2Redis(id, 20L);
}catch (Exception e) {
throw new RuntimeException(e);
} finally {
unLock(lockKey);
}
});
}
// 6、存在,写入 Redis
stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(shop), RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
return shop;
}
}