Redis实战篇2：商户缓存

最新推荐文章于 2024-08-26 17:09:54 发布
最新推荐文章于 2024-08-26 17:09:54 发布
阅读量837 收藏 20
点赞数 36
文章标签： 缓存 redis 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jialuosi/article/details/139145217
版权

说明

        该实战篇基于某马的Redis课程中的《某马点评项目》。非常适合有相关经验、缺少企业级解决方案，或者想要复习的人观看，全篇都会一步一步的推导其为什么要这么做，分析其优缺点，达到能够应用的地步。

        本实战篇中心思想就是把项目中的实战抽象成一个个的知识点进行讲解，让初学者达到举一反三的地步而不是只会照着视频敲代码而不去独立思考为什么要这么做。

        关于项目代码请移步到 某马程序员公众号，回复Redis获取。

一、如何添加缓存

        为什么要添加缓存？
        想必大部分的人都用过美团饿了么等APP，要知道的是，在这些APP中，小手一扒拉动辄就是十几二多条的商品信息需要刷新，而且根据付费推荐算法，很多人在同一个地区都会刷新出来同样的店铺，像这种高频热点数据，我们就可以使用Redis，以提高反应速度。 

        那么接下来分析一下，如何添加商户的缓存
        首先，根据我们学习篇3中的缓存更新策略，商户信息属于无须高一致性的信息，所以我们用超时剔除的方案即可，既能保证一定的准确性，同时又不浪费太多的性能。

二、添加缓存 

2.1 简单思路，查询、删除、更新的方法

关于商户信息操作，首先查询

  1. 根据ID查询店铺
  2. 先去Redis中查询，如果没有则去数据库中查询
  3. 将数据库中的结果写入Redis中，并且设置过期时间

删除更新操作：这个就要考虑到一致性，我们使用先操作数据库后删除缓存的办法进行（如果删除缓存操作出现了异常则数据库更新成功缓存更新失败，这样无法保证双写一致性，所以记得在删除更新操作的时候加上事务注解）

作为中间过渡思想不列举代码了

三、 缓存穿透与解决方案

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

我们要知道，为什么要用Redis，不仅仅是因为Redis的响应速度快，同时也是因为MySQL能承载的并发不高，为了避免很多用户同时访问MySQL数据从而使用的Redis，如果有大量缓存穿透的事件发生，那么就会有大量请求打到MySQL上，造成MySQL服务器宕机。

关于什么是布隆过滤器，可以看看这篇大佬的文章，讲的很全面 

布隆过滤器icon-default.png?t=N7T8https://blog.csdn.net/qq_41125219/article/details/119982158

        理解了前置内容，我们知道刚刚的2.1的简单方案并不可行，他会造成缓存穿透的问题，如果查询一直打向数据库，那么会造成数据库宕机的可能性。

3.1 缓存空值的解决方案

整体流程图如下 ，我们需要在2.1的基础上完成两件事：

  1. 在查询MySQL时判断有无商铺信息，如果没有，则缓存一个空值到Redis中
  2. 在查询Redis时，如果命中了商铺信息缓存，需要判断其是否为空值，如果为空则返回错误信息

public Result queryByIdOne(Long id){
    // 1. 从redis查缓存
    //RedisConstants.CACHE_SHOP_KEY：一个常量键名
    //id：商铺ID
    String key = RedisConstants.CACHE_SHOP_KEY+id;
    String shopJson = stringRedisTemplate.opsForValue().get(key);
    // 2. 判断是否存在
    // 2.1 从redis中获取的值存在且不为空值 则正常返回数据
    if(shopJson != null && !"".equals(shopJson)){
        // 2.1.1 把刚刚查询到的json转化为对象
        Shop shop = JSONUtil.toBean(shopJson, Shop.class);
        return Result.ok(shop);
    }
    // 2.2 如果不属于正常值 则判断其是否为空字符串
    if(shopJson != null){
        // 2.2.1 如果为空字符串，则返回信息
        return Result.fail("店铺信息不存在");
    }
    // 4. 不存在，根据ID查询数据库
    Shop shop = getById(id);
    // 5. 不存在，返回错误
    if(shop == null){
        // 5.1 如果数据库中都不存在该店铺的信息 则向redis中写入一个空值 防止缓存穿透
        stringRedisTemplate.opsForValue().set(key,"",RedisConstants.CACHE_NULL_TTL, TimeUnit.MINUTES);
        return Result.fail("店铺信息不存在");
    }
    // 6. 存在，写入redis 设置缓存世界
    stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shop),RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
    // 7. 返回数据
    return Result.ok(shop);
}

四、缓存雪崩与解决方案

缓存雪崩：是指在同一时段大量的缓存key同时失效或者Redis服务宕机，导致大量请求到达数据库，带来巨大压力。
同样的道理，大量的key失效，则有大量的请求到MySQL服务器，这也会导致SQL服务器瞬间宕机。

为什么同一时段大量的缓存key同时失效？

在开发中，为了某一项事件或者活动的正常开始，我们通常会预先的把一些热点数据直接缓存到Redis中，这个叫预热，这种情况下就有同一时间段大量缓存失效的可能性。

五、缓存击穿

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

雪崩与击穿的区别：

雪崩是一大推key失效
击穿是一个被高并发访问并且缓存重建业务较复杂的key失效

 
看上图，线程1查询未命中，去数据库中重建缓存，如果这个查询的内容并发高，并且重建缓存非常复杂，那么可能在重建的过程中有非常多的并发查询重建缓存的步骤在进行，那么在这段时间内所有的请求都会打到SQL服务器上面造成宕机。

我们常见的解决方案有两种：互斥锁  | 逻辑过期

5.1 互斥锁

互斥锁很好理解，在缓存重建之前获取一把锁，这样只有获取锁的线程可以执行缓存重建，其他线程需要等待，这样就避免了服务器宕机，但是同时也带来了性能下降的问题。

 

5.2 逻辑过期

当线程查询缓存并且发现其逻辑时间过期后，会尝试获取互斥锁，此时如果获取成功，则会开启一个新的线程来帮助其完成重建缓存的任务，自己则返回旧的已过期的数据，其他线程查询时如果过期也会尝试获取锁，如果失败了也会返回旧的已过期的数据，而不是选择等待，这样就避免了性能浪费的问题，但是也带来了数据不一致的问题，不适用于强一致性的场景下。



5.3 对比互斥锁与逻辑过期 

5.4 代码实现：基于互斥锁方案

需要注意的是，我们使用的锁并不是传统上的lock锁，而是setnx。
我们先来回顾一下setnx，他也是一个存方法，且紧当这个key的value为空的时候才可以存，如果不为空则会失败，我们可以用这个原理来实现互斥锁，同时在setnx的时候也要存储时间，否则可能会因为某些问题导致这个锁一直没有被释放从而造成的死锁问题。

 

  1. 获取锁与释放锁 
    1. /**
 * 获取互斥锁
 * 锁的原理是通过redis的setnx只能添加一次的原理实现
 *  1. 如果没有值 则获取锁成功 返回true
 *  2. 如果有值，则会导致写入失败 从而返回false
 * @param key
 * @return
 */
private boolean tryLock(String key){
    Boolean aBoolean = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
    return BooleanUtil.isTrue(aBoolean);
}
/**
 * 释放互斥锁
 * 就是删除redis当中锁的键
 * @param key
 */
private void unLock(String key){
    stringRedisTemplate.delete(key);
}
  2. 主要业务 
    1.     /**
     * 解决缓存击穿
     * @param id
     * @return
     */
public Shop queryWithMutex(Long id){
    // 1. 从redis查缓存
    String key = RedisConstants.CACHE_SHOP_KEY+id;
    String shopJson = stringRedisTemplate.opsForValue().get(key);
    // 2. 判断是否存在
    // 2.1 从redis中获取的值存在且不为空值 则正常返回数据
    if(shopJson != null && !"".equals(shopJson)){
        // 2.1.1 把刚刚查询到的json转化为对象
        Shop shop = JSONUtil.toBean(shopJson, Shop.class);
        return shop;
    }
    // 2.2 如果不属于正常值 则判断其是否为空字符串
    if(shopJson != null){
        // 2.2.1 如果为空字符串，则返回信息
        return null;
        // 2.2.2 如果为null 证明没有去数据库查过 则去查询数据库信息
    }
    // 4 实现缓存重建
    // 4.1 获取互斥锁
    String lockKey = RedisConstants.LOCK_SHOP_KEY+id; //设置锁名 每个店铺有自己的锁
    Shop shop = null;
    try {
        boolean isLock = tryLock(lockKey);
        // 4.2 判断是否成功
        if(!isLock){
            // 4.3 如果失败 则休眠，并且重新获取互斥锁
            Thread.sleep(50);
            queryWithMutex(id); // 递归 重新获取锁
        }
        // 4.4 如果成功得到了互斥锁则去根据ID查询数据库
        shop = getById(id);
        // 5. 不存在，返回错误
        if(shop == null){
            // 5.1 如果数据库中都不存在该店铺的信息 则向redis中写入一个空值 防止缓存穿刺
            stringRedisTemplate.opsForValue().set(key,"",RedisConstants.CACHE_NULL_TTL, TimeUnit.MINUTES);
            return null;
        }
        // 6. 存在，写入redis 设置缓存世界
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shop),RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }finally {
        // 7. 释放锁
        unLock(lockKey);
    }
    // 8. 返回数据
    return shop;
}

5.5 代码实现：基于逻辑过期方案

逻辑过期，顾名思义，就是不设置TTL过期时间，在传递数据的时候手动添加一个过期时间字段，也就是说，什么时候过期由程序员说的算而不是redis。

从Redis中查询缓存理论上来讲是不会出现查询不到的情况的，因为一般这种需要逻辑过期时间的的事件都是活动事件，需要在活动开始之前就人工的把热点信息全部都缓存到redis当中，之后在人工的删除。但是为了健壮性，还是考虑一下未命中的情况。
我们来看看如何传递，首先要知道的是，我们在同步数据到Redis当中还需要新增一个字段，也就是过期时间字段。方法为将需要同步到Redis中的数据存放到下类中并且可以通过setexpireTime来设置时间即可。

@Data
public class RedisData {
    private LocalDateTime expireTime; //过期时间
    private Object data; //同步的数据
}

然后写一个写入这个类的函数，即需传入店铺ID以及过期时间即可，时间单位为秒

public void savaShop2Redis(Long id,Long expireSeconds){
    // 1.查询店铺信息
    Shop shop = getById(id);
    // 2.封装逻辑过期时间
    RedisData redisData = new RedisData();
    redisData.setData(shop);
    //plusSeconds(expireSeconds) ：当前时间+多少秒
    redisData.setExpireTime(LocalDateTime.now().plusSeconds(expireSeconds));
    // 3.写入redis缓存
  stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY+id,JSONUtil.toJsonStr(redisData));
}

再来创建一个线程池

private static  final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);

来看总代码：

/**
 * 解决缓存击穿（设置逻辑过期时间）
 * @param id
 * @return
 */
public Shop queryWithLogicalExpire(Long id){
    // 1. 从redis查缓存
    String key = RedisConstants.CACHE_SHOP_KEY+id;
    String shopJson = stringRedisTemplate.opsForValue().get(key);
    // 2. 判断是否存在
    // 2.1 从redis中获取的值如果为空
    if(shopJson == null || "".equals(shopJson)){
        // 3. 如果不存在 直接返回
        return null;
    }
    // 4. 如果命中，则将json反序列化为对象
    RedisData redisData = JSONUtil.toBean(shopJson, RedisData.class);
    // TODO 到时候在研究一下 这个其实返回的是JSONObject对象
    Shop shopRedis = JSONUtil.toBean((JSONObject) redisData.getData(), Shop.class);
    LocalDateTime expireTime = redisData.getExpireTime();
    // 5. 判断是否过期
    if(expireTime.isAfter(LocalDateTime.now())){
        //如果逻辑过期时间在当前时间之后，则未过期 例如
        // 逻辑时间为20:00 当前时间为19:30 逻辑时间在当前时间之后
        // 5.1 直接返回当前结果
        return shopRedis;
    }
    // 6. （如果到了这一步，证明已经过期了） 需要重建缓存
    // 6.1 获取互斥锁
    String lockKey = RedisConstants.LOCK_SHOP_KEY+id;
    boolean isLock = tryLock(lockKey);
    // 6.2 判断互斥锁是否成功
    if(isLock){
        // 获取成功 开启独立线程，实现缓存重建
        CACHE_REBUILD_EXECUTOR.submit(() ->{
            // 缓存重建
            try {
                this.savaShop2Redis(id,20L);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }finally {
                //释放锁
                unLock(lockKey);
            }
        });
    }
    // 7. 返回过期的数据
    return shopRedis;
}

六、封装函数

为什么要封装函数？我们可以看到上面，如果说有几十个功能都需要解决击穿/穿透问题，哪每一个都写一遍吗？肯定是不能的，这其中有很多可以抽象为共用方法来实现，来看规则

 

6.1 方法1 

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

6.2 方法2

/**
 * 将任意java对象序列化为json并存储在string类型的key中，并且可以设置逻辑过期时间，
 * 用于处理缓存击穿问题
 */
public void setWithLogicalExpire(String key, Object value, Long time, TimeUnit unit) {
    //封装逻辑过期时间
    RedisData redisData = new RedisData();
    redisData.setExpireTime(LocalDateTime.now().plusSeconds(unit.toSeconds(time)));
    redisData.setData(value);
    stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(redisData));
}

6.3 方法3

如果不懂泛型的话，需要泛型的知识作为补充

如何调用：
 

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

主程序： 

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

public <R,ID> R queryWithPassThrough(
        String keyPrefix, ID id, Class<R> type, Function<ID,R> dbFallback,
        Long time, TimeUnit unit){
    // 1. 从redis查缓存
    String key = keyPrefix+id;
    String json = stringRedisTemplate.opsForValue().get(key);
    // 2. 判断是否存在
    // 2.1 从redis中获取的值存在且不为空值 则正常返回数据
    if(json != null && !"".equals(json)){
        // 2.1.1 把刚刚查询到的json转化为对象
        return JSONUtil.toBean(json, type);
    }
    // 2.2 如果不属于正常值 则判断其是否为空字符串
    if(json != null){
        // 2.2.1 如果为空字符串，则返回信息
        //return Result.fail("店铺信息不存在");
        return null;
        // 2.2.2 如果为null 证明没有去数据库查过 则去查询数据库信息
    }
    // 4. 不存在，根据ID查询数据库
    R r = dbFallback.apply(id);
    // 5. 不存在，返回错误
    if(r == null){
        // 5.1 如果数据库中都不存在该店铺的信息 则向redis中写入一个空值 防止缓存穿刺
        stringRedisTemplate.opsForValue().set(key,"",RedisConstants.CACHE_NULL_TTL, TimeUnit.MINUTES);
        return null;
    }
    // 6. 如果存在，写入redis 设置缓存世界
    this.set(key,r,time,unit);
    // 7. 返回数据
    return r;
}

 6.4 方法4

Shop shop1 = cacheClient.queryWithLogicalExpire(RedisConstants.CACHE_SHOP_KEY, id,
            Shop.class, this::getById, RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
/**
 * 根据指定的key查询缓存，并反序列化为指定类型，需要利用逻辑过期解决缓存击穿问题
 */
public <R,ID> R queryWithLogicalExpire(String keyPrefix,ID id,Class<R> type,
                 Function<ID,R> dbFallback,Long time, TimeUnit unit){
    // 1. 从redis查缓存
    String key = keyPrefix+id;
    String json = stringRedisTemplate.opsForValue().get(key);
    // 2. 判断是否存在
    // 2.1 从redis中获取的值如果为空
    if(json == null || "".equals(json)){
        // 3. 如果不存在 直接返回
        return null;
    }
    // 4. 如果命中，则将json反序列化为对象
    RedisData redisData = JSONUtil.toBean(json, RedisData.class);
    // TODO 到时候在研究一下 这个其实返回的是JSONObject对象
    R r = JSONUtil.toBean((JSONObject) redisData.getData(), type);
    LocalDateTime expireTime = redisData.getExpireTime();
    // 5. 判断是否过期
    if(expireTime.isAfter(LocalDateTime.now())){
        //如果逻辑过期时间在当前时间之后，则未过期 例如
        // 逻辑时间为20:00 当前时间为19:30 逻辑时间在当前时间之后
        // 5.1 直接返回当前结果
        return r;
    }
    // 6. （如果到了这一步，证明已经过期了） 需要重建缓存
    // 6.1 获取互斥锁
    String lockKey = RedisConstants.LOCK_SHOP_KEY+id;
    boolean isLock = tryLock(lockKey);
    // 6.2 判断互斥锁是否成功
    if(isLock){
        // 获取成功 开启独立线程，实现缓存重建
        CACHE_REBUILD_EXECUTOR.submit(() ->{
            // 缓存重建
            try {
                // 查询数据库
                R r1 = dbFallback.apply(id);
                // 重建缓存
                this.setWithLogicalExpire(key,r1,time,unit);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }finally {
                //释放锁
                unLock(lockKey);
            }
        });
    }
    // 7. 返回过期的数据
    return r;
}

 七、总结

 

三种缓存更新策略

主动更新方案：

 缓存穿透

缓存雪崩

缓存击穿

加洛斯
关注
  • 36
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Redis实战(3)-数据结构List实战一之商品信息的有序存储
青松之竹_Java博客
02-05 1083
摘要：电商平台的管理后端一般有两大角色的用户可以使用，一个是系统管理员，一个是平台的卖家/商家，对于商家而言，管理自个儿的商品是日常工作中再为普通不过的事情了，本文我们将以“有序存储并展示电商平台中商家上传的各式各样的商品列表”，这里的关键词是“有序存储与展示”，我们将借助缓存中间件Redis的数据结构~列表List进行实战实现！
Redis实战(4)-数据结构List实战之队列特性实现消息多线程 广播通知
青松之竹_Java博客
02-06 795
摘要：电商平台的管理后端一般有两大角色的用户可以使用，一个是系统管理员，一个是平台的卖家/商家，对于商家而言，管理自个儿的商品是日常工作中再为普通不过的事情了，而对于系统管理员而言，有时候需要发布一些活动公告通知商家进行报名参加，本文我们将基于List的队列特性实现公告消息的广播通知功能！
【Redis】实战篇：商户查询缓存（缓存穿透、缓存雪崩、缓存击穿问题）
小新的博客
10-20 804
进入缓存的世界
11.29_黑马Redis实战篇商户查询缓存
2301_80185446的博客
11-29 1291
黑马redis实战篇商户查询中可能会出现的一些bug以及代码以及心得
Redis实战2.查询缓存
Gus10124的博客
06-01 989
自用黑马Redis笔记
【Redis】Redis实战：黑马点评之商户查询缓存
qq_50675319的博客
09-17 1162
在原来的业务逻辑中，如果用户查询缓存未命中，会去直接查询数据库，在这种情况下，如果用户查询的是热点数据且缓存重建比较复杂，就容易出现缓存击穿问题，这里我们可以假设商铺查询就是热点数据，需要针对缓存击穿问题设计相应的解决方案 相较于原来从缓存中查询不到数据后直接查询数据库而言，现在的方案是进行查询之后，如果从缓存未命中，则进行互斥锁的获取，获取互斥锁后，判断是否获得到了锁，如果没有获得锁，则休眠，过一段时间再对上述业务逻辑进行重试，获取到锁的线程可以需要去查询数据库并将数
Redis从入门到精通(四)Redis实战(二)商户查询缓存 测试项目代码
04-04
本教程将基于“Redis从入门到精通(四)Redis实战(二)商户查询缓存”的主题，深入探讨如何利用Redis来实现商户查询的高效缓存策略。我们将通过测试项目代码来理解这一过程。 首先，让我们理解Redis缓存的基本概念。...
Redis实战
爱哭的毛毛虫的博客
10-09 1949
redis中各种数据类型的使用
ZNS SSD是不是持久缓存的理想选择？
存储随笔
08-23 1237
具体来说，ZNS SSDs能够减少内部垃圾收集过程中的写放大（WA），这有助于延长SSD的寿命并避免因额外的数据移动而导致的吞吐量降低和不稳定延迟。持久缓存结合了缓存的快速访问特性和非易失性存储的持久性，使得数据能够在系统断电后仍然得以保存，从而提高了数据的可靠性和系统的整体性能。这种方案对于追求高性能和低延迟的应用来说是一个很好的选择。然而，需要注意的是较大的Region大小可能会导致更长的Region插入时间和更大的内存消耗，这可能需要在实际应用中通过适当的Region大小选择来平衡性能和资源消耗。
NRC-SIM：基于Node-RED的多级多核缓存模拟器
bit_mike的博客
08-23 990
论文介绍了一个基于Node-RED的多级多核缓存模拟器NRC-SIM，允许用户修改缓存配置参数，如核心数量、缓存级别和一致性协议等，并观察这些参数的影响。NRC-SIM通过Web界面提供简化的用户体验，允许任何连接到网络的设备进行缓存模拟。使用Node-RED的模块化、基于流的设计，NRC-SIM能够将用户输入转换为适当的格式，执行追踪驱动的缓存模拟。
清除系统缓存提高写盘速度的tips
最新发布
qq_34999565的博客
08-26 148
当内存中存储了大量数据缓存时，系统的可用内存会减少。在内存资源紧张的情况下，执行 echo 3 > /proc/sys/vm/drop_caches 可以清理内存中的页缓存、目录项缓存（dentries）和 inode 缓存，从而释放出更多的内存空间供程序使用。如果系统即将进行新的数据缓存或处理操作，尤其是涉及大量数据的处理任务时，清理缓存可以释放内存，为后续操作提供更多的可用内存。这个命令部分的作用是通过向 /proc/sys/vm/drop_caches 文件写入一个值，来指示内核清理特定的内存缓存。
Linux文件IO缓存
weixin_42198851的博客
08-26 602
当操作磁盘文件时，缓冲大块数据以减少系统调用，C 语言函数库的 I/O 函数（比如， fprintf()、fscanf()、fgets()、fputs()、fputc()、fgetc()）正是这么做的。3. 总之，如果需要强制刷新内核缓冲区，那么在设计应用程序时就应考虑是否可以使用大 尺寸的 write()缓冲区，或者在调用 fsync()或 fdatasync()时谨慎行事，而不是在打开文件时就使用 O_SYNC 标志。有时也称此为直接 I/O（direct I/O）或者裸 I/O(raw I/O)。
Django缓存设置
sheji888的专栏
08-26 222
在Django中设置缓存可以显著提高网站的性能，特别是在处理大量请求或数据库查询时。Django支持多种缓存后端，包括内存缓存、文件缓存、数据库缓存和更高级的选项如Memcached和Redis。
Spring系列之Spring Cache缓存注解的使用
echola_mendes的博客
08-23 1435
Spring Cache 是 Spring Framework 提供的一个用于操作缓存的抽象层，它简化了在 Spring 应用程序中集成和使用缓存的过程Spring Cache 不直接实现任何缓存技术，而是定义了一套标准接口和注解，使得开发人员可以轻松地切换底层缓存实现，而无需修改业务逻辑代码是不是有点似懂非懂，那么使用一个🌰来了解@Service@Autowire@Autowired//查询用户if(user!= null) {
【手写数据库内核组件】0304 缓存策略，缓存经典穿透，击穿，雪崩，抖动问题，在缓存池中实战中的解决与应对
一个追逐梦想的码农
08-26 82
一般增加缓存是为了减少IO次数，让更多业务需要的数据驻留在内存中，提升整体的性能。 但是引入缓存后，会带来缓存穿透、抖动、击穿、雪崩的问题； 本节就来看一看这些问题在我们实现的缓存池上如何解决的。
ruoyi-app前端在缓存中添加nick_name和user_id属性值
liao3399084的博客
08-26 112
ruoyi-app原生自带只有avatar、name、roles、permissions；在显示中，我们大多数需要nick_name、user_id；当然获取方式也可以通过name去调用接口查询，但我想偷个懒。代码已经调好的，复制即用；至于修改点，细心一点应该能自己发现。
优化系统性能：深入探讨Web层缓存与Redis应用的挑战与对策
dsgdauigfs的博客
08-26 725
Web层缓存显著提高了应用性能，通过减少重复的数据处理和数据库查询来加快响应时间。Redis作为高效的内存数据结构存储系统，在实现缓存层中发挥了重要作用，它支持各种数据结构，能够迅速存取数据，从而减少数据库负担，提升用户体验。然而，缓存机制也面临挑战，如缓存穿透、缓存击穿和缓存雪崩等问题。缓存穿透通过缓存空对象和布隆过滤器来解决，前者避免了每次查询都访问数据库，后者有效减少了恶意请求的影响。缓存击穿则通过设置随机过期时间来缓解，这样可以避免大量请求同时涌向数据库。
使用LinkedHashMap实现固定大小的LRU缓存
shyの个人笔记
08-26 823
使用LinkedHashMap实现固定大小的LRU缓存
Redis基础与实战：Java缓存策略、NoSQL对比与Redis特性
Redis是一种高性能的键值存储系统，它被广泛应用于各种场景，特别是在Java开发中作为缓存解决方案。Redis以其强大的功能和灵活性区别于传统的关系型数据库(RDBMS)。 在Java缓存机制中，Redis作为一种非关系型数据库...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值