# Docker方式（推薦）
docker run -p 6379:6379 --name redis-redisbloom redislabs/rebloom:latest
# 手動編譯
git clone https://github.com/RedisBloom/RedisBloom.git
cd RedisBloom
make
redis-server --loadmodule ./redisbloom.so

# 創(chuàng)建布隆過濾器
BF.RESERVE user_filter 0.001 1000000  # key, 誤判率0.1%, 容量100萬
# 添加元素
BF.ADD user_filter user:1001
BF.MADD user_filter user:1002 user:1003  # 批量添加
# 查詢元素
BF.EXISTS user_filter user:1001  # 返回1（可能存在）
BF.EXISTS user_filter user:9999  # 返回0（一定不存在）
# 查看過濾器信息
BF.INFO user_filter

<!-- pom.xml -->
<dependencies>
    <!-- Spring Boot Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- Spring Data Redis -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <!-- Redisson（包含布隆過濾器實現(xiàn)） -->
    <dependency>
        <groupId>org.redisson</groupId>
        <artifactId>redisson-spring-boot-starter</artifactId>
        <version>3.24.1</version>
    </dependency>
</dependencies>

# application.yml
spring:
  redis:
    host: localhost
    port: 6379
    database: 0
    # password: your_password  # 如有密碼需配置

import org.redisson.api.RBloomFilter;
import org.redisson.api.RedissonClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class BloomFilterConfig {
    @Bean
    public RBloomFilter<String> userBloomFilter(RedissonClient redissonClient) {
        // 獲取或創(chuàng)建布隆過濾器
        RBloomFilter<String> bloomFilter = redissonClient.getBloomFilter("userBloomFilter");
        // 初始化：預(yù)計元素數(shù)量100萬，誤判率0.1%
        bloomFilter.tryInit(1000000L, 0.001);
        return bloomFilter;
    }
    @Bean
    public RBloomFilter<Long> productBloomFilter(RedissonClient redissonClient) {
        RBloomFilter<Long> bloomFilter = redissonClient.getBloomFilter("productBloomFilter");
        bloomFilter.tryInit(500000L, 0.001);  // 50萬商品，誤判率0.1%
        return bloomFilter;
    }
}

import org.redisson.api.RBloomFilter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
@Component
public class BloomFilterInitializer implements CommandLineRunner {
    @Autowired
    private RBloomFilter<String> userBloomFilter;
    @Autowired
    private UserRepository userRepository;
    @Override
    public void run(String... args) throws Exception {
        // 應(yīng)用啟動時，將數(shù)據(jù)庫中的有效用戶ID預(yù)熱到布隆過濾器
        List<String> allUserIds = userRepository.findAllUserIds();
        for (String userId : allUserIds) {
            userBloomFilter.add(userId);
        }
        System.out.println("布隆過濾器預(yù)熱完成，已添加 " + allUserIds.size() + " 個用戶ID");
    }
}

import org.redisson.api.RBloomFilter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import java.util.concurrent.TimeUnit;
@Service
public class UserService {
    @Autowired
    private RBloomFilter<String> userBloomFilter;
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    @Autowired
    private UserRepository userRepository;
    // 緩存過期時間
    private static final long CACHE_EXPIRE_SECONDS = 30 * 60;  // 30分鐘
    /**
     * 三級防護(hù)：布隆過濾器 → Redis緩存 → 數(shù)據(jù)庫
     */
    public User getUserById(String userId) {
        // 1. 第一級：布隆過濾器預(yù)檢
        if (!userBloomFilter.contains(userId)) {
            // 布隆過濾器判定一定不存在，直接返回，避免穿透數(shù)據(jù)庫
            log.warn("布隆過濾器攔截?zé)o效用戶ID: {}", userId);
            return null;
        }
        // 2. 第二級：查詢Redis緩存
        String cacheKey = "user:" + userId;
        User user = (User) redisTemplate.opsForValue().get(cacheKey);
        if (user != null) {
            return user;  // 緩存命中，直接返回
        }
        // 3. 第三級：查詢數(shù)據(jù)庫
        user = userRepository.findById(userId).orElse(null);
        if (user != null) {
            // 數(shù)據(jù)庫存在，寫入Redis緩存
            redisTemplate.opsForValue().set(
                cacheKey, 
                user, 
                CACHE_EXPIRE_SECONDS, 
                TimeUnit.SECONDS
            );
        } else {
            // 數(shù)據(jù)庫不存在，緩存空值（短期），防止緩存穿透
            // 注意：這種情況是布隆過濾器誤判，實際數(shù)據(jù)不存在
            redisTemplate.opsForValue().set(
                cacheKey, 
                new User(),  // 空對象或特定標(biāo)記
                5,  // 短時間，如5分鐘
                TimeUnit.MINUTES
            );
        }
        return user;
    }
    /**
     * 新增用戶時，同步更新布隆過濾器
     */
    public void addUser(User user) {
        // 1. 保存到數(shù)據(jù)庫
        userRepository.save(user);
        // 2. 添加到布隆過濾器
        userBloomFilter.add(user.getId());
        // 3. 清除Redis緩存（如有）
        redisTemplate.delete("user:" + user.getId());
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/api/users")
public class UserController {
    @Autowired
    private UserService userService;
    @GetMapping("/{userId}")
    public ResponseEntity<?> getUser(@PathVariable String userId) {
        User user = userService.getUserById(userId);
        if (user == null) {
            return ResponseEntity.status(HttpStatus.NOT_FOUND)
                    .body(Result.error("用戶不存在"));
        }
        return ResponseEntity.ok(Result.success(user));
    }
    @PostMapping
    public ResponseEntity<?> createUser(@RequestBody User user) {
        userService.addUser(user);
        return ResponseEntity.ok(Result.success("用戶創(chuàng)建成功"));
    }
}

// 參數(shù)計算公式
public class BloomFilterCalculator {
    /**
     * 計算最優(yōu)位數(shù)組長度
     * @param n 預(yù)期元素數(shù)量
     * @param p 可接受誤判率
     */
    public static long optimalNumOfBits(long n, double p) {
        if (p == 0) {
            p = Double.MIN_VALUE;
        }
        return (long) (-n * Math.log(p) / (Math.log(2) * Math.log(2)));
    }
    /**
     * 計算最優(yōu)哈希函數(shù)個數(shù)
     * @param n 預(yù)期元素數(shù)量
     * @param m 位數(shù)組長度
     */
    public static int optimalNumOfHashFunctions(long n, long m) {
        return Math.max(1, (int) Math.round((double) m / n * Math.log(2)));
    }
}

@Service
public class BloomFilterMonitor {
    @Autowired
    private RedissonClient redissonClient;
    /**
     * 獲取布隆過濾器狀態(tài)
     */
    public Map<String, Object> getBloomFilterStatus(String filterName) {
        RBloomFilter<?> bloomFilter = redissonClient.getBloomFilter(filterName);
        Map<String, Object> status = new HashMap<>();
        status.put("name", filterName);
        status.put("expectedInsertions", bloomFilter.getExpectedInsertions());
        status.put("falseProbability", bloomFilter.getFalseProbability());
        status.put("size", bloomFilter.count());  // 實際插入數(shù)量
        // 計算當(dāng)前誤判率（估算）
        double currentErrorRate = calculateCurrentErrorRate(bloomFilter);
        status.put("currentErrorRate", currentErrorRate);
        return status;
    }
}

# 查看Redis中所有布隆過濾器
redis-cli keys "*bloom*"
# 查看特定過濾器信息
redis-cli BF.INFO userBloomFilter
# 手動添加測試數(shù)據(jù)
redis-cli BF.ADD userBloomFilter "test_user_001"
# 性能測試：批量查詢
redis-cli --pipe < query_commands.txt