Redis实战篇(二)查询缓存

这篇具有很好参考价值的文章主要介绍了Redis实战篇(二)查询缓存。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

一、什么是缓存

缓存就是数据交换的缓冲区,是存贮数据的临时地方,一般读写性能较高。

1、 缓存的作用:
  • 降低后端负载
  • 提高读写效率,降低响应时间
2、缓存的成本:
  • 数据一致性成本
  • 代码维护成本
  • 运维成本

二、添加Redis缓存

Redis实战篇(二)查询缓存

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Override
    public Result queryById(Long id) {
        String key = "code:shop:" + id;
        //1、从redis中获取缓存
        String shopJson = stringRedisTemplate.opsForValue().get(key);
        //2、判断是否存在
        if (StringUtil.isNotBlank(shopJson)) {
            //3、存在直接返回
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return Result.ok(shop);
        }
        //4、不存在,查询数据库
        Shop shop = getById(id);
        //5、不存在,返回错误
        if (shop == null) {
            return Result.fail("未查询到数据");
        }
        //6、存在,写入redis
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shop));
        //7、返回
        return Result.ok(shop);
    }

三、缓存更新策略

1、三种更新策略

内存淘汰 超时剔除 主动更新
说明 不用自己维护,利用Redis的内存淘汰机制,当内存不足时自动淘汰部分数据。下次查询时更新缓存 给缓存数据添加TTL时间,到期后自动删除缓存。下次查询时更新缓存。 编写业务逻辑,在修改数据库的同时,更新缓存。
一致性 一般
维护成本

如何选择:
根据业务场景,当低一致性需求时,使用内存淘汰机制。例如店铺类型的查询缓存。
当高一致性需求时,使用主动更新,并以超时剔除作为辅助。例如商铺详情查询。

2、主动更新策略

策略 说明
Cache Aside Pattern 由缓存的调用者,在更新数据库的同时更新缓存
Read/Write Through Pattern 缓存和数据库整合成一个服务,由服务来维护一致性。
Write Behind Caching Pattern 调用者只操作缓存,由其他线程异步的将缓存数据持久化到数据库

Redis实战篇(二)查询缓存

3、总结

缓存更新策略的最佳实践方案:

  1. 低一致性需求:使用Reids自带的内存淘汰机制
  2. 高一致性需求:主动更新,并以超时剔除作为辅助方案
    读操作:缓存命中直接返回;缓存未命中查询数据库,并写入缓存,设定超时时间
    写操作:先写数据库,再删除缓存;要确保数据库和缓存操作的原子性

四、缓存穿透

1、定义

指客户端请求的数据在缓存中和数据库中都不存在,这样缓存永远都不会生效,这些请求都会打到数据库。

2、解决方案

(1)缓存空对象
优点 缺点
实现简单,维护方便 额外的内存消耗;可能造成短期的不一致

Redis实战篇(二)查询缓存

(2)布隆过滤器

Redis实战篇(二)查询缓存

优点 缺点
内存占用较少,没有多余key 实现复杂;存在误判可能

五、缓存雪崩

1、定义

指在同一时段大量的缓存key同时失效或者Redis服务宕机,导致大量请求到达数据库,带来巨大压力。

2、解决方案

(1)给不同的key的TTL添加随机值
(2)利用Redis集群提高服务的可用性
(3)给缓存业务添加降级限流策略
(4)给业务添加多级缓存

六、缓存击穿

1、定义

缓存击穿问题也叫热点key问题,就是一个被高并发访问并且缓存重建业务较复杂的key突然失效了,无数的请求访问会在瞬间给数据库带来巨大的冲击。

2、解决方案

Redis实战篇(二)查询缓存

Redis实战篇(二)查询缓存

3、基于互斥锁方式解决缓存击穿问题

Redis实战篇(二)查询缓存

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

4、基于逻辑过期方式解决缓存击穿问题

Redis实战篇(二)查询缓存
线程 存数据到redis

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

七、缓存工具封装

八、总结

Redis实战篇(二)查询缓存文章来源地址https://www.toymoban.com/news/detail-405495.html

到了这里,关于Redis实战篇(二)查询缓存的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Redis学习(三)分布式缓存、多级缓存、Redis实战经验、Redis底层原理

    单节点Redis存在着: 数据丢失问题:单节点宕机,数据就丢失了。 并发能力和存储能力问题:单节点能够满足的并发量、能够存储的数据量有限。 故障恢复问题:如果Redis宕机,服务不可用,需要一种自动的故障恢复手段。 RDB持久化 RDB(Redis database backup file,Redis数据库备份

    2024年02月16日
    浏览(40)
  • Redis实战(3)——缓存模型与缓存更新策略

    1 什么是缓存? 缓存 就是数据交换的缓冲区, 是存贮数据的临时区,一般读写性能较高 textcolor{red}{是存贮数据的临时区,一般读写性能较高} 是存贮数据的临时区,一般读写性能较高 。缓存可在多个场景下使用 以一次 w e b 请求为例,演示不同阶段的缓存作用 textcolor{blue}

    2024年02月15日
    浏览(41)
  • 【Redis】什么是缓存穿透,如何预防缓存穿透?

    缓存穿透是指查询一个一定不存在的数据,由于缓存中不存在,这时会去数据库查询查不到数据则不写入缓存,这将导致这个不存在的数据每次请求都要到数据库去查询,这就造成缓存穿透。简单来说,就是访问业务系统不存在的数据,就可能会造成缓存穿透。 缓存穿透会产

    2024年02月12日
    浏览(38)
  • 【Redis】什么是缓存击穿,如何预防缓存击穿?

    缓存击穿是指一个 Key 非常热点,大并发集中对这一个点进行访问,当这个Key 在失效的瞬间,持续的大并发就会穿破缓存,直接请求数据库。缓存击穿和缓存雪崩的区别在于,缓存击穿是针对某一个 Key缓存而言,缓存雪崩则是很多 Key。一般的网站很难有某个数据达到缓存击

    2024年02月12日
    浏览(40)
  • Redis学习(三)持久化机制、分布式缓存、多级缓存、Redis实战经验

    单节点Redis存在着: 数据丢失问题:单节点宕机,数据就丢失了。 并发能力和存储能力问题:单节点能够满足的并发量、能够存储的数据量有限。 故障恢复问题:如果Redis宕机,服务不可用,需要一种自动的故障恢复手段。 RDB持久化 RDB(Redis database backup file,Redis数据库备份

    2024年02月16日
    浏览(50)
  • Redis实战案例4-缓存更新策略

    缓存中的数据一致性问题(数据库更新数据,而Redis存的是旧数据) 内存淘汰策略:当内存很充足时,很长时间无法淘汰数据,所以很难控制淘汰,一致性差; 超时剔除:取决于TTL大小,可以达到控制目的,但是在TTL时间内也可能存在数据库更新从而Redis中变成旧数据; 主动

    2024年02月10日
    浏览(41)
  • Redis—Redis介绍(是什么/为什么快/为什么做MySQL缓存等)

    一、Redis是什么 Redis 是一种 基于内存的数据库 ,对数据的读写操作都是在内存中完成,因此读写速度非常快,常用于 缓存,消息队列、分布式锁等场景 。         Redis 提供了多种数据类型来支持不同的业务场景,比如 String(字符串)、Hash(哈希)、 List (列表)、Set(集合)、

    2024年02月10日
    浏览(66)
  • Redis什么是缓存穿透、击穿、雪崩?如何解决

    通常后端会采用Mysql等磁盘数据库,可以持久化但是访问慢,高并发时性能差,需要设置Nosql内存型数据库缓存:Redis等 但缓存可能出现:缓存穿透、缓存击穿、缓存雪崩等问题 查找数据的顺序是:先查找缓存,再查找数据库 当查找一个数据时,缓存没有都会请求数据库,当

    2024年02月09日
    浏览(59)
  • 一线大厂Redis高并发缓存架构实战与性能优化

    我们都知道,一般的互联网公司redis部署都是主从结构的,那么复制基本都是异步执行的, 那就存在一个问题,当我们设置分布式锁的时候,还没来得及将key复制到从节点,主节点挂了,那么从节点会成为主节点,但是主节点的分布式锁key就会丢失掉,如果新线程进来执行同

    2024年02月08日
    浏览(43)
  • 中间件系列 - Redis入门到实战(高级篇-多级缓存)

    学习视频: 黑马程序员Redis入门到实战教程,深度透析redis底层原理+redis分布式锁+企业解决方案+黑马点评实战项目 中间件系列 - Redis入门到实战 本内容仅用于个人学习笔记,如有侵扰,联系删除 学习目标 JVM进程缓存 Lua语法入门 实现多级缓存 缓存同步策略 传统的缓存策略

    2024年02月03日
    浏览(57)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包