布隆过滤器【1970年由布隆提出；Redis缓存穿透解决方案】

什么是布隆过滤器

布隆过滤器（Bloom Filter），是1970年，由一个叫布隆的小伙子提出的，距今已经五十年了。

它实际上是一个很长的二进制向量和一系列随机映射函数，二进制大家应该都清楚，存储的数据不是0就是1，默认是0。

主要用于判断一个元素是否在一个集合中，0代表不存在某个数据，1代表存在某个数据。

布隆过滤器用途

• 解决Redis缓存穿透

• 举例：在爬虫时，对爬虫网址进行过滤，已经存在布隆中的网址，不再爬取。

• 举例：垃圾邮件过滤，对每一个发送邮件的地址进行判断是否在布隆的黑名单中，如果在就判断为垃圾邮件。

布隆过滤器原理

存入过程
布隆过滤器上面说了，就是一个二进制数据的集合。当一个数据加入这个集合时，经历如下洗礼（这里有缺点，下面会讲）：

1. 通过K个哈希函数计算该数据，返回K个计算出的hash值
2. 这些K个hash值映射到对应的K个二进制的数组下标
3. 将K个下标对应的二进制数据改成1。

例如，第一个哈希函数返回x，第二个第三个哈希函数返回y与z，那么： X、Y、Z对应的二进制改成1。

查询过程

布隆过滤器主要作用就是查询一个数据，在不在这个二进制的集合中，查询过程如下：

1. 通过K个哈希函数计算该数据，对应计算出的K个hash值

2. 通过hash值找到对应的二进制的数组下标

3. 判断：如果存在一处位置的二进制数据是0，那么该数据不存在。如果都是1，该数据存在集合中。（这里有缺点，下面会讲）

删除过程

一般不能删除布隆过滤器里的数据，这是一个缺点之一，我们下面会分析。

布隆过滤器的优缺点

优点

由于存储的是二进制数据，所以占用的空间很小

它的插入和查询速度是非常快的，时间复杂度是O（K），可以联想一下HashMap的过程

保密性很好，因为本身不存储任何原始数据，只有二进制数据

缺点

这就要回到我们上面所说的那些缺点了。

添加数据是通过计算数据的hash值，那么很有可能存在这种情况：两个不同的数据计算得到相同的hash值。

例如图中的“你好”和“hello”，假如最终算出hash值相同，那么他们会将同一个下标的二进制数据改为1。这个时候，你就不知道下标为2的二进制，到底是代表“你好”还是“hello”。

由此得出如下缺点：

1. 存在误判
   假如上面的图没有存"hello"，只存了"你好"，那么用"hello"来查询的时候，会判断"hello"存在集合中。
   因为“你好”和“hello”的hash值是相同的，通过相同的hash值，找到的二进制数据也是一样的，都是1。

2. 删除困难
   还是用上面的举例，因为“你好”和“hello”的hash值相同，对应的数组下标也是一样的。
   这时候想去删除“你好”，连“hello”都一起删了。（0代表有这个数据，1代表没有这个数据）

实现布隆过滤器
有很多种实现方式，其中一种就是Guava提供的实现方式。

1. 引入Guava pom配置

<dependency>
  <groupId>com.google.guava</groupId>
  <artifactId>guava</artifactId>
  <version>29.0-jre</version>
</dependency>
 

import com.google.common.hash.BloomFilter;
import com.google.common.hash.Funnels;

public class BloomFilterCase {

  /**
   * 预计要插入多少数据
   */
  private static int size = 1000000;

  /**
   * 期望的误判率
   */
  private static double fpp = 0.01;

  /**
   * 布隆过滤器
   */
  private static BloomFilter<Integer> bloomFilter = BloomFilter.create(Funnels.integerFunnel(), size, fpp);


  public static void main(String[] args) {
    // 插入10万样本数据
    for (int i = 0; i < size; i++) {
      bloomFilter.put(i);
    }

    // 用另外十万测试数据，测试误判率
    int count = 0;
    for (int i = size; i < size + 100000; i++) {
      if (bloomFilter.mightContain(i)) {
        count++;
        System.out.println(i + "误判了");
      }
    }
    System.out.println("总共的误判数:" + count);
  }
}

深入分析代码

@VisibleForTesting
  static <T> BloomFilter<T> create(
      Funnel<? super T> funnel, long expectedInsertions, double fpp, Strategy strategy) {
    。。。。
}

参数

• funnel：数据类型(一般是调用Funnels工具类中的)
• expectedInsertions：期望插入的值的个数
• fpp：误判率(默认值为0.03)
• strategy：哈希算法

调整fpp误判率

情景一：fpp = 0.01

• 误判个数：947
  
• 占内存大小：9585058位数
  

情景总结

• 误判率可以通过fpp参数进行调节
• fpp越小，需要的内存空间就越大：0.01需要900多万位数，0.03需要700多万位数。
• fpp越小，集合添加数据时，就需要更多的hash函数运算更多的hash值，去存储到对应的数组下标里。（忘了去看上面的布隆过滤存入数据的过程）

Redis缓存穿透解决方案：布隆过滤器

首先，布孔过滤器类似于一个白名单、黑名单，主要元素就是判断元素存不存在一个过滤器中，核心在此。

白名单

场景：
前端发送一个查询请求，通过参数key，首先通过布隆过滤器，如果不存在过滤器（白名单）中，就会被过滤器给拦截，然后直接返回这个空数据给前端；如果key存在于过滤器中，就会往下执行正常的查Redis、mysql的流程；
这里有个流程4：如果mysql中查询不到这个key，说明什么？说明key在白名单中，单数MySQL查不到，也就是说布隆过滤器误判了！那么这个4路线就是打算把这个误判给删除，以防止下次重复同样的请求，但是由于布隆过滤器哈希碰撞导致删除很难（容易误伤），所以这个线路4是实际走不通的！
注意

1. 整体来说，由于我们前面说到布隆过滤器的误判概率是比较小的，所以直接打到MySQL的概率也就小，这种情况不用过于担心！
2. 所有合法参数key都要放到布隆过滤器、Redis中。

黑名单

场景:某视频网站推送视频给用户
布隆过滤器作用:当黑名单使用。
要求:已经推送过的视频,不在推送给用户
流程:当推送给用户一批视频时,先判断这些视频是否存在过滤器里,如果存在就不推送给用户,不存在就推送给用户,同时将推送过的视频存入过滤器黑名单里。防止下次重复推送。

代码：
用户实体类:

@Data
public class User implements Serializable {

    public static String maYunPhone = "18890019390";

    private Long id;
    
    private String userName;
    
    private Integer age;
    
}

/**
 * 解决缓存穿透—白名单
 */
public class RedissonBloomFilter {

    /**
     * 构造Redisson
     */
    static RedissonClient redisson = null;

    static RBloomFilter<String> bloomFilter = null;

    static {
      Config config = new Config();
      config.useSingleServer().setAddress("redis://127.0.0.1:6379");

      //构造Redisson
      redisson = Redisson.create(config);
      //构造布隆过滤器
      bloomFilter = redisson.getBloomFilter("userIdFilter");

      // 将查询数据放入Redis缓存和布隆过滤器里
      initData(redisson, bloomFilter);
  }
  
  public static void main(String[] args) {
    User user = getUserById(2L);
    System.out.println("user对象为：" + JSON.toJSONString(user));
  }
  
  private static void initData(RedissonClient redisson, RBloomFilter<String> bloomFilter) {

      //初始化布隆过滤器：预计元素为100000000L,误差率为3%
      bloomFilter.tryInit(100000000L,0.01);

      //将id为1的数据，插入到布隆过滤器中
      bloomFilter.add("1");
      bloomFilter.add("2");

      // 将id为1对应的user数据，插入到Redis缓存中
      redisson.getBucket("1").set("{id:1, userName:'张三', age:18}");
    }

    public static User getUserById(Long id) {

      if (null == id) {
          return null;
      }
      String idKey = id.toString();

      // 开始模拟缓存穿透
      // 前端查询请求key
      if (bloomFilter.contains(idKey)) {

          // 通过了过滤器白名单校验，去Redis里查询真正的数据
          RBucket<Object> bucket = redisson.getBucket(idKey);
          Object object = bucket.get();

          // 如果Redis有数据，直接返回该数据
          if (null != object) {
              System.out.println("从Redis里面查询出来的");
              String userStr = object.toString();
              return JSON.parseObject(userStr, User.class);
          }

          // 如果Redis为空，去查询数据库
          User user = selectByDb(idKey);
          if (null == user) {
              return null;
          } else {
              // 将数据重新刷进缓存
              redisson.getBucket(id.toString()).set(JSON.toJSONString(user));
          }
          return user;
      }

      return null;
    }

    private static User selectByDb(String id) {
      System.out.println("从MySQL里面查询出来的");
      User user = new User();
      user.setId(1L);
      user.setUserName("张三");
      user.setAge(18);
      return user;
    }

}

部分转载于：
https://www.cnblogs.com/itlaoge/p/14219693.html