封装Redis工具类实践

更新时间：2025年12月06日 09:32:35 作者：Super_Leng

本文介绍了基于StringRedisTemplate封装的Redis工具类,该工具类提供了多种方法来处理缓存,包括设置TTL过期时间、逻辑过期时间、处理缓存击穿和穿透问题,在ShopServiceImpl中调用了这些方法

一、封装Redis工具类

基于StringRedisTemplate封装一个缓存工具类，满足下列需求：

方法1：将任意Java对象序列化为json并存储在string类型的key中，并且可以设置TTL过期时间
方法2：将任意Java对象序列化为json并存储在string类型的key中，并且可以设置逻辑过期时间，用于处理缓存击穿问题
方法3：根据指定的key查询缓存，并反序列化为指定类型，利用缓存空值的方式解决缓存穿透问题
方法4：根据指定的key查询缓存，并反序列化为指定类型，需要利用逻辑过期解决缓存击穿问题
方法5：根据指定的key查询缓存，并反序列化为指定类型，需要利用互斥锁解决缓存击穿问题

1. 使用构造方法注入StringRedisTemplate

@Slf4j
@Component
public class CacheClient {

    private final StringRedisTemplate stringRedisTemplate;

    // 构造方法注入StringRedisTemplate
    public CacheClient(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }
}

2. 方法1

将任意Java对象序列化为json并存储在string类型的key中，并且可以设置TTL过期时间

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

3. 方法2

将任意Java对象序列化为json并存储在string类型的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));
}

4. 方法3

根据指定的key查询缓存，并反序列化为指定类型，利用缓存空值的方式解决缓存穿透问题

/**
 * @param keyPrefix 业务的缓存key前缀，例如："cache:shop:"
 * @param id
 * @param type 对象类型，例如：User.class、Shop.class
 * @param dbFallback 传入查询数据库的方法，例如：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) {
        // 返回一个错误信息
        return null;
    }

    // 4.不存在，根据id查询数据库
    R r = dbFallback.apply(id);
    // 5.不存在，返回错误
    if (r == null) {
        // 将空值写入redis
        stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
        // 返回错误信息
        return null;
    }
    // 6.存在，写入redis
    this.set(key, r, time, unit);
    return r;
}

5. 方法4

根据指定的key查询缓存，并反序列化为指定类型，需要利用逻辑过期解决缓存击穿问题

@Data
public class RedisData {
    // 逻辑过期时间
    private LocalDateTime expireTime;
    // 缓存预热对象
    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反序列化为对象
     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.成功，开启独立线程，实现缓存重建
         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;
 }

6. 方法5

根据指定的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) {
        // 返回一个错误信息
        return null;
    }

    // 4.实现缓存重建
    // 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.获取锁成功，根据id查询数据库
        r = dbFallback.apply(id);
        // 5.不存在，返回错误
        if (r == null) {
            // 将空值写入redis
            stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
            // 返回错误信息
            return null;
        }
        // 6.存在，写入redis
        this.set(key, r, time, unit);
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    } finally {
        // 7.释放锁
        unlock(lockKey);
    }
    // 8.返回
    return r;
}

二、调用Redis工具类

在ShopServiceImpl中，调用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);
    }
}

总结

以上为个人经验，希望能给大家一个参考，也希望大家多多支持脚本之家。

您可能感兴趣的文章:

Redis高可用之持久化
在web服务器中，高可用是指服务器可以正常访问的时间，衡量的标准是在多长时间内可以提供正常服务(99.9%、99.99%、99.999%等等)，Redis中，实现高可用的技术主要包括持久化、主从复制、哨兵和cluster集群，感兴趣的同学可以阅读本文
2023-04-04
配置Redis序列化方式不生效问题及解决
这篇文章主要介绍了配置Redis序列化方式不生效问题及解决方案,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
2023-12-12
利用Redis进行数据缓存的项目实践
在实际的业务场景中，Redis 一般和其他数据库搭配使用，用来减轻后端数据库的压力，本文就介绍了利用Redis进行数据缓存的项目实践，具有一定的参考价值，感兴趣的可以了解一下
2022-06-06
redis基本类型和使用方法详解
这篇文章主要介绍了redis基本类型和使用方法详解,需要的朋友可以参考下
2020-02-02
redis与memcached的区别_动力节点Java学院整理
Memcached是以LiveJurnal旗下Danga Interactive公司的Bard Fitzpatric为首开发的高性能分布式内存缓存服务器。那么redis与memcached有什么区别呢？下面小编给大家介绍下redis与memcached的区别，感兴趣的朋友参考下吧
2017-08-08
Windows下安装Redis服务的图文教程
Redis是有名的NoSql数据库，一般Linux都会默认支持。但在Windows环境中，可能需要手动安装设置才能有效使用。下面通过本文给大家介绍Windows下安装Redis服务的图文教程，感兴趣的朋友一起看看吧
2018-08-08
手把手教你用Redis 实现点赞功能并且与数据库同步
本文主要介绍了Redis 实现点赞功能并且与数据库同步，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2022-05-05
Redis定时任务原理的实现
本文主要是基于 redis 6.2 源码进行分析定时事件的数据结构和常见操作，文中通过示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2022-03-03
gem install redis报错的解决方案
今天小编就为大家分享一篇关于gem install redis报错的解决方案，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
2019-01-01
Redis节省内存的十个技巧分享
你是否在工作中遇到过Redis的bigkey导致的内存占用严重、查询耗时大大增加？同时bigKey还可能导致Redis实例的崩溃,因为内存不够用了,所以本文给大家介绍了Redis极大节省内存的10个技巧,需要的朋友可以参考下
2024-04-04