• 22-09-20 西安 谷粒商城（04）Redisson、布隆过滤器、AOP赋能自定义注解@GmallCache

    Redisson

    1、Redisson做分布式锁

     分布式锁主流的实现方案：

    1. 基于数据库实现分布式锁
    2. 基于缓存（Redis），性能最高
    3. 基于Zookeeper，可靠性最高

    Redisson是一个在Redis的基础上实现的Java驻内存数据网格，它不仅提供了一系列的分布式的Java常用对象，还提供了许多分布式服务。

    Redisson的宗旨是促进使用者对Redis的关注分离（Separation of Concern），从而让使用者能够将精力更集中地放在处理业务逻辑上

    1、依赖、配置

    1. <dependency>
    2.     <groupId>org.redissongroupId>
    3.     <artifactId>redissonartifactId>
    4.     <version>3.11.2version>
    5. dependency>

    创建配置类

    1. @Configuration
    2. public class RedissonConfig {
    3.  
    4.     //初始化redis客户端对象注入到容器中
    5.     @Bean
    6.     public RedissonClient redissonClient(){
    7.         Config config = new Config();
    8.         // 可以用"rediss://"来启用SSL连接
    9.         config.useSingleServer().setAddress("redis://192.168.2.108:6379");
    10.         return Redisson.create(config);
    11.     }
    12. }

    当然了还有一些常用配置，参考如下：

    ====================================

    2、使用Redisson分布式锁

    锁的名字就是锁的粒度，粒度越细越快

    1. /**
    2.  * 秒杀案例测试
    3.  */
    4. @GetMapping("index/testlock")
    5. public void testLock() {
    6.     //只要锁的名称相同就是同一把锁  getlock（）获取一个可重入的锁
    7.     RLock lock = this.redissonClient.getLock("lock");
    8.     //阻塞等待获取锁，默认等待3秒
    9.     lock.lock();
    10.     //获取redis中num的值
    11.     int num = Integer.parseInt(
    12.             redisTemplate.opsForValue().get("num").toString()
    13.     );
    14.     num++;
    15.     //设置到redis中
    16.     redisTemplate.opsForValue().set("num", num);
    17.     //解锁
    18.     lock.unlock();
    19. }

    1.锁名称相同就认为是同一把锁

    2.redisson自动续期 默认是30S，每10S会续期到30S,也就是每10S会进行喂狗操作

    只要锁没有指定释放时间,每隔lockWatchdogTimeout/3 就会给锁续期,续满看门狗时间30S 

     3.redisson底层的所有操作都依赖于lua脚本

     4.加锁操作 + 过期时间操作 能保证原子性   获取锁 + 判断锁 + 删除锁 也能保证原子性

    获取锁的其他方式

    除了最常用的可重入锁，还有公平锁和读写锁

    1. //获取分布式公平锁
    2. RLock fairLock = this.redissonClient.getFairLock("xxx");
    3. //加锁
    4. fairLock.lock();
    5. //释放锁
    6. fairLock.unlock();
    7.  
    8.  
    9. //获取分布式读写锁
    10. RReadWriteLock rwLock = this.redissonClient.getReadWriteLock("xxx");
    11. //读锁
    12. rwLock.readLock().lock();
    13. rwLock.readLock().unlock();
    14. //写锁
    15. rwLock.writeLock().lock();
    16. rwLock.writeLock().unlock();

     读写锁：允许一个写锁和多个读锁同时竞争

    Redisson还通过加锁的方法提供了leaseTime的参数来指定加锁的时间。超过这个时间后锁便自动解开了。[可以防止死锁]

    1. //可重入锁，最经常使用的锁
    2. lock.lock();
    3.  
    4. // 加锁以后10秒钟自动解锁
    5. // 无需调用unlock方法手动解锁
    6. lock.lock(10, TimeUnit.SECONDS);
    7.  
    8. // 尝试加锁，最多等待100秒，上锁以后10秒自动解锁
    9. boolean res = lock.tryLock(100, 10, TimeUnit.SECONDS);

    测试一下，服务多实例启动，并给num设置为0

    使用ab测试

    ab -n 5000 -c 100 http://www.gmall.com/index/testlock

    redis客户端结果，真不错

    redlock算法

    redis在分布式系统中保证分布式锁 分布式数据安全的一种算法

    安全属性（Safety property）: 独享（相互排斥）。在任意一个时刻，只有一个客户端持有锁。  setnx


    活性A(Liveness property A): 无死锁。即便持有锁的客户端崩溃（crashed)或者网络被分裂（gets partitioned)，锁仍然可以被获取。  设置过期时间


    活性B(Liveness property B): 容错。 只要大部分Redis节点都活着，客户端就可以获取和释放锁.

    红锁：多个锁组成的锁，超过一半成功才代表获取到锁

    2、Redisson分布式锁解决缓存穿透

    热点key单个或者批量同时失效，大量的请求缓存查询失败，会去查询数据库。线程处理请求的时间变长，服务器并发能力下降，可能导致服务器宕机

    解决办法：只让一个请求线程查询数据库，然后设置到缓存中 其他的请求以后走缓存

    1.     @Override
    2.     public List queryLvl2CategoriesWithSub(Long pid) {
    3.         //1.先查询缓存
    4.         String key = "idx:cache:cates:" + pid;
    5.         Object obj = redisTemplate.opsForValue().get(key);
    6.         //缓存有的话直接返回
    7.         if (obj != null) {
    8.             return (List) obj;
    9.         }
    10.  
    11.         //2.缓存没有,加锁控制只让一个线程查询数据库的数据
    12.         RLock lock = redissonClient.getLock("cates:lock");
    13.         lock.lock(30l, TimeUnit.SECONDS);
    14.         try {
    15.             // 双查：解决并发多个等待获取锁查询数据库数据的线程每个都查询数据库：
    16.             // 再次查询缓存 如果有缓存直接返回
    17.             obj = redisTemplate.opsForValue().get(key);
    18.             if (obj != null) {
    19.                 return (List) obj;
    20.             }
    21.             //-只有第一个线程才会这么通过，远程服务调用查询2/3级分类
    22.             ResponseVo> listResponseVo = pmsFeign.queryCategoriesWithSub(pid);
    23.  
    24.             //3.将查询到的值设置到redis缓存中
    25.             long ttl = 1800 + new Random().nextInt(200);
    26.             //校验空值-解决缓存穿透问题
    27.             if (CollectionUtils.isEmpty(listResponseVo.getData())) {
    28.                 //如果是空值，ttl有效期就设置的短一些
    29.                 ttl = new Random().nextInt(500);
    30.             }
    31.             redisTemplate.opsForValue()
    32.                     .set(key, listResponseVo.getData(), ttl, TimeUnit.SECONDS);
    33.  
    34.             return listResponseVo.getData();
    35.         } catch (Exception e) {
    36.             e.printStackTrace();
    37.         } finally {
    38.             lock.unlock();
    39.         }
    40.         return null;
    41.     }

    在首页上触发鼠标移动事件，去查询2/3级分类

     redis数据库中：

    3、自定义注解@GmallCache

    1. @Target(ElementType.METHOD)
    2. @Documented
    3. @Retention(RetentionPolicy.RUNTIME)
    4. public @interface GmallCache {
    5.     // 自定义注解需要管理的参数：缓存的key、锁的名称(击穿)、缓存过期时间、随机过期时间(雪崩)
    6.     String key() default "cache";
    7.     String lockName() default "lock";
    8.     int timeout() default 5*60;//单位秒
    9.     int random() default 2*60;//单位秒
    10. }

    此时我们就可以这么使用了，对缓存管理抽取，把上面那么长的方法简化到极致

    1. @Override
    2. @GmallCache(key = "idx:cache:cates" ,lockName = "cates:lock",timeout = 30*60 , random = 10*60)
    3. public List queryLvl2CategoriesWithSub(Long pid) {
    4.     //远程服务调用查询2/3级分类
    5.     ResponseVo> listResponseVo = pmsFeign.queryCategoriesWithSub(pid);
    6.     return listResponseVo.getData();
    7. }

    但是我们还得使用aop赋能，通过切面给注解添加功能

    4、AOP使用 【redis缓存管理+分布式锁】

    获取标注@GmallCache的方法信息以及该方法上注解信息

    编写一个切面类，咱不使用切入点表达式了，使用@annotation 对指定注解进行切面通知

    1. @Aspect
    2. @Component
    3. public class GmallCacheAspect {
    4.  
    5.     //环绕通知: 对使用自定义注解GmallCache的方法进行增强
    6.     //@annotation 对指定注解进行切面通知
    7.     @Around("@annotation(com.atguigu.gmall.index.aspect.GmallCache)")
    8.     public Object around(ProceedingJoinPoint joinPoint) throws Throwable {//切入点： 可以获取到切入点方法对象 和参数等信息
    9.         MethodSignature signature = (MethodSignature) joinPoint.getSignature();//获取切入点方法信息
    10.         Method method = signature.getMethod();//获取目标方法的对象
    11.         Class returnType = signature.getReturnType();
    12.         //1.获取目标方法的返回值类型
    13.         System.out.println("目标方法的返回值类型: "+returnType.getName());
    14.  
    15.         //2、获取目标方法的参数列表
    16.         Object[] args = joinPoint.getArgs();
    17.         System.out.println("目标方法的参数: "+args[0].toString());
    18.  
    19.         //3、获取目标方法上的注解对象：获取注解对象中的 缓存key  lockkey  过期时间...
    20.         GmallCache gmallCache = method.getAnnotation(GmallCache.class);
    21.         String key = gmallCache.key();
    22.         String lockName = gmallCache.lockName();
    23.         int timeout = gmallCache.timeout();
    24.         int random = gmallCache.random();
    25.         System.out.println("目标方法上的注解: "+"key="+key+",lockName="+lockName+",timeout="+timeout+",random="+random);
    26.  
    27.         //4、执行目标对象方法:查询数据库中的二级分类和子集合数据
    28.         Object result = joinPoint.proceed(args);
    29.         return result;
    30.     }
    31. }

    环绕通知:@Around，目标方法的执行需要我们手动调用，在它的前后进行扩展

    2021/10/30 北京 spring【3】静态代理，动态代理、 AOP面向切面编程_￡小羽毛的博客-CSDN博客

     浏览器访问： http://localhost:18087/index/cates/2

    控制台打印：

    ===========

    使用aop赋能完成缓存管理

    在上面获取到那么多的信息之后，我们就可以对该方法做缓存管理了

    1. @Aspect
    2. @Component
    3. public class GmallCacheAspect {
    4.     @Autowired
    5.     RedisTemplate redisTemplate;
    6.     @Autowired
    7.     RedissonClient redissonClient;
    8.  
    9.     //环绕通知: 对使用自定义注解GmallCache的方法进行增强
    10.     //@annotation 对指定注解进行切面通知
    11.     @Around("@annotation(com.atguigu.gmall.index.aspect.GmallCache)")
    12.     public Object around(ProceedingJoinPoint joinPoint) throws Throwable {//切入点： 可以获取到切入点方法对象 和参数等信息
    13.         MethodSignature signature = (MethodSignature) joinPoint.getSignature();//获取切入点方法信息
    14.         Method method = signature.getMethod();//获取目标方法的对象
    15.         Class returnType = signature.getReturnType();
    16.         //1.获取目标方法的返回值类型
    17.         System.out.println("目标方法的返回值类型: "+returnType.getName());
    18.  
    19.         //2、获取目标方法的参数列表
    20.         Object[] args = joinPoint.getArgs();
    21.         System.out.println("目标方法的参数: "+args[0].toString());
    22.  
    23.         //3、获取目标方法上的注解对象：获取注解对象中的 缓存key  lockkey  过期时间...
    24.         GmallCache gmallCache = method.getAnnotation(GmallCache.class);
    25.         String key = gmallCache.key();
    26.         String lockName = gmallCache.lockName();
    27.         int timeout = gmallCache.timeout();
    28.         int random = gmallCache.random();
    29.         System.out.println("目标方法上的注解: "+"key="+key+",lockName="+lockName+",timeout="+timeout+",random="+random);
    30.  
    31.  
    32.         //4，判断是否存在缓存，有缓存则直接返回
    33.         String cacheKey = key;
    34.         if(ArrayUtils.isNotEmpty(args)){
    35.             cacheKey = key+":"+ StringUtils.join(args,"-");
    36.             lockName = lockName+":"+StringUtils.join(args,"-");
    37.         }
    38.  
    39.         //使用布隆过滤器去决定是否查询缓存。。 todo
    40.  
    41.         // redisTemplate配置过键和值的序列化器，所以返回的Object真实类型就是原数据自己的类型
    42.         Object obj = redisTemplate.opsForValue().get(cacheKey);
    43.         if(obj!=null){
    44.             return obj;
    45.         }
    46.  
    47.         //5、缓存不存在，执行目标方法:查询数据库中的二级分类和子集合数据
    48.         //分布式锁：解决雪崩
    49.         RLock lock = redissonClient.getLock(lockName);
    50.         lock.lock();
    51.         //再次判断是否有缓存
    52.         obj = redisTemplate.opsForValue().get(cacheKey);
    53.         if(obj!=null){
    54.             lock.unlock();//查询到缓存后释放锁
    55.             return obj;
    56.         }
    57.         try{
    58.             Object result = joinPoint.proceed(args);
    59.             long cacheTime = timeout+new Random().nextInt(random);
    60.             if(result==null  || (result instanceof List && CollectionUtils.isEmpty((List)result))){
    61.                 //空值也存入到缓存中  时间稍短
    62.                 cacheTime = random;
    63.             }
    64.             //存入缓存
    65.             redisTemplate.opsForValue().set(cacheKey , result , cacheTime, TimeUnit.SECONDS);
    66.             return result;
    67.         }finally {
    68.             lock.unlock();
    69.         }
    70.     }
    71. }

    5、信号量和闭锁

    在配置类中可以初始化信号量和闭锁

    1. //初始化redis客户端对象注入到容器中
    2. @Bean
    3. public RedissonClient redissonClient(){
    4.     Config config = new Config();
    5.     // 可以用"rediss://"来启用SSL连接
    6.     config.useSingleServer().setAddress("redis://192.168.2.108:6379");
    7.     RedissonClient redissonClient = Redisson.create(config);
    8.     //1初始化信号量
    9.     RSemaphore sempahore = redissonClient.getSemaphore("sempahore");
    10.     //设置资源数量
    11.     sempahore.trySetPermits(1);
    12.     //2 初始化闭锁
    13.     RCountDownLatch cdl = redissonClient.getCountDownLatch("cdl");
    14.     cdl.trySetCount(1);
    15.     return redissonClient;
    16. }

    这里就测试一下闭锁。。

    1.     @Autowired
    2.     private RedissonClient redissonClient;
    3.  
    4.     @ResponseBody
    5.     @GetMapping("/index/testlock2")
    6.     public ResponseVo testLock2(){
    7.         //testLock2 的请求阻塞等待cdl 闭锁的值为0才继续执行
    8.         RCountDownLatch cdl = redissonClient.getCountDownLatch("cdl");
    9.         try {
    10.             cdl.await();
    11.         } catch (InterruptedException e) {
    12.             e.printStackTrace();
    13.         }
    14.         System.out.println("testLock2终于执行了....");
    15.         return ResponseVo.ok();
    16.     }
    17.     
    18.     @ResponseBody
    19.     @GetMapping("/index/testlock3")
    20.     public ResponseVo testLock3(){
    21.         RCountDownLatch cdl = redissonClient.getCountDownLatch("cdl");
    22.         try {
    23.             cdl.countDown();//倒计数-1
    24.         } catch (Exception e) {
    25.             e.printStackTrace();
    26.         }
    27.         System.out.println("testLock3执行了....");
    28.         return ResponseVo.ok();
    29.     }

    访问testLock2方法：

    浏览器效果

    访问testlock3方法：

    浏览器效果俩个效果都出来了。。。

    6、秒杀测试

    分布式锁可以解决秒杀超卖问题，但是一次只能有一个线程获取锁，执行秒杀的业务。高并发的场景下吞吐量低。改为使用分布式信号量

    秒杀的思路图

    秒杀的伪代码

    管理员初始化，1001是商品skuId

    布隆过滤器BloomFilter

    1、布隆过滤器特征

    布隆过滤器是一种数据结构，比较巧妙的概率型数据结构，特点是高效地插入和查询，可以用来告诉 “某样东西一定不存在或者可能存在”。

    ==================

    布隆过滤器是一种牺牲准确率换取空间及时间效率的概率型数据结构，它的3个特征

    1. 布隆过滤器判定一个数据不存在，它就一定不存在

    2. 判定一个数据存在，它可能不存在（误判）

    3. 数据只能插入不能删除

    布隆过滤器的优点：

    • 时间复杂度低，增加和查询元素的时间复杂为O(N)，（N为哈希函数的个数，通常情况比较小）

    • 保密性强，布隆过滤器不存储元素本身

    • 存储空间小，如果允许存在一定的误判，布隆过滤器是非常节省空间的（相比其他数据结构如Set集合）

    布隆过滤器的缺点：

    • 有点一定的误判率，但是可以通过调整参数来降低

    • 很难删除元素

    2、布隆过滤器原理

    参考文章： 布隆过滤器原理 以及解决redis穿透问题-KuangStudy-文章

    其内部维护一个全为0的bit数组，需要说明的是，布隆过滤器有一个误判率的概念，误判率越低，则数组越长，所占空间越大。误判率越高则数组越小，所占的空间越小。

    数据加入这个集合时：

    假设，根据误判率，我们生成一个10位的bit数组，以及2个hash函数（(f_1,f_2)）

    0代表不存在某个数据，1代表存在某个数据。

    假设输入集合为((N_1,N_2)),经过计算(f_1(N_1))得到的数值得为2，(f_2(N_1))得到的数值为5，则将数组下标为2和下表为5的位置置为1，如下图所示

    同理，经过计算(f_1(N_2))得到的数值得为3，(f_2(N_2))得到的数值为6，则将数组下标为3和下表为6的位置置为1，如下图所示

    ==========

    数据查询过程

     这个时候，我们有第三个数(N_3)，我们判断(N_3)在不在集合((N_1,N_2))中，就进行(f_1(N_3)，f_2(N_3))的计算

    1. 若值恰巧都位于上图的红色位置中，我们则认为，(N_3)在集合((N_1,N_2))中
    2.  
    3. 若值有一个不位于上图的红色位置中，我们则认为，(N_3)不在集合((N_1,N_2))中

    以上就是布隆过滤器的计算原理

    3、影响BloomFilter误判率因素

    影响布隆过滤器误判率的因素，有两个：

    1. 布隆过滤器的bit数组长度

      过小的布隆过滤器很快所有的 bit 位均为 1，那么查询任何值都会返回“可能存在”，起不到过滤的目的了。布隆过滤器的长度会直接影响误报率，布隆过滤器越长其误报率越小。

    2. 布隆过滤器的hash函数个数

      个数越多则布隆过滤器 bit 位置位 1 的速度越快，且布隆过滤器的效率越低；但是如果太少的话，那我们的误报率会变高。

    如何选择适合业务的 哈希函数的个数（k） 和bit数组的长度（m）值呢，公式如下：

    k 为哈希函数个数，m 为布隆过滤器长度，n 为插入的元素个数，p 为误报率

    布隆过滤器真实失误率p公式：

    布隆过滤器不需要我们自己来实现，因为已经有很多成熟的实现方案：

    1. Google的guava

    2. redisson

    3. redis插件  官方地址：GitHub - RedisBloom/RedisBloom: Probabilistic Datatypes Module for Redis

    4、布隆重建

    删除困难，需要额外编写逻辑进行布隆重建

    原理:将之前布隆对象删除,重新生成一个布隆对象即可，通过定时任务实现

    5、谷歌guava的布隆过滤器

    引入依赖

    1. <dependency>
    2.     <groupId>com.google.guavagroupId>
    3.     <artifactId>guavaartifactId>
    4.     <version>30.1.1-jreversion>
    5. dependency>

    测试类

    1. @SpringBootTest //自动提供IOC容器
    2. public class MybatisTest {
    3.  
    4.     BloomFilter bloomFilter;
    5.  
    6.     @PostConstruct //布隆过滤器的初始化
    7.     public void init(){
    8.         //参数1： 指定将来存入布隆过滤器的 数据 类型+编码 (计算hash的算法)
    9.         //参数2： 预期的元素个数
    10.         //参数3： 误判率
    11.         bloomFilter =
    12.                 BloomFilter.create(Funnels.stringFunnel(Charsets.UTF_8), 10, 0.3);
    13.         //存入数据：使用多个hash算法为存入的数据计算 并对数组长度求余 设置到布隆过滤器的数组中
    14.         bloomFilter.put("1");
    15.         bloomFilter.put("2");
    16.         bloomFilter.put("3");
    17.         bloomFilter.put("4");
    18.         bloomFilter.put("5");
    19.     }
    20.  
    21.     @Test
    22.     public void contextLoads() {
    23.         System.out.println("1："+bloomFilter.mightContain("1"));
    24.         System.out.println("2："+bloomFilter.mightContain("2"));
    25.         System.out.println("3："+bloomFilter.mightContain("3"));
    26.         System.out.println("4："+bloomFilter.mightContain("4"));
    27.         System.out.println("5："+bloomFilter.mightContain("5"));
    28.         System.out.println("6："+bloomFilter.mightContain("6"));
    29.         System.out.println("7："+bloomFilter.mightContain("7"));
    30.         System.out.println("8："+bloomFilter.mightContain("8"));
    31.         System.out.println("9："+bloomFilter.mightContain("9"));
    32.         System.out.println("10："+bloomFilter.mightContain("10"));
    33.         System.out.println("11："+bloomFilter.mightContain("11"));
    34.         System.out.println("12："+bloomFilter.mightContain("12"));
    35.         System.out.println("13："+bloomFilter.mightContain("13"));
    36.         System.out.println("14："+bloomFilter.mightContain("14"));
    37.         System.out.println("15："+bloomFilter.mightContain("15"));
    38.         System.out.println("16："+bloomFilter.mightContain("16"));
    39.     }
    40.  
    41. }

    不存在的一定不存在 认为存在的可能不存在，看看结果

    6、redisson的布隆过滤器

    依赖的话就是之前引入的这个

    1. <dependency>
    2.     <groupId>org.redissongroupId>
    3.     <artifactId>redissonartifactId>
    4.     <version>3.11.2version>
    5. dependency>

    配置类配置

    1. @Configuration
    2. public class RedissonConfig {
    3.  
    4.     //初始化redis客户端对象注入到容器中
    5.     @Bean
    6.     public RedissonClient redissonClient(){
    7.         Config config = new Config();
    8.         // 可以用"rediss://"来启用SSL连接
    9.         config.useSingleServer().setAddress("redis://192.168.2.108:6379");
    10.         return Redisson.create(config);
    11.     }
    12. }

    测试类中测试

    1. @Autowired
    2. RedissonClient redissonClient;
    3. @Test
    4. public void testRedissonBloom(){
    5.     RBloomFilter bloom = this.redissonClient.getBloomFilter("bloom");
    6.     bloom.tryInit(10l, 0.3);
    7.     bloom.add("1");
    8.     bloom.add("2");
    9.     bloom.add("3");
    10.     bloom.add("4");
    11.     bloom.add("5");
    12.     System.out.println("1："+bloom.contains("1"));
    13.     System.out.println("2："+bloom.contains("2"));
    14.     System.out.println("3："+bloom.contains("3"));
    15.     System.out.println("4："+bloom.contains("4"));
    16.     System.out.println("5："+bloom.contains("5"));
    17.     System.out.println("6："+bloom.contains("6"));
    18.     System.out.println("7："+bloom.contains("7"));
    19.     System.out.println("8："+bloom.contains("8"));
    20.     System.out.println("9："+bloom.contains("9"));
    21.     System.out.println("10："+bloom.contains("10"));
    22.     System.out.println("11："+bloom.contains("11"));
    23.     System.out.println("12："+bloom.contains("12"));
    24.     System.out.println("13："+bloom.contains("13"));
    25.     System.out.println("14："+bloom.contains("14"));
    26.     System.out.println("15："+bloom.contains("15"));
    27.     System.out.println("16："+bloom.contains("16"));
    28. }

    结果打印：看的出来确实没人家谷歌算法做得好

    7、BloomFilter解决缓存穿透

    使用布隆过滤器主要是为了解决Redis缓存穿透问题 

    布隆过滤器可以前置到查询缓存之前，但是没有必要，因为大部分请求缓存直接命中返回

    上面使用Ridisson缓存管理的缓存穿透解决方案是：缓存空值，但是会导致 redis中内存占用过高

    添加布隆过滤器的配置类：

    这样在项目启动时就可以将所有的二级分类的id存入到布隆过滤器中

    项目启动时可以将存在的数据查询出来 使用布隆过滤器的多种hash算法，每个算法计算数据的hash值
    得到了多个值再和非常长的数组的长度进行求余 将多个hash算法计算后hash值%数组 的余存到数组中

    1. @Configuration
    2. public class BloomFilterConfig {
    3.  
    4.     @Autowired
    5.     private RedissonClient redissonClient;
    6.     
    7.     @Autowired
    8.     private GmallPmsFeign gmallPmsFeign;
    9.  
    10.     @Bean
    11.     public RBloomFilter rBloomFilter(){
    12.         // 初始化布隆过滤器
    13.         RBloomFilter bloomfilter = this.redissonClient.getBloomFilter("bloom:cates");
    14.         //参数1：预期的元素个数  参数2：误判率
    15.         bloomfilter.tryInit(50l, 0.03);
    16.  
    17.         //远程服务调用查询所有的二级分类id
    18.         ResponseVo> listResponseVo = this.gmallPmsFeign.queryCategory(0l);
    19.         List categoryEntities = listResponseVo.getData();
    20.         if (!CollectionUtils.isEmpty(categoryEntities)){
    21.             //每个二级分类的分类id存入到布隆过滤器
    22.             categoryEntities.forEach(categoryEntity -> {
    23.                 bloomfilter.add(categoryEntity.getId().toString());
    24.             });
    25.         }
    26.         return bloomfilter;
    27.     }
    28. }

    修改“AOP缓存管理”封装的代码：

    如果传入二级分类的id了，布隆过滤器说不存在那就是一定不存在，所以直接return null，不用再去查询缓存了

    1. if(ArrayUtils.isNotEmpty(args)){
    2.     //使用布隆过滤器判断查询的数据是否存在：
    3.     //cid查询它的二级分类： cid必须存在 并且它有二级分类集合  这个cid就有数据
    4.     // 项目启动时 可以将存在并且有二级分类的cid存入到布隆过滤器中
    5.     RBloomFilter bloomFilter = redissonClient.getBloomFilter("bloom:cates");
    6.     boolean contains = bloomFilter.contains(args[0].toString());
    7.     if(!contains){
    8.         //缓存一定不存在
    9.         log.info("bloomfilter判断数据不存在：{}" ,args[0].toString());
    10.         return null;
    11.     }
    12.     cacheKey = key+":"+StringUtils.join(args,"-");
    13.     lockName = lockName+":"+StringUtils.join(args,"-");
    14. }
      15.  

      总结：缓存穿透的解决方案
       

       
 
      1、布隆过滤器过滤大部分的空值请求，但是它有误判率
       2、redis缓存空值
       

      
                
                    
                

                
    15. 

                    相关阅读:
      
                    
Java包装类和泛型                            
      
操作系统 day06（进程控制、原语）                            
      
springboot集成spring-security(1)                            
      
IDEA插件推荐：TabColor                            
      
【操作系统】文件管理（六）—— 文件存储空间管理                            
      
DoTween简单的API，以及一些回调                            
      
内联函数、带默认形参值的函数、引用传参以及函数重载的具体介绍和例子                            
      
PyQt5 PyQtChart                            
      
一文让你学会 Java 中的内部类                            
      
Qt中QTimer定时器的用法                            
      
                          
                
      16. 
                
    16. 
                    原文地址：https://blog.csdn.net/m0_56799642/article/details/126955191
                
      17.