04、Redis实战：封装工具

于 2024-08-21 22:38:14 发布
阅读量404 收藏 16
点赞数 7
分类专栏： Redis 文章标签： redis 数据库 缓存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012011912/article/details/141404463
版权

3.1、封装Redis工具类

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

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

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

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

    public void setWithLogicExpire(String key, Object value, Long time, TimeUnit timeUnit) {
    //由于需要设置逻辑过期时 间，所以我们需要用到RedisData
    RedisData<Object> redisData = new Red isData<>();
    //redisData的data就是传进来的value对象
    redisData.setData(value);
    //逻辑过期时间就是当前时间加上传进来的参数时间，用TimeUnit可以将时间转为秒，随后与当前时间相加
   redisData.setExpireTime(LocalDateTime.now().plusSeconds(timeUnit.toSeconds(time)));
    //由于是逻辑过期，所以这里不需要设置过期时间，只存一下key和value就好了，同时注意value是ridisData类型
    stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(redisData));
}

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

    • 改为通用方法，那么返回值就需要进行修改，不能返回Shop了，那我们直接设置一个泛型，同时ID的类型，也不一定都是Long类型，所以我们也采用泛型。
    • Key的前缀也会随着业务需求的不同而修改，所以参数列表里还需要加入Key的前缀
    • 通过id去数据库查询的具体业务需求我们也不清楚，所以我们也要在参数列表中加入一个查询数据库逻辑的函数
    • 最后再加上设置TTL需要的两个参数
    • 那么综上所述，我们的参数列表需要
      1. key前缀
      2. id（类型泛型）
      3. 返回值类型（泛型）
      4. 查询的函数
      5. TTL需要的两个参数
    public <R, ID> R queryWithPassThrough(String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit timeUnit) {
    //先从Redis中查，这里的常量值是固定的前缀 + 店铺id
    String key = keyPrefix + id;
    String json = stringRedisTemplate.opsForValue().get(key);
    //如果不为空（查询到了），则转为R类型直接返回
    if (StrUtil.isNotBlank(json)) {
        return JSONUtil.toBean(json, type);
    }
    if (json != null) {
        return null;
    }
    //否则去数据库中查，查询逻辑用我们参数中注入的函数
    R r = dbFallback.apply(id);
    //查不到，则将空值写入Redis
    if (r == null) {
        stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
        return null;
    }
    //查到了则转为json字符串
    String jsonStr = JSONUtil.toJsonStr(r);
    //并存入redis，设置TTL
    this.set(key, jsonStr, time, timeUnit);
    //最终把查询到的商户信息返回给前端
    return r;
}

    调用：

    public Result queryById(Long id) {
    Shop shop = cacheClient.
            queryWithPassThrough(CACHE_SHOP_KEY, id, Shop.class, this::getById, CACHE_SHOP_TTL, TimeUnit.MINUTES);
    if (shop == null) {
        return Result.fail("店铺不存在！！");
    }
    return Result.ok(shop);
}

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

    public <R, ID> R queryWithLogicalExpire(String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit timeUnit) {
    //1. 从redis中查询商铺缓存
    String key = keyPrefix + id;
    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())) {
        //5. 未过期，直接返回商铺信息
        return r;
    }
    //6. 过期，尝试获取互斥锁
    String lockKey = LOCK_SHOP_KEY + id;
    boolean flag = tryLock(lockKey);
    //7. 获取到了锁
    if (flag) {
        //8. 开启独立线程
        CACHE_REBUILD_EXECUTOR.submit(() -> {
            try {
                R tmp = dbFallback.apply(id);
                this.setWithLogicExpire(key, tmp, time, timeUnit);
            } catch (Exception e) {
                throw new RuntimeException(e);
            } finally {
                unlock(lockKey);
            }
        });
        //9. 直接返回商铺信息
        return r;
    }
    //10. 未获取到锁，直接返回商铺信息
    return r;
}

  • 方法5：根据指定的Key查询缓存，并反序列化为指定类型，需要利用互斥锁解决缓存击穿问题

    public <R, ID> R queryWithMutex(String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit timeUnit) {
    //先从Redis中查，这里的常量值是固定的前缀 + 店铺id
    String key = keyPrefix + id;
    String json = stringRedisTemplate.opsForValue().get(key);
    //如果不为空（查询到了），则转为Shop类型直接返回
    if (StrUtil.isNotBlank(json)) {
        return JSONUtil.toBean(json, type);
    }
    if (json != null) {
        return null;
    }
    R r = null;
    String lockKey = LOCK_SHOP_KEY + id;
    try {
        //否则去数据库中查
        boolean flag = tryLock(lockKey);
        if (!flag) {
            Thread.sleep(50);
            return queryWithMutex(keyPrefix, id, type, dbFallback, time, timeUnit);
        }
        r = dbFallback.apply(id);
        //查不到，则将空值写入Redis
        if (r == null) {
            stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
            return null;
        }
        //并存入redis，设置TTL
        this.set(key, r, time, timeUnit);
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    } finally {
        unlock(lockKey);
    }
    return r;
}

在ShopServiceImpl 中

import cn.hutool.core.util.BooleanUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import com.hmdp.entity.RedisData;
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.*;

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

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

    public void setWithLogicExpire(String key, Object value, Long time, TimeUnit timeUnit) {
        RedisData<Object> redisData = new RedisData<>();
        redisData.setData(value);
        redisData.setExpireTime(LocalDateTime.now().plusSeconds(timeUnit.toSeconds(time)));
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(redisData));
    }

    public <R, ID> R queryWithPassThrough(String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit timeUnit) {
        //先从Redis中查，这里的常量值是固定的前缀 + 店铺id
        String key = keyPrefix + id;
        String json = stringRedisTemplate.opsForValue().get(key);
        //如果不为空（查询到了），则转为R类型直接返回
        if (StrUtil.isNotBlank(json)) {
            return JSONUtil.toBean(json, type);
        }
        if (json != null) {
            return null;
        }
        //否则去数据库中查，查询逻辑用我们参数中注入的函数
        R r = dbFallback.apply(id);
        //查不到，则将空值写入Redis
        if (r == null) {
            stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
            return null;
        }
        //查到了则转为json字符串
        String jsonStr = JSONUtil.toJsonStr(r);
        //并存入redis，设置TTL
        this.set(key, jsonStr, time, timeUnit);
        //最终把查询到的商户信息返回给前端
        return r;
    }

    public <R, ID> R queryWithLogicalExpire(String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit timeUnit) {
        //1. 从redis中查询商铺缓存
        String key = keyPrefix + id;
        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())) {
            //5. 未过期，直接返回商铺信息
            return r;
        }
        //6. 过期，尝试获取互斥锁
        String lockKey = LOCK_SHOP_KEY + id;
        boolean flag = tryLock(lockKey);
        //7. 获取到了锁
        if (flag) {
            //8. 开启独立线程
            CACHE_REBUILD_EXECUTOR.submit(() -> {
                try {
                    R tmp = dbFallback.apply(id);
                    this.setWithLogicExpire(key, tmp, time, timeUnit);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                } finally {
                    unlock(lockKey);
                }
            });
            //9. 直接返回商铺信息
            return r;
        }
        //10. 未获取到锁，直接返回商铺信息
        return r;
    }

    public <R, ID> R queryWithMutex(String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit timeUnit) {
        //先从Redis中查，这里的常量值是固定的前缀 + 店铺id
        String key = keyPrefix + id;
        String json = stringRedisTemplate.opsForValue().get(key);
        //如果不为空（查询到了），则转为Shop类型直接返回
        if (StrUtil.isNotBlank(json)) {
            return JSONUtil.toBean(json, type);
        }
        if (json != null) {
            return null;
        }
        R r = null;
        String lockKey = LOCK_SHOP_KEY + id;
        try {
            //否则去数据库中查
            boolean flag = tryLock(lockKey);
            if (!flag) {
                Thread.sleep(50);
                return queryWithMutex(keyPrefix, id, type, dbFallback, time, timeUnit);
            }
            r = dbFallback.apply(id);
            //查不到，则将空值写入Redis
            if (r == null) {
                stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
                return null;
            }
            //并存入redis，设置TTL
            this.set(key, r, time, timeUnit);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            unlock(lockKey);
        }
        return r;
    }

    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);
    }
}
海绵宝宝丶哈
关注
  • 7
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Redis】Redis实战：黑马点评之优惠券秒杀
qq_50675319的博客
09-19 1217
每个店铺都可以发布优惠券：当用户抢购时，就会生成订单并保存到tb_voucher_order这张表中，而订单表如果使用数据库自增ID就存在一些问题：id的规律性太明显如果我们的id具有太明显的规则，用户或者说商业对手很容易猜测出来我们的一些敏感信息，比如商城在一天时间内，卖出了多少单，这明显不合适。受单表数据量的限制。
【Redis】Redis实战：黑马点评之商户查询缓存
qq_50675319的博客
09-17 1152
在原来的业务逻辑中，如果用户查询缓存未命中，会去直接查询数据库，在这种情况下，如果用户查询的是热点数据且缓存重建比较复杂，就容易出现缓存击穿问题，这里我们可以假设商铺查询就是热点数据，需要针对缓存击穿问题设计相应的解决方案 相较于原来从缓存中查询不到数据后直接查询数据库而言，现在的方案是进行查询之后，如果从缓存未命中，则进行互斥锁的获取，获取互斥锁后，判断是否获得到了锁，如果没有获得锁，则休眠，过一段时间再对上述业务逻辑进行重试，获取到锁的线程可以需要去查询数据库并将数
Redis实战：Redis在Java中的基本使用
热门推荐
栗筝i的博客
08-19 1万+
本片将介绍 Redis 在 Java 中的基本使用
SpringBoot实战：整合Redis、mybatis，封装RedisUtils工具类等（附源码）
2401_84003839的博客
04-30 637
面试前的“练手”还是很重要的，所以开始面试之前一定要准备好啊，不然也是耽搁面试官和自己的时间。我自己是刷了不少面试题的，所以在面试过程中才能够做到心中有数，基本上会清楚面试过程中会问到哪些知识点，高频题又有哪些，所以刷题是面试前期准备过程中非常重要的一点。面试前的“练手”还是很重要的，所以开始面试之前一定要准备好啊，不然也是耽搁面试官和自己的时间。
Redis：原理速成+项目实战——Redis实战6（封装缓存工具（高级写法）&&缓存总结）
m0_52380556的博客
01-05 1344
Redis：原理速成+项目实战——Redis实战6（封装缓存工具（高级写法）&&缓存总结）
最详细 | redis实战:JackSon/FastJson方式序列化深度解析
qq_51033936的博客
09-25 5274
Jackson2JsonRedisSerializer和FastJsonRedisSerializer的实战应用
redis 工具类封装
swadian2008的博客
02-20 498
目录 1-在springboot项目的pom.xml 2-在application.properties中配置redis参数 3-编写redis的配置类 4-编写redis的工具类 5-测试类RedisController.java 1-在springboot项目的pom.xml 在配置文件里加入redis的jar依赖 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.or
Redis实战指南：基础知识、实战技巧、应用场景及最佳实践全攻略
学海无涯，行者无疆
06-11 2166
在Java系统实现过程中，我们不可避免地会借助大量开源功能组件。然而，这些组件往往功能丰富且体系庞大，官方文档常常详尽至数百页。而在实际项目中，我们可能仅需使用其中的一小部分功能，这就造成了一个挑战：如何在有限的时间和精力下，高效地掌握并使用这些组件的核心功能，以实现投入产出最大化？ 针对这一问题，我基于二八原则，整理编写本文。 首先，我会聚焦于组件的常见和核心功能，这些功能通常是我们在日常开发中频繁使用到的，也是构建稳定、高效系统的基石。通过深入了解这些核心功能的使用方法和最佳实践，我们可以确保在关键
03、Redis实战：商户查询缓存、缓存更新策略、缓存穿透、缓存雪崩、缓存击穿
最新发布
u012011912的博客
08-21 722
什么是缓存?就像自行车,越野车的避震器举个例子:越野车,山地自行车,都拥有"避震器",防止车体加速后因惯性,在酷似"U"字母的地形上飞跃,硬着陆导致的损害,像个弹簧一样;同样,实际开发中,系统也需要"避震器",防止过高的数据访问猛冲系统,导致其操作线程无法及时处理信息而瘫痪;这在实际开发中对企业讲,对产品口碑,用户评价都是致命的;所以企业非常重视缓存技术;缓存(Cache),就是数据交换的缓冲区,俗称的缓存就是缓冲区内的数据。
Redis深度历险：核心原理和应用实践.zip
02-27
《Redis深度历险：核心原理和应用实践》这本书是一本深入了解Redis数据库的宝贵资源，尤其在C++开发环境中具有很高的参考价值。Redis是一款高性能的键值存储系统，广泛应用于缓存、消息队列、计数器等多个场景。下面...
javaredis源码-RedisInAction:Redis实战Java源代码
05-20
《Redis实战Java源代码》是基于Java实现的与Redis数据库交互的开源项目，它提供了丰富的API和工具，便于开发者在Java应用中高效地使用Redis。本文将深入解析这个项目的源码，探讨其核心功能和设计原理，以帮助你更好...
SpringBoot整合Redis、mybatis实战，封装RedisUtils工具类.docx
06-26
整合依赖--> <dependency> <groupId>...同时，通过封装工具类，可以简化代码，提高代码的可读性和可维护性。在实际项目中，还需要根据具体需求进行更复杂的配置和设计，如Redis的事务支持、分布式锁等高级功能的实现。
SSM REDIS集成实战
11-03
在实战中，提供的工具类可能会包含常用的Redis操作封装，如计数器、队列、集合等操作的便捷方法，方便在项目中直接调用。这些工具类能够帮助你更高效地利用Redis的功能，避免重复编写相同的操作代码。 总结，SSM与...
Java如何使用 Redis 实现分布式锁
Takumilove的博客
08-21 393
互斥性：任何时刻只有一个客户端能持有锁。不会发生死锁：即使客户端崩溃，锁也能被其他客户端获取。解铃还须系铃人：加锁和解锁必须由同一个客户端完成。操作具备原子性：加锁和解锁的操作需要是原子的，不能被打断。通过 Redis 的setnx命令配合过期时间、UUID 以及 LUA 脚本，我们可以构建一个可靠的分布式锁，满足上述所有条件。这种锁在高并发环境下能够有效防止资源竞争，保证系统的稳定性。
【速览】Redis（更新中）
椰子的职场成长记录
08-20 292
Redis 支持多种数据结构，如字符串（strings）、哈希（hashes）、列表（lists）、集合（sets）、有序集合（sorted sets）等。持久化：Redis 支持两种持久化方式，RDB（快照）和 AOF（追加文件），以确保数据在重启后不会丢失。原子操作：Redis 的所有操作都是原子的，这使得它非常适合于需要高并发和数据一致性的场景。Lua 脚本：Redis 支持在服务器端执行 Lua 脚本，可以用于实现复杂的业务逻辑。事务支持：Redis 支持事务，可以将多个命令打包在一起执行。
redis常用操作命令
diffiii
08-21 84
显示服务器时间 , 时间戳(秒), 微秒数。模糊查询以fine为前缀的key值。模糊查询以ha为后缀的key值。删除指定key，多个用空格隔开。当前数据库key的数量。登录redis客户端。退出redis客户端。
Redis中String数据类型常用命令
m0_65347933的博客
08-16 444
Redis中String数据类型常用命令：1、基本操作；2、计数与长度；3、设置和获取部分值；4、过期与持久化
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值