封裝Redis工具類實(shí)踐

更新時(shí)間：2025年12月06日 09:32:35 作者：Super_Leng

本文介紹了基于StringRedisTemplate封裝的Redis工具類,該工具類提供了多種方法來處理緩存,包括設(shè)置TTL過期時(shí)間、邏輯過期時(shí)間、處理緩存擊穿和穿透問題,在ShopServiceImpl中調(diào)用了這些方法

一、封裝Redis工具類

基于StringRedisTemplate封裝一個(gè)緩存工具類，滿足下列需求：

方法1：將任意Java對(duì)象序列化為json并存儲(chǔ)在string類型的key中，并且可以設(shè)置TTL過期時(shí)間
方法2：將任意Java對(duì)象序列化為json并存儲(chǔ)在string類型的key中，并且可以設(shè)置邏輯過期時(shí)間，用于處理緩存擊穿問題
方法3：根據(jù)指定的key查詢緩存，并反序列化為指定類型，利用緩存空值的方式解決緩存穿透問題
方法4：根據(jù)指定的key查詢緩存，并反序列化為指定類型，需要利用邏輯過期解決緩存擊穿問題
方法5：根據(jù)指定的key查詢緩存，并反序列化為指定類型，需要利用互斥鎖解決緩存擊穿問題

1. 使用構(gòu)造方法注入StringRedisTemplate

@Slf4j
@Component
public class CacheClient {

    private final StringRedisTemplate stringRedisTemplate;

    // 構(gòu)造方法注入StringRedisTemplate
    public CacheClient(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }
}

2. 方法1

將任意Java對(duì)象序列化為json并存儲(chǔ)在string類型的key中，并且可以設(shè)置TTL過期時(shí)間

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

3. 方法2

將任意Java對(duì)象序列化為json并存儲(chǔ)在string類型的key中，并且可以設(shè)置邏輯過期時(shí)間，用于處理緩存擊穿問題

public void setWithLogicalExpire(String key, Object value, Long time, TimeUnit unit) {
    // 設(shè)置邏輯過期
    RedisData redisData = new RedisData();
    redisData.setData(value);
    redisData.setExpireTime(LocalDateTime.now().plusSeconds(unit.toSeconds(time)));
    // 寫入Redis
    stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(redisData));
}

4. 方法3

根據(jù)指定的key查詢緩存，并反序列化為指定類型，利用緩存空值的方式解決緩存穿透問題

/**
 * @param keyPrefix 業(yè)務(wù)的緩存key前綴，例如："cache:shop:"
 * @param id
 * @param type 對(duì)象類型，例如：User.class、Shop.class
 * @param dbFallback 傳入查詢數(shù)據(jù)庫的方法，例如：getById(id);
 * @param time
 * @param unit
 * @param <R>   返回值類型
 * @param <ID>  id的類型，String、Integer、Long。。。
 * @return
 */
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.從redis查詢商鋪緩存
    String json = stringRedisTemplate.opsForValue().get(key);
    // 2.判斷是否存在
    if (StrUtil.isNotBlank(json)) {
        // 3.存在，直接返回
        return JSONUtil.toBean(json, type);
    }
    // 判斷命中的是否是空值
    if (json != null) {
        // 返回一個(gè)錯(cuò)誤信息
        return null;
    }

    // 4.不存在，根據(jù)id查詢數(shù)據(jù)庫
    R r = dbFallback.apply(id);
    // 5.不存在，返回錯(cuò)誤
    if (r == null) {
        // 將空值寫入redis
        stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
        // 返回錯(cuò)誤信息
        return null;
    }
    // 6.存在，寫入redis
    this.set(key, r, time, unit);
    return r;
}

5. 方法4

根據(jù)指定的key查詢緩存，并反序列化為指定類型，需要利用邏輯過期解決緩存擊穿問題

@Data
public class RedisData {
    // 邏輯過期時(shí)間
    private LocalDateTime expireTime;
    // 緩存預(yù)熱對(duì)象
    private Object data;
}

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反序列化為對(duì)象
     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.成功，開啟獨(dú)立線程，實(shí)現(xiàn)緩存重建
         CACHE_REBUILD_EXECUTOR.submit(() -> {
             try {
                 // 查詢數(shù)據(jù)庫
                 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;
 }

6. 方法5

根據(jù)指定的key查詢緩存，并反序列化為指定類型，需要利用互斥鎖解決緩存擊穿問題

/**
 * 自定義互斥鎖，利用redis的setnx方法來表示獲取鎖
 * @param key
 * @return
 */
private boolean tryLock(String key) {
    Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", LOCK_SHOP_TTL, TimeUnit.SECONDS);
    return BooleanUtil.isTrue(flag);
}

/**
 * 釋放互斥鎖
 * @param key
 */
private void unlock(String key) {
    stringRedisTemplate.delete(key);
}

public <R, ID> R queryWithMutex(String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit unit) {
    String key = keyPrefix + id;
    // 1.從redis查詢商鋪緩存
    String shopJson = stringRedisTemplate.opsForValue().get(key);
    // 2.判斷是否存在
    if (StrUtil.isNotBlank(shopJson)) {
        // 3.存在，直接返回
        return JSONUtil.toBean(shopJson, type);
    }
    // 判斷命中的是否是空值
    if (shopJson != null) {
        // 返回一個(gè)錯(cuò)誤信息
        return null;
    }

    // 4.實(shí)現(xiàn)緩存重建
    // 4.1.獲取互斥鎖
    String lockKey = LOCK_SHOP_KEY + id;
    R r = null;
    try {
        boolean isLock = tryLock(lockKey);
        // 4.2.判斷是否獲取成功
        if (!isLock) {
            // 4.3.獲取鎖失敗，休眠并重試
            Thread.sleep(50);
            return queryWithMutex(keyPrefix, id, type, dbFallback, time, unit);
        }
        // 4.4.獲取鎖成功，根據(jù)id查詢數(shù)據(jù)庫
        r = dbFallback.apply(id);
        // 5.不存在，返回錯(cuò)誤
        if (r == null) {
            // 將空值寫入redis
            stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
            // 返回錯(cuò)誤信息
            return null;
        }
        // 6.存在，寫入redis
        this.set(key, r, time, unit);
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    } finally {
        // 7.釋放鎖
        unlock(lockKey);
    }
    // 8.返回
    return r;
}

二、調(diào)用Redis工具類

在ShopServiceImpl中，調(diào)用Redis工具類

@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {

    @Resource
    private CacheClient cacheClient;


    @Override
    public Result queryById(Long id) {
        // 解決緩存穿透
        Shop shop = cacheClient.queryWithPassThrough(CACHE_SHOP_KEY, id, Shop.class, this::getById, CACHE_SHOP_TTL, TimeUnit.MINUTES);

        // 互斥鎖解決緩存擊穿
        // Shop shop = cacheClient.queryWithMutex(CACHE_SHOP_KEY, id, Shop.class, this::getById, CACHE_SHOP_TTL, TimeUnit.MINUTES);

        // 邏輯過期解決緩存擊穿
        // Shop shop = cacheClient.queryWithLogicalExpire(CACHE_SHOP_KEY, id, Shop.class, this::getById, 20L, TimeUnit.SECONDS);

        if (shop == null) {
            return Result.fail("店鋪不存在！");
        }

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