Redis实现布隆过滤器缓存去重的"智能门卫"(实例详解)

import org.springframework.data.redis.core.stringredistemplate;
import java.nio.charset.standardcharsets;
import java.security.messagedigest;
import java.security.nosuchalgorithmexception;
/**
 * 基于redis bitmap手动实现布隆过滤器
 */
public class redisbloomfilter {
    // redis键名
    private final string key;
    // bit数组长度
    private final long bitsize;
    // 哈希函数个数
    private final int hashcount;
    private final stringredistemplate stringredistemplate;
    // 构造器：初始化参数
    public redisbloomfilter(string key, long n, double p, stringredistemplate stringredistemplate) {
        this.key = key;
        this.stringredistemplate = stringredistemplate;
        // 计算bit数组长度
        this.bitsize = (long) (-n * math.log(p) / (math.log(2) * math.log(2)));
        // 计算哈希函数个数
        this.hashcount = (int) (this.bitsize / n * math.log(2));
    }
    // 添加元素到布隆过滤器
    public void add(object value) {
        byte[] bytes = value.tostring().getbytes(standardcharsets.utf_8);
        long[] hashes = hash(bytes, hashcount, bitsize);
        for (long hash : hashes) {
            // 把对应bit位置置为1
            stringredistemplate.opsforvalue().setbit(key, hash, true);
        }
    }
    // 判断元素是否存在（存在返回true，不存在返回false；true可能是误判）
    public boolean contains(object value) {
        byte[] bytes = value.tostring().getbytes(standardcharsets.utf_8);
        long[] hashes = hash(bytes, hashcount, bitsize);
        for (long hash : hashes) {
            // 只要有一个bit位为0，就确定不存在
            if (!stringredistemplate.opsforvalue().getbit(key, hash)) {
                return false;
            }
        }
        return true;
    }
    // 多哈希函数实现（基于md5拆分）
    private long[] hash(byte[] bytes, int hashcount, long bitsize) {
        long[] hashes = new long[hashcount];
        try {
            messagedigest md5 = messagedigest.getinstance("md5");
            byte[] digest = md5.digest(bytes);
            // 把md5结果（16字节）拆分成多个哈希值
            for (int i = 0; i < hashcount; i++) {
                long hash = 0;
                for (int j = i * 2; j < (i + 1) * 2 && j < digest.length; j++) {
                    hash = hash * 256 + (digest[j] & 0xff);
                }
                // 确保哈希值在bit数组长度范围内
                hashes[i] = hash % bitsize;
            }
        } catch (nosuchalgorithmexception e) {
            throw new runtimeexception("哈希函数初始化失败", e);
        }
        return hashes;
    }
}

// 初始化布隆过滤器：key为"user:bloom:filter"，预估10万条数据，误判率0.01
redisbloomfilter bloomfilter = new redisbloomfilter("user:bloom:filter", 100000, 0.01, stringredistemplate);
// 添加元素
bloomfilter.add("user123");
bloomfilter.add("order456");
// 判断元素是否存在
boolean exists = bloomfilter.contains("user123"); // 大概率返回true
boolean notexists = bloomfilter.contains("user789"); // 一定返回false

<dependency>
    <groupid>org.redisson</groupid>
    <artifactid>redisson-spring-boot-starter</artifactid>
    <version>3.23.3</version> // 版本与redis版本适配
</dependency>

import org.redisson.api.rbloomfilter;
import org.redisson.api.redissonclient;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.stereotype.component;
@component
public class redissonbloomfilterdemo {
    @autowired
    private redissonclient redissonclient;
    // 初始化布隆过滤器
    public rbloomfilter<string> initbloomfilter() {
        // 布隆过滤器名称
        string filtername = "user:bloom:filter:redisson";
        // 获取布隆过滤器实例
        rbloomfilter<string> bloomfilter = redissonclient.getbloomfilter(filtername);
        // 初始化：预估10万条数据，误判率0.01（redisson会自动计算m和k）
        bloomfilter.tryinit(100000, 0.01);
        return bloomfilter;
    }
    // 测试使用
    public void testbloomfilter() {
        rbloomfilter<string> bloomfilter = initbloomfilter();
        // 添加元素
        bloomfilter.add("user123");
        bloomfilter.add("order456");
        // 判断元素是否存在
        boolean exists = bloomfilter.contains("user123"); // 大概率true
        boolean notexists = bloomfilter.contains("user789"); // 一定false
        // 统计已添加元素数量（近似值）
        long count = bloomfilter.count();
        system.out.println("已添加元素数量：" + count);
    }
}