Redis：逻辑过期实现

傷城~ 2024-03-24 08:34 38阅读 0赞

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 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.CACHE_NULL_TTL;
    import static com.hmdp.utils.RedisConstants.LOCK_SHOP_KEY;
    
    @Slf4j
    @Component
    public class CacheClient {
    
        private final StringRedisTemplate stringRedisTemplate;
    
        private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);
    
        public CacheClient(StringRedisTemplate stringRedisTemplate) {
            this.stringRedisTemplate = stringRedisTemplate;
        }
    
        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 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));
        }
    
    
        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)) {
    
                // 存在，直接返回
                return null;
            }
    
            // 3.命中，需要先把json反序列化为对象
            RedisData redisData = JSONUtil.toBean(json, RedisData.class);
            R r = JSONUtil.toBean((JSONObject) redisData.getData(), type);
            LocalDateTime expireTime = redisData.getExpireTime();
    
            // 4.判断是否过期
            if(expireTime.isAfter(LocalDateTime.now())) {
    
                // 未过期，直接返回信息
                return r;
            }
    
            // 5.已过期，需要缓存重建
            // 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 newR = dbFallback.apply(id);
                        // 重建缓存
                        this.setWithLogicalExpire(key, newR, time, unit);
    
                    } catch (Exception e) {
                        throw new RuntimeException(e);
                    }finally {
    
                        // 释放锁
                        unlock(lockKey);
                    }
                });
            }
    
            // 6.4.返回过期的信息
            return r;
        }
    }

import cn.hutool.core.util.StrUtil;
     
    /**
     *  服务实现类
     */
    @Service
    public class DemoServiceImpl extends ServiceImpl<DemoMapper, Demo> implements IDemoService {
     
        @Resource
        private CacheClient cacheClient;
     
        @Override
        public Result queryById(Long id) {
     
     
            // 逻辑过期解决缓存击穿
            Demo demo = cacheClient
                .queryWithLogicalExpire(CACHE_SHOP_KEY, id, Demo.class, this::getById, CACHE_DEMO_TTL, TimeUnit.MINUTES);
     
            if (demo== null) {
                return Result.fail("demo不存在！");
            }
     
            // 返回
            return Result.ok(demo);
        }
     
    }