item2-4 (商户查询缓存1)

@GetMapping("/{id}")
public Result queryShopById(@PathVariable("id") Long id) {
    //这里是直接查询数据库
    return shopService.queryById(id);
}

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

@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Override
    public Result queryById(Long id) {
        String key = CACHE_SHOP_KEY + id;
        // 从 redis 查询缓存
        String shopJson = stringRedisTemplate.opsForValue().get(key);

        // 判断是否存在
        if(StrUtil.isNotBlank(shopJson)){
            // 存在 直接返回
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return Result.ok(shop);
        }

        // 不存在根据id查询数据库
        Shop shop = getById(id);

        // 不存在 返回 404
        if(shop == null){
            return Result.fail("店铺不存在");
        }

        // 存在 写入 redis
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shop));

        // 返回
        return Result.ok(shop);
    }
}

@Override
public Result update(Shop shop) {
    Long id = shop.getId();
    if(id == null){
        return Result.fail("商户id为空");
    }
    updateById(shop);
    stringRedisTemplate.delete(CACHE_SHOP_KEY + id);
    return Result.ok();
}

@Override
public Result queryById(Long id) {
    String key = CACHE_SHOP_KEY + id;
    // 从 redis 查询缓存
    String shopJson = stringRedisTemplate.opsForValue().get(key);

    // 判断是否存在
    // “”也是返回 false
    if(StrUtil.isNotBlank(shopJson)){
        // 存在 直接返回
        Shop shop = JSONUtil.toBean(shopJson, Shop.class);
        return Result.ok(shop);
    }
    // 判断命中的是否是空值
    if(shopJson != null){
        // “” 的情况
        return Result.fail("店铺不存在");
    }

    // 不存在根据id查询数据库
    Shop shop = getById(id);

    // 不存在 返回 404
    if(shop == null){
        // 将空值写入
        stringRedisTemplate.opsForValue().set(key, "", CACHE_SHOP_TTL, TimeUnit.MINUTES);
        return Result.fail("店铺不存在");
    }

    // 存在 写入 redis
    stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shop), CACHE_SHOP_TTL, TimeUnit.MINUTES);

    // 返回
    return Result.ok(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);
}

/**
 * 互斥锁实现
 * @param id
 * @return
 */
public Shop queryWithMutex(Long id) {
  String key = CACHE_SHOP_KEY + id;
  // 从 redis 查询缓存
  String shopJson = stringRedisTemplate.opsForValue().get(key);

  // 判断是否存在
  // “”也是返回 false
  if (StrUtil.isNotBlank(shopJson)) {
      // 存在 直接返回
      return JSONUtil.toBean(shopJson, Shop.class);
  }
  // 判断命中的是否是空值
  if (shopJson != null) {
      // “” 的情况
      return null;
  }

  // 实现缓存重建
  // 获取互斥锁
  String lockKey = "lock:shop:" + id;
  Shop shop = null;
  try {
      boolean isLock = tryLock(lockKey);
      if (!isLock) {
          // 失败休眠重试
          Thread.sleep(50);
          return queryWithMutex(id);
      }
      // 成功，根据id查询数据库
      shop = getById(id);

      // 模拟重建延时
      Thread.sleep(200);

      // 不存在 返回 404
      if (shop == null) {
          // 将空值写入
          stringRedisTemplate.opsForValue().set(key, "", CACHE_SHOP_TTL, TimeUnit.MINUTES);
          return null;
      }
      // 存在 写入 redis
      stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shop), CACHE_SHOP_TTL, TimeUnit.MINUTES);
  }
  catch (InterruptedException e) {
      unlock(lockKey);
      throw new RuntimeException(e);
  }
  finally {
      // 释放锁
      unlock(lockKey);
  }
  // 返回
  return shop;
}

@Data
public class RedisData {
    private LocalDateTime expireTime;
    private Object data;
}

public void saveShop2Redis(Long id, Long expireSeconds) {
  // 查询店铺数据
  Shop shop = getById(id);
  // 封装逻辑过期时间
  RedisData redisData = new RedisData();
  redisData.setExpireTime(LocalDateTime.now().plusSeconds(expireSeconds));
  redisData.setData(shop);
  // 写入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 key = CACHE_SHOP_KEY + id;
  // 从 redis 查询缓存
  String shopJson = stringRedisTemplate.opsForValue().get(key);

  // 判断是否存在
  if(StrUtil.isBlank(shopJson)){
      // 不存在 直接返回
      return null;
  }

  // 命中，先吧json反序列化为对象
  RedisData redisData = JSONUtil.toBean(shopJson, RedisData.class);
  Shop shop = JSONUtil.toBean((JSONObject) redisData.getData(), Shop.class);
  LocalDateTime expireTime = redisData.getExpireTime();

  // 判断逻辑时间是否过期
  if(expireTime.isAfter(LocalDateTime.now())){
      // 未过期 直接返回
      return shop;
  }

  // 已过期 需要缓存重建
  String lockKey = 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);
          }
      });

  }

  // 直接返回过期信息
  return shop;
}