Redis框架（九）：大众点评项目 缓存工具封装

最新推荐文章于 2023-02-17 15:54:55 发布
最新推荐文章于 2023-02-17 15:54:55 发布
阅读量490 收藏 3
点赞数 1
分类专栏： Redis框架 文章标签： redis 缓存 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/futurn_hero/article/details/128301112
版权

大众点评项目 缓存工具封装

SpringCloud章节复习已经过去，新的章节Redis开始了，这个章节中将会回顾Redis实战项目 大众点评
主要依照以下几个原则

  1. 基础+实战的Demo和Coding上传到我的代码仓库
  2. 在原有基础上加入一些设计模式，stream+lamdba等新的糖
  3. 通过DeBug调试，进入组件源码去分析底层运行的规则和设计模式

代码会同步在我的gitee中去，觉得不错的同学记得一键三连求关注，感谢：
Redis优化-链接: RedisUnitToolProject
在这里插入图片描述

需求：缓存工具封装

我们已经在上面三节处理了各种细节：缓存穿透、缓存击穿、缓存雪崩

我们在开发过程中，如果每次缓存操作都处理一遍，那太繁琐了

为了开发的流畅和严谨，我们在这一节整合以往的四种处理方案，将其封装成工具类，这样就可以直接调工具，而不是RedisTemplate

在这里插入图片描述

业务实现

其实代码和上几节基本一直，但是为了封装处理， 需要回顾线程池、函数式编程接口 和泛型使用

@Slf4j
@Component
public class CacheClient {

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    //需要回顾线程池、函数式编程接口 和泛型使用
    private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);

定义好对应的属性


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

    public void setWithLogicalExpire(String key, Object value, Long time, TimeUnit unit){
        RedisData redisData = new RedisData();
        redisData.setExpireTime(LocalDateTime.now().plusSeconds(unit.toSeconds(time)));
        redisData.setObject(value);
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(redisData));
    }

定义好对应的两种存储方法，分别是通过为了 缓存穿透， 缓存击穿

缓存穿透


    //通过泛型来进行处理不可知的类型，通过函数式编程传入IT用户的查询信息
    public <R, ID> R queryWithPassThrough(String keyPrefix, ID id, Class<R> type,
                                          Function<ID, R> dbFallback, Long time, TimeUnit unit){
        log.debug("RedisTool method...");
        String key = keyPrefix + id;
        String json = stringRedisTemplate.opsForValue().get(key);
        if (StrUtil.isNotBlank(json)) {
            return JSONUtil.toBean(json, type);
        }

        if(json!=null){
            return null;
        }

        //数据库查询怎么办，通过传入函数式编程处理
        R r = dbFallback.apply(id);

        if(r==null){
            stringRedisTemplate.opsForValue().set(key, "", RedisConstants.CACHE_NULL_TTL, TimeUnit.MINUTES);
            return null;
        }

        this.set(key, r, time, unit);

        return r;
    }

逻辑过期时间处理缓存击穿

    // 逻辑过期时间 通过线程池进行处理
    public <ID, R> R queryWithLogicalExpire(String keyPrefix, ID id, Class<R> type,
                                         Function<ID, R> dbFallback, Long time, TimeUnit unit){
        log.debug("RedisTool queryWithLogicalExpire Method...");
        String key = keyPrefix + id;
        String json = stringRedisTemplate.opsForValue().get(key);
        if(StrUtil.isBlank(json)){
            return null;
        }

        RedisData data = JSONUtil.toBean(json, RedisData.class);
//        Shop shop = JSONUtil.toBean((JSONObject) data.getObject(), Shop.class);
        JSONObject object = (JSONObject) data.getObject();
        R r = JSONUtil.toBean(object, type);

        if(data.getExpireTime().isAfter(LocalDateTime.now())){
            return r;
        }

        //过期了，就通过独立线程 -> 互斥锁处理缓存击穿
        String lockKey = RedisConstants.LOCK_SHOP_KEY + id;
        if (!tryLock(lockKey)) {
            log.debug("lockKey: " + lockKey + " Result： " + r);
            CACHE_REBUILD_EXECUTOR.submit(()->{
                try {
                    this.saveShop2Redis(id,  dbFallback, keyPrefix,  time,  unit);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                    /*e.printStackTrace();*/
                }finally {
                    //删除暂时的key, 释放互斥锁
                    stringRedisTemplate.delete(lockKey);
                }
            });
        }

        if(r==null){
            return null;
        }

        return r;
    }

    public boolean tryLock(String key){

        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", RedisConstants.LOCK_SHOP_TTL, TimeUnit.SECONDS);
        //这里不可以直接返回flag，因为在拆箱过程中可能出现flag为null的情况；
        return BooleanUtil.isTrue(flag);
    }

    public <ID, R> void saveShop2Redis(ID id,
                                       Function<ID, R> dbFallback,
                                       String keyPrefix,
                                       Long time,
                                       TimeUnit unit){

        R r = dbFallback.apply(id);
        setWithLogicalExpire(keyPrefix + id,  r, time, unit);

    }

}

这样我们就可以直接去调用了，

queryWithLogicalExpire

    @Override
    public Result queryById(Long id) {

        Shop shop = cacheClient.queryWithLogicalExpire(RedisConstants.CACHE_SHOP_KEY, id, Shop.class, this::getById,
                RedisConstants.CACHE_NULL_TTL, TimeUnit.HOURS);

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

        return Result.ok(shop);
    }

queryWithPassThrough

    public Result queryById(Long id) {
/*        Shop shop = cacheClient.queryWithPassThrough(key, id, Shop.class, idf -> getById(idf),
                RedisConstants.CACHE_NULL_TTL, TimeUnit.MINUTES);*/

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

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

        return Result.ok(shop);
    }

代码总览

@Slf4j
@Component
public class CacheClient {

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    //需要回顾线程池、函数式编程接口
    // 和泛型使用
    private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);



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

    public void setWithLogicalExpire(String key, Object value, Long time, TimeUnit unit){
        RedisData redisData = new RedisData();
        redisData.setExpireTime(LocalDateTime.now().plusSeconds(unit.toSeconds(time)));
        redisData.setObject(value);
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(redisData));
    }


    //通过泛型来进行处理不可知的类型，通过函数式编程传入IT用户的查询信息
    public <R, ID> R queryWithPassThrough(String keyPrefix, ID id, Class<R> type,
                                          Function<ID, R> dbFallback, Long time, TimeUnit unit){
        log.debug("RedisTool method...");
        String key = keyPrefix + id;
        String json = stringRedisTemplate.opsForValue().get(key);
        if (StrUtil.isNotBlank(json)) {
            return JSONUtil.toBean(json, type);
        }

        if(json!=null){
            return null;
        }

        //数据库查询怎么办，通过传入函数式编程处理
        R r = dbFallback.apply(id);

        if(r==null){
            stringRedisTemplate.opsForValue().set(key, "", RedisConstants.CACHE_NULL_TTL, TimeUnit.MINUTES);
            return null;
        }

        this.set(key, r, time, unit);

        return r;
    }

    // 逻辑过期时间 通过线程池进行处理
    public <ID, R> R queryWithLogicalExpire(String keyPrefix, ID id, Class<R> type,
                                         Function<ID, R> dbFallback, Long time, TimeUnit unit){
        log.debug("RedisTool queryWithLogicalExpire Method...");
        String key = keyPrefix + id;
        String json = stringRedisTemplate.opsForValue().get(key);
        if(StrUtil.isBlank(json)){
            return null;
        }

        RedisData data = JSONUtil.toBean(json, RedisData.class);
//        Shop shop = JSONUtil.toBean((JSONObject) data.getObject(), Shop.class);
        JSONObject object = (JSONObject) data.getObject();
        R r = JSONUtil.toBean(object, type);

        if(data.getExpireTime().isAfter(LocalDateTime.now())){
            return r;
        }

        //过期了，就通过独立线程 -> 互斥锁处理缓存击穿
        String lockKey = RedisConstants.LOCK_SHOP_KEY + id;
        if (!tryLock(lockKey)) {
            log.debug("lockKey: " + lockKey + " Result： " + r);
            CACHE_REBUILD_EXECUTOR.submit(()->{
                try {
                    this.saveShop2Redis(id,  dbFallback, keyPrefix,  time,  unit);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                    /*e.printStackTrace();*/
                }finally {
                    //删除暂时的key, 释放互斥锁
                    stringRedisTemplate.delete(lockKey);
                }
            });
        }

        if(r==null){
            return null;
        }

        return r;
    }

    public boolean tryLock(String key){

        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", RedisConstants.LOCK_SHOP_TTL, TimeUnit.SECONDS);
        //这里不可以直接返回flag，因为在拆箱过程中可能出现flag为null的情况；
        return BooleanUtil.isTrue(flag);
    }

    public <ID, R> void saveShop2Redis(ID id,
                                       Function<ID, R> dbFallback,
                                       String keyPrefix,
                                       Long time,
                                       TimeUnit unit){

        R r = dbFallback.apply(id);
        setWithLogicalExpire(keyPrefix + id,  r, time, unit);

    }

}

总结

在这里插入图片描述

测试一下

在这里插入图片描述
suc

是一个Bug
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
go-redis-cache:使用Redis缓存进行微服务
04-11
去redis缓存使用Redis缓存进行微服务创建Go微服务
redis缓存封装
liuqiang211的专栏
06-30 235
【代码】redis缓存封装。
Redis+Springboot实现缓存功能、缓存更新策略、缓存穿透、缓存雪崩、缓存击穿、缓存工具封装
weixin_51351637的博客
11-02 2783
数据交换的缓冲区（称为Cache），是存储数据的临时地方，一般读写性能较高/*** 根据id查询商铺信息* @param id 商铺id* @return 商铺详情数据*/}用户查询的数据在Redis与数据库中都没有。
Redis对象及redisObject源码解析
weixin_46935110的博客
11-22 1071
Redis对象及redisObject源码解析
redis缓存（redis缓存工具封装篇）
Mrs_DongDong的博客
09-08 915
缓存(Cache),就是数据交换的缓冲区,俗称的缓存就是缓冲区内的数据例 1 : Static final ConcurrentHashMap < K , V > map = new ConcurrentHashMap < >();本地用于高并发例 2 : static final Cache < K , V > USER_CACHE = CacheBuilder . newBuilder() . build();用于redis等缓存。（参考黑马redis）
封装自己的本地缓存类（单例模式、适配器模式应用）
赵忠洋的博客
08-25 425
很多小伙伴比较喜欢直接使用 localStorage 或者 sessionStorage。虽然可以满足大多数场景，但是在特殊需求情况下就需要进行二次封装处理，例如 设置过期时间、使用其他存储方式、每次存取需要序列化与反序列化。而且有些项目体量大、产品一直迭代、维护人员和开发人员一茬接一茬的这种项目，有时在不同模块 甚至不同页面 使用的缓存都是单独封装的 或者 是’裸奔’的。为方便项目使用，特对常规操作进行封装。此篇文章会带着你从零到一的封装一个本地缓存类，从需求分析到架构设计以及部分设计模式的讲解。
spring-boot-redis-app:使用Redis缓存的Spring Boot项目
03-08
spring-boot-redis-app:使用Redis缓存的Spring Boot项目
lua-resty-redis-util：openrestylua-resty-redis封装工具类
02-03
lua-resty-redis-util：openrestylua-resty-redis封装工具类
slim-redis-cache:用于Slim框架的Redis缓存中间件
05-09
用于Slim框架的Redis缓存中间件。 安装 composer require abouvier/slim-redis-cache 用法 在本地Redis服务器中将每个成功的HTTP响应缓存8小时。 $ app = new \ Slim \ Slim (); // ... $ client = new \ Predis \...
redis-access:redis接口的java封装
05-26
原子的++，只能在int or long类型时使用2 增加flushDb操作主要需要实现几个功能：1 数据获取2 数据缓存3 分布式锁4 带锁的数据处理为了实现这几个功能，对redis做了一层相对很薄的封装，过程如下：1 首先，我们需要...
web项目服务器缓存怎么做,对Cache类简单的封装，实现web项目服务器端缓存。
weixin_35895994的博客
08-06 323
Cache介绍：出生于.NetFramework 2,实现用于 Web 应用程序的缓存。代码简单的封装，有更好的封装代码，欢迎指点。''''/// /// 缓存操作类/// public class DataCache{/// /// 获取当前应用程序指定CacheKey的Cache值/// /// /// public static object GetCache(string CacheKey...
分布式封装缓存的帮助类
2201_75837601的博客
01-28 146
分布式封装缓存的帮助类
【Redis】redis 存储对象 的三种方式
九师兄
09-22 7387
1.概述 转载：https://blog.csdn.net/u014756827/article/details/88830973 2.方式一：序列化操作 public class SerializeUtil { /* * 序列化 * */ public static byte[] serizlize(Object object){ ObjectOutputStream oos = null; ByteArrayOutputStream b
Redis数据类型之redisObject
小麦大大博客
08-29 7135
1、Redis中的object 为了便于操作，Redis定义了redisObjec结构体来表示string、hash、list、set、zset五种数据类型。redisObject定义在redis.h文件中： typedef struct redisObject { unsigned type:4; unsigned encoding:4; ...
redis 中Set类型 及常用命令(附有示例)
热门推荐
peinanwei__的博客
04-01 1万+
一、Redis中Set介绍 Redis set 对外提供的功能与list类似，是一个列表的功能 特点： set是可以自动排重的， 当你需要存储一个列表数据，又不希望出现重复数据时，set是一个很好选择，并且set提供了判断某个成员是否在一个set集合内的重要接口，这个也是list所不能提供的 redis的Set是String类型的无序集合，它底层其实是一个value为null的hash表，所以添加、删除、查找的复杂度都是O(1) 一个算法，随...
Redis源码初识三 RedisObject
死磕各种源码
12-14 167
RedisObjectRedisObjectserver.h(源码)字段含义不同类型，用到的数据结构扩展(字符串embstr)object.c源码 RedisObject redis所有类型，key都是sds存储，value都是对应redisOjbect server.h(源码) typedef struct redisObject { unsigned type:4; unsigned encoding:4; unsigned lru:LRU_BITS; /* LRU time (
redis缓存工具封装类
bubbleJessica的博客
02-17 220
redis封装工具类
缓存工具封装-Redis学习笔记03
weixin_42587931的博客
06-26 268
Redis缓存工具封装
【Redis】缓存工具封装
Decade_Faiz的博客
01-12 780
将封装成一个缓存工具类，方便以后重复使用。
redis雪崩：缓存穿透，缓存击穿
最新发布
07-21
Redis雪崩、缓存穿透和缓存击穿都是与缓存相关的问题，以下是它们的具体含义： 1. Redis雪崩：指在某个时间点，缓存中的大量数据同时失效或过期，导致大量请求直接访问数据库，给数据库造成巨大压力，甚至导致...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值