Redis实现布隆过滤器的代码详解

# 下载
wget https://codeload.github.com/RedisBloom/RedisBloom/tar.gz/refs/tags/v2.2.18
# 解压
tar -zxvf v2.2.18

# 进入到解压目录
cd RedisBloom-2.2.18/
# 编译
make

# vim查看redis.conf
vim /opt/redis-stable/redis.conf
# 在文件后面加上如下配置
loadmodule /opt/RedisBloom-2.2.18/redisbloom.so

# 关闭redis
ps -ef | grep redis | awk -F" " '{print $2;}' | xargs kill -9
# 启动redis
/opt/redis-stable/src/redis-server redis.conf
# 连接客户端
/opt/redis-stable/src/redis-cli -c -h 127.0.0.1 -p 6379 -a 123456

127.0.0.1:6379> bf.add spider:url www.baidu.net
(integer) 1
127.0.0.1:6379> bf.exists spider:url www.baidu.net
(integer) 1
127.0.0.1:6379> bf.madd spider:url www.taobao.com www.123qq.com
1) (integer) 1
2) (integer) 1
127.0.0.1:6379> bf.mexists spider:url www.jd.com www.taobao.com
1) (integer) 0
2) (integer) 1

<dependency>
	<groupId>redis.clients</groupId>
	<artifactId>jedis</artifactId>
	<version>3.9.0</version>
</dependency>
<dependency>
	<groupId>com.redislabs</groupId>
	<artifactId>jrebloom</artifactId>
	<version>2.2.2</version>
</dependency>

import io.rebloom.client.Client;
import redis.clients.jedis.Jedis;
public class JrebloomDemo {
    public static void main(String[] args) {
        //连接本地的 Redis 服务
        Jedis jedis = new Jedis("192.168.115.239", 6379);
        //jedis.auth("123456");
        //创建client也支持连接池的:public Client(Pool<Jedis> pool)
        Client client = new Client(jedis);
        // 测试数据
        int capacity = 10000;
        // 容错率,只能设置0 < error rate range < 1  不然直接会异常！
        double errorRate = 0.01;
        // 测试的key值
        String key = "ceshi";
        // 创建过滤器:可以创建指定位数和容错率的布隆过滤器,如果过滤器已经存在创建的话就会异常
        if (!jedis.exists(key)) {
            client.createFilter(key, capacity, errorRate);
        }
        for (int i = 0; i < capacity; i++) {
            client.bfInsert(key, String.valueOf(i));
        }
        System.out.println("存入元素为=={" + capacity + "}");
        // 统计误判次数
        int count = 0;
        // 我在数据范围之外的数据，测试相同量的数据，判断错误率是不是符合我们当时设定的错误率
        for (int i = capacity; i < capacity * 2; i++) {
            if (client.exists(key, String.valueOf(i))) {
                count++;
            }
        }
        System.out.println("误判元素为=={" + count + "}");
        // 删除过滤器
        client.delete(key);
    }
}

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

import org.redisson.Redisson;
import org.redisson.api.RBloomFilter;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
public class RedissonBloomFilter {
    public static void main(String[] args) {
        Config config = new Config();
        config.useSingleServer()
                .setAddress("redis://127.0.0.1:6379")
                //.setPassword("123456")
                .setDatabase(0);
        //获取客户端
        RedissonClient redissonClient = Redisson.create(config);
        // 测试数据
        int capacity = 10000;
        // 容错率,只能设置0 < error rate range < 1  不然直接会异常！
        double errorRate = 0.01;
        // 测试的key值
        String key = "ceshi";
        RBloomFilter<String> bloomFilter = redissonClient.getBloomFilter(key);
        // 初始化布隆过滤器，预计统计元素数量为10000，期望误差率为0.01
        bloomFilter.tryInit(capacity, errorRate);
        for (long i = 0; i < capacity; i++) {
            bloomFilter.add(String.valueOf(i));
        }
        System.out.println("存入元素为=={" + capacity + "}");
        // 统计误判次数
        int count = 0;
        // 我在数据范围之外的数据，测试相同量的数据，判断错误率是不是符合我们当时设定的错误率
        for (int i = capacity; i < capacity * 2; i++) {
            if (bloomFilter.contains(String.valueOf(i))) {
                count++;
            }
        }
        System.out.println("误判元素为=={" + count + "}");
        // 删除过滤器
        // bloomFilter.delete();
    }
}