封装Redis工具类（做到拿来即用）

最新推荐文章于 2025-01-23 13:43:20 发布
原创 最新推荐文章于 2025-01-23 13:43:20 发布 · 895 阅读 · 8 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#redis #java #spring boot

开发板推荐：天空星STM32F407VET6开发板

超高性价比 STM32主控 | 超高主频 | 一板兼容百芯 | 比赛神器 | 沉金彩色丝印

点击查看

1.封装Redis工具类

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

方法1：将任意Java对象序列化为json并存储在string类型的key中，并且可以设置TTL过期时间
方法2：将任意Java对象序列化为json并存储在string类型的key中，并且可以设置逻辑过期时间，用于处理缓存击穿问题

方法3：根据指定的key查询缓存，并反序列化为指定类型，利用缓存空值的方式解决缓存穿透问题
方法4：根据指定的key查询缓存，并反序列化为指定类型，需要利用逻辑过期解决缓存击穿问题

2.CacheClient工具类的实现

2.1各个方法的代码实现

@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;
    }

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

  1. set 方法：

    • 用于普通的缓存设置。
    • 可以指定缓存的过期时间和时间单位（如秒、分钟、小时等）。
    • 用途： 适用于普通的数据缓存，满足基本的缓存需求。
 /**
     * 将任意Java对象序列化为json并存储在string类型的key中，并且可以设置TTL过期时间
     * @param value
     * @param key
     * @param time
     * @param unit
     */
    public void set(Object value, String key, Long time, TimeUnit unit){
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(value),time,unit);
    }

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

  1. setWithLogicalExpire 方法：

    • 用于设置带逻辑过期时间的缓存数据。
    • 在缓存中存储数据时同时包含一个逻辑过期时间字段。
    • 用途： 适用于防止缓存击穿，确保在缓存过期时能够返回旧数据并异步刷新。
 /**
     * 将任意Java对象序列化为json并存储在string类型的key中，并且可以设置逻辑过期时间，用于处理缓
     * @param value
     * @param key
     * @param time
     * @param unit
     */
    public void setWithLogicalExpire(Object value, String key, 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));
    }

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

  1. queryWithPassThrough 方法：

    • 实现了缓存穿透的解决方案。
    • 当缓存中没有数据时，从数据库中查询并缓存结果；如果数据库中也没有数据，则将空值写入缓存，避免缓存穿透。
    • 用途： 防止无效请求频繁穿透缓存访问数据库。
/**
     * 缓存穿透
     * @return
     */
    public <R,ID> R queryWithPassThrough(String pre, ID id, Class<R> type, Function<ID,R> dbFallback,Long time, TimeUnit unit){

        String key = pre + id;
        //1.从redis中查询缓存
        String json = stringRedisTemplate.opsForValue().get(key);
        //2.判断是否命中
        if (StrUtil.isNotBlank(json)) {
            //3.命中 返回商铺信息
            return JSONUtil.toBean(json,type);
        }
        //判断是否为null值
        if(json != null){
            return null;
        }
        //4.未命中 根据id查询数据库
        R r = dbFallback.apply(id);
        if (r == null) {
            //5.将空值存入redis
            stringRedisTemplate.opsForValue().set(key,"",CACHE_NULL_TTL, TimeUnit.MINUTES);
            //5.存在 返回
            return null;
        }
        //6.存在 写入redis 返回商品信息
        this.set(r,pre,time,unit);
        return r;
    }

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

  1. queryWithLogicalExpire 方法：

    • 使用逻辑过期解决缓存击穿问题。
    • 当缓存数据过期时，通过异步线程更新缓存，同时仍然返回旧数据，保证系统的高可用性。
    • 用途： 适用于热点数据，防止在缓存失效时大量请求同时涌向数据库。
 /**
     * 利用逻辑过期时间解决缓存击穿
     * @return
     */
    public <R,ID> R queryWithLogicalExpire(String pre,ID id,Class<R> type,Function<ID,R> dbFallback,Long time, TimeUnit unit){
        String key = pre + 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);
        JSONObject data =(JSONObject) redisData.getData();
        R r = JSONUtil.toBean(data,type);

        //4.判断缓存是否过期
        LocalDateTime expireTime = redisData.getExpireTime();

        if(expireTime.isAfter(LocalDateTime.now())){
            //5.未过期 返回商铺信息
            return r;
        }
        //6.已过期 缓存重建
        //6.1获取互斥锁
        String lockKey = LOCK_SHOP_KEY + id;
        boolean isTryLock = tryLock(lockKey);
        //6.2判断是否获取成功
        if (isTryLock) {
            //6.3成功

            //再次检查缓存中的数据是否过期,如果没有过期，无需重建
            //1.从redis中查询缓存
            Json = stringRedisTemplate.opsForValue().get(key);
            //2.不存在 直接返回空（不是热点数据）
            if(StrUtil.isBlank(Json)){
                return null;
            }
            //3.存在 需要先把Json反序列化为对象
            redisData = JSONUtil.toBean(Json, RedisData.class);
            data =(JSONObject) redisData.getData();
            r = JSONUtil.toBean(data, type);
            //4.判断缓存是否过期
            expireTime = redisData.getExpireTime();
            if(expireTime.isAfter(LocalDateTime.now())){
                //5.未过期 返回商铺信息
                return r;
            }
            //还过期 开启独立线程 缓存重建
            CACHE_REBUILD_EXECUTOR.submit(() -> {
                try {
                    //先查数据库
                    R r1 = dbFallback.apply(id);
                    //再写入Redis
                    this.setWithLogicalExpire(r1,key,time,unit);

                } catch (Exception e) {
                    throw new RuntimeException(e);
                }finally {
                    //释放锁
                    unLock(lockKey);
                }
            });


        }
        //6.4返回商铺信息
        return r;
    }
 /**
     * 获取锁
     * @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);
    }

2.2完整代码

 

@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;
    }

    /**
     * 将任意Java对象序列化为json并存储在string类型的key中，并且可以设置TTL过期时间
     * @param value
     * @param key
     * @param time
     * @param unit
     */
    public void set(Object value, String key, Long time, TimeUnit unit){
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(value),time,unit);
    }

    /**
     * 将任意Java对象序列化为json并存储在string类型的key中，并且可以设置逻辑过期时间，用于处理缓
     * @param value
     * @param key
     * @param time
     * @param unit
     */
    public void setWithLogicalExpire(Object value, String key, 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));
    }
    /**
     * 缓存穿透
     * @return
     */
    public <R,ID> R queryWithPassThrough(String pre, ID id, Class<R> type, Function<ID,R> dbFallback,Long time, TimeUnit unit){

        String key = pre + id;
        //1.从redis中查询缓存
        String json = stringRedisTemplate.opsForValue().get(key);
        //2.判断是否命中
        if (StrUtil.isNotBlank(json)) {
            //3.命中 返回商铺信息
            return JSONUtil.toBean(json,type);
        }
        //判断是否为null值
        if(json != null){
            return null;
        }
        //4.未命中 根据id查询数据库
        R r = dbFallback.apply(id);
        if (r == null) {
            //5.将空值存入redis
            stringRedisTemplate.opsForValue().set(key,"",CACHE_NULL_TTL, TimeUnit.MINUTES);
            //5.存在 返回
            return null;
        }
        //6.存在 写入redis 返回商品信息
        this.set(r,pre,time,unit);
        return r;
    }

    /**
     * 获取锁
     * @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);
    }

    /**
     * 利用逻辑过期时间解决缓存击穿
     * @return
     */
    public <R,ID> R queryWithLogicalExpire(String pre,ID id,Class<R> type,Function<ID,R> dbFallback,Long time, TimeUnit unit){
        String key = pre + 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);
        JSONObject data =(JSONObject) redisData.getData();
        R r = JSONUtil.toBean(data,type);

        //4.判断缓存是否过期
        LocalDateTime expireTime = redisData.getExpireTime();

        if(expireTime.isAfter(LocalDateTime.now())){
            //5.未过期 返回商铺信息
            return r;
        }
        //6.已过期 缓存重建
        //6.1获取互斥锁
        String lockKey = LOCK_SHOP_KEY + id;
        boolean isTryLock = tryLock(lockKey);
        //6.2判断是否获取成功
        if (isTryLock) {
            //6.3成功

            //再次检查缓存中的数据是否过期,如果没有过期，无需重建
            //1.从redis中查询缓存
            Json = stringRedisTemplate.opsForValue().get(key);
            //2.不存在 直接返回空（不是热点数据）
            if(StrUtil.isBlank(Json)){
                return null;
            }
            //3.存在 需要先把Json反序列化为对象
            redisData = JSONUtil.toBean(Json, RedisData.class);
            data =(JSONObject) redisData.getData();
            r = JSONUtil.toBean(data, type);
            //4.判断缓存是否过期
            expireTime = redisData.getExpireTime();
            if(expireTime.isAfter(LocalDateTime.now())){
                //5.未过期 返回商铺信息
                return r;
            }
            //还过期 开启独立线程 缓存重建
            CACHE_REBUILD_EXECUTOR.submit(() -> {
                try {
                    //先查数据库
                    R r1 = dbFallback.apply(id);
                    //再写入Redis
                    this.setWithLogicalExpire(r1,key,time,unit);

                } catch (Exception e) {
                    throw new RuntimeException(e);
                }finally {
                    //释放锁
                    unLock(lockKey);
                }
            });


        }
        //6.4返回商铺信息
        return r;
    }

}

3.ShopServiceImpl

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

    @Resource
    private CacheClient cacheClient;
    @Override
    public Result queryById(Long id) {
        //缓存穿透
        //Shop shop = queryWithPassThrough(id);

        //this::getById == id->getById(id)
        //Shop shop
        // = cacheClient
        //        .queryWithPassThrough(CACHE_SHOP_KEY, id, Shop.class, this::getById, CACHE_NULL_TTL, TimeUnit.MINUTES);

        //互斥锁解决缓存击穿
        //Shop shop = queryWithMutex(id);
        //逻辑过期解决缓存击穿
        //Shop shop = queryWithLogicalExpire(id)

        //逻辑过期解决缓存击穿
        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);
    }
}

4.测试

TODO：使用逻辑过期解决缓存击穿问题，需要自行进行数据预热。

运行其中test2()即可

class HmDianPingApplicationTests {
    @Autowired
    private ShopServiceImpl shopService;

    @Resource
    private CacheClient cacheClient;
    @Test
    public void test() throws InterruptedException {
        shopService.saveShop2Redis(1L,10L);
    }
    @Test
    public void test2() throws InterruptedException {
        Shop shop = shopService.getById(1L);

        cacheClient.setWithLogicalExpire(shop, CACHE_SHOP_KEY + 1L,10L, TimeUnit.SECONDS);
    }

}

开发板推荐：天空星STM32F407VET6开发板

超高性价比 STM32主控 | 超高主频 | 一板兼容百芯 | 比赛神器 | 沉金彩色丝印

点击查看
top_and_king
关注
RedisTemplate工具类
01-19
基于spring和redis的redisTemplate工具类 针对所有的hash 都是以h开头的方法 针对所有的Set 都是以s开头的方法 针对所有的List 都是以l开头的方法
SpringBoot Redis工具类封装
专注基础架构领域
06-18 8339
SpringBoot整合Redis的博客很多，但是很多都不是我想要的结果。因为我只需要整合完成后，可以操作Redis就可以了，并不需要配合缓存相关的注解使用（如@Cacheable）。看了很多博客后，我成功的整合了，并写了个Redis操作工具类。特意在此记录一下，方便后续查阅。 一、Maven依赖 1、本文所采用的SpringBoot的版本如下 <parent> &lt...
SpringBoot 中操作 Redis 及工具类的封装
m0_71777195的博客
05-06 1238
在我们项目开发中总是免不了会使用缓存，Redis现在基本是我们公司中非常常见的缓存方案，包括在用户token的缓存，热点信息的缓存等，这篇文章主要讲讲在SpringBoot项目中如何去操作Redis，及最后工具类的封装。
Spring集成Redis｜通用Redis工具类
最新发布
赵同学的博客
01-23 857
Spring通用Redis工具类
Redis工具类
Jin的随手笔记
03-28 4550
​ 直接用RedisTemplate操作Redis，需要很多行代码，因此直接封装好一个RedisUtils，这样写代码更方便点。这个RedisUtils交给Spring容器实例化，使用时直接注解注入。
Redis(七) - 封装Redis工具类
及时当勉励，岁月不待人
07-20 3880
Redis(七) - 封装Redis工具类
Redis工具类封装RedisUtils
热门推荐
IT小跟班
02-26 3万+
本文参考：https://blog.it-follower.com/posts/2563248908.html SpringBoot项目集成Redis相当简单，只需要pom中加入对应依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>sp...
Redis工具类封装RedisUtils（两种）
YHJ
05-09 1万+
RedisTemplate工具类1 本文参考：https://blog.it-follower.com/posts/2563248908.html SpringBoot项目集成Redis相当简单，只需要pom中加入对应依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</a...
java Redis 操作工具类封装（备忘）
cheng_ji的专栏
12-24 1219
在 Java 中，封装 Redis 的常见操作是提升开发效率和代码可维护性的好方法。使用 Redis 可以帮助你的应用在缓存、消息队列、会话存储等方面显著提高性能。以下是一个基于Jedis客户端的 Redis 操作工具类封装示例。
RedisTest
Leon_Jinhai_Sun的博客
09-10 463
@Test public void test44() { Map<String, Object> map = new HashMap<String, Object>(); // map.put("powerConsumption", 80); // map.put("reportStatus", 2); // ...
Redis封装工具类
酷小亚
10-09 1290
Redis封装工具类 1、导入依赖 2、配置文件 3、Redis序列化配置 4、Redis封装工具类 5、测试 6、运行结果
springboot整合redis
Big Data
08-13 396
Jedis和Lettuce的区别在哪？ 1、Jedis 是直连模式，在多个线程间共享一个 Jedis 实例时是线程不安全的，每个线程都去拿自己的 Jedis 实例，当连接数量增多时，物理连接成本就较高了。 2、Lettuce的连接是基于Netty的，连接实例可以在多个线程间共享，如果你不知道Netty也没事，大致意思就是一个多线程的应用可以使用同一个连接实例，而不用担心并发线程的数量。通过异步的方式可以让我们更好地利用系统资源。 既然有这么大的好处，干脆就用了这个，跟上时代的变化。下面新建一个Spri
Redis实战案例9-封装Redis工具类
qq_45681515的博客
06-29 623
redis实战笔记
【Redis】封装Redis工具类
qq_39921135的博客
08-06 1110
经过前面几节的学习，我们已经解决了缓存使用过程中的各种各样的一些问题，但是我们发现无论是解决缓存穿透还是解决缓存击穿，她们的代码逻辑都是挺复杂的，如果说我们每次开发的时候都要去写这些逻辑，其实开发的成本还是挺高的，所以将来我们一定会将这些解决方案封装成工具。这四个方法你可以认为这个方法是两两配对的，方法一和方法三对应起来，即对应一些常见的、普通的缓存，可以解决缓存穿透、设置TTL过期。因为你封装的这个工具类，它并不知道使用者要操作的数据是什么类型，因此这个方法在使用的时候需要指定类型，然后才能做反序列化。
封装Redis工具类
青山猿的博客
04-25 395
方法2：将任意Java对象序列化为json并存储在string类型的key中，并且可以设置逻辑过期时间，用于处理缓。方法1：将任意Java对象序列化为json并存储在string类型的key中，并且可以设置TTL过期时间。方法3：根据指定的key查询缓存，并反序列化为指定类型，利用缓存空值的方式解决缓存穿透问题。方法4：根据指定的key查询缓存，并反序列化为指定类型，需要利用逻辑过期解决缓存击穿问题。在ShopServiceImpl 中。
Redis的封装工具类
m0_69114709的博客
08-02 372
【代码】Redis的封装工具类。
redis java 封装类_GitHub - wjy060708/RedisUtil: 最全的Java操作Redis的工具类，使用StringRedisTemplate实现，封装了对Redis五种基...
weixin_42110362的博客
02-12 306
RedisUtil介绍最全的Java操作Redis的工具类，封装了对Redis五种基本类型的各种操作，力求符合Redis的原生操作，使用StringRedisTemplate实现！解惑很多人提出疑问“为什么没有操作Object的方法？”，请看这里介绍redistemplate和stringredistemplate。用法一、keys相关命令NO方法描述1void delete(String key...
RedisTemplate常用方法封装
点滴记录
04-22 2107
【代码】RedisTemplate常用方法封装。
spring boot-引入Redis并封装redistemplate操作工具类
西京刀客
03-28 2617
springboot引入Redis及其使用案例
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值