高并发订单去重：布隆过滤器过滤已存在订单号的实战方案

m = - (n * ln p) / (ln 2)^2  （位数组长度）k = (m / n) * ln 2            （哈希函数数量）

<dependency>    <groupId>com.google.guava</groupId>    <artifactId>guava</artifactId>    <version>32.1.3-jre</version> <!-- 选择最新稳定版 --></dependency>

import com.google.common.base.Charsets;import com.google.common.hash.BloomFilter;import com.google.common.hash.Funnel;import com.google.common.hash.HashFunction;import com.google.common.hash.Hashing;import java.util.concurrent.ConcurrentHashMap;/** * 单机版订单号布隆过滤器（Guava实现） */public class OrderBloomFilter {    // 布隆过滤器实例（单例，避免重复创建）    private static final BloomFilter<String> ORDER_BLOOM_FILTER;        // 订单号漏斗（定义如何将订单号转换为哈希输入，需与哈希函数匹配）    private static final Funnel<String> ORDER_FUNNEL = (orderId, into) -> into.putString(orderId, Charsets.UTF_8);        // 静态初始化：按参数创建布隆过滤器    static {        long expectedInsertions = 200_000_000; // 预计插入2亿个订单号        double fpp = 0.001; // 误判率0.1%        // 创建布隆过滤器（使用MurmurHash3哈希函数）        ORDER_BLOOM_FILTER = BloomFilter.create(ORDER_FUNNEL, expectedInsertions, fpp);    }        // 禁止外部实例化    private OrderBloomFilter() {}        /**     * 添加订单号到布隆过滤器     * @param orderId 订单号     */    public static void addOrderId(String orderId) {        if (orderId == null || orderId.isEmpty()) {            throw new IllegalArgumentException("订单号不能为空");        }        ORDER_BLOOM_FILTER.put(orderId);    }        /**     * 判断订单号是否可能存在（true=可能存在，false=一定不存在）     * @param orderId 订单号     * @return 存在性判断     */    public static boolean mightContainOrderId(String orderId) {        if (orderId == null || orderId.isEmpty()) {            return false;        }        return ORDER_BLOOM_FILTER.mightContain(orderId);    }        // 测试示例    public static void main(String[] args) {        String orderId1 = "20251115123456789";        String orderId2 = "20251115987654321";                // 添加orderId1        OrderBloomFilter.addOrderId(orderId1);                // 判断存在性        System.out.println(OrderBloomFilter.mightContainOrderId(orderId1)); // true（存在）        System.out.println(OrderBloomFilter.mightContainOrderId(orderId2)); // false（不存在）    }}

/** * 订单服务（整合布隆过滤器） */@Servicepublic class OrderService {    @Autowired    private OrderMapper orderMapper; // 订单数据库DAO        /**     * 创建订单（先布隆过滤器过滤，再数据库校验）     */    public String createOrder(OrderDTO orderDTO) {        String orderId = generateOrderId(); // 生成订单号                // 步骤1：布隆过滤器快速判断        if (OrderBloomFilter.mightContainOrderId(orderId)) {            // 步骤2：可能存在，查数据库二次校验（解决误判）            OrderDO existOrder = orderMapper.selectByOrderId(orderId);            if (existOrder != null) {                throw new BusinessException("订单号已存在，请勿重复提交");            }        }                // 步骤3：订单不存在，创建订单        OrderDO orderDO = convertToOrderDO(orderDTO, orderId);        orderMapper.insert(orderDO);                // 步骤4：将新订单号添加到布隆过滤器        OrderBloomFilter.addOrderId(orderId);                return orderId;    }        // 生成订单号（时间戳+随机数，确保唯一）    private String generateOrderId() {        return new SimpleDateFormat("yyyyMMddHHmmss").format(new Date())                 + RandomUtils.nextInt(1000, 9999);    }}

# BF.RESERVE key error_rate capacity [EXPANSION expansion]# key=order_bloom_filter，error_rate=0.001（误判率），capacity=200000000（预计2亿订单）BF.RESERVE order_bloom_filter 0.001 200000000

import org.springframework.data.redis.core.RedisTemplate;import org.springframework.stereotype.Component;import javax.annotation.Resource;/** * 分布式订单号布隆过滤器（Redis实现） */@Componentpublic class RedisOrderBloomFilter {    // Redis布隆过滤器key    private static final String ORDER_BLOOM_KEY = "order:bloom:filter";    // 误判率（与Redis初始化时一致）    private static final double ERROR_RATE = 0.001;    // 预计订单数量（与Redis初始化时一致）    private static final long EXPECTED_ORDER_COUNT = 200_000_000;        @Resource    private RedisTemplate<String, String> redisTemplate;        /**     * 初始化Redis布隆过滤器（项目启动时执行一次）     */    public void initBloomFilter() {        // 判断过滤器是否已存在，不存在则初始化        Boolean exists = redisTemplate.hasKey(ORDER_BLOOM_KEY);        if (Boolean.FALSE.equals(exists)) {            // 调用BF.RESERVE命令初始化            redisTemplate.execute((connection) -> {                byte[] key = ORDER_BLOOM_KEY.getBytes();                return connection.execute("BF.RESERVE",                         key,                         String.valueOf(ERROR_RATE).getBytes(),                         String.valueOf(EXPECTED_ORDER_COUNT).getBytes());            }, true);        }    }        /**     * 添加订单号到Redis布隆过滤器     */    public void addOrderId(String orderId) {        if (orderId == null || orderId.isEmpty()) {            return;        }        // 调用BF.ADD命令添加        redisTemplate.execute((connection) -> {            byte[] key = ORDER_BLOOM_KEY.getBytes();            byte[] value = orderId.getBytes();            return connection.execute("BF.ADD", key, value);        }, true);    }        /**     * 判断订单号是否可能存在     */    public boolean mightContainOrderId(String orderId) {        if (orderId == null || orderId.isEmpty()) {            return false;        }        // 调用BF.EXISTS命令判断        return (Boolean) redisTemplate.execute((connection) -> {            byte[] key = ORDER_BLOOM_KEY.getBytes();            byte[] value = orderId.getBytes();            return connection.execute("BF.EXISTS", key, value);        }, true);    }}

@Servicepublic class DistributedOrderService {    @Autowired    private OrderMapper orderMapper;        @Autowired    private RedisOrderBloomFilter redisOrderBloomFilter;        @Autowired    private RedissonClient redissonClient; // 分布式锁，确保订单创建原子性        public String createOrder(OrderDTO orderDTO) {        String orderId = generateOrderId();        // 分布式锁：避免同一订单号被多个服务同时创建（双重保险）        RLock lock = redissonClient.getLock("order:create:" + orderId);        lock.lock(5, TimeUnit.SECONDS); // 锁超时5秒                try {            // 步骤1：Redis布隆过滤器判断            if (redisOrderBloomFilter.mightContainOrderId(orderId)) {                // 步骤2：数据库二次校验                OrderDO existOrder = orderMapper.selectByOrderId(orderId);                if (existOrder != null) {                    throw new BusinessException("订单号已存在");                }            }                        // 步骤3：创建订单            OrderDO orderDO = convertToOrderDO(orderDTO, orderId);            orderMapper.insert(orderDO);                        // 步骤4：添加到Redis布隆过滤器（Redis操作是原子的）            redisOrderBloomFilter.addOrderId(orderId);                        return orderId;        } finally {            lock.unlock(); // 释放锁        }    }}

// 冷加载示例（分批读取，每次1000条）public void loadHistoryOrderIds() {    long total = orderMapper.countAll();    long batchSize = 1000;    long batchNum = (total + batchSize - 1) / batchSize;        for (long i = 0; i < batchNum; i++) {        List<String> orderIds = orderMapper.selectOrderIdByPage(i * batchSize, batchSize);        for (String orderId : orderIds) {            redisOrderBloomFilter.addOrderId(orderId);        }        // 每批加载后休眠100ms，避免压垮Redis        try {            Thread.sleep(100);        } catch (InterruptedException e) {            Thread.currentThread().interrupt();        }    }}