一、Redis缓存

1、缓存使用

image.png
为了系统性能的提升，我们一般都会将部分数据放入缓存中，加速访问。而 db 承担数据落
盘工作。
哪些数据适合放入缓存？
1、即时性、数据一致性要求不高的
2、访问量大且更新频率不高的数据（读多，写少）
举例：电商类应用，商品分类，商品列表等适合缓存并加一个失效时间(根据数据更新频率
来定)，后台如果发布一个商品，买家需要 5 分钟才能看到新的商品一般还是可以接受的。

  1. data = cache.load(id);    //从缓存加载数据 
  2. If(data == null){ 
  3.     data = db.load(id);    //从数据库加载数据 
  4.     cache.put(id,data);    //保存到 cache 中 
  5. }
  6. return data;

注意：在开发中，凡是放入缓存中的数据我们都应该指定过期时间，使其可以在系统即使没有主动更新数据也能自动触发数据加载进缓存的流程。避免业务崩溃导致的数据永久不一致问题。

2、整合 redis 作为缓存

image.png

产生堆外内存溢出：
图片1.png
image.png

二、缓存失效问题

1、缓存穿透

缓存穿透是指查询一个一定不存在的数据，由于缓存是不命中，将去查询数据库，但是数据库也无此记录，我们没有将这次查询的null写入缓存，这将导致这个不存在的数据每次请求都要到存储层去查询，失去了缓存的意义。
在流量大时，可能DB就挂掉了，要是有人利用不存在的key频繁攻击我们的应用，这就是漏洞。l
解决：
缓存空结果、并且设置短的过期时间。布隆过滤器、mvc拦截器

2、缓存雪崩

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

  1. 规避雪崩：缓存数据的过期时间设置随机，防止同一时间大量数据过期现象发生。
  2. 如果缓存数据库是分布式部署，将热点数据均匀分布在不同缓存数据库中。
  3. 设置热点数据永远不过期。
  4. 出现雪崩：降级 熔断
  5. 事前：尽量保证整个redis 集群的高可用性，发现机器宕机尽快补上。选择合适的内存淘汰策略。
  6. 事中：本地ehcache缓存 + hystrix限流&降级，避免MySQL崩掉

  7. 事后：利用redis 持久化机制保存的数据尽快恢复缓存

    3、缓存击穿

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

  8. 设置热点数据永远不过期。

  9. 加互斥锁：业界比较常用的做法，是使用mutex。简单地来说，就是在缓存失效的时候（判断拿出来的值为空），不是立即去load db去数据库加载，而是先使用缓存工具的某些带成功操作返回值的操作（比如Redis的SETNX或者Memcache的ADD）去set一个mutex key，当操作返回成功时，再进行load db的操作并回设缓存；否则，就重试整个get缓存的方法。

    三、锁的时序问题

    要保证查询数据与数据放入redis是一个原子操作，否则会出现多次查询数据库的情况
    image.png
    图片20.png

    四、分布式缓存

    本地缓存

    image.png
    本地模式在分布式下的问题
    image.png
    image.png

    1、模拟分布式系统

    image.png

2、分布式锁与本地锁

image.png

3、分布式锁原理

3.1 占分布式锁，同时设置锁过期时间，必须和加锁同步原子操作。setIfAbsent同redis的setNx
3.2 必须保证获取值对比+ 对比成功后删除是一个原子操作。使用Lua脚本
image.pngimage.png

4、分布式锁演进-阶段一

image.png

5、分布式锁演进-阶段二

image.png

6、分布式锁演进-阶段三

image.png

7、分布式锁演进-阶段四

image.png

8、分布式锁演进-阶段五-最终形态

image.png
image.png

五、Redisson

1、简介

Redisson 是架设在 Redis 基础上的一个 Java 驻内存数据网格（In-Memory Data Grid）。充分 的利用了 Redis 键值数据库提供的一系列优势，基于 Java 实用工具包中常用接口，为使用者 提供了一系列具有分布式特性的常用工具类。使得原本作为协调单机多线程并发程序的工 具包获得了协调分布式多机多线程并发系统的能力，大大降低了设计和研发大规模分布式系统的难度。同时结合各富特色的分布式服务，更进一步简化了分布式环境中程序相互之间的协作。
官方文档：https://github.com/redisson/redisson/wiki/%E7%9B%AE%E5%BD%95

2、引入依赖

image.png

3、配置

image.png
图片2.png

4、分布式锁测试

image.png

5、看门狗原理（可重入锁）

图片3.png
图片4.png

6、读写锁测试

基于Redis的Redisson分布式可重入读写锁RReadWriteLock Java对象实现了
java.util.concurrent.locks.ReadWriteLock接口。其中读锁和写锁都继承了RLock接口。
分布式可重入读写锁允许同时有多个读锁和一个写锁处于加锁状态。
图片5.png
图片6.png

7、信号量测试

信号量为存储在redis中的一个数字，当这个数字大于0时，即可以调用acquire()方法增加数量，也可以调用release()方法减少数量，但是当调用release()之后小于0的话方法就会阻塞，直到数字大于0
基于Redis的Redisson的分布式信号量（Semaphore）Java对象RSemaphore采用了与java.util.concurrent.Semaphore相似的接口和用法。同时还提供了异步（Async）、反射式（Reactive）和RxJava2标准的接口。
图片7.png

8、闭锁测试

基于Redisson的Redisson分布式闭锁（CountDownLatch）Java对象RCountDownLatch采用了与java.util.concurrent.CountDownLatch相似的接口和用法。
图片8.png
图片9.png

六、缓存一致性解决

1、双写模式

image.png

2、失效模式

image.png

3、改进方法1-分布式读写锁

image.png

4、改进方法2-使用 cananl

image.png

七、SpringCache

1、简介

Spring从3.1开始定义了org.springframework.cache.Cache和org.springframework.cache.CacheManager 接口来统一不同的缓存技术； 并支持使用JCache（JSR-107）注解简化我们开发；
Cache接口为缓存的组件规范定义，包含缓存的各种操作集合；Cache接口下Spring提供了各种xxxCache的实现；如RedisCache，EhCacheCache，ConcurrentMapCache等；
每次调用需要缓存功能的方法时，Spring 会检查检查指定参数的指定的目标方法是否已 经被调用过；如果有就直接从缓存中获取方法调用后的结果，如果没有就调用方法并缓 存结果后返回给用户。下次调用直接从缓存中获取。
使用Spring缓存抽象时我们需要关注以下两点：
1、确定方法需要被缓存以及他们的缓存策略
2、从缓存中读取之前缓存存储的数据

2、基础概念

图片10.png

3、注解

图片11.png
图片12.png

4、表达式语法

图片13.png

5、加入依赖

图片14.png

6、配置文件

图片15.png

7、自定义缓存配置

图片16.png

8、写模式@Cacheable

图片17.png

9、失效模式@CacheEvict

图片18.png

10、SpringCache原理与不足

原理：
CacheManager（RedisCacheManager）->Cache（RedisCache）->Cache复制缓存的读写

10.1 读模式

1）缓存穿透：查询一个null数据。解决方案：缓存空数据，可通过
spring.cache.redis.cache-null-values=true
2）缓存击穿：大量并发进来同时查询一个正好过期的数据。解决方案：加锁。 默认是无加锁的;
使用sync = true加本地锁（分布式系统下会访问多次数据库，可以接受）来解决击穿问题（调用的是RedisCache加锁的get方法）
图片19.png
3）缓存雪崩：大量的key同时过期。解决：加随机时间。
加上过期时间spring.cache.redis.time-to-live=3600000

10.2 写模式

（缓存与数据库一致）SpringCache没有设计锁
读写加锁
引入Canal，感知到MySQL的更新去更新Redis
读多写多，直接去数据库查询就行

10.3 总结

常规数据（读多写少，即时性，一致性要求不高的数据），完全可以使用Spring-Cache
常规的写模式(只要缓存的数据有过期时间就足够了)
特殊数据：特殊设计

  1. @Service("categoryService")
  2. public class CategoryServiceImpl extends ServiceImpl<CategoryDao, CategoryEntity> implements CategoryService {
  4.     @Autowired
  5.     private CategoryBrandRelationService categoryBrandRelationService;
  7.     @Autowired
  8.     private StringRedisTemplate stringRedisTemplate;
  10.     @Autowired
  11.     private RedissonClient redisson;
  13.     /**
  14.      * 查出所有分类以及子分类，以树形结构组装起来
  15.      * @return
  16.      */
  17.     @Override
  18.     public List<CategoryEntity> listWithTree() {
  20.         // 1、查出所有分类
  21.         List<CategoryEntity> entityList = baseMapper.selectList(null);
  23.         // 2、组装成父子的树形结构
  24.         // 2.1、找到所有的一级分类，filter筛选所有的一级分类，map设置一级分类的子菜单
  25.         List<CategoryEntity> level1Menus = entityList.stream().filter(categoryEntity ->
  26.                         categoryEntity.getParentCid() == 0
  27.         ).map(menu -> {
  28.             menu.setChildren(getChildrens(menu, entityList));
  29.             return menu;
  30.         }).sorted((menu1, menu2) -> {
  31.             return (menu1.getSort() == null ? 0 : menu1.getSort()) - (menu2.getSort() == null ? 0 : menu2.getSort());
  32.         }).collect(Collectors.toList());
  34.         return level1Menus;
  35.     }
  37.     /**
  38.      * 递归查找所有菜单的子菜单
  39.      */
  40.     private List<CategoryEntity> getChildrens(CategoryEntity root, List<CategoryEntity> entityList){
  42.         List<CategoryEntity> children = entityList.stream().filter(categoryEntity -> {
  43.             return categoryEntity.getParentCid() == root.getCatId();
  44.         }).map(menu -> {
  45.             // 1、找到子菜单
  46.             menu.setChildren(getChildrens(menu, entityList));
  47.             return menu;
  48.         }).sorted((menu1, menu2) -> {
  49.             // 2、菜单的排序
  50.             return (menu1.getSort() == null ? 0 : menu1.getSort()) - (menu2.getSort() == null ? 0 : menu2.getSort());
  51.         }).collect(Collectors.toList());
  53.         return children;
  54.     }
  56.     /**
  57.      * 删除
  58.      */
  59.     @Override
  60.     public void removeMenuByIds(List<Long> asList) {
  62.         //TODO  1、检查当前删除的菜单，是否被别的地方引用
  63.         baseMapper.deleteBatchIds(asList);
  64.     }
  66.     /**
  67.      * 找到catelogId的完整路径；
  68.      * [父/子/孙]
  69.      * @param catelogId
  70.      * @return  [2,25,225]
  71.      */
  72.     @Override
  73.     public Long[] findCatelogPath(Long catelogId) {
  75.         List<Long> paths = new ArrayList<>();
  76.         List<Long> finalPath = findParentPath(catelogId, paths);
  78.         Collections.reverse(finalPath);
  79.         return finalPath.toArray(new Long[finalPath.size()]);
  80.     }
  82.     // 得到的结果为：225,25,2
  83.     private List<Long> findParentPath(Long catelogId, List<Long> paths) {
  85.         paths.add(catelogId);
  86.         CategoryEntity categoryEntity = baseMapper.selectById(catelogId);
  87.         if(categoryEntity.getParentCid() != 0){
  88.             // 判断父节点id是否为0，然后递归查询以上的所有节点数据
  89.             findParentPath(categoryEntity.getParentCid(), paths);
  90.         }
  91.         return paths;
  92.     }
  94.     /**
  95.      * 级联更新所有关联的数据
  96.      *
  97.      * @CacheEvict：失效模式。根据缓存分区失效
  98.      * 1、删除缓存分区category下某个具体cache，用key="'类名'"，注意有单引号
  99.      *      @CacheEvict(value = "category", key = "'updateCascade'")
  100.      *
  101.      * 2、同时删除缓存category下的多个cache
  102.      *     @Caching(evict = {
  103.      *             @CacheEvict(value = "category", key = "'updateCascade'"),
  104.      *             @CacheEvict(value = "category", key = "'getLevel1Categorys'")
  105.      *     })
  106.      * 3、删除缓存分区category下所有cache
  107.      *      @CacheEvict(value = "category",allEntries = true)
  108.      * 4、存储同一类型的数据，都可以指定成同一个分区。分区名默认就是缓存的前置
  109.      */
  110.     @CacheEvict(value = "category",allEntries = true)
  111.     @Transactional
  112.     @Override
  113.     public void updateCascade(CategoryEntity category) {
  115.         this.updateById(category);
  117.         // 更新关联表
  118.         categoryBrandRelationService.updateCategory(category.getCatId(),category.getName());
  119.     }
  121.     /**
  122.      * 查询所有一级分类
  123.      *
  124.      * 1、每个需要缓存的数据都来指定要放到哪个名字的缓存。 【缓存的分区（按照业务类型分）】，可以同时放到多个分区。
  125.      * 2、@Cacheable({"category"})
  126.      *      代表当前方法的结果需要缓存，如果缓存中有，方法不用调用
  127.      *      如果缓存中没有，会调用方法，最后将方法的结果放入缓存
  128.      * 3、默认行为
  129.      *      1）如果缓存中有，方法不用调用
  130.      *      2）key默认自动生成；缓存的名字：simpleKey[]（自主生成的key值）
  131.      *      3）缓存的value值。默认使用jdk序列化机制，将序列化后的数据存到redis
  132.      *      4）默认ttl时间为-1
  133.      * 4、自定义：
  134.      *      1）指定生成的缓存使用的key：key属性指定，接收一个SPEL
  135.      *      2）指定缓存的数据的存活时间，配置文件中修改ttl
  136.      *      3）将数据保存为json格式
  137.      */
  138.     @Cacheable(value = "category",key = "#root.methodName")   // category为设置的缓存分区
  139.     @Override
  140.     public List<CategoryEntity> getLevel1Categorys() {
  142.         System.out.println("未走缓存，查询数据库.......");
  143.         LambdaQueryWrapper<CategoryEntity> wrapper = new LambdaQueryWrapper<>();
  144.         wrapper.eq(CategoryEntity::getParentCid, 0);
  145.         List<CategoryEntity> categoryEntities = baseMapper.selectList(wrapper);
  146.         return categoryEntities;
  147.     }
  149.     // 方式五、使用spring Cache
  150.     @Cacheable(value = "category",key = "#root.methodName")
  151.     @Override
  152.     public Map<String, List<Catelog2Vo>> getCatelogJson() {
  154.         System.out.println("未走缓存，查询数据库.......");
  155.         /**
  156.          * 优化:将数据库中的多次查询变为一次,存至缓存selectList,需要的数据从list取出,避免频繁的数据库交互
  157.          */
  158.         List<CategoryEntity> selectList = baseMapper.selectList(null);
  159.         //1.查出所有1级分类
  160.         List<CategoryEntity> level1 = getParent_cid(selectList, 0L);
  161.         //2.封装数据
  162.         Map<String, List<Catelog2Vo>> parent_cid = getParentCid(selectList, level1);
  163.         return parent_cid;
  164.     }
  167.     //方式四、使用分布式锁Redisson
  168.     public Map<String, List<Catelog2Vo>> getCatelogJsonFromDbWithRedissonLock() {
  170.         // 1、锁的名字，锁的粒度，越细越快
  171.         // 自动续期，自动删除，不会出现死锁
  172.         RLock lock = redisson.getLock("catalogJson-lock");
  173.         lock.lock();    // 阻塞式等待
  174.         // 加锁成功，执行业务
  175.         Map<String, List<Catelog2Vo>> dataFromDB;
  176.         try {
  177.             dataFromDB = getDataFromDB();
  178.         } finally {
  179.             lock.unlock();
  180.         }
  181.         return dataFromDB;
  182.     }
  184.     //方式三、使用分布式程锁Redis
  185.     public Map<String, List<Catelog2Vo>> getCatelogJson2() {
  187.         //加入缓存逻辑,缓存中存的数据是JSON字符串。JSON跨语言,跨平台兼容
  188.         //从缓存中取出的数据要逆转为能用的对象类型,序列化与发序列化
  189.         String catalogJSON = stringRedisTemplate.opsForValue().get("catalogJSON");
  190.         if (StringUtils.isEmpty(catalogJSON)) {
  191.             //缓存中没有数据,查询数据库
  192.             Map<String, List<Catelog2Vo>> catelogJsonFromDb = getCatelogJsonFromDbWithRedisLock();
  193.             //查到的数据再放入缓存,将对象转为JSON放入缓存中。保证查询与放入redis是一个原子操作，否则会出现多次查询数据库的情况
  194.             String s = JSON.toJSONString(catelogJsonFromDb);
  195.             stringRedisTemplate.opsForValue().set("catalogJSON", s, 1, TimeUnit.DAYS);
  196.             return catelogJsonFromDb;
  197.         }
  198.         Map<String, List<Catelog2Vo>> result = JSON.parseObject(catalogJSON, new TypeReference<Map<String, List<Catelog2Vo>>>() {});
  199.         return result;
  200.     }
  201.     //分布式程锁Redis
  202.     public Map<String, List<Catelog2Vo>> getCatelogJsonFromDbWithRedisLock() {
  204.         //占分布式锁，同时设置锁过期时间，必须和加锁同步原子操作。setIfAbsent同redis的setNx
  205.         String uuid = UUID.randomUUID().toString();
  206.         Boolean lock = stringRedisTemplate.opsForValue().setIfAbsent("lock", uuid, 300, TimeUnit.SECONDS);
  207.         if (lock) {
  208.             //加锁成功，执行业务
  209.             Map<String, List<Catelog2Vo>> dataFromDB;
  210.             try {
  211.                 dataFromDB = getDataFromDB();
  212.             } finally {
  213.                 String script = "if redis.call('get',KEYS[1]) == ARGV[1] then return redis.call('del',KEYS[1])else return 0 end";
  214.                 // 删除锁，Lua脚本。必须删除自己的锁，用uuid区别。不能删错了
  215.                 // 必须保证获取值对比 + 对比成功后删除是一个原子操作
  216.                 Long lock1 = stringRedisTemplate.execute(new DefaultRedisScript<Long>(script, Long.class), Arrays.asList("lock", uuid));
  217.             }
  218.             return dataFromDB;
  219.         } else {
  220.             //加锁失败，休眠2秒，重试。同synchronized
  221.             try {
  222.                 Thread.sleep(2000);
  223.             } catch (Exception e) {
  224.                 e.printStackTrace();
  225.             }
  226.             return getCatelogJsonFromDbWithRedisLock();         //自旋操作。加锁失败后每隔2秒再次进行加锁尝试
  227.         }
  228.     }
  230.     // 抽取公共方法，直接从数据库获取数据
  231.     private Map<String, List<Catelog2Vo>> getDataFromDB() {
  233.         String catalogJSON = stringRedisTemplate.opsForValue().get("catalogJSON");
  234.         if (!StringUtils.isEmpty(catalogJSON)) {
  235.             Map<String, List<Catelog2Vo>> result = JSON.parseObject(catalogJSON
  236.                                                                 , new TypeReference<Map<String, List<Catelog2Vo>>>() {});
  237.             return result;
  238.         }
  239.         // 将数据库的多次查询变为一次
  240.         List<CategoryEntity> selectList = baseMapper.selectList(null);
  241.         //1.查出所有1级分类
  242.         List<CategoryEntity> level1 = getParent_cid(selectList, 0L);
  243.         //2.封装数据
  244.         Map<String, List<Catelog2Vo>> parent_cid = getParentCid(selectList, level1);
  245.         String s = JSON.toJSONString(parent_cid);
  246.         stringRedisTemplate.opsForValue().set("catalogJSON", s, 1, TimeUnit.DAYS);
  247.         return parent_cid;
  248.     }
  250.     //方式二、本地进程锁实现
  251.     public Map<String, List<Catelog2Vo>> getCatelogJsonFromDbWithLocalLock() {
  253.         // 只要是同一把锁，就能锁住需要这个锁的所有线程
  254.         // synchronized (this)：springBoot所有的组件在容器中都是单例的
  255.         // TODO 本地锁：synchronized、JUC（Lock），在分布式情况下，想要锁住所有，必须使用分布式锁
  257.         synchronized (this) {
  258.             // 得到锁以后，应该再去缓存中确定一次，如果没有才需要继续查询
  259.             String catalogJSON = stringRedisTemplate.opsForValue().get("catalogJSON");
  260.             if (!StringUtils.isEmpty(catalogJSON)) {
  261.                 Map<String, List<Catelog2Vo>> result = JSON.parseObject(catalogJSON
  262.                                                                             , new TypeReference<Map<String, List<Catelog2Vo>>>() { });
  263.                 return result;
  264.             }
  265.             List<CategoryEntity> selectList = baseMapper.selectList(null);
  266.             //1.查出所有1级分类
  267.             List<CategoryEntity> level1 = getParent_cid(selectList, 0L);
  268.             //2.封装数据
  269.             Map<String, List<Catelog2Vo>> parent_cid = getParentCid(selectList, level1);
  270.             String parentCidString = JSON.toJSONString(parent_cid);
  271.             //3.放入redis缓存。保证查询与放入redis是一个原子操作，否则会出现多次查询数据库的情况
  272.             stringRedisTemplate.opsForValue().set("catalogJSON", parentCidString, 1, TimeUnit.DAYS);
  273.             return parent_cid;
  274.         }
  275.     }
  277.     //方式一、没有锁，直接从数据库获取，但优化了取数据逻辑
  278.     public Map<String, List<Catelog2Vo>> getCatelogJsonFromDb() {
  280.         /**
  281.          * 优化:将数据库中的多次查询变为一次,存至selectList,需要的数据从list取出,避免频繁的数据库交互
  282.          */
  283.         List<CategoryEntity> selectList = baseMapper.selectList(null);
  284.         //1.查出所有1级分类
  285.         List<CategoryEntity> level1 = getParent_cid(selectList, 0L);
  286.         //2.封装数据
  287.         Map<String, List<Catelog2Vo>> parent_cid = getParentCid(selectList, level1);
  288.         return parent_cid;
  289.     }
  291.     // 查出所有1级分类
  292.     private List<CategoryEntity> getParent_cid(List<CategoryEntity> selectList, Long parent_cid) {
  293.         List<CategoryEntity> level1 = selectList.stream().filter(item -> item.getParentCid() == parent_cid).collect(Collectors.toList());
  294.         return level1;
  295.     }
  297.     // 封装数据
  298.     private Map<String, List<Catelog2Vo>> getParentCid(List<CategoryEntity> selectList, List<CategoryEntity> level1) {
  300.         Map<String, List<Catelog2Vo>> parent_cid = level1.stream().collect(Collectors.toMap(k -> k.getCatId().toString(), v -> {
  301.                     //1.查出1级分类中所有2级分类
  302.                     List<CategoryEntity> categoryEntities = getParent_cid(selectList, v.getCatId());
  303.                     //2.封装上面的结果
  304.                     List<Catelog2Vo> catelog2Vos = null;
  305.                     if (categoryEntities != null) {
  306.                         catelog2Vos = categoryEntities.stream().map(l2 -> {
  307.                             Catelog2Vo catelog2Vo = new Catelog2Vo(v.getCatId().toString(), null, l2.getCatId().toString(), l2.getName());
  308.                             //查询当前2级分类的3级分类
  309.                             List<CategoryEntity> level3 = getParent_cid(selectList, l2.getCatId());
  310.                             if (level3 != null) {
  311.                                 List<Catelog2Vo.Catelog3Vo> collect = level3.stream().map(l3 -> {
  312.                                     //封装指定格式
  313.                                     Catelog2Vo.Catelog3Vo catelog3Vo = new Catelog2Vo.Catelog3Vo(l2.getCatId().toString(), l3.getCatId().toString(), l3.getName());
  314.                                     return catelog3Vo;
  315.                                 }).collect(Collectors.toList());
  316.                                 catelog2Vo.setCatalog3List(collect);
  317.                             }
  318.                             return catelog2Vo;
  319.                         }).collect(Collectors.toList());
  320.                     }
  321.                     return catelog2Vos;
  322.                 }
  323.         ));
  324.         return parent_cid;
  325.     }
  327.     // 初级方式：每次遍历从数据库获取数据，性能很差
  328.     public Map<String, List<Catelog2Vo>> getCatelogJsonBase() {
  330.         // 1、查出所有一级分类
  331.         List<CategoryEntity> level1Categorys = getLevel1Categorys();
  333.         // 2、封装数据为map集合。key为一级分类ID，value为一级分类对应的二级分类和三级分类
  334.         Map<String, List<Catelog2Vo>> map = level1Categorys.stream().collect(Collectors.toMap(k -> k.getCatId().toString(), v -> {
  336.             // 3、获取一级分类对应的二级分类
  337.             LambdaQueryWrapper<CategoryEntity> wrapper = new LambdaQueryWrapper<CategoryEntity>();
  338.             wrapper.eq(CategoryEntity::getParentCid, v.getCatId());
  339.             List<CategoryEntity> categoryEntities = baseMapper.selectList(wrapper);
  341.             // 4、封装二级分类为Catelog2Vo
  342.             List<Catelog2Vo> catelog2VoList = new ArrayList<>();
  343.             if (!CollectionUtils.isEmpty(categoryEntities)) {
  344.                 catelog2VoList = categoryEntities.stream().map(leve2 -> {
  345.                     Catelog2Vo catelog2Vo = new Catelog2Vo(v.getCatId().toString(), null,
  346.                             leve2.getCatId().toString(), leve2.getName());
  348.                     // 5、获取二级分类下的三级分类
  349.                     LambdaQueryWrapper<CategoryEntity> wrapper1 = new LambdaQueryWrapper<CategoryEntity>();
  350.                     wrapper.eq(CategoryEntity::getParentCid, leve2.getCatId());
  351.                     List<CategoryEntity> categorysLevel3 = baseMapper.selectList(wrapper1);
  353.                     // 6、封装二级分类下的三级分类为Catelog3Vo
  354.                     List<Catelog2Vo.Catelog3Vo> catelog3VoList = new ArrayList<>();
  355.                     if (!CollectionUtils.isEmpty(categorysLevel3)) {
  356.                         catelog3VoList = categorysLevel3.stream().map(leve3 -> {
  357.                             Catelog2Vo.Catelog3Vo catelog3Vo = new Catelog2Vo.Catelog3Vo(leve2.getCatId().toString(),
  358.                                                                                 leve3.getCatId().toString(), leve3.getName());
  359.                             return catelog3Vo;
  360.                         }).collect(Collectors.toList());
  361.                     }
  362.                     catelog2Vo.setCatalog3List(catelog3VoList);
  363.                     return catelog2Vo;
  364.                 }).collect(Collectors.toList());
  365.             }
  366.             return catelog2VoList;
  367.         }));
  368.         return map;
  369.     }
  370. }