布隆过滤器在redisson中的使用

最新推荐文章于 2025-03-05 09:30:00 发布
最新推荐文章于 2025-03-05 09:30:00 发布
阅读量2.3k 收藏 4
点赞数
分类专栏： 学习 分布式 文章标签： redis 过滤器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Lipeaun/article/details/110245359
版权

布隆过滤器在redisson中的使用

数据库的数据是存储在磁盘上的，高速访问会存在性能问题，使用缓存中间件Redis，可以缓解数据访问的压力；同时数据库查询不到的数据会放在缓存中，并存入 NULL 值，降低数据库消耗；但是若是这样的NULL值过多则会降低缓存性能，什么方式能过滤掉这些无意义的查询，布隆过滤器由此而生

本质：

​ 布隆过滤器使用Bit-map(位图)进行标记，达到判断“一定不存在和可能存在”的目的

解决什么问题：

​ redis缓存穿透

基于redisson的BloomFilter的使用

1.引入redisson工具maven依赖

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.12.3</version>
</dependency>

2.修改springboot配置文件

redisson:
  host:
    config: redis://192.168.152.129:6379
# slf4j日志配置
logging:
  # 配置级别
  #分包配置级别，即不同的目录下可以使用不同的级别
  level:
    com: debug
  # 在不指定路径，只指定输出日志的文件名，默认输出至当前项目下
  # 若指定，则会输出至指定目录下
  file:
    path: log\book.log

3.新建conf层

@Configuration
public class RedissonConf {//加载redisson配置
    @Autowired
    private Environment env;
    @Bean
    public RedissonClient redissonClient(){
        Config cfg=new Config();
        cfg.useSingleServer().
                setAddress(env.getProperty("redisson.host.config")).
                setKeepAlive(true);
        
        return Redisson.create(cfg);
    }
}

4.BloomFilter数值过滤

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest
public class RedissonTest {
    //定义日志
    private static final Logger log= LoggerFactory.getLogger(RedissonTest.class);
    //定义操作Redisson的客户端实例
    @Autowired
    private RedissonClient redissonClient;
    @Test
    public void test1(){
        String key="MyBloom";
        Integer total=100000;
        RBloomFilter<Integer> bloomFilter=redissonClient.getBloomFilter(key);
        //初始化布隆过滤器
        bloomFilter.tryInit(total,0.01);//精度越高，消耗空间越大
        //生成元素
        for(int i=1;i<=total;i++){
            bloomFilter.add(i);
        }
        log.info("测试该布隆过滤器里面是否含有1：{}",bloomFilter.contains(1));
        log.info("测试该布隆过滤器里面是否含有-1：{}",bloomFilter.contains(-1));
        log.info("测试该布隆过滤器里面是否含有100：{}",bloomFilter.contains(100));
        log.info("测试该布隆过滤器里面是否含有10000：{}",bloomFilter.contains(10000));
    }
}

5.BloomFilter键值过滤

我们先建立dto层

@Data
@ToString
@EqualsAndHashCode
@NoArgsConstructor
@AllArgsConstructor
public class BloomDto implements Serializable {
    private Integer id;
    private String msg;
}

然后查询

@Test
public void test2(){
    String key="MyBloom1";
    Integer total=1000;
    RBloomFilter<BloomDto> bloomFilter=redissonClient.getBloomFilter(key);
    //初始化布隆过滤器
    bloomFilter.tryInit(total,0.01);

    bloomFilter.add(new BloomDto(100,"北京"));
    bloomFilter.add(new BloomDto(101,"上海"));
    bloomFilter.add(new BloomDto(102,"深圳"));
    bloomFilter.add(new BloomDto(103,"武汉"));
    bloomFilter.add(new BloomDto(104,"哈尔滨"));

    log.info("该布隆过滤器是否包含数据(1,\"1\")：{}",bloomFilter.contains(new BloomDto(1,"1")));
    log.info("该布隆过滤器是否包含数据(1,\"北京\")：{}",bloomFilter.contains(new BloomDto(1,"北京")));
    log.info("该布隆过滤器是否包含数据(101,\"上海\")：{}",bloomFilter.contains(new BloomDto(101,"上海")));
    log.info("该布隆过滤器是否包含数据(104,\"哈尔滨\")：{}",bloomFilter.contains(new BloomDto(104,"哈尔滨")));
}

6.Bloomfltermap过滤

先建RMapDto

@Data
@ToString
@EqualsAndHashCode
@NoArgsConstructor
@AllArgsConstructor
public class RMapDto implements Serializable {
    private Integer id;
    private String name;
}

查询

@Test
public void test3(){//map形式存储
    String key="MyBloom2";
    RMap<Integer,RMapDto> rmap=redissonClient.getMap(key);
    RMapDto dto1=new RMapDto(1,"map1");
    RMapDto dto2=new RMapDto(2,"map2");
    RMapDto dto3=new RMapDto(3,"map3");
    RMapDto dto4=new RMapDto(4,"map4");
    RMapDto dto5=new RMapDto(5,"map5");
    RMapDto dto6=new RMapDto(6,"map6");
    RMapDto dto7=new RMapDto(7,"map7");
    RMapDto dto8=new RMapDto(8,"map8");

    rmap.put(dto1.getId(),dto1);
    rmap.putIfAbsent(dto2.getId(),dto2);
    rmap.putIfAbsentAsync(dto3.getId(),dto3);
    rmap.putAsync(dto4.getId(),dto4);
    rmap.fastPut(dto5.getId(),dto5);
    rmap.fastPutIfAbsent(dto6.getId(),dto6);
    rmap.fastPutAsync(dto7.getId(),dto7);
    rmap.fastPutIfAbsentAsync(dto8.getId(),dto8);

    log.info("---往映射数据结构RMap中添加数据元素完毕---");
}

@Test
public void test4() {//map形式查询
    //String key="MyBloom1";
    //RMap<Integer,RMapDto> rmap=redissonClient.getMap(key);
	//此处若key并不存在会报错：channel: [id: 0xc0ad866d, L:/192.168.152.1:63613 - R:192.168.152.129/192.168.152.129:6379] command: (HLEN), params: [MyBloom1]
    String key="MyBloom2";
    RMap<Integer,RMapDto> rmap=redissonClient.getMap(key);
    Set<Integer> ss=rmap.keySet();
    Map<Integer,RMapDto> map=rmap.getAll(ss);
    log.info("元素列表：{} ",map);

    rmap.remove(6);//指定删除
    log.info("元素列表：{} ",rmap.getAll(ss));

    Integer is[] ={1,2,3};//快速删除
    rmap.fastRemove(is);
    log.info("元素列表：{} ",rmap.getAll(ss));
}

设置过期时间、异步存储

@Test
public void test5() {//map形式存储
    String key="MyBloom3";
    RMapCache<Integer,RMapDto> rmap=redissonClient.getMapCache(key);

    RMapDto dto1=new RMapDto(1,"map1");
    RMapDto dto2=new RMapDto(2,"map2");
    RMapDto dto3=new RMapDto(3,"map3");
    RMapDto dto4=new RMapDto(4,"map4");
    RMapDto dto5=new RMapDto(5,"map5");
    RMapDto dto6=new RMapDto(6,"map6");
    RMapDto dto7=new RMapDto(7,"map7");
    RMapDto dto8=new RMapDto(8,"map8");

    rmap.put(dto1.getId(),dto1);
    rmap.putIfAbsent(dto2.getId(),dto2,5, TimeUnit.SECONDS);
    rmap.putIfAbsentAsync(dto3.getId(),dto3);
    rmap.putAsync(dto4.getId(),dto4);
    rmap.fastPut(dto5.getId(),dto5,10,TimeUnit.SECONDS);
    rmap.fastPutIfAbsent(dto6.getId(),dto6);
    rmap.fastPutAsync(dto7.getId(),dto7);
    rmap.fastPutIfAbsentAsync(dto8.getId(),dto8);

    Set<Integer> ss=rmap.keySet();
    Map<Integer,RMapDto> map=rmap.getAll(ss);
    log.info("元素列表：{} ",map);

    try {
        Thread.sleep(5000);
        Set<Integer> ss1=rmap.keySet();
        Map<Integer,RMapDto> map1=rmap.getAll(ss1);
        log.info("5s元素列表：{} ",map1);

        Thread.sleep(5000);
        Set<Integer> ss2=rmap.keySet();
        Map<Integer,RMapDto> map2=rmap.getAll(ss2);
        log.info("又5s元素列表：{} ",map2);

    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

元素列表：{1=RMapDto(id=1, name=map1), 2=RMapDto(id=2, name=map2), 3=RMapDto(id=3, name=map3), 4=RMapDto(id=4, name=map4), 5=RMapDto(id=5, name=map5), 6=RMapDto(id=6, name=map6), 7=RMapDto(id=7, name=map7), 8=RMapDto(id=8, name=map8)} 
5s后元素列表：{1=RMapDto(id=1, name=map1), 3=RMapDto(id=3, name=map3), 4=RMapDto(id=4, name=map4), 5=RMapDto(id=5, name=map5), 6=RMapDto(id=6, name=map6), 7=RMapDto(id=7, name=map7), 8=RMapDto(id=8, name=map8)} 
又5s后元素列表：{1=RMapDto(id=1, name=map1), 3=RMapDto(id=3, name=map3), 4=RMapDto(id=4, name=map4), 6=RMapDto(id=6, name=map6), 7=RMapDto(id=7, name=map7), 8=RMapDto(id=8, name=map8)} 
2020-11-27 20:09:40.398  INFO 14896 --- [extShutdownHook] o.s.s.concurrent.ThreadPoolTaskExecutor  : Shutting down ExecutorService 'applicationTaskExecutor'
Process finished with exit code 0

由最后的结果可见布隆过滤器的基本使用暂没出现什么问题

SpringBoot系列之集成Redisson实现布隆过滤器
Nicky's blog
04-11 670
在高并发和大数据量的场景下，布隆过滤器是一种非常高效的存储结构，可以用于快速判断一个元素是否存在于集合中。本文将介绍如何在Spring Boot中集成Redisson来实现布隆过滤器，并通过一个订单查询的示例来展示其应用。
布隆过滤器用Redisson实现的例子
fajing_feiyue的博客
07-18 3150
背景介绍 之前这边有写过关于布隆过滤器过滤器的安装使用，但是这次使用使用jrebloom来实现， jrebloom目前只提供一个maven依赖供我们使用。 考虑到后续代码维护，bug的修复。使用redisson来做布隆过滤器是更加安全做法。 下面是关于布隆过滤器的使用： 布隆过滤器的原理、redis布隆过滤器的安装和使用 代码实现 下面使用Redisson对布隆过滤器进行的封装。 1、引入maven依赖 <!-- https://mvnrepository.com/artifact/org.red
Redisson实现布隆过滤器
LiuQQ567的博客
01-24 1722
​ 布隆过滤器（Bloom Filter）是1970年由布隆提出的。它实际上是一个很长的二进制向量和一系列随机映射函数。布隆过滤器可以用于检索一个元素是否在一个集合中。它的优点是空间效率和查询时间都比一般的算法要好的多，缺点是有一定的误识别率和删除困难。​ 如果还是不太好理解的话，就可以把布隆过滤器理解为一个set集合，我们可以通过add往里面添加元素，通过contains来判断是否包含某个元素。
【Redis】布隆过滤器
人类所有真实的快乐，一定是恒久的努力
03-05 3894
布隆过滤器的简介、Redis的布隆过滤器的实现
使用 Redisson 实现布隆过滤器
weixin_56018532的博客
03-05 1595
作用：高效判断某个元素是否可能存在于集合中（存在“可能误判”，但“不存在”是确定的）。适用场景：缓存穿透防护、爬虫 URL 去重、防止重复请求等。特点空间效率高，但有一定误判率。不支持删除操作（需结合 Counting Bloom Filter）。
Redis之布隆过滤器
songzerong的博客
06-07 290
由一个二进制数组和一个Hash算法组成，是一个概率性的算法（若不在的元素，一定不存在；在的不一定在，主要是存在Hash冲突的可能），判断一个元素是否在一个集合中。使用场景如黑名单、邮件垃圾的过滤、爬虫网址判重。​ 缓存穿透问题：通过查询缓存不存在的key，采用架构设计时采取的兜底方案，强制必须去查询数据库，从而产生了缓存击穿。补充redis的布隆过滤器代码。
redis中布隆过滤器使用详解
弹指天下
03-27 5303
布隆过滤器的原理其实非常简单，就是bitmap + 多重hash，主要优势就是仅利用较小的空间就可以实现在大规模数据下快速判断某一对象是否存在，缺点是存在误判的可能，但不会漏判，也就是存在的对象一定会判断为存在，而不存在的对象会有较低的概率为误判为存在，且不支持对象的删除，因为会增加误判的概率。最典型的使用是解决`缓存穿透`的问题。
基于Redisson的Redis结合布隆过滤器使用
cristianoxm的博客
07-18 2211
布隆过滤器的误判是指多个输入经过哈希之后在相同的bit位置1了，这样就无法判断究竟是哪个输入产生的， 因此误判的根源在于相同的 bit 位被多次映射且置 1。这种情况也造成了布隆过滤器的删除问题，因为布隆过滤器的每一个 bit 并不是独占的，很有可能多个元素 共享了某一位。此时我们查询一个没添加过的不存在的字符串inexistent-key，它有可能计算后坑位也是1/3/5 ，这就是误判了。如果这些点， 有任何一个为零则被查询变量一定不在， 如果都是 1，则被查询变量很 可能存在。
Redis教程(十九)：Redis的Redisson布隆过滤器
十三月的博客
05-27 858
布隆过滤器（Bloom Filter）是一种空间效率极高的概率型数据结构，用于快速检测一个元素是否存在于一个集合中。由于其独特的特性，布隆过滤器可以在需要节省空间且可以接受一定误判率的场合下，非常有效地使用。
使用Redisson的布隆过滤器解决缓存穿透问题
hikktn的博客
10-23 586
以下是一个使用Redisson库的RBloomFilter来解决缓存穿透问题的Java代码示例。在这个示例中，我们会通过布隆过滤器预先过滤无效的请求，以减少对数据库的压力。通过使用Redisson的RBloomFilter，我们有效地避免了无效请求对数据库的冲击。这种方法非常适合于高并发场景下的缓存穿透问题，确保了系统的稳定性和性能。首先，确保在项目中引入Redisson依赖（在。
如何使用Redisson的布隆过滤器？
付聪
10-02 612
【代码】如何使用Redisson的布隆过滤器？
Redis实现布隆过滤器的方法及原理
09-08
布隆过滤器优点是空间效率和查询时间都比一般的算法要好的多，缺点是有一定的误识别率和删除困难。本文将介绍布隆过滤器的原理以及Redis如何实现布隆过滤器，感兴趣的朋友跟随小编一起看看吧
redis布隆过滤器的使用
xiaofeixiagg666的博客
06-06 2215
说起redis的布隆过滤器，很多人想到的就是解决redis的缓存穿透的问题，但是想想还会用到哪些应用场景吗？比如：我们看到的头条中新闻的推荐，如果是用户已经看过了这个新闻，不应该再推荐给用户才对？这个怎么实现？如果是单纯的去重，数据观看记录得记录下来，这个存储下来，在高并发的情况下，这个方案肯定不行的。很多人会说，使用缓存啊，那更不可可能，历史的数据都缓存起来，消耗很多物理资源，并且效率越来越差，数据越来越多。这个时候，你就可以考虑布隆过滤器来实现这个功能了。哈希表也能用于判断元素是否在集合中，但是布隆过滤
Redis--布隆过滤器--使用/原理/实例
IT利刃出鞘的博客
11-12 4392
本文介绍Redis的布隆过滤器的原理，优缺点，使用场景，实例。
【Redisson】Redisson--布隆(Bloom Filter)过滤器
DreamSun的博客
05-15 5554
布隆过滤器（Bloom Filter）是1970年由布隆提出的。它实际上是一个很长的二进制向量和一系列随机映射函数。布隆过滤器可以用于检索一个元素是否在一个集合中。它的优点是空间效率和查询时间都比一般的算法要好的多，缺点是有一定的误识别率和删除困难。​上面这句介绍比较全面的描述了什么是布隆过滤器，如果还是不太好理解的话，就可以把布隆过滤器理解为一个set集合，我们可以通过add往里面添加元素，通过contains来判断是否包含某个元素。
布隆过滤器
xiaocaij_icai的博客
10-03 774
通常我们会遇到很多要判断一个元素是否在某个集合中的业务场景，一般想到的是将集合中所有元素保存起来，然后通过比较确定。但是随着集合中元素的增加，我们需要的存储空间也会呈现线性增长，最终达到瓶颈。当有变量被加入集合时，通过 K 个映射函数将这个变量映射成位图中的 K 个点，把它们置为 1（假定有两个变量都通过 3 个映射函数）。在程序的世界中，布隆过滤器是程序员的一把利器，利用它可以快速地解决项目中一些比较棘手的问题。一个元素如果判断结果为存在的时候元素不一定存在，但是判断结果为不存在的时候则一定不存在。
Redis 之布隆过滤器(BloomFilter)
稚枭天卓
10-14 8924
1. 认识BloomFilter 1.1 原理 布隆过滤器，英文叫BloomFilter，可以说是一个二进制向量和一系列随机映射函数实现。 可以用于检索一个元素是否在一个集合中。 下面来看看布隆过滤器是如何判断元素在一个集合中，如下图: 有三个hash函数和一个位数组，oracle经过三个hash函数，得到第1、4、5位为1，database同理得到2、5、10位1，...
Redis布隆过滤器详解
怪咖@的博客
06-27 8205
布隆过滤器（Bloom Filter）是 Redis 4.0 版本提供的新功能，它被作为插件加载到 Redis 服务器中，给 Redis 提供强大的去重功能。相比于 Set 集合的去重功能而言，布隆过滤器在空间上能节省 90% 以上，但是它的不足之处是去重率大约在 99% 左右，也就是说有 1% 左右的误判率，这种误差是由布隆过滤器的自身结构决定的。俗话说“鱼与熊掌不可兼得”，如果想要节省空间，就需要牺牲 1% 的误判率，而且这种误判率，在处理海量数据时，几乎可以忽略。
Redis学习之Redisson布隆过滤器
我家有猫已长成的博客
05-14 3360
Redis学习之Redisson布隆过滤器 的简介。
java 布隆过滤器redisson
最新发布
03-16
<think>好的，用户想了解如何在Java中使用Redisson实现布隆过滤器。我需要先回忆一下布隆过滤器的基本概念和Redisson的相关知识。布隆过滤器是一种概率型数据结构，用于判断一个元素是否可能存在于集合中，可以有效地防止缓存穿透问题。Redisson是一个Java的Redis客户端，提供了许多分布式数据结构，包括布隆过滤器。 接下来，我需要整理用户提供的引用内容。引用[1]和[3]提到了Redisson的RBloomFilter类，引用[2]展示了使用Jedis的示例，但用户更关心的是Redisson的实现。引用[4]提到分片布隆过滤器的优化方法，可能需要考虑在示例中是否包含这部分内容，但用户主要请求的是基础教程和示例代码，所以分片可能作为优化部分提及。 用户需要教程、示例和代码，所以应该分步骤说明。首先，添加Redisson依赖，然后配置Redisson客户端，接着初始化布隆过滤器，添加元素和检查存在性。需要注意布隆过滤器的参数，如预期插入数量和误判率，这些参数会影响布隆过滤器的大小和哈希函数的数量。 需要确保代码示例正确，使用正确的类和方法。例如，Redisson的RBloomFilter需要指定名称、预期元素数量和误判概率。然后使用add方法添加元素，contains方法检查存在性。同时，要提醒用户布隆过滤器的特性，比如可能存在误判，删除元素困难，以及初始化后参数不能修改。 可能还需要比较Redisson的实现与其他方法，比如引用[2]中的Jedis实现，指出Redisson的优势，如更简洁的API和自动管理底层细节。此外，引用[4]提到的分片优化可以作为性能优化建议的一部分，但用户的问题主要是基础实现，所以可能放在注意事项或优化建议部分。 最后，生成相关问题，帮助用户进一步学习，比如性能调优、误判率计算、与其他过滤器的比较等。要确保问题相关且有引导性，帮助用户深入理解布隆过滤器的使用和优化。</think>### Redisson实现布隆过滤器教程 #### 一、实现步骤 1. **添加Redisson依赖** 在Maven项目中引入Redisson依赖： ```xml <dependency> <groupId>org.redisson</groupId> <artifactId>redisson</artifactId> <version>3.17.7</version> <!-- 使用最新版本 --> </dependency> ``` 2. **配置Redisson客户端** 创建与Redis服务器的连接配置： ```java Config config = new Config(); config.useSingleServer().setAddress("redis://localhost:6379"); RedissonClient redisson = Redisson.create(config); ``` 3. **初始化布隆过滤器** 设置预期插入元素数量和误判率（默认0.03）： ```java RBloomFilter<String> bloomFilter = redisson.getBloomFilter("userFilter"); bloomFilter.tryInit(1000000L, 0.01); // 参数：预期元素量，误判率 ``` 4. **添加元素与查询存在性** ```java bloomFilter.add("user:1001"); // 添加元素 boolean exists = bloomFilter.contains("user:1002"); // 检查存在性 ``` #### 二、完整代码示例 ```java import org.redisson.Redisson; import org.redisson.api.RBloomFilter; import org.redisson.api.RedissonClient; import org.redisson.config.Config; public class BloomFilterDemo { public static void main(String[] args) { // 1. 配置Redis连接 Config config = new Config(); config.useSingleServer().setAddress("redis://localhost:6379"); // 2. 创建客户端实例 RedissonClient redisson = Redisson.create(config); // 3. 初始化布隆过滤器（名称需唯一） RBloomFilter<String> bloomFilter = redisson.getBloomFilter("userFilter"); bloomFilter.tryInit(1000000L, 0.01); // 预期插入100万元素，1%误判率 // 4. 数据操作 bloomFilter.add("user:1001"); bloomFilter.add("user:1002"); System.out.println(bloomFilter.contains("user:1001")); // true System.out.println(bloomFilter.contains("user:9999")); // false // 5. 关闭连接 redisson.shutdown(); } } ``` #### 三、关键特性说明 1. **参数动态调整** 通过`tryInit()`设置的容量和误判率需在**首次初始化时确定**，后期不可修改[^3]。 2. **分布式特性** 所有客户端共享同一个Redis实例中的布隆过滤器状态，天然支持分布式环境[^1]。 3. **性能优化建议** - 分片存储：当数据量极大时采用多个布隆过滤器分片，降低单次操作延迟[^4] - 容量预估：初始容量建议设置为实际数据量的1.5-2倍 - 哈希优化：Redisson自动计算最优哈希函数数量 #### 四、典型应用场景 1. 缓存穿透防护（如商品ID预过滤） 2. 爬虫URL去重 3. 推荐系统内容排重
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值