redis缓存------实现增删改查中的redis缓存实现

最新推荐文章于 2023-09-20 16:48:59 发布
最新推荐文章于 2023-09-20 16:48:59 发布
阅读量303 收藏 1
点赞数 1
分类专栏： redis 文章标签： 缓存 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_64035133/article/details/130830418
版权

流程分析

实现代码

   @GetMapping("/{id}")
    public Result queryShopById(@PathVariable("id") Long id) {
        return shopService.queryById(id);
    }

 service


    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Override
    public Result queryById(Long id) {
        //从redis中查询商铺缓存
        String key = CACHE_SHOP_KEY + id;
        String shopJson = stringRedisTemplate.opsForValue().get(key);
        //判断是否存在
        if (StrUtil.isNotBlank(shopJson)) {
            //存在，直接返回
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return Result.ok(shop);
        }
        //不存在，根据id查询数据库
        Shop shopById = this.getById(id);

        if (shopById == null) {
            //不存在，返回错误
            return Result.fail("店铺不存在");
        }
        //存在，写入redis
        stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shopById));
        return Result.ok(shopById);
    }

缓存更新的策略

 主动更新策略需要考虑的问题

 对比之下先操作数据库再删缓存更好

缓存更新策略总结：

修改之前的代码，在原本的redis中添加超时时间 

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Override
    public Result queryById(Long id) {
        //从redis中查询商铺缓存
        String key = CACHE_SHOP_KEY + id;
        String shopJson = stringRedisTemplate.opsForValue().get(key);
        //判断是否存在
        if (StrUtil.isNotBlank(shopJson)) {
            //存在，直接返回
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return Result.ok(shop);
        }
        //不存在，根据id查询数据库
        Shop shopById = this.getById(id);

        if (shopById == null) {
            //不存在，返回错误
            return Result.fail("店铺不存在");
        }
        //存在，写入redis
        stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shopById),CACHE_SHOP_TTL, TimeUnit.MINUTES);
        return Result.ok(shopById);
    }

修改商铺信息

   @Override
    @Transactional
    public Result updateredis(Shop shop) {

        //修改数据库
        this.updateById(shop);
        //删除redis缓存
        String key = CACHE_SHOP_KEY + shop.getId();
        if (key == null) {
            //id不存在，直接返回错误
            return Result.fail("商铺id不能为空");
        }
        stringRedisTemplate.delete(key);
        return Result.ok();
    }

缓存穿透

缓存穿透的原因：

 

两种解决办法：

 缓存空对象的思路：

 实现代码

@Override
    public Result queryById(Long id) {
        //从redis中查询商铺缓存
        String key = CACHE_SHOP_KEY + id;
        String shopJson = stringRedisTemplate.opsForValue().get(key);
        //判断是否存在
        if (StrUtil.isNotBlank(shopJson)) {
            //存在，直接返回
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return Result.ok(shop);
        }
        //判断是否为空字符串
        if (shopJson != null){
            /**
             * 因为StrUtil.isNotBlank(shopJson)在shopjson未null，“”时都为false，所以当shopJson！=null就等于“”
             */
            //缓存为空
            return Result.fail("店铺不存在！！！");
        }
        //不存在，根据id查询数据库
        Shop shopById = this.getById(id);

        if (shopById == null) {
            //将空值缓存到redis
            stringRedisTemplate.opsForValue().set(key,"",CACHE_NULL_TTL,TimeUnit.MINUTES);
            //不存在，返回错误
            return Result.fail("店铺不存在");
        }
        //存在，写入redis
        stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shopById),CACHE_SHOP_TTL, TimeUnit.MINUTES);
        return Result.ok(shopById);
    }

缓存穿透的解决方案（总结）：

 缓存雪崩

 缓存击穿

 解决方案的分析

 两种方案的优缺点

互斥锁案例

思路

 

 实现原理：setnx

实现代码

    @Override
    public Result queryById(Long id) {

        //互斥锁解决缓存击穿
        Shop shop = queryWithMutext(id);

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




//获取锁
    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);
    }
    //商铺缓存击穿
    private Shop queryWithMutext(Long id){
        //从redis中查询商铺缓存
        String key = CACHE_SHOP_KEY + id;
        String shopJson = stringRedisTemplate.opsForValue().get(key);
        //判断是否存在
        if (StrUtil.isNotBlank(shopJson)) {
            //存在，直接返回
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return shop;
        }
        //判断是否为空字符串
        if (shopJson != null){
            /**
             * 因为StrUtil.isNotBlank(shopJson)在shopjson未null，“”时都为false，所以当shopJson！=null就等于“”
             */
            //缓存为空
            return null;
        }

        // todo 实现缓存重建
        String lockKey= null;
        Shop shopById = null;
        try {
            // todo 1.获取互斥锁
            lockKey = LOCK_SHOP_KEY+id;
            boolean isLock = tryLock(lockKey);
            // todo 2.判断获取是否成功
            if (!isLock) {
                // todo 3.失败，进行休眠
                Thread.sleep(50);
                return queryWithMutext(id);
            }

            //获取锁成功再次判断redis中受否存在
            String shopJsontwo = stringRedisTemplate.opsForValue().get(key);
            //判断是否存在
            if (StrUtil.isNotBlank(shopJsontwo)) {
                //存在，直接返回
                Shop shop = JSONUtil.toBean(shopJsontwo, Shop.class);
                return shop;
            }
            // 成功且redis中依旧没有时间，根据id查询数据库
            shopById = this.getById(id);

            if (shopById == null) {
                //将空值缓存到redis
                stringRedisTemplate.opsForValue().set(key,"",CACHE_NULL_TTL,TimeUnit.MINUTES);
                //不存在，返回错误
                return null;
            }
            //存在，写入redis
            stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shopById),CACHE_SHOP_TTL, TimeUnit.MINUTES);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }finally {
            // todo 释放互斥锁
            unlock(lockKey);
        }

        return shopById;
    }

逻辑过期案例

 需要初始化redis中的数据

初始化的方法：


    //初始化redis中的热点数据
    public void saveshop2Redis(Long id,Long exprireSeconds){
        //查询店铺数据
        Shop shop = getById(id);
        //封装过期时间
        RedisData redisData = new RedisData();
        redisData.setData(shop);
        redisData.setExpireTime(LocalDateTime.now().plusSeconds(exprireSeconds));
        //写入redis
        stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY+id,JSONUtil.toJsonStr(redisData));
    }
/**
*逻辑过期
*/
 //创建线程池
    private static final ExecutorService CACHE_REBUILD_EXECUTOR= Executors.newFixedThreadPool(10);

    //逻辑过期
    private Shop queryWithLogicalExpire(Long id){
        //从redis中查询商铺缓存
        String key = CACHE_SHOP_KEY + id;
        String shopJson = stringRedisTemplate.opsForValue().get(key);
        //判断是否存在
        if (StrUtil.isBlank(shopJson)) {
            return null;
        }
        //命中，将json反序列化成对象
        RedisData redisData = JSONUtil.toBean(shopJson, RedisData.class);
        JSONObject data = (JSONObject) redisData.getData();
        Shop shop = JSONUtil.toBean(data, Shop.class);
        LocalDateTime expireTime = redisData.getExpireTime();
        //判断缓存是否过期
        if (expireTime.isAfter(LocalDateTime.now())){
            //未过期，直接返回数据
            return shop;
        }
        //过期，需要重建缓存
        //获得互斥锁
        String lockKey=LOCK_SHOP_KEY+id;
        boolean b = tryLock(lockKey);
        if (b){
            //判断redis中是否存在数据，数据中的时间是否过期
            String shopJson2 = stringRedisTemplate.opsForValue().get(key);
            //判断是否存在
            if (StrUtil.isBlank(shopJson2)) {
                return null;
            }
            //命中，将json反序列化成对象
            RedisData redisData2 = JSONUtil.toBean(shopJson2, RedisData.class);
            JSONObject data2 = (JSONObject) redisData2.getData();
            Shop shop2 = JSONUtil.toBean(data2, Shop.class);
            LocalDateTime expireTime2 = redisData2.getExpireTime();
            //判断缓存是否过期
            if (expireTime2.isAfter(LocalDateTime.now())){
                //未过期，直接返回数据
                return shop2;
            }
            //  获取互斥锁成功
            //开启新的线程，实现重建缓存
            CACHE_REBUILD_EXECUTOR.submit(()->{
                try {
                    //重建缓存，缓存时间应为20分钟，这里为20s
                    this.saveshop2Redis(id,20l);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                } finally {
                    //释放锁
                    unlock(lockKey);
                }

            });
        }

        //获取互斥锁失败，直接返回店铺信息
        //开启独立线程
        return shop;
    }

创建通用工具类

package com.hmdp.utils;

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 com.hmdp.entity.Shop;
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.*;

@Component
@Slf4j
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 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.setData(value);
        redisData.setExpireTime(LocalDateTime.now().plusSeconds(unit.toSeconds(time)));
        // 写入Redis
        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 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;
    }

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

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

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

}

xzm_
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2、使用RedisTemplate实现基本数据类型增删改查
weixin_46147113的博客
11-27 952
基于RedisTemplate实现基本数据增删改查
Mybatis-plus基于redis实现二级缓存过程解析
08-18
在上面的代码中，我们使用了RedisTemplate来操作Redis缓存，并使用ReentrantReadWriteLock来实现读写锁，以确保缓存的线程安全。 最后，我们需要在Mapper接口中使用自定义的缓存管理类： ```java @Mapper public ...
SpringBoot + Redis 实现增删改查的缓存
weixin_47009272的博客
12-11 1139
SpringBoot + Redis 实现增删改查的缓存
Redis学习之缓存实现及缓存更新
最新发布
ysk_0904的博客
09-20 119
什么是缓存？缓存就是数据交换的缓冲区（称作Cache [ kæʃ ] ），是存贮数据的临时地方，一般读写性能较高。为什么需要缓存？提前准备好数据，便于更快地读写。缓存是把双刃剑，要权衡利弊。优点:降低后端负载提高读写效率，降低响应时间缺点:数据一致性成本 代码维护成本 运维成本。
redis中springboot的redisTemplate简单的增删查
weixin_61503139的博客
09-03 1490
Result.ok("第一个"):Result.fail("第二个");//设置不过期时间的Key。//设置存储的过期时间。//删除指定的key。
RedisJSON存储、更新和检索JSON文档
Database operation and maintenance
07-13 2749
RedisJSON 存储、更新和检索JSON文档、使用RedisJson、 RedisJson安装部署、RedisJson常用操作
redis2-nginx-module-0.15
07-18
Redis2-NGINX-Module 是一个用于 NGINX Web 服务器的扩展模块，它允许开发者将 NGINX 与 Redis 数据库集成，实现高效的数据缓存和交互。这个版本是 0.15，它提供了一系列功能，帮助提升 Web 应用的性能，减少数据库...
Redis缓存管理工具：Redis-Desktop
12-29
在本文中，我们将深入探讨Redis-Desktop的主要功能、优点和如何使用它来优化Redis缓存管理。 **Redis-Desktop Manager简介** Redis-Desktop Manager是一款跨平台的Redis GUI工具，支持Windows、Mac OS和Linux操作...
redis++使用说明,windows下编译redis-plus-plus
06-13
在实际应用中，Redis++可以作为缓存系统，用于存储临时数据，以提高应用程序的性能。同时，Redis++也可以用于消息队列，用于异步处理任务。除此之外，Redis++也可以作为数据存储系统，用于存储结构化数据。 Redis++...
redis-windows-7.0.3.rar
07-15
Redis 是一个高性能的键值对存储系统，常用于数据库缓存和消息中间件，因其高效性和易用性在IT行业中广泛应用。此压缩包"redis-windows-7.0.3.rar"提供的是Redis针对Windows操作系统的最新版本7.0.3。在Windows环境...
Redis使用hash增删改查
qq_71695227的博客
05-08 423
StringBoot+MySQL+Mybatis-plus+Redis使用hash实现增删改查
用Redis和MyBatis完成缓存数据的增加、删除、修改、查询
bingyuderizi的专栏
05-07 1505
1. 安装Redis Redis在Windows上不支持，在Windows上可以先安装WSL（即Linux）。 CMD用管理员打开，执行wsl --install。安装完成后重启电脑。如果Linux没启动。点击开始按钮，在最近添加里面有Ubuntu，以管理员身份打开。 安装Redis sudo apt-add-repository ppa:redislabs/redis sudo apt-get update sudo apt-get upgrade sudo apt-get install
RedisTemplate操作Redis
qq_41787812的博客
04-20 132
RedisTemplate操作Redis
redis缓存
JesJiang的博客
06-30 513
redis
Redis总结
bool的博客
12-15 392
黑马程序员 Redis教程 P1：Redis介绍 mysql数据库，数据库以“文件形式存储在硬盘”里边。 Redis 什么是Redis Redis是远程数据服务，内存高速缓存数据库，支持丰富的数据结构，如String、list、hash、set、sorted set，可持久化，保证了数据安全。Redis是做数据缓存的。 缓存有两种类型：数据缓存、页面缓存 使用缓存减轻数据库的负载。 在开发的时候如果有一些数据在短时间之内不会发生变化，而他们还要被频繁的访问，为了提高用户的请求速度和降低网站的负载，
带你100% 地了解 Redis 6.0 的客户端缓存
程序IT圈
05-15 162
近日 Redis 6.0.0 GA 版本发布，这是 Redis 历史上最大的一次版本更新，包括了客户端缓存 (Client side caching)、ACL、Threaded I/O ...
redis在Java中进行增删改查操作
Boy_Martin的博客
08-31 4594
redis进行增删改查操作常用工具类
Redis增删改查操作
qq_56776641的博客
02-22 2206
Redis的SortedSet是一个可排序的set集合，与Java中的TreeSet有些类似，但底层数据结构却差别很大。但是，因为 HyperLogLog 只会根据输入元素来计算基数，而不会储存输入元素本身，所以 HyperLogLog 不能像集合那样，返回输入的各个元素。HyperLogLog 的优点是：在输入元素的数量或者体积非常非常大时，计算基数所需的空间总是固定的、并且是很小的。redis存储的是：key，value格式的数据，其中key都是字符串，value常用的有8种不同的数据结构。
redis缓存（redis缓存工具封装篇）
Mrs_DongDong的博客
09-08 930
缓存(Cache),就是数据交换的缓冲区,俗称的缓存就是缓冲区内的数据例 1 : Static final ConcurrentHashMap < K , V > map = new ConcurrentHashMap < >();本地用于高并发例 2 : static final Cache < K , V > USER_CACHE = CacheBuilder . newBuilder() . build();用于redis等缓存。（参考黑马redis）
测试spring boot中整合redis中缓存实现增删改查
04-20
好的，这是一个技术问题，我可以为您解答。为了使用 Redis 缓存，您需要在 Spring Boot 应用程序中配置 Spring Data Redis，然后使用 RedisTemplate 对象执行针对 Redis 的操作。您可以使用以下代码示例将 RedisTemplate 注入到您的代码中： ``` @Autowired private RedisTemplate<String, Object> redisTemplate; ``` 然后，您可以使用 RedisTemplate 执行 Redis 操作，例如获取缓存中的数据： ``` String key = "myKey"; Object value = redisTemplate.opsForValue().get(key); ``` 修改缓存中的数据： ``` String key = "myKey"; Object newValue = "myNewValue"; redisTemplate.opsForValue().set(key, newValue); ``` 删除缓存中的数据： ``` String key = "myKey"; redisTemplate.delete(key); ``` 这是一个基本的示例，您可以根据您的需求进行调整。希望对您有所帮助！

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值