springboot Redis 布隆過濾器

一、布隆的定義是什么？

布隆過濾器（英語：Bloom Filter）是1970年由布隆提出的。它實際上是一個很長的二進制向量和一系列隨機映射函數。布隆過濾器可以
用於檢索一個元素是否在一個集合中。它的優點是空間效率和查詢時間都遠遠超過一般的算法，缺點是有一定的誤識別率和刪除困難。
Bloom Filter（BF）是一種空間效率很高的隨機數據結構，它利用位數組很簡潔地表示一個集合，並能判斷一個元素是否屬於這個集合。
它是一個判斷元素是否存在集合的快速的概率算法。Bloom Filter有可能會出現錯誤判斷，但不會漏掉判斷。也就是Bloom Filter判斷元
素不再集合，那肯定不在。如果判斷元素存在集合中，有一定的概率判斷錯誤。因此，Bloom Filter”不適合那些“零錯誤的應用場合。
而在能容忍低錯誤率的應用場合下，Bloom Filter比其他常見的算法（如hash，折半查找）極大節省了空間。

二、布隆的原理是什么

布隆過濾器的原理是，當一個元素被加入集合時，通過K個散列函數將這個元素映射成一個位數組中的K個點，把它們置為1。檢索時，我
們只要看看這些點是不是都是1就（大約）知道集合中有沒有它了：如果這些點有任何一個0，則被檢元素一定不在；如果都是1，則被檢
元素很可能在。這就是布隆過濾器的基本思想。
Bloom Filter跟單哈希函數Bit-Map不同之處在於：Bloom Filter使用了k個哈希函數，每個字符串跟k個bit對應。從而降低了沖突的概
率。

三、Bloom Filter的缺點
bloom filter，犧牲了判斷的准確率、刪除的便利性 
存在誤判，可能要查到的元素並沒有在容器中，但是hash之后得到的k個位置上值都是1。如果bloom filter中存儲的是黑名單，
那么可以通過建立一個白名單來存儲可能會誤判的元素。
刪除困難。一個放入容器的元素映射到bit數組的k個位置上是1，刪除的時候不能簡單的直接置為0，可能會影響其他元素的判
斷。可以采用Counting Bloom Filter

四、在springboot中怎么引用布隆

當然在此之前你需要配置RedisConfig並且引入對應的spring-data-redis的包

 

RedisService：

/**
 * 根據給定的布隆過濾器添加值
 */
public <T> void addByBloomFilter(BloomFilterHelper<T> bloomFilterHelper, String key, T value) {
    Preconditions.checkArgument(bloomFilterHelper != null, "bloomFilterHelper不能為空");
    int[] offset = bloomFilterHelper.murmurHashOffset(value);
    for (int i : offset) {
        redisTemplate.opsForValue().setBit(key, i, true);
    }
}

/**
 * 根據給定的布隆過濾器判斷值是否存在
 */
public <T> boolean includeByBloomFilter(BloomFilterHelper<T> bloomFilterHelper, String key, T value) {
    Preconditions.checkArgument(bloomFilterHelper != null, "bloomFilterHelper不能為空");
    int[] offset = bloomFilterHelper.murmurHashOffset(value);
    for (int i : offset) {
        if (!redisTemplate.opsForValue().getBit(key, i)) {
            return false;
        }
    }

    return true;
}

BloomFilterHelper：

package com.worken.saas.ebiz.heart.utils;

import com.google.common.base.Preconditions;
import com.google.common.hash.Funnel;
import com.google.common.hash.Hashing;

public class BloomFilterHelper <T> {

    private int numHashFunctions;

    private int bitSize;

    private Funnel<T> funnel;

    public BloomFilterHelper(Funnel<T> funnel, int expectedInsertions, double fpp) {
        Preconditions.checkArgument(funnel != null, "funnel不能為空");
        this.funnel = funnel;
        bitSize = optimalNumOfBits(expectedInsertions, fpp);
        numHashFunctions = optimalNumOfHashFunctions(expectedInsertions, bitSize);
    }

    int[] murmurHashOffset(T value) {
        int[] offset = new int[numHashFunctions];

        long hash64 = Hashing.murmur3_128().hashObject(value, funnel).asLong();
        int hash1 = (int) hash64;
        int hash2 = (int) (hash64 >>> 32);
        for (int i = 1; i <= numHashFunctions; i++) {
            int nextHash = hash1 + i * hash2;
            if (nextHash < 0) {
                nextHash = ~nextHash;
            }
            offset[i - 1] = nextHash % bitSize;
        }

        return offset;
    }

    /**
     * 計算bit數組長度
     */
    private int optimalNumOfBits(long n, double p) {
        if (p == 0) {
            p = Double.MIN_VALUE;
        }
        return (int) (-n * Math.log(p) / (Math.log(2) * Math.log(2)));
    }

    /**
     * 計算hash方法執行次數
     */
    private int optimalNumOfHashFunctions(long n, long m) {
        return Math.max(1, (int) Math.round((double) m / n * Math.log(2)));
    }

}

在應用的實現類中時候：

//預計插入量    100
//可接受的錯誤率 0.01  

private BloomFilterHelper<String> orderBloomFilterHelper = new BloomFilterHelper<>((Funnel<String>) (from, into) -> into.putString(from, Charsets.UTF_8)
        .putString(from, Charsets.UTF_8), 100 , 0.01);

/**
 * 看訂單是否包含在這個過濾器中
 */

redisService.includeByBloomFilter(orderBloomFilterHelper, "order", orderDetailDO.getOrderId())；

/**
 * 將訂單Id增加到過濾器中
 */

redisService.addByBloomFilter(orderBloomFilterHelper, "order", orderDetailDO.getOrderId());