三级分类业务改造-使用缓存

1.使用redis做缓存

/**
 * 渲染对应的二三级分类数据
 * 1.往缓存中放的是JSON,取出来的也是JSON，可逆转为能用的对象类型
 * json跨语言跨平台兼容
 *  * 2.bug:
 * spring-boot-starter-data-redis低版本中可能出现堆外内存溢出OutOfDirectMemoryError
 * 原因分析:
 * a.Springboot2.0以后默认使用lettuce作为操作redis的客户端,它使用netty进行网络通信
 * b.lettuce的bug导致netty堆外内存溢出,netty如果没有指定堆外内存，默认使用虚拟机的-Xms的值,
 * 可以使用-Dio.netty.maxDirectMemory进行设置
 * 解决方案:
 * a.调大虚拟机堆外内存(头脑简单，傻瓜式，后期还会出现此问题)
 * b.先排除lettuce的核心包(升级lettuce客户端，2.切换使用jedis)
 * c.升级版本(新版本的Springboot的针对lettuce做了相关优化)
 * @return
  */
 @Override
 public Map<String, List<Catelog2Vo>> getCatalogJson() {
     String catelogJSON = stringRedisTemplate.opsForValue().get("catelogJSON");
     if(StringUtils.isEmpty(catelogJSON)){
         Map<String, List<Catelog2Vo>> catalogJsonByDB = getCatalogJsonByDB();
         String s = JSON.toJSONString(catalogJsonByDB);
         stringRedisTemplate.opsForValue().set("catelogJSON",s);
         return catalogJsonByDB;
     }

     Map<String, List<Catelog2Vo>> result = JSON.parseObject(catelogJSON,new TypeReference<Map<String, List<Catelog2Vo>>>(){});
     return result;
 }

 public Map<String, List<Catelog2Vo>> getCatalogJsonByDB() {
     System.out.println("查询了数据库");

     //将数据库的多次查询变为一次
     List<CategoryEntity> selectList = this.baseMapper.selectList(null);

     //1、查出所有分类
     //1、1）查出所有一级分类
     List<CategoryEntity> level1Categorys = getParent_cid(selectList, 0L);

     //封装数据
     Map<String, List<Catelog2Vo>> parentCid = level1Categorys.stream().collect(Collectors.toMap(k -> k.getCatId().toString(), v -> {
         //1、每一个的一级分类,查到这个一级分类的二级分类
         List<CategoryEntity> categoryEntities = getParent_cid(selectList, v.getCatId());

         //2、封装上面的结果
         List<Catelog2Vo> catelog2Vos = null;
         if (categoryEntities != null) {
             catelog2Vos = categoryEntities.stream().map(l2 -> {
                 Catelog2Vo catelog2Vo = new Catelog2Vo(v.getCatId().toString(), null, l2.getCatId().toString(), l2.getName().toString());

                 //1、找当前二级分类的三级分类封装成vo
                 List<CategoryEntity> level3Catelog = getParent_cid(selectList, l2.getCatId());

                 if (level3Catelog != null) {
                     List<Catelog2Vo.Category3Vo> category3Vos = level3Catelog.stream().map(l3 -> {
                         //2、封装成指定格式
                         Catelog2Vo.Category3Vo category3Vo = new Catelog2Vo.Category3Vo(l2.getCatId().toString(), l3.getCatId().toString(), l3.getName());

                         return category3Vo;
                     }).collect(Collectors.toList());
                     catelog2Vo.setCatalog3List(category3Vos);
                 }

                 return catelog2Vo;
             }).collect(Collectors.toList());
         }

         return catelog2Vos;
     }));

     return parentCid;
 }

2.bug

spring-boot-starter-data-redis低版本中可能出现堆外内存溢出OutOfDirectMemoryError

2.1.原因分析:

• Springboot2.0以后默认使用lettuce作为操作redis的客户端,它使用netty进行网络通信
• lettuce的bug导致netty堆外内存溢出,netty如果没有指定堆外内存，默认使用虚拟机的-Xms的值,可以使用-Dio.netty.maxDirectMemory进行设置

2.2.解决方案:

• 调大虚拟机堆外内存(头脑简单，傻瓜式，后期还会出现此问题)
• 先排除lettuce的核心包(1.升级lettuce客户端，2.切换使用jedis)
• 升级Springboot版本(新版本的Springboot的针对lettuce做了相关优化)
  修改gulimall-product的pom文件

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <exclusions>
        <exclusion>
            <groupId>io.lettuce</groupId>
            <artifactId>lettuce-core</artifactId>
        </exclusion>
    </exclusions>
</dependency>

<!-- 引入jedis -->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
</dependency>

3.高并发下缓存失效

3.1.缓存穿透

指查询一个一定不存在的数据，由于缓存是不命中，将去查询数据库，但是数据库也无此记录，我们没有将这次查询的null写入缓存，这将导致这个不存在的数据每次请求都要到存储层去查询，失去了缓存的意义

风险：
利用不存在的数据进行攻击，数据库瞬时压力增大，最终导致崩溃
解决：
null结果缓存，并加入短暂过期时间

3.2.缓存雪崩

缓存雪崩是指在我们设置缓存时key采用了相同的过期时间，导致缓存在某一时刻同时失效，请求全部转发到DB，DB瞬时压力过重雪崩

解决：
原有的失效时间基础上增加一个随机值，比如1-5分钟随机，这样每一个缓存的过期时间的重复率就会降低，就很难引发集体失效的事件。

3.3.缓存击穿

• 对于一些设置了过期时间的key，如果这些key可能会在某些时间点被超高并发地访问，是一种非常“热点”的数据。
• 如果这个key在大量请求同时进来前正好失效，那么所有对这个key的数据查询都落到db，我们称为缓存击穿。
  
  解决：
  加锁
  大量并发只让一个去查，其他人等待，查到以后释放锁，其他人获取到锁，先查缓存，就会有数据，不用去db

4.完整代码

/**
  * 渲染对应的二三级分类数据
  * 1.往缓存中放的是JSON,取出来的也是JSON，可逆转为能用的对象类型
  * json跨语言跨平台兼容
  *
  * 2.bug:
  * spring-boot-starter-data-redis低版本中可能出现堆外内存溢出OutOfDirectMemoryError
  * 原因分析:
  * a.Springboot2.0以后默认使用lettuce作为操作redis的客户端,它使用netty进行网络通信
  * b.lettuce的bug导致netty堆外内存溢出,netty如果没有指定堆外内存，默认使用虚拟机的-Xms的值,
  * 可以使用-Dio.netty.maxDirectMemory进行设置
  * 解决方案:
  * a.调大虚拟机堆外内存(头脑简单，傻瓜式，后期还会出现此问题)
  * b.先排除lettuce的核心包(升级lettuce客户端，2.切换使用jedis)
  * c.升级版本(新版本的Springboot的针对lettuce做了相关优化)
  * @return
  */
 @Override
 public Map<String, List<Catelog2Vo>> getCatalogJson() {
     String catelogJSON = stringRedisTemplate.opsForValue().get("catelogJSON");
     if(StringUtils.isEmpty(catelogJSON)){
         System.out.println("缓存不命中。。。。。查询数据库");
         Map<String, List<Catelog2Vo>> catalogJsonByDB = getCatalogJsonByDB();

         return catalogJsonByDB;
     }

     System.out.println("缓存命中。。。。。");
     Map<String, List<Catelog2Vo>> result = JSON.parseObject(catelogJSON,new TypeReference<Map<String, List<Catelog2Vo>>>(){});
     return result;
 }

 public Map<String, List<Catelog2Vo>> getCatalogJsonByDB() {
     //得到锁以后，我们应该再去缓存中确定一次，如果没有才需要继续查询
     String catalogJson = stringRedisTemplate.opsForValue().get("catalogJson");
     if (!StringUtils.isEmpty(catalogJson)) {
         //缓存不为空直接返回
         Map<String, List<Catelog2Vo>> result = JSON.parseObject(catalogJson, new TypeReference<Map<String, List<Catelog2Vo>>>() {
         });
         return result;
     }

     //将数据库的多次查询变为一次
     List<CategoryEntity> selectList = this.baseMapper.selectList(null);

     //1、查出所有分类
     //1、1）查出所有一级分类
     List<CategoryEntity> level1Categorys = getParent_cid(selectList, 0L);

     //封装数据
     Map<String, List<Catelog2Vo>> parentCid = level1Categorys.stream().collect(Collectors.toMap(k -> k.getCatId().toString(), v -> {
         //1、每一个的一级分类,查到这个一级分类的二级分类
         List<CategoryEntity> categoryEntities = getParent_cid(selectList, v.getCatId());

         //2、封装上面的结果
         List<Catelog2Vo> catelog2Vos = null;
         if (categoryEntities != null) {
             catelog2Vos = categoryEntities.stream().map(l2 -> {
                 Catelog2Vo catelog2Vo = new Catelog2Vo(v.getCatId().toString(), null, l2.getCatId().toString(), l2.getName().toString());

                 //1、找当前二级分类的三级分类封装成vo
                 List<CategoryEntity> level3Catelog = getParent_cid(selectList, l2.getCatId());

                 if (level3Catelog != null) {
                     List<Catelog2Vo.Category3Vo> category3Vos = level3Catelog.stream().map(l3 -> {
                         //2、封装成指定格式
                         Catelog2Vo.Category3Vo category3Vo = new Catelog2Vo.Category3Vo(l2.getCatId().toString(), l3.getCatId().toString(), l3.getName());

                         return category3Vo;
                     }).collect(Collectors.toList());
                     catelog2Vo.setCatalog3List(category3Vos);
                 }

                 return catelog2Vo;
             }).collect(Collectors.toList());
         }

         return catelog2Vos;
     }));

     String s = JSON.toJSONString(parentCid);
     stringRedisTemplate.opsForValue().set("catelogJSON",s,1, TimeUnit.DAYS);
     return parentCid;
 }