• 谷粒商城【成神路】-【10】——缓存

    目录

    🧂1.引入缓存的优势

    🥓2.哪些数据适合放入缓存 

    🌭3.使用redis作为缓存组件 

    🍿4.redis存在的问题 

    🧈5.添加本地锁 

    🥞6.添加分布式锁

    🥚7.整合redisson作为分布式锁

    🚗🚗🚗1.引入缓存的优势

    为了系统性能的提升，我们一般都会将部分数据放入缓存中,加速访问。而db承担数据落盘工作。

    🚗🚗🚗2.哪些数据适合放入缓存 

    • 即时性、数据—致性要求不高的
    • 访问量大且更新频率不高的数据(读多,写少)

    🚗🚗🚗3.使用redis作为缓存组件 

    先确保reidis正常启动

    3.1配置redis

    • 1.引入依赖
    1.         
    2.         
    3.             org.springframework.boot
    4.             spring-boot-starter-data-redis
    5.
    • 2.配置reids信息
    1. spring
    2.   redis:
    3.     port: 6379
    4.     host: ip地址
    5.     password: XXX

    3.2优化查询 

    之前都是从数据库查询的，现在加入缓存逻辑~

    1.  /**
    2.      * 使用redis缓存
    3.      */
    4.     @Override
    5.     public Map> getCatalogJson() {
    6.  
    7.         //1.加入缓存，缓存中存的数据全都是json
    8.         String catalogJson = redisTemplate.opsForValue().get("catalogJson");
    9.         if (StringUtils.isEmpty(catalogJson)) {
    10.             //2.缓存中如果没有，再去数据库查找
    11.             Map> catalogJsonFromDB = getCatalogJsonFromDB();
    12.             //3.将数据库查到的数据，将对象转换为json存放到缓存
    13.             String s = JSON.toJSONString(catalogJsonFromDB);
    14.             redisTemplate.opsForValue().set("catalogJson", s);
    15.         }
    16.         //4.从缓存中获取，转换为我们指定的类型
    17.         Map> result = JSON.parseObject(catalogJson, new TypeReference>>() {
    18.         });
    19.  
    20.         return result;
    21.     }
    22.  
    23.     /**
    24.      * 从数据库查询并封装的分类数据
    25.      *
    26.      * @return
    27.      */
    28.     public Map> getCatalogJsonFromDB() {
    29.  
    30.         /**
    31.          * 优化：将数据库查询的多次变为一次
    32.          */
    33.  
    34.         List selectList = baseMapper.selectList(null);
    35.  
    36.         //1.查出所有1级分类
    37.         List leve1Categorys = getParent_cid(selectList, 0L);
    38.  
    39.         //2.封装数据
    40.         Map> parentCid = leve1Categorys.stream().collect(Collectors.toMap(k -> k.getCatId().toString(), v -> {
    41.             //1.每一个一级分类
    42.             List categoryEntities = getParent_cid(selectList, v.getCatId());
    43.             List catalog2Vos = null;
    44.             if (categoryEntities != null) {
    45.                 catalog2Vos = categoryEntities.stream().map(l2 -> {
    46.                     Catalog2Vo vo = new Catalog2Vo(v.getCatId().toString(), null, l2.getCatId().toString(), l2.getName());
    47.                     //找二级分类的三级分类
    48.                     List categoryEntities3 = getParent_cid(selectList, l2.getCatId());
    49.                     if (categoryEntities3 != null) {
    50.                         List collect = categoryEntities3.stream().map(l3 -> {
    51.                             Catalog2Vo.Catalog3Vo catalog3Vo = new Catalog2Vo.Catalog3Vo(l2.getCatId().toString(), l3.getCatId().toString(), l3.getName());
    52.                             return catalog3Vo;
    53.                         }).collect(Collectors.toList());
    54.                         vo.setCatalog3List(collect);
    55.                     }
    56.                     return vo;
    57.                 }).collect(Collectors.toList());
    58.             }
    59.             return catalog2Vos;
    60.         }));
    61.  
    62.         return parentCid;
    63.     }

    3.3测试 

    在本地第一次查询后，查看redis，发现redis已经存储

    使用JMeter压测一下

    🚗🚗🚗4.redis存在的问题 

    4.1缓存穿透

    • 缓存穿透：  查询一个一定不存在的数据，由于缓存是不命中，将去查询数据库,但是数据库也无此记录,我们没有将这次查询的null写入缓存,这将导致这个不存在的数据每次请求都要到存储层去查询，失去了缓存的意义
    • 解决方案：null结果缓存，并加入短暂过期时间

    4.2缓存雪崩 

    • 缓存雪崩： 在我们设置缓存时key采用了相同的过期时间,导致缓存在某一时刻同时失效,大量请求全部转发到DB, DB瞬时压力过重雪崩。
    • 解决方案：原有的失效时间基础上增加一个随机值，比如1-5分钟随机,这样每一个缓存的过期时间的重复率就会降低,就很难引发集体失效的事件。

    4.3缓存击穿 

    缓存击穿 ：对于一些设置了过期时间的key,如果这些key可能会在某些时间点被超高并发地访问，是一种非常“热点”的数据。如果这个key在大量请求同时进来前正好失效,那么所有对这个key的数据查询都落到db,我们称为缓存击穿。

    解决方案：枷锁    大量并发只让一个去查,其他人等待,查到以后释放锁,其他人获取到锁,先查缓存,就会有数据,不用去db

    🚗🚗🚗5.添加本地锁 

    若在缓存redis中没有查到，也去数据库查询，在查询数据库时，添加本地锁，在查之前，再次判断缓存reids中是否有数据，如果有，直接返回，如果没有，在查数据库，在查完数据库后，由于延迟原因，我们查完数据库时，将数据存放到缓存中，然后在释放锁

    1. /**
    2.      * 使用redis缓存
    3.      */
    4.     @Override
    5.     public Map> getCatalogJson() {
    6.         //1.使用redis缓存，存储为json对象
    7.         String catalogJson = redisTemplate.opsForValue().get("catalogJson");
    8.         //2.判断缓存中是否有
    9.         if (StringUtils.isEmpty(catalogJson)) {
    10.             System.out.println("缓存没有命中~查询数据库...");
    11.             //3.如果缓存中没有，从数据库
    12.             Map> catalogJsonFromDB = getCatalogJsonFromDB();
    13.             return catalogJsonFromDB;
    14.         }
    15.         System.out.println("缓存命中....直接返回");
    16.         //5.如果缓存中有，转换为我们需要的类型
    17.         Map> result = JSON.parseObject(catalogJson, new TypeReference>>() {
    18.         });
    19.         return result;
    20.     }
    21.  
    22.  
    23.     /**
    24.      * 从数据库查询并封装的分类数据
    25.      *
    26.      * @return
    27.      */
    28.     public Map> getCatalogJsonFromDB() {
    29.  
    30.         /**
    31.          * 优化：将数据库查询的多次变为一次
    32.          */
    33.  
    34.         //TODO 本地锁，在分布式下，必须使用分布式锁
    35.         //加锁，防止缓存击穿，使用同一把锁
    36.         synchronized (this) {
    37.  
    38.             //加所以后，我们还要去缓存中确定一次，如果缓存中没有，才继续查数据库
    39.             String catalogJson = redisTemplate.opsForValue().get("catalogJson");
    40.             if (!StringUtils.isEmpty(catalogJson)) {
    41.                 //如果缓存中有，从缓存中获取
    42.                 Map> result = JSON.parseObject(catalogJson, new TypeReference>>() {
    43.                 });
    44.                 return result;
    45.             }
    46.             System.out.println("查询了数据库~");
    47.  
    48.             List selectList = baseMapper.selectList(null);
    49.  
    50.             //1.查出所有1级分类
    51.             List leve1Categorys = getParent_cid(selectList, 0L);
    52.  
    53.             //2.封装数据
    54.             Map> parentCid = leve1Categorys.stream().collect(Collectors.toMap(k -> k.getCatId().toString(), v -> {
    55.                 //1.每一个一级分类
    56.                 List categoryEntities = getParent_cid(selectList, v.getCatId());
    57.                 List catalog2Vos = null;
    58.                 if (categoryEntities != null) {
    59.                     catalog2Vos = categoryEntities.stream().map(l2 -> {
    60.                         Catalog2Vo vo = new Catalog2Vo(v.getCatId().toString(), null, l2.getCatId().toString(), l2.getName());
    61.                         //找二级分类的三级分类
    62.                         List categoryEntities3 = getParent_cid(selectList, l2.getCatId());
    63.                         if (categoryEntities3 != null) {
    64.                             List collect = categoryEntities3.stream().map(l3 -> {
    65.                                 Catalog2Vo.Catalog3Vo catalog3Vo = new Catalog2Vo.Catalog3Vo(l2.getCatId().toString(), l3.getCatId().toString(), l3.getName());
    66.                                 return catalog3Vo;
    67.                             }).collect(Collectors.toList());
    68.                             vo.setCatalog3List(collect);
    69.                         }
    70.                         return vo;
    71.                     }).collect(Collectors.toList());
    72.                 }
    73.                 return catalog2Vos;
    74.             }));
    75.             //4.将从数据库中获取的数据，转换为Json存储到redis
    76.             String s = JSON.toJSONString(parentCid);
    77.             //设置缓存时间，方式雪崩
    78.             redisTemplate.opsForValue().set("catalogJson", s, 1, TimeUnit.DAYS);
    79.             return parentCid;
    80.         }
    81.     }

    🚗🚗🚗6.添加分布式锁

    使用分布式锁 步骤

    • 1.先去redis中设置一个key，为了保持原子性，同时设置过期时间
    • 2.判断是否设置成功，成功则继续业务操作，失败则自选再次获取
    • 3.执行业务之后，需要删除key释放锁，为了保持原子性，使用lua脚本
    1.  /**
    2.      * 使用redis缓存
    3.      */
    4.     @Override
    5.     public Map> getCatalogJson() {
    6.         //1.使用redis缓存，存储为json对象
    7.         String catalogJson = redisTemplate.opsForValue().get("catalogJson");
    8.         //2.判断缓存中是否有
    9.         if (StringUtils.isEmpty(catalogJson)) {
    10.             System.out.println("缓存没有命中~查询数据库...");
    11.             //3.如果缓存中没有，从数据库
    12.             Map> catalogJsonFromDB = getCatalogJsonFromDBWithRedisLock();
    13.             return catalogJsonFromDB;
    14.         }
    15.         System.out.println("缓存命中....直接返回");
    16.         //5.如果缓存中有，转换为我们需要的类型
    17.         Map> result = JSON.parseObject(catalogJson, new TypeReference>>() {
    18.         });
    19.         return result;
    20.     }
    21.  
    22.  
    23.     /**
    24.      * 从数据库中获取数据，使用分布所锁
    25.      *
    26.      * @return
    27.      */
    28.     public Map> getCatalogJsonFromDBWithRedisLock() {
    29.         //1.占分布式锁，去redis占位
    30.         String uuid = UUID.randomUUID().toString();
    31.         //2.设置过期时间,必须和加锁同步
    32.         Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", uuid, 300, TimeUnit.SECONDS);
    33.         if (lock) {
    34.             System.out.println("获取分布式锁成功..." + redisTemplate.opsForValue().get("lock"));
    35.             //加锁成功...执行业务
    36.             Map> dataFromDb;
    37.             try {
    38.                 dataFromDb = getDataFromDb();
    39.             } finally {
    40.                 String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
    41.                 //删除锁，原子性
    42.                 Long lock1 = redisTemplate.execute(new DefaultRedisScript(script, Long.class), Arrays.asList("lock"), uuid);
    43.             }
    44.             return getDataFromDb();
    45.         } else {
    46.             //加锁失败...重试
    47.             //休眠100毫秒
    48.             try {
    49.                 Thread.sleep(2000);
    50.             } catch (InterruptedException e) {
    51.  
    52.             }
    53.             return getCatalogJsonFromDBWithRedisLock();//自旋方式
    54.         }
    55.     }
    56.  
    57.  
    58.  
    59.  
    60.     /**
    61.      * 提起方法，从数据库中获取
    62.      *
    63.      * @return
    64.      */
    65.     private Map> getDataFromDb() {
    66.         //加所以后，我们还要去缓存中确定一次，如果缓存中没有，才继续查数据库
    67.         String catalogJson = redisTemplate.opsForValue().get("catalogJson");
    68.         if (!StringUtils.isEmpty(catalogJson)) {
    69.             //如果缓存中有，从缓存中获取
    70.             Map> result = JSON.parseObject(catalogJson, new TypeReference>>() {
    71.             });
    72.             return result;
    73.         }
    74.         System.out.println("查询了数据库~");
    75.  
    76.         List selectList = baseMapper.selectList(null);
    77.  
    78.         //1.查出所有1级分类
    79.         List leve1Categorys = getParent_cid(selectList, 0L);
    80.  
    81.         //2.封装数据
    82.         Map> parentCid = leve1Categorys.stream().collect(Collectors.toMap(k -> k.getCatId().toString(), v -> {
    83.             //1.每一个一级分类
    84.             List categoryEntities = getParent_cid(selectList, v.getCatId());
    85.             List catalog2Vos = null;
    86.             if (categoryEntities != null) {
    87.                 catalog2Vos = categoryEntities.stream().map(l2 -> {
    88.                     Catalog2Vo vo = new Catalog2Vo(v.getCatId().toString(), null, l2.getCatId().toString(), l2.getName());
    89.                     //找二级分类的三级分类
    90.                     List categoryEntities3 = getParent_cid(selectList, l2.getCatId());
    91.                     if (categoryEntities3 != null) {
    92.                         List collect = categoryEntities3.stream().map(l3 -> {
    93.                             Catalog2Vo.Catalog3Vo catalog3Vo = new Catalog2Vo.Catalog3Vo(l2.getCatId().toString(), l3.getCatId().toString(), l3.getName());
    94.                             return catalog3Vo;
    95.                         }).collect(Collectors.toList());
    96.                         vo.setCatalog3List(collect);
    97.                     }
    98.                     return vo;
    99.                 }).collect(Collectors.toList());
    100.             }
    101.             return catalog2Vos;
    102.         }));
    103.         //4.将从数据库中获取的数据，转换为Json存储到redis
    104.         String s = JSON.toJSONString(parentCid);
    105.         //设置缓存时间，方式雪崩
    106.         redisTemplate.opsForValue().set("catalogJson", s, 1, TimeUnit.DAYS);
    107.         return parentCid;
    108.     }

    🚗🚗🚗7.整合redisson作为分布式锁

    7.1引入依赖

    1.        
    2.         
    3.             org.redisson
    4.             redisson
    5.             3.12.0
    6.

    7.2程序化配置

    在配置地址时，一定要添加reds：//

    1. @Configuration
    2. public class MyRedissonConfig {
    3.  
    4.  
    5.     @Bean(destroyMethod = "shutdown")
    6.     public RedissonClient redissonClient() throws IOException {
    7.         //1.创建配置
    8.         Config config = new Config();
    9.         config.useSingleServer().setAddress("redis://192.168.20.130:6379");
    10.         //2.根据config创建redisson实例
    11.         RedissonClient redissonClient = Redisson.create(config);
    12.         return redissonClient;
    13.     }
    14. }

    7.3实例解析

    • 1.锁的自动续期，如果业务超长，运行期间自动给锁续上新的30秒，不用担心业务超长，所自动过期被删除掉
    • 2.加锁的业务只要运行完成，就不会给当前锁续期，即使不手动解锁，锁默认在30秒后自动删除
    1.  @Autowired
    2.  RedissonClient redissonClient;
    3.  
    4.  @ResponseBody
    5.     @GetMapping("/hello")
    6.     public String hello() {
    7.         //1.设置redis的key获取一把锁，只要名字相同，就是同一把锁
    8.         RLock lock = redissonClient.getLock("my-lock");
    9.         //2.手动枷锁
    10.         lock.lock();//阻塞式等待，默认30秒
    11.         try {
    12.             //3.执行业务
    13.             System.out.println("枷锁成功！" + Thread.currentThread().getName());
    14.             //4.模拟业务消耗时间
    15.             Thread.sleep(20000);
    16.         } catch (Exception e) {
    17.  
    18.         } finally {
    19.             //3.释放锁
    20.             System.out.println("释放锁~"+Thread.currentThread().getName());
    21.             lock.unlock();//不删除，默认30秒后过期，自动删除
    22.         }
    23.         return "hello";
    24.     }
    • 3.如果我们传递了锁的超时时间，就发送给redis执行脚本，进行占锁，默认超时就是我们指定的时间
    • 4.如果未指定锁的超时时间，就使用30*1000【LockWatchingTimeOut看门狗默认时间】 
      • 只要占锁成功，就会启动一个定时任务【重新给锁设置过期时间，新的过期时间就是看门狗的默认时间】，每隔（【LockWatchingTimeOut看门狗默认时间】/3）折磨长时间自动续期；

    7.4读写锁 

    • 1.保证一定能读到最新数据，修改期间，写锁是一个排他锁，读锁是一个共享锁
    • 2.读+读：相当于并发，在redis中记录好，都会读取成功
    • 3.写+读：等待写锁释放
    • 4.写+写：阻塞方式
    • 5.读+写：有读锁，写也需要等待
    1.  @GetMapping("/write")
    2.     @ResponseBody
    3.     public String write() {
    4.  
    5.         RReadWriteLock readWriteLock = redissonClient.getReadWriteLock("readWrite-lock");
    6.         String word = "";
    7.         RLock rLock = readWriteLock.writeLock();
    8.         try {
    9.             //该数据加写锁，读数据加读锁
    10.             rLock.lock();
    11.             word = UUID.randomUUID().toString();
    12.             Thread.sleep(3000);
    13.             redisTemplate.opsForValue().set("writeValue", word);
    14.         } catch (InterruptedException e) {
    15.             e.printStackTrace();
    16.         } finally {
    17.             rLock.unlock();
    18.         }
    19.         return word;
    20.     }
    21.  
    22.  
    23.     /**
    24.      * 读写锁
    25.      * @return
    26.      */
    27.     @GetMapping("/read")
    28.     @ResponseBody
    29.     public String read() {
    30.         String word = "";
    31.         RReadWriteLock readWriteLock = redissonClient.getReadWriteLock("readWrite-lock");
    32.         //加读锁
    33.         RLock rLock = readWriteLock.readLock();
    34.         rLock.lock();
    35.         try {
    36.             word = redisTemplate.opsForValue().get("writeValue");
    37.         } catch (Exception e) {
    38.             e.printStackTrace();
    39.         }finally {
    40.             rLock.unlock();
    41.         }
    42.         return word;
    43.     }

  • 相关阅读:
    我参加第七届NVIDIA Sky Hackathon——训练ASR模型
    ADO.NET+kafka实现发布订阅保存到数据库
    成功解决：Xshell 无法连接虚拟机。如何使用Xshell连接CentOS7虚拟机（详细步骤过程）
    spdlog C++日志管理 安装和下载
    mybatis
    bugxxx
    在博客文章中使用mermaid 定义流程图，序列图，甘特图
    共话龙蜥：如何协同构建统一生态？
    修改ctags让fzf.vim插件显示C,C++方法声明的标签
    Spring Cloud zuul扩展能力设计和心得
  • 原文地址：https://blog.csdn.net/dfdg345/article/details/136508188