redis 布隆过滤器

什么情况下需要布隆过滤器？

先来看几个比较常见的例子

• 字处理软件中，需要检查一个英语单词是否拼写正确
• 在 FBI，一个嫌疑人的名字是否已经在嫌疑名单上
• 在网络爬虫里，一个网址是否被访问过
• yahoo, gmail等邮箱垃圾邮件过滤功能

这几个例子有一个共同的特点： 如何判断一个元素是否存在一个集合中？

常规思路

• 数组
• 链表
• 树、平衡二叉树、Trie
• Map (红黑树)
• 哈希表

虽然上面描述的这几种数据结构配合常见的排序、二分搜索可以快速高效的处理绝大部分判断元素是否存在集合中的需求。但是当集合里面的元素数量足够大，如果有500万条记录甚至1亿条记录呢？这个时候常规的数据结构的问题就凸显出来了。数组、链表、树等数据结构会存储元素的内容，一旦数据量过大，消耗的内存也会呈现线性增长，最终达到瓶颈。有的同学可能会问，哈希表不是效率很高吗？查询效率可以达到O(1)。但是哈希表需要消耗的内存依然很高。使用哈希表存储一亿 个垃圾 email 地址的消耗？哈希表的做法：首先，哈希函数将一个email地址映射成8字节信息指纹；考虑到哈希表存储效率通常小于50%（哈希冲突）；因此消耗的内存：8 * 2 * 1亿 字节 = 1.6G 内存，普通计算机是无法提供如此大的内存。这个时候，布隆过滤器（Bloom Filter）就应运而生。在继续介绍布隆过滤器的原理时，先讲解下关于哈希函数的预备知识。

哈希函数

哈希函数的概念是：将任意大小的数据转换成特定大小的数据的函数，转换后的数据称为哈希值或哈希编码。下面是一幅示意图

可以明显的看到，原始数据经过哈希函数的映射后称为了一个个的哈希编码，数据得到压缩。哈希函数是实现哈希表和布隆过滤器的基础。

布隆过滤器介绍

• 巴顿.布隆于一九七零年提出
• 一个很长的二进制向量 （位数组）
• 一系列随机函数 (哈希)
• 空间效率和查询效率高
• 有一定的误判率（哈希表是精确匹配）

布隆过滤器原理

布隆过滤器（Bloom Filter）的核心实现是一个超大的位数组和几个哈希函数。假设位数组的长度为m，哈希函数的个数为k

以上图为例，具体的操作流程：假设集合里面有3个元素{x, y, z}，哈希函数的个数为3。首先将位数组进行初始化，将里面每个位都设置位0。对于集合里面的每一个元素，将元素依次通过3个哈希函数进行映射，每次映射都会产生一个哈希值，这个值对应位数组上面的一个点，然后将位数组对应的位置标记为1。查询W元素是否存在集合中的时候，同样的方法将W通过哈希映射到位数组上的3个点。如果3个点的其中有一个点不为1，则可以判断该元素一定不存在集合中。反之，如果3个点都为1，则该元素可能存在集合中。注意：此处不能判断该元素是否一定存在集合中，可能存在一定的误判率。可以从图中可以看到：假设某个元素通过映射对应下标为4，5，6这3个点。虽然这3个点都为1，但是很明显这3个点是不同元素经过哈希得到的位置，因此这种情况说明元素虽然不在集合中，也可能对应的都是1，这是误判率存在的原因。

什么是恶意流量穿透
假设我们的Redis里存有一组用户的注册email，以email作为Key存在，同时它对应着DB里的User表的部分字段。

一般来说，一个合理的请求过来我们会先在Redis里判断这个用户是否是会员，因为从缓存里读数据返回快。如果这个会员在缓存中不存在那么我们会去DB中查询一下。

现在试想，有千万个不同IP的请求（不要以为没有，我们就在2018年和2019年碰到了，因为攻击的成本很低）带着Redis里根本不存在的key来访问你的网站，这时我们来设想一下：

请求到达Web服务器；
请求派发到应用层->微服务层；
请求去Redis捞数据，Redis内不存在这个Key；
于是请求到达DB层，在DB建立connection后进行一次查询
千万乃至上亿的DB连接请求，先不说Redis是否撑的住DB也会被瞬间打爆。这就是“Redis穿透”又被称为“缓存击穿”，它会打爆你的缓存或者是连DB一起打爆进而引起一系列的“雪崩效应”。

怎么防
那就是使用布隆过滤器，可以把所有的user表里的关键查询字段放于Redis的bloom过滤器内。有人会说，这不疯了，我有4000万会员？so what！

你把4000会员放在Redis里是比较夸张，有些网站有8000万、1亿会员呢？因此我没让你直接放在Redis里，而是放在布隆过滤器内！

布隆过滤器内不是直接把key,value这样放进去的，它存放的内容是这么一个样的：

BloomFilter是一种空间效率的概率型数据结构，由Burton Howard Bloom 1970年提出的。通常用来判断一个元素是否在集合中。具有极高的空间效率，但是会带来假阳性(False positive)的错误。

False positive&&False negatives
由于BloomFiter牺牲了一定的准确率换取空间效率。所以带来了False positive的问题。

False positive
BloomFilter在判断一个元素在集合中的时候，会出现一定的错误率，这个错误率称为False positive的。通常缩写为fpp。

False negatives
BloomFilter判断一个元素不在集合中的时候的错误率。 BloomFilter判断该元素不在集合中，则该元素一定不再集合中。故False negatives概率为0。

BloomFilter使用长度为m bit的字节数组，使用k个hash函数，增加一个元素: 通过k次hash将元素映射到字节数组中k个位置中，并设置对应位置的字节为1。
查询元素是否存在: 将元素k次hash得到k个位置，如果对应k个位置的bit是1则认为存在，反之则认为不存在。

由于它里面存的都是bit，因此这个数据量会很小很小，小到什么样的程度呢？在写本博客时我插了100万条email信息进入Redis的bloom filter也只占用了3Mb不到。

Bloom Filter会有几比较关键的值，根据这个值你是大致可以算出放多少条数据然后它的误伤率在多少时会占用多少系统资源的。这个算法有一个网址：https://krisives.github.io/bloom-calculator/，我们放入100万条数据，假设误伤率在0.001%，看，它自动得出Redis需要申请的系统内存资源是多少？

那么怎么解决这个误伤率呢？很简单的，当有误伤时业务或者是运营会来报误伤率，这时你只要添加一个小白名单就是了，相对于100万条数据来说，1000个白名单不是问题。并且bloom filter的返回速度超块，80-100毫秒内即返回调用端该Key存在或者是不存了。
 

布隆过滤器的另一个用武场景
假设我用python爬虫爬了4亿条url，需要去重？

看，布隆过滤器就是用于这个场景的。

下面就开始我们的Redis BloomFilter之旅。

给Redis安装Bloom Filter
Redis从4.0才开始支持bloom filter，因此本例中我们使用的是Redis5.4。

Redis的bloom filter下载地址在这：https://github.com/RedisLabsModules/redisbloom.git

git clone https://github.com/RedisLabsModules/redisbloom.git
cd redisbloom
make # 编译
让Redis启动时可以加载bloom filter有两种方式：

手工加载式：

redis-server --loadmodule ./redisbloom/rebloom.so
每次启动自加载：

编辑Redis的redis.conf文件，加入：

loadmodule /soft/redisbloom/redisbloom.so
Like this:

在Redis里使用Bloom Filter
基本指令：

bf.reserve {key} {error_rate} {size}

127.0.0.1:6379> bf.reserve userid 0.01 100000
OK
上面这条命令就是：创建一个空的布隆过滤器，并设置一个期望的错误率和初始大小。{error_rate}过滤器的错误率在0-1之间，如果要设置0.1%，则应该是0.001。该数值越接近0，内存消耗越大，对cpu利用率越高。

bf.add {key} {item}

127.0.0.1:6379> bf.add userid '181920'
(integer) 1
上面这条命令就是：往过滤器中添加元素。如果key不存在，过滤器会自动创建。

bf.exists {key} {item}

127.0.0.1:6379> bf.exists userid '101310299'
(integer) 1
上面这条命令就是：判断指定key的value是否在bloomfilter里存在。存在：返回1，不存在：返回0。
 

正文
首先是pom.xml文件，加入我们这次使用redis & BloomFilter 的核心依赖包：

        <!--使用Redis-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!--借助guava的布隆过滤器-->
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>19.0</version>
        </dependency>
然后是yml的redis连接信息：

spring:
  redis:
    database: 3
    host: 127.0.0.1
    port: 6379
    password: 12345
    jedis.pool.max-idle: 100
    jedis.pool.max-wait: -1ms
    jedis.pool.min-idle: 2
    timeout: 2000ms
如果是一般的使用redis存字符串的话，使用StringRedisTemplate，就不需要配置序列化。
但是咱们这里使用的是RedisTemplate<String, Object> redisTemplate ，存储的是对象，所以为了防止存入的对象值在查看的时候不显示乱码，就需要配置相关的序列化（其实我们存的bit结构数据，布隆过滤器存值分分钟都是百万级别的，会因为数据量太大redis客户端也没办法显示，不过不影响使用）。

RedisConfig.class：

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.common.base.Charsets;
import com.google.common.hash.Funnel;
import com.jc.mytest.util.BloomFilterHelper;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
 
/**
 * @Author: JCccc
 * @CreateTime: 2018-09-11
 * @Description:
 */
 
@Configuration
@EnableCaching
public class RedisConfig {
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory connectionFactory) {
 
        RedisCacheManager rcm=RedisCacheManager.create(connectionFactory);
 
        return rcm;
    }
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
        redisTemplate.setConnectionFactory(factory);
 
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new
                Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        //序列化设置 ，这样计算是正常显示的数据，也能正常存储和获取
        redisTemplate.setKeySerializer(jackson2JsonRedisSerializer);
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashKeySerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
 
        return redisTemplate;
    }
    @Bean
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory factory) {
        StringRedisTemplate stringRedisTemplate = new StringRedisTemplate();
        stringRedisTemplate.setConnectionFactory(factory);
        return stringRedisTemplate;
    }
 
 
 
 
    //初始化布隆过滤器，放入到spring容器里面
    @Bean
    public BloomFilterHelper<String> initBloomFilterHelper() {
        return new BloomFilterHelper<>((Funnel<String>) (from, into) -> into.putString(from, Charsets.UTF_8).putString(from, Charsets.UTF_8), 1000000, 0.01);
    }
 
 
 
}

 
BloomFilterHelper .calss：

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;
        // 计算bit数组长度
        bitSize = optimalNumOfBits(expectedInsertions, fpp);
        // 计算hash方法执行次数
        numHashFunctions = optimalNumOfHashFunctions(expectedInsertions, bitSize);
    }
 
    public 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;
        }
        int sizeOfBitArray = (int) (-n * Math.log(p) / (Math.log(2) * Math.log(2)));
        return sizeOfBitArray;
    }
 
    /**
     * 计算hash方法执行次数
     */
    private int optimalNumOfHashFunctions(long n, long m) {
        int countOfHash = Math.max(1, (int) Math.round((double) m / n * Math.log(2)));
        return countOfHash;
    }
}

然后是具体的布隆过滤器配合redis使用的 方法类，RedisBloomFilter.class ：

import com.google.common.base.Preconditions;
import com.jc.mytest.util.BloomFilterHelper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
 
/**
 * @Author : JCccc
 * @CreateTime : 2020/4/23
 * @Description :
 **/
@Service
public class RedisBloomFilter {
    @Autowired
    private RedisTemplate redisTemplate;
 
    /**
     * 根据给定的布隆过滤器添加值
     */
    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) {
           System.out.println("key : " + key + " " + "value : " + i);
            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) {
            System.out.println("key : " + key + " " + "value : " + i);
            if (!redisTemplate.opsForValue().getBit(key, i)) {
                return false;
            }
        }
 
        return true;
    }
 
}

到这里，其实整合redis并使用BloomFilter布隆过滤器 的代码都已经完毕了。

存入值代码分析
在使用测试之前，稍微讲讲这里的流程、思路，我们把目光放到 存入值到布隆过滤器的方法addByBloomFilter上，

如果你了解过或者看过我文章开头说的那篇《JAVA 你应该有所了解的布隆过滤器》 ，那么你对这个方法的阅读就是一目了然。

红色框内的代码，就是把我们需要存入的value，通过算法计算出相关需要绑定 1的 bit位  的数组。

而蓝色框内的代码，就是将计算完得到的bit位数组，存入redis里面的bit结构里面，i就是数组内的bit位位置，每个都设置为true。

校验值代码分析

红色框内的代码，就是把我们需要校验的value，通过算法计算出相关需要绑定 1的 bit位  的数组。

而蓝色框内的代码，就是遍历计算完得到的bit位数组，检查在redis的bit结构里，是不是每一个都绑定了1（是不是都是true），

根据布隆过滤器的原则，只要有一个不是1（true），那么就是这个值不存在！

简单写两个接口，展示一下效果（测试直接写了两个get接口，没有结合其他业务逻辑）：

 

  @Autowired
    RedisBloomFilter redisBloomFilter;
    
    @Autowired
    private BloomFilterHelper bloomFilterHelper;
 
    @ResponseBody
    @RequestMapping("/add")
    public String addBloomFilter(@RequestParam ("orderNum") String orderNum) {
 
 
        try {
            redisBloomFilter.addByBloomFilter(bloomFilterHelper,"bloom",orderNum);
        } catch (Exception e) {
            e.printStackTrace();
            return "添加失败";
        }
 
        return "添加成功";
    }
 
    @ResponseBody
    @RequestMapping("/check")
    public boolean checkBloomFilter(@RequestParam ("orderNum") String orderNum) {
 
        boolean b = redisBloomFilter.includeByBloomFilter(bloomFilterHelper, "bloom", orderNum);
 
        return b;
    }

 

先调用存值接口：

可以看到对于 存入的值，order20200423 ，计算出来7个bit位，这些都设置成true了。

接下来调用一下校验值接口，可以看到同样的值order20200423  计算出来的bit位一样，而且redis里面都是true，所以返回了存在（但是咱们知道布隆过滤器年迈，对于存在的检测，会随着存入的数据量的增大而慢慢出现误判）：

那么咱们校验一个不存在的 值， 因为缓存穿透就是恶意查询不存在的值，例如id为 -1 这种情况（毕竟很多项目里，id的存值或者有一些key都是不考虑到负数的，而且接口还不做校验，所以-1基本不存在），

这时候布隆过滤器 校验结果，不存在！这个非常值得信赖，百分百是不存在的：

ps：

那么很多小伙伴是不是觉得布隆过滤器只能用来判断不存在 ，因为这个可信。 感觉有点不是滋味。

布隆过滤器因为保证效率，导致误判存在的情况的出现，这种情况其实也是能补救，解决方案思路很多，

我个人简单说一个，如果某个值判断存在，失误了，你发现了。 你可以把这个值存起来，例如就是一个误判列表那种，用redis的list结构也行。这样再加一层误判查询检索的逻辑环节，这样也是能起到一定程度的解决。 

毕竟100万条数据，出现误判总量也就1000条， 也就是误判列表也就存1000个数据。

具体需不需使用到它的判断存在？ 如果业务范围允许误判率跟布隆过滤器的误判率是相差不大的，也能使用。

对于一般的场景，咱们就是使用它来筛选不存在的值的。 因为它的 不存在 是肯定的。

OK，该篇就到此。