public static final String SHOPCACHEPREFIX = "cache:shop:";
    
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    // JSON工具
    ObjectMapper objectMapper = new ObjectMapper();

    @Override
    public Result queryById(Long id) {
        //從Redis查詢商鋪緩存
        String cacheShop = stringRedisTemplate.opsForValue().get(SHOPCACHEPREFIX + id);

        //判斷緩存中數(shù)據(jù)是否存在
        if (!StringUtil.isNullOrEmpty(cacheShop)) {
            //緩存中存在則直接返回
            try {
                // 將子字符串轉(zhuǎn)換為對象
                Shop shop = objectMapper.readValue(cacheShop, Shop.class);
                return Result.ok(shop);
            } catch (JsonProcessingException e) {
                e.printStackTrace();
            }
        }

        //緩存中不存在，則從數(shù)據(jù)庫里進行數(shù)據(jù)查詢
        Shop shop = getById(id);

        //數(shù)據(jù)庫里不存在，返回404
        if (null==shop){
            return Result.fail("信息不存在");
        }
        //數(shù)據(jù)庫里存在，則將信息寫入Redis
        try {
            String shopJSon = objectMapper.writeValueAsString(shop);
          stringRedisTemplate.opsForValue().set(SHOPCACHEPREFIX+id,shopJSon,30,TimeUnit.MINUTES);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        //返回
        return Result.ok(shop);
    }

  @Override
    @Transactional
    public Result updateShop(Shop shop) {
        Long id = shop.getId();
        if (null==id){
            return Result.fail("店鋪id不能為空");
        }
        //更新數(shù)據(jù)庫
        boolean b = updateById(shop);
        //刪除緩存
        stringRedisTemplate.delete(SHOPCACHEPREFIX+shop.getId());
        return Result.ok();
    }

public static final String SHOPCACHEPREFIX = "cache:shop:";

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    // JSON工具
    ObjectMapper objectMapper = new ObjectMapper();

    @Override
    public Result queryById(Long id) {
        //從Redis查詢商鋪緩存
        String cacheShop = stringRedisTemplate.opsForValue().get(SHOPCACHEPREFIX + id);

        //判斷緩存中數(shù)據(jù)是否存在
        if (!StringUtil.isNullOrEmpty(cacheShop)) {
            //緩存中存在則直接返回
            try {
                // 將子字符串轉(zhuǎn)換為對象
                Shop shop = objectMapper.readValue(cacheShop, Shop.class);
                return Result.ok(shop);
            } catch (JsonProcessingException e) {
                e.printStackTrace();
            }
        }

        // 因為上面判斷了cacheShop是否為空，如果進到這個方法里面則一定是空，直接過濾，不打到數(shù)據(jù)庫
        if (null != cacheShop){
            return Result.fail("信息不存在");
        }

        //緩存中不存在，則從數(shù)據(jù)庫里進行數(shù)據(jù)查詢
        Shop shop = getById(id);

        //數(shù)據(jù)庫里不存在，返回404
        if (null==shop){
            // 緩存空對象
            stringRedisTemplate.opsForValue().set(SHOPCACHEPREFIX+id,"",2,TimeUnit.MINUTES);
            return Result.fail("信息不存在");
        }
        //數(shù)據(jù)庫里存在，則將信息寫入Redis
        try {
            String shopJSon = objectMapper.writeValueAsString(shop);
            stringRedisTemplate.opsForValue().set(SHOPCACHEPREFIX+id,shopJSon,30,TimeUnit.MINUTES);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        //返回
        return Result.ok(shop);
    }

    /**
     * 嘗試獲取鎖
     *
     * @param key
     * @return
     */
    private boolean tryLock(String key) {
        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
        return BooleanUtil.isTrue(flag);
    }

    /**
     * 刪除鎖
     *
     * @param key
     */
    private void unLock(String key) {
        stringRedisTemplate.delete(key);
    }

public Shop queryWithMutex(Long id) throws InterruptedException {
        //從Redis查詢商鋪緩存
        String cacheShop = stringRedisTemplate.opsForValue().get(SHOPCACHEPREFIX + id);

        //判斷緩存中數(shù)據(jù)是否存在
        if (!StringUtil.isNullOrEmpty(cacheShop)) {
            //緩存中存在則直接返回
            try {
                // 將子字符串轉(zhuǎn)換為對象
                Shop shop = objectMapper.readValue(cacheShop, Shop.class);
                return shop;
            } catch (JsonProcessingException e) {
                e.printStackTrace();
            }
        }

        // 因為上面判斷了cacheShop是否為空，如果進到這個方法里面則一定是空，直接過濾，不打到數(shù)據(jù)庫
        if (null != cacheShop) {
            return null;
        }

        Shop shop = new Shop();
        // 緩存擊穿，獲取鎖
        String lockKey = "lock:shop:" + id;
        try{
            boolean b = tryLock(lockKey);
            if (!b) {
                // 獲取鎖失敗了
                Thread.sleep(50);
                return queryWithMutex(id);
            }
            //緩存中不存在，則從數(shù)據(jù)庫里進行數(shù)據(jù)查詢
           shop = getById(id);

            //數(shù)據(jù)庫里不存在，返回404
            if (null == shop) {
                // 緩存空對象
                stringRedisTemplate.opsForValue().set(SHOPCACHEPREFIX + id, "", 2, TimeUnit.MINUTES);
                return null;
            }
            //數(shù)據(jù)庫里存在，則將信息寫入Redis
            try {
                String shopJSon = objectMapper.writeValueAsString(shop);
                stringRedisTemplate.opsForValue().set(SHOPCACHEPREFIX + id, shopJSon, 30, TimeUnit.MINUTES);
            } catch (JsonProcessingException e) {
                e.printStackTrace();
            }
        }catch (Exception e){

        }finally {
            // 釋放互斥鎖
            unLock(lockKey);
        }

        //返回
        return shop;

    }

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

  /**
     * 邏輯過期時間對象寫入緩存
     * @param id
     * @param expireSeconds
     */
    public void saveShopToRedis(Long id,Long expireSeconds){
        // 查詢店鋪數(shù)據(jù)
        Shop shop = getById(id);
        // 封裝為邏輯過期
        RedisData redisData = new RedisData();
        redisData.setData(shop);
        redisData.setExpireTime(LocalDateTime.now().plusSeconds(expireSeconds));
        // 寫入Redis
        stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY+id, JSONUtil.toJsonStr(redisData));
    }

/**
     * 緩存擊穿：邏輯過期解決
     * @param id
     * @return
     * @throws InterruptedException
     */
    public Shop queryWithPassLogicalExpire(Long id) throws InterruptedException {
        //1. 從Redis查詢商鋪緩存
        String cacheShop = stringRedisTemplate.opsForValue().get(SHOPCACHEPREFIX + id);

        //2. 判斷緩存中數(shù)據(jù)是否存在
        if (StringUtil.isNullOrEmpty(cacheShop)) {
            // 3. 不存在
            return null;
        }
        // 4. 存在，判斷是否過期
        RedisData redisData = JSONUtil.toBean(cacheShop, RedisData.class);
        JSONObject jsonObject = (JSONObject) redisData.getData();
        Shop shop = JSONUtil.toBean(jsonObject, Shop.class);
        LocalDateTime expireTime = redisData.getExpireTime();

        // 5. 判斷是否過期
        if (expireTime.isAfter(LocalDateTime.now())){
            // 5.1 未過期
            return shop;
        }
        // 5.2 已過期
        String lockKey = "lock:shop:"+id;
        boolean flag = tryLock(lockKey);
        if (flag){
            // TODO 獲取鎖成功，開啟獨立線程，實現(xiàn)緩存重建，建議使用線程池去做
            CACHE_REBUILD_EXECUTOR.submit(()->{
                try {
                    // 重建緩存
                    this.saveShopToRedis(id,1800L);
                }catch (Exception e){
                    
                }finally {
                    // 釋放鎖
                    unLock(lockKey);
                }
             
            });

        }
        // 獲取鎖失敗，返回過期的信息
        return shop;
    }

    /**
     * 線程池
     */
    private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);