黑马redis实战篇-商铺缓存

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

目录

五、实战篇-商户查询缓存

5.1 什么是缓存

5.2 添加Redis缓存

1、不添加redis时，数据查询的作用模型：

2、添加redis时，数据查询的作用模型：

3、业务流程图：​编辑

4、代码实现

5、练习题

5.3 缓存更新策略

1、主动更新

2.Cache Aside Pattern（旁路缓存模式）

3、总结

4、给查询商铺的缓存添加超时剔除和主动更新的策略

5.4 缓存穿透

1、解决方案

2、解决商铺查询时，缓存穿透问题

3、总结

5.5 缓存雪崩

5.6 缓存击穿

1、解决方案

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

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

4、JMeter下载和安装

5.7 缓存工具封装

五、实战篇-商户查询缓存

5.1 什么是缓存

缓存就是数据交换的缓冲区（称作Cache ），是存储数据的临时地方，一般读写性能较高

 

缓存的作用:

  • 降低后端负载 ---直接访问缓存，返回数据

  • 提高读写效率，降低响应时间---基于内存存储

缓存的成本：

  • 数据一致性成本

  • 代码维护成本----解决一致性问题代码复杂

  • 运维成本-- 要保证高可用搭建集群

5.2 添加Redis缓存

1、不添加redis时，数据查询的作用模型：

 

2、添加redis时，数据查询的作用模型：

redis命中直接返回数据，未命中数据库查询返回数据，并且将数据缓存到redis中

 

3、业务流程图：

 

4、代码实现

 public Result selectShopInfoById(Long id) {
        String key = CACHE_SHOP_KEY + id;
        //1.判断redis中是否存在该id的数据
        String str = stringRedisTemplate.opsForValue().get(key);
        if (StrUtil.isNotBlank(str)) {
            //2.存在 直接返回数据
            return Result.ok(JSONUtil.toBean(str,Shop.class));
        }
        //3.不存在 查询数据库是否存在
        Shop shop = baseMapper.selectById(id);
        if (StringUtils.isEmpty(shop)) {
            //4.不存在直接返回 404
            return Result.fail("店铺不存在");
        }
        //5.存在将数据存储在redis，然后返回
        String shopJsonStr = JSONUtil.toJsonStr(shop);
        stringRedisTemplate.opsForValue().set(key,shopJsonStr);
        return Result.ok(shop);
    }

5、练习题

给店铺类型业务添加缓存

 

public Result queryOrderByAscList() {
        //1.判断redis是否存在 商铺类型的缓存
        Long size = stringRedisTemplate.opsForList().size(CACHE_SHOP_TYPE_KEY);
        if (size > 0){
            //2.存在 直接取出返回
            List<String> range = stringRedisTemplate.opsForList().range(CACHE_SHOP_TYPE_KEY, 0, size);
            List<ShopType> shopTypes = range.stream().map(item -> {
                return  JSONUtil.toBean(item,ShopType.class);
            }).collect(Collectors.toList());
            //.sorted(Comparator.comparing(ShopType::getSort).reversed())
            return Result.ok(shopTypes);
        }
        //3.不存在，查询数据库
        QueryWrapper<ShopType> queryWrapper = new QueryWrapper<>();
        queryWrapper.orderByAsc("sort");
        List<ShopType> shopTypes = baseMapper.selectList(queryWrapper);
        if (shopTypes.size() <= 0){
            //4.数据库不存在 直接返回错误
            return Result.fail("数据不存在");
        }
        //5.数据库存在，将数据存储在缓存中然后返回
        List<String> collect = shopTypes.stream().map(item -> {
            return JSONUtil.toJsonStr(item);
        }).collect(Collectors.toList());
        stringRedisTemplate.opsForList().rightPushAll(CACHE_SHOP_TYPE_KEY,collect);
        //设置过期时间是1天
        stringRedisTemplate.expire(CACHE_SHOP_TYPE_KEY,CACHE_SHOP_TYPE_TTL, TimeUnit.MINUTES);

        return Result.ok(shopTypes);
    }

5.3 缓存更新策略

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

业务场景：

  • 低一致性需求：使用内存淘汰机制。例如店铺类型的查询缓存

  • 高一致性需求：主动更新，并以超时时间作为兜底方案。例如店铺详情查询的缓存

1、主动更新

  • Cache Aside Pattern 有缓存的调用缓存，在更新数据库的同时更新缓存

  • Read/Write Through Pattern 缓存和数据库整合为一个服务，由服务来维护一致性。调用者调用该服务，无序关心缓存一致性问题

  • Write Behind Caching Pattern 调用者只操作缓存，由其他线程异步的将缓存数据持久化到数据库，保证最终一致

Redis的主动更新有三种常见的方案，包括：
​
Cache Aside Pattern（旁路缓存模式）：应用程序先从缓存中获取数据，如果缓存中不存在要访问的数据，则从数据库获取，再将数据写入缓存中。
优点：高效性能，减少数据库访问次数和负载，适合于对数据实时性要求不高的应用。
​
缺点：存在缓存和数据库数据不一致的问题，当读写并发量大时，可能会出现脏数据。
​
Read/Write Through Pattern（读写穿透模式）：数据缓存和数据库相连，应用程序从缓存中获取数据，如缓存中没有相应数据，会通过缓存访问层查找数据。该层在未命中数据后，查询数据库。若命中则返回数据，并同步写入缓存中；否则返回空值或默认值。
优点：保证缓存、数据库数据一致性，并且在缓存失效的情况下，也可以避免因读操作而引起的数据库压力过大，同时也可以防止缓存数据与数据库之间的数据不一致。
​
缺点：每次访问数据都必须通过缓存去访问数据库，增加了结构的复杂性并降低了系统的效率。
​
Write Behind Caching Pattern（写回缓存模式）：在进行写操作时，不直接将数据写入到数据库中，而是先将数据写入缓存中，待缓存达到一定条件后再批量同步到数据库中。
优点：提高了写操作的性能，并且降低了数据库负载，可以适用于写入比较频繁但读取全量较少的应用场景，同时也减少了与数据库的交互次数和延迟。
​
缺点：由于只在达到缓存阈值之后才进行同步，因此可能会存在缓存中未及时更新的数据，从而引起数据不一致性问题，同时当缓存重新启动时还需要从磁盘上读取数据进行恢复，增加了复杂度。
​
需要针对具体应用场景选择合适的主动更新方案，并结合Redis中提供的其他功能一起使用。

这里比较常用的：Cache Aside Pattern（旁路缓存模式）

2.Cache Aside Pattern（旁路缓存模式）

操作缓存和数据库有三个问题需要考虑：

  1. 删除缓存还是更新缓存？

    • 更新缓存：每次更新数据库都更新缓存，无效写操作较多

    • 删除缓存：更新数据库时让缓存失败，查询时再更新缓存（比较符合）

  2. 如何保障缓存与数据库的操作同时成功或失败？

    • 单体系统，将缓存与数据库操作放在一个事务

    • 分布式系统，利用TCC等分布式事务方案

  3. 先操作缓存还是先操作数据库？

    • 先删除缓存，再操作数据库（不推荐，更新数据库时间长，出现概率很大）

      第一个线程删除缓存后，在更新数据库的时候，还没更新成功的时候，
​
第二个线程访问了，发现缓存没有，查询数据库的数据，这是数据库的数据的旧的，将旧的数据更新到缓存中出现了不一致性

       

      可以使用延时双删的策略，即先删除缓存，在更新数据库，然后休眠500毫秒在删除缓存，但是因为第二次延时时间，不确定性很大，一般不推荐使用

    • 先操作数据库，再删除缓存（推荐，相较于上一种出现概率很低）

      因为某种原因，缓存找中数据没了，线程1访问的时候发现没有缓存，查询数据库得到旧数据，要进行写入缓存操作时
线程2进行了更新数据库，删除缓存，然后线程1更新了缓存为旧数据

       

3、总结

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

  1. 低一致性需求：使用Redis自带的内存淘汰机制

  2. 高一致性需求：主动更新，并以超时剔除作为兜底方案

    • 读操作 Cache Aside Pattern（旁路缓存模式）：

      • 缓存未命则直接返回

      • 缓存未命中则查询数据库，并写入缓存，设定超时时间

    • 写操作：

      • 先写数据库，然后再删除缓存

      • 要确保数据库与缓存操作的原子性

4、给查询商铺的缓存添加超时剔除和主动更新的策略

修改ShopController中的业务逻辑，满足下面的需求：

  1. 根据id查询商铺时，如果缓存未命中，则查询数据库，将数据库结果写入缓存，并设置超时时间

    @Override
    public Result selectShopInfoById(Long id) {
        String key = CACHE_SHOP_KEY + id;
        //1.判断redis中是否存在该id的数据
        String str = stringRedisTemplate.opsForValue().get(key);
        if (StrUtil.isNotBlank(str)) {
            //2.存在 直接返回数据
            return Result.ok(JSONUtil.toBean(str,Shop.class));
        }
        //3.不存在 查询数据库是否存在
        Shop shop = baseMapper.selectById(id);
        if (StringUtils.isEmpty(shop)) {
            //4.不存在直接返回 404
            return Result.fail("店铺不存在");
        }
        //5.存在将数据存储在redis，然后返回
        String shopJsonStr = JSONUtil.toJsonStr(shop);
        stringRedisTemplate.opsForValue().set(key,shopJsonStr,CACHE_SHOP_TTL, TimeUnit.MINUTES);
        return Result.ok(shop);
    }

  2. 根据id修改店铺时，先修改数据库，再删除缓存

     @Override
    @Transactional
    public Result updateShopById(Shop shop) {
        Long id = shop.getId();
        if (id == null) {
            return Result.fail("店铺id不能为空");
        }
        //修改数据库
        baseMapper.updateById(shop);
        //删除缓存
        stringRedisTemplate.delete(CACHE_SHOP_KEY+shop.getId());
        return Result.ok();
    }

5.4 缓存穿透

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

1、解决方案

常见的解决方案有两种：

  • 缓存空对象

    • 优点:实现简单，维护方便

    • 缺点：

      • 额外的内存消耗 ---设置ttl过期时间

      • 可能造成短期的不一致 ----插入数据的时候，更新缓存将null的覆盖

         

  • 布隆过滤

    • 优点：内存占用较少，没有多余key

    • 缺点：

      • 实现复杂

      • 存在误判可能---布隆过滤器是居于hash算法，存在哈希碰撞问题

        判断不存在的肯定不存在，判断存在的时候，可能不存在

         

2、解决商铺查询时，缓存穿透问题

 

public Result selectShopInfoById(Long id) {
        String key = CACHE_SHOP_KEY + id;
        //1.判断redis中是否存在该id的数据
        String str = stringRedisTemplate.opsForValue().get(key);
        if (StrUtil.isNotBlank(str)) {
            //2.存在 直接返回数据
            return Result.ok(JSONUtil.toBean(str,Shop.class));
        }
        //上面判断后 执行到这句的时候，只能是null或者空字符串
        if (str != null) {
            return Result.fail("店铺不存在");
        }
​
        //3.不存在 查询数据库是否存在
        Shop shop = baseMapper.selectById(id);
        if (StringUtils.isEmpty(shop)) {
            //将null存入到redis中
            stringRedisTemplate.opsForValue().set(key,"",CACHE_NULL_TTL,TimeUnit.MINUTES);
            //4.不存在直接返回 404
             return Result.fail("店铺不存在");
        }
        //5.存在将数据存储在redis，然后返回
        String shopJsonStr = JSONUtil.toJsonStr(shop);
        stringRedisTemplate.opsForValue().set(key,shopJsonStr,CACHE_SHOP_TTL, TimeUnit.MINUTES);
        return Result.ok(shop);
    }
 
​

3、总结

缓存穿透产生的原因是什么？

  • 用户请求的数据在缓存和数据库汇总都不存在，不断发起这样的请求给数据库带来巨大压力

缓存穿透的解决方案有那些？

  • 缓存null值

  • 布隆过滤器

  • 增强id的复杂度，避免被猜测id规律，然后做好数据的基础格式校验

  • 加强用户权限校验

  • 做好热点参数的限流

5.5 缓存雪崩

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

解决方案：

  • 给不同的key的TTL添加随机值

  • 利用Redis集群提高服务的可用性

  • 给缓存业务添加降级限流策略

  • 给业务添加多级缓存

     

5.6 缓存击穿

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

 

1、解决方案

互斥锁

 

逻辑过期

 

比较

解决方案优点缺点
互斥锁没有额外的内存消耗 保证了一致性 实现简单线程需要等待，性能受影响 可能有死锁的情况
逻辑过期线程无序等待，性能好不保证一致性 存在内存消耗 实现复杂

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

需求：根据id查询商铺的业务，基于互斥锁方式来解决缓存击穿问题

 

 private  Result cacheShopWithMutex(Long id) {
            String key = CACHE_SHOP_KEY + id;
            Shop shop = null;
            //1.判断redis中是否存在该id的数据
            String str = stringRedisTemplate.opsForValue().get(key);
            if (StrUtil.isNotBlank(str)) {
                //2.存在 直接返回数据
                return Result.ok(JSONUtil.toBean(str,Shop.class));
            }
            //上面判断后 执行到这句的时候，只能是null或者空字符串
            if (str != null) {
                return Result.fail("店铺不存在");
            }
        String lockKey = LOCK_SHOP_KEY + id;
        try {
​
            //3.不存在 先尝试获取互斥锁  利用redis中string字符串中set
            Boolean flagBoolean = stringRedisTemplate.opsForValue().setIfAbsent(lockKey, "1", LOCK_SHOP_TTL, TimeUnit.SECONDS);
            boolean flag = BooleanUtil.isTrue(flagBoolean);
            //4.获取锁失败
            if (!flag) {
                //获取锁失败休眠一会
                Thread.sleep(100);
                //然后进行重试 ---递归
                return selectShopInfoById(id);
            }
            //5.如果获取锁成功 查询数据库
            shop = baseMapper.selectById(id);
            //模拟重建延迟
            Thread.sleep(200);
            //如果数据库中没有数据
            if (StringUtils.isEmpty(shop)) {
                //将null存入到redis中
                stringRedisTemplate.opsForValue().set(key,"",CACHE_NULL_TTL,TimeUnit.MINUTES);
                //不存在直接返回 404
                return Result.fail("店铺不存在");
            }
            //.存在将数据存储在redis，然后返回
            String shopJsonStr = JSONUtil.toJsonStr(shop);
            stringRedisTemplate.opsForValue().set(key,shopJsonStr,CACHE_SHOP_TTL, TimeUnit.MINUTES);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            //6.释放锁
            stringRedisTemplate.delete(lockKey);
        }
        return Result.ok(shop);
    }

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

需求：根据id查询商铺的业务，基于逻辑过期方式来解决缓存击穿问题

 

//弄一个线程池
    private static  final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);
    //逻辑过期
    private Result cacheShopWithLogicTTL(Long id) {
        String key = CACHE_SHOP_KEY + id;
        //1.判断redis中是否存在该id的数据
        String str = stringRedisTemplate.opsForValue().get(key);
        if (StrUtil.isBlank(str)) {
            //2.不存在 直接返回空
            return Result.fail("商铺信息为空");
        }
​
​
        //3.存在 判断缓存是否过期  逻辑时间
        RedisData redisData = JSONUtil.toBean(str, RedisData.class);
        LocalDateTime expireTime = redisData.getExpireTime();
        JSONObject data = (JSONObject)redisData.getData();
        Shop shop = JSONUtil.toBean(data, Shop.class);
        if (expireTime.isAfter(LocalDateTime.now())) {
            //4.未过期 直接返回商铺信息
            return Result.ok(shop);
        }
        //5.过期了尝试获取互斥锁
        String lockKey = LOCK_SHOP_KEY + id;
        Boolean aBoolean = stringRedisTemplate.opsForValue().setIfAbsent(lockKey, "1", LOCK_SHOP_TTL, TimeUnit.SECONDS);
        boolean flag = BooleanUtil.isTrue(aBoolean);
        if (!flag) {
            //6.如果未获取到锁 直接返回旧数据
            return Result.ok(shop);
        }
        //7.成功获取到锁 开启一个独立线程
        CACHE_REBUILD_EXECUTOR.submit(() -> {
            //重构缓存
            try {
                saveShopToRedis(id,30L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                stringRedisTemplate.delete(lockKey);
            }
            //释放锁
        });
        //8.返回旧的数据
        return Result.ok(shop);
    }

4、JMeter下载和安装

参考

JMeter下载和安装_仰望_1的博客-CSDN博客

1.下载

2.解压

 

 

3.设置环境变量

 

4.path中设置

 

5.启动

双击打开bin中的jemter.bat

 

就自动启动了

 

6.设置中文

 

7.进行配置

 

 

 

8、输入参数，测试

 

 

 

5.7 缓存工具封装

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

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

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

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

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

封装类：CacheClient

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 lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
​
import javax.annotation.Resource;
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.*;
​
/**
 * @packageName: com.hmdp.utils
 * @author: winter
 * @date: 2023/4/25 8:55
 * @version: 1.0
 * @email 1660420659@qq.com
 * @description: 封装Redis工具类
 */
@Slf4j
@Component
public class CacheClient {
​
    @Resource
    private StringRedisTemplate stringRedisTemplate;
​
    /**
     * 将任意Java对象序列化为json并存储在String类型的key中，
     * 并且可设置TTL过期时间
     * @param key  key
     * @param obj  存储对象
     * @param timeTTL  过期时间
     * @param timeUnit  单位
     */
    public void set(String key, Object obj, Long timeTTL, TimeUnit timeUnit) {
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(obj),timeTTL,timeUnit);
    }
​
    /**
     * 将任意Java对象序列化为json并存储在String类型的key中，
     * 并在可以设计逻辑过期时间，用于处理缓存击穿问题
     * @param key  key
     * @param obj  存储对象
     * @param timeTTL  过期时间
     * @param timeUnit  单位
     */
    public  void setWithLogicalExpire(String key,Object obj,Long timeTTL, TimeUnit timeUnit) {
        RedisData redisData = new RedisData();
        redisData.setData(obj);
        redisData.setExpireTime(LocalDateTime.now().plusSeconds(timeUnit.toSeconds(timeTTL)));
        stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(redisData));
    }
​
    /**
     * 通过key获取字符串
     * @param key
     * @return
     */
    public String get(String key) {
        String str = stringRedisTemplate.opsForValue().get(key);
        return str;
    }
​
    /**
     * 根据指定的key查询缓存，并反序列化为指定类型，利用缓存空值的方式解决缓存穿透问题
     * @param key  key值
     * @param id  id值
     * @param tClass  类型
     * @param function 手写方法
     * @param timeTTL  过期时间
     * @param timeUnit  时间单位
     * @param <T>  对象类型
     * @param <ID> id类型
     * @return  对象
     */
    public <T,ID> T getWithPassThrough(String key,ID id, Class<T> tClass, Function<ID,T> function,Long timeTTL, TimeUnit timeUnit) {
        //1.判断redis中是否存在该id的数据
        String str = get(key);
        if (StrUtil.isNotBlank(str)) {
            //2.存在 直接返回数据
            return JSONUtil.toBean(str,tClass);
        }
        //上面判断后 执行到这句的时候，只能是null或者空字符串
        if (str != null) {
            return null;
        }
​
        //3.不存在 查询数据库是否存在
        T shop = function.apply(id);
        if (StringUtils.isEmpty(shop)) {
            //将null存入到redis中
            set(key,"",CACHE_NULL_TTL,timeUnit);
            //4.不存在直接返回 404
            return null;
        }
        //5.存在将数据存储在redis，然后返回
        set(key,shop,timeTTL,timeUnit);
        return shop;
    }
​
​
    //弄一个线程池
    private static  final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);
​
    /**
     * 根据指定的key查询缓存，并反序列化为指定类型，需要利用逻辑过期解决缓存击穿问题
     * @param key key
     * @param id id
     * @param tClass  RedisDate中存储对象类型
     * @param function 方法
     * @param timeTTL 过期时间
     * @param timeUnit 过期类型
     * @param <T>  对象类型
     * @param <ID>  id类型
     * @return 对象
     */
    public <T,ID> T getWithLogicalExpire(String key,ID id, Class<T> tClass, Function<ID,T> function,Long timeTTL, TimeUnit timeUnit) {
        //1.判断redis中是否存在该id的数据
        String str = get(key);
        if (StrUtil.isBlank(str)) {
            //2.不存在 直接返回空
            return null;
        }
​
​
        //3.存在 判断缓存是否过期  逻辑时间
        RedisData redisData = JSONUtil.toBean(str, RedisData.class);
        LocalDateTime expireTime = redisData.getExpireTime();
        JSONObject data = (JSONObject)redisData.getData();
        T shop = JSONUtil.toBean(data, tClass);
        if (expireTime.isAfter(LocalDateTime.now())) {
            //4.未过期 直接返回商铺信息
            return shop;
        }
        //5.过期了尝试获取互斥锁
        String lockKey = LOCK_SHOP_KEY + id;
        Boolean aBoolean = stringRedisTemplate.opsForValue().setIfAbsent(lockKey, "1", LOCK_SHOP_TTL, TimeUnit.SECONDS);
        boolean flag = BooleanUtil.isTrue(aBoolean);
        if (!flag) {
            //6.如果未获取到锁 直接返回旧数据
            return shop;
        }
        //7.成功获取到锁 开启一个独立线程
        CACHE_REBUILD_EXECUTOR.submit(() -> {
            //重构缓存
            try {
                //查询店铺数据
                T tshop = function.apply(id);
                //模拟
                Thread.sleep(200);
                //封装逻辑过期时间
                setWithLogicalExpire(key,tshop,timeTTL,timeUnit);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                stringRedisTemplate.delete(lockKey);
            }
            //释放锁
        });
        //8.返回旧的数据
        return shop;
    }
}
​

测试：ShopServiceImpl

 @Override
    public Result selectShopInfoById(Long id) throws InterruptedException {
        //1.缓存穿透 存储null值解决方案
//     return  cacheShopWithPassThrough(id);
        //2.缓存击穿  --互斥锁解决方案
//       return cacheShopWithMutex(id);
        //3.缓存击穿 ---逻辑过期解决方案
//        return cacheShopWithLogicTTL(id);
​
        //4.使用封装类中解决缓存穿透  存储null值办法
//        Shop shop = cacheClient.getWithPassThrough(CACHE_SHOP_KEY + id, id, Shop.class
//                            ,this::getById, CACHE_SHOP_TTL, TimeUnit.MINUTES);
//        return Result.ok(shop);
​
        //5.使用封装类中解决缓存击穿  逻辑过期方式
        //为了测试 将逻辑过期时间设置短一点
        Shop shop = cacheClient.getWithLogicalExpire(CACHE_SHOP_KEY + id, id, Shop.class
                , this::getById, 10L, TimeUnit.SECONDS);
        return Result.ok(shop);
    }

具体代码

redis实战篇-hmdp-短信登录-商铺缓存: 存放黑马点评中redis进行短信登录、商铺查询的代码 ，包括前端后后端

Tokey_W
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
黑马redis教程
12-23
随着互联网web2.0网站的兴起，非关系型的数据库现在成了一个极其热门的新领域，非关系数据库产品的发展非常迅速。而传统的关系数据库在应付web2.0网站，特别是超大规模和高并发的 SNS类型的web2．0纯动态网站己经显得力不从心，暴露了很多难以克服的问题，例如： · 1、High performance．对数据库高并发读写的需求 web2.0网站要根据用户个性化信息来实时生成动态页面和提供动态信息，所以基本上无法使用动态页面静态化技术，因此数据库并发负载非常高，往往要达到每秒上万次读写请求。关系数据库应付上万次SQL查询还勉强顶得住，但是应付上万次SQL写数据请求，硬盘℃就己经无法承受了。其实对于普通的BBS网站，往往也存在对高并发写请求的需求，例如网站的实时统计在线用户状态，记 ． 录热门帖子的点击次数，投票计数等，因此这是一个相当普遍的需求。
Redis实战—黑马点评项目—商户查询缓存
LHB123456789L的博客
03-19 213
商户查询缓存 笔记
Redis项目实战——商户查询缓存
weixin_46838605的博客
08-29 717
部分热点key（被高并发访问且缓存重建业务较复杂的key）在缓存中失效或过期，如果第一次请求未命中，会去数据库查询并写入缓存，但若在此期间有大量同样的请求涌入，就会有大量请求涌到数据库要求查询，给数据库造成巨大压力。客户端请求的数据在缓存和数据库中都没有，无法建立缓存，如果多次请求这个不存在的数据，这些请求就会全部打到数据库，给数据库造成压力。大量redis缓存中的key同时失效或过期，或者redis服务器宕机，大量请求直接到达数据库，给数据库造成巨大压力。宕机一个redis还有其他redis。
黑马-Redis
qq_36811160的博客
12-10 1116
# 1、Redis基础 2、Redis高级 1.1持久化 1、RDB（关注点：数据） 概述 将当前数据进行保存，快照形式，存储数据结果，存储格式简单，关注点在数据 启动方式 命令： 127.0.0.1:6379> save 作用：手动执行一次保存操作，默会在Redis的安装路径的data目录下生成一个dump.rdb二进制文件 save指令相关配置 dbfilename dump.rdb 说明：设置温蒂数据库文件名，默认值为dump.rdb 经验：通常设置为dump-端口号.rdb dir
黑马redis小作业：给店铺类型查询业务添加缓存
ZZDT099的博客
02-17 243
黑马redis小作业：给店铺类型查询业务添加缓存
Another-Redis-Desktop-Manager.1.5.6
07-22
官网下载太慢，这里做了提取，可以在这里下载
黑马点评-redis实战项目-heima-review.zip
最新发布
01-29
黑马点评-redis实战项目-heima-review
redis++使用说明,windows下编译redis-plus-plus
06-13
redis++使用说明,windows下编译redis-plus-plus
redis-windows-7.2.4.zip
01-14
Redis 是一个高性能的key-value数据库
《Redis实战》-redis-in-action.zip
11-07
《Redis实战》-redis-in-action
黑马(linux、redis、oracle、maven、全栈基础班视频教程
11-16
黑马(linux、redis、oracle、maven、全栈基础班视频教程
黑马---Redis实战篇
qq_52714234的博客
11-19 916
redis
黑马Redis | 基础篇
weixin_54232666的博客
01-17 619
黑马程序员Redis实战教程基础篇的学习笔记，想快速入门redis，这一篇就够了
【黑马程序员】Redis 课程 P37 的练习_三种方式实现功能_【黑马点评项目】给店铺类型查询业务添加缓存
做笔记，记录学习中遇到的问题。
11-11 2077
记录学习时刻。三种方式（String、List、ZSet）实现【黑马程序员】于 2022-2-28 的Redis 课程 P37 的练习，即实现【黑马点评项目】中给店铺类型查询业务添加缓存的功能。（其实就是熟悉一下 SpringDataRedis）
【黑马点评】给店铺类型查询业务添加缓存【业务实现】
qq_45721579的博客
06-18 1082
【黑马点评】给店铺类型查询业务添加缓存【业务实现】
黑马---Redis入门到实战【实战篇】
Father_Of_Soft的博客
05-08 1498
黑马程序员Redis项目实战---实战篇，体验真实场景应用Redis~
黑马点评给店铺类型查询业务添加缓存（String实现）
Blocking The Sky
06-28 150
【代码】黑马点评给店铺类型查询业务添加缓存（String实现）
黑马Redis学习——基础篇
Ydin00的博客
08-12 787
黑马Redis课程笔记
Springboot整合redis（黑马）
qq_56800327的博客
01-21 557
java十万数据秒级入库_Redis实战--使用Jedis实现百万数据秒级插入
06-10
很高兴为您回答这个问题。首先，使用Jedis实现Redis操作可以高效地实现大规模数据的存储和查询。下面是使用Jedis实现百万数据秒级插入的步骤： 1. 首先，您需要引入Jedis的依赖，可以使用Maven或Gradle等构建工具进行引入。 2. 然后，您需要创建一个Jedis连接池，这样可以避免每次操作都要重新连接Redis数据库，从而提高性能。 3. 接下来，您需要将数据按照Redis的数据结构进行存储，例如可以使用Hash结构存储。将数据转化为Hash结构后，可以使用pipeline方式批量插入数据。 4. 最后，您需要关闭Jedis连接池，释放资源。 使用以上步骤，可以实现百万数据秒级插入。同时，您还可以使用Redis的其他功能，例如缓存、分布式锁等，来进一步提高应用的性能和可用性。 希望这个回答对您有帮助。如果您还有其他问题，请随时提出。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值