1、配置类

  1. import com.google.common.base.Charsets;
  2. import com.google.common.hash.Funnel;
  3. import com.luban.common.constant.RedisKeyPrefixConst;
  4. import com.luban.mall.component.BloomRedisService;
  5. import com.luban.mall.service.PmsProductService;
  6. import com.luban.mall.util.BloomFilterHelper;
  7. import lombok.extern.slf4j.Slf4j;
  8. import org.springframework.beans.factory.InitializingBean;
  9. import org.springframework.beans.factory.annotation.Autowired;
  10. import org.springframework.context.annotation.Bean;
  11. import org.springframework.context.annotation.Configuration;
  12. import org.springframework.data.redis.core.RedisTemplate;
  13. import org.springframework.util.CollectionUtils;
  14. import java.util.List;
  16. @Slf4j
  17. @Configuration
  18. public class BloomFilterConfig implements InitializingBean{
  20.     @Autowired
  21.     private PmsProductService productService;
  23.     @Autowired
  24.     private RedisTemplate template;
  26.     @Bean
  27.     public BloomFilterHelper<String> initBloomFilterHelper() {
  28.         return new BloomFilterHelper<>((Funnel<String>) (from, into) -> into.putString(from, Charsets.UTF_8)
  29.                 .putString(from, Charsets.UTF_8), 1000000, 0.01);//误差率
  30.     }
  32. /**
  33.      * 布隆过滤器bean注入
  34.      * @return
  35.      */
  37.     @Bean
  38.     public BloomRedisService bloomRedisService(){
  39.         BloomRedisService bloomRedisService = new BloomRedisService();
  40.         bloomRedisService.setBloomFilterHelper(initBloomFilterHelper());
  41.         bloomRedisService.setRedisTemplate(template);
  42.         return bloomRedisService;
  43.     }
  45.     @Override
  46.     public void afterPropertiesSet() throws Exception {
  47.         List<Long> list = productService.getAllProductId();
  48.         log.info("加载产品到布隆过滤器当中,size:{}",list.size());
  49.         if(!CollectionUtils.isEmpty(list)){
  50.             list.stream().forEach(item->{
  51.               //  LocalBloomFilter.put(item);
  52.                bloomRedisService().addByBloomFilter(RedisKeyPrefixConst.PRODUCT_REDIS_BLOOM_FILTER,item+"");
  53.             });
  54.         }
  55.     }
  56. }

2、布隆拦截器

  2. import com.fasterxml.jackson.databind.ObjectMapper;
  3. import com.luban.common.api.CommonResult;
  4. import com.luban.common.constant.RedisKeyPrefixConst;
  5. import com.luban.mall.component.BloomRedisService;
  6. import lombok.extern.slf4j.Slf4j;
  7. import org.springframework.beans.factory.annotation.Autowired;
  8. import org.springframework.util.AntPathMatcher;
  9. import org.springframework.util.PathMatcher;
  10. import org.springframework.web.servlet.HandlerInterceptor;
  12. import javax.servlet.http.HttpServletRequest;
  13. import javax.servlet.http.HttpServletResponse;
  14. import java.util.Map;
  17. @Slf4j
  18. public class BloomFilterInterceptor implements HandlerInterceptor {
  20.     @Autowired
  21.     private BloomRedisService bloomRedisService;
  24.     @Override
  25.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
  26.         String currentUrl = request.getRequestURI();
  27.         PathMatcher matcher = new AntPathMatcher();
  28.         //解析出pathvariable
  29.         Map<String, String> pathVariable = matcher.extractUriTemplateVariables("/pms/productInfo/{id}", currentUrl);
  30.         //布隆过滤器存储在redis中
  31.         if(bloomRedisService.includeByBloomFilter(RedisKeyPrefixConst.PRODUCT_REDIS_BLOOM_FILTER,pathVariable.get("id"))){
  32.             return true;
  33.         }
  35.         /**
  36.          * 存储在本地jvm布隆过滤器中
  37.          */
  38.      /*   if(LocalBloomFilter.match(pathVariable.get("id"))){
  39.             return true;
  40.         }*/
  41.         /*
  42.          * 不在本地布隆过滤器当中，直接返回验证失败
  43.          * 设置响应头
  44.          */
  45.         response.setHeader("Content-Type","application/json");
  46.         response.setCharacterEncoding("UTF-8");
  47.         String result = new ObjectMapper().writeValueAsString(CommonResult.validateFailed("产品不存在!"));
  48.         response.getWriter().print(result);
  49.         return false;
  51.     }
  53. }

3、本地布隆过滤器（生产不用）

  1. import com.google.common.hash.BloomFilter;
  2. import com.google.common.hash.Funnels;
  4. import java.nio.charset.StandardCharsets;
  7. public class LocalBloomFilter {
  9.     private static final BloomFilter<String> bloomFilter = BloomFilter.create(Funnels.stringFunnel(StandardCharsets.UTF_8),1000000,0.01);
  11.     /**
  12.      * 谷歌guava布隆过滤器
  13.      * @param id
  14.      * @return
  15.      */
  16.     public static boolean match(String id){
  17.         return bloomFilter.mightContain(id);
  18.     }
  20.     public static void put(Long id){
  21.         bloomFilter.put(id+"");
  22.     }
  23. }

4、redis布隆

  2. import com.google.common.base.Preconditions;
  3. import com.luban.mall.util.BloomFilterHelper;
  4. import org.springframework.data.redis.core.RedisTemplate;
  6. public class BloomRedisService {
  8.     private RedisTemplate<String, Object> redisTemplate;
  10.     private BloomFilterHelper bloomFilterHelper;
  12.     public void setBloomFilterHelper(BloomFilterHelper bloomFilterHelper) {
  13.         this.bloomFilterHelper = bloomFilterHelper;
  14.     }
  16.     public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
  17.         this.redisTemplate = redisTemplate;
  18.     }
  20.     /**
  21.      * 根据给定的布隆过滤器添加值
  22.      */
  23.     public <T> void addByBloomFilter(String key, T value) {
  24.         Preconditions.checkArgument(bloomFilterHelper != null, "bloomFilterHelper不能为空");
  25.         int[] offset = bloomFilterHelper.murmurHashOffset(value);
  26.         for (int i : offset) {
  27.             redisTemplate.opsForValue().setBit(key, i, true);
  28.         }
  29.     }
  31.     /**
  32.      * 根据给定的布隆过滤器判断值是否存在
  33.      */
  34.     public <T> boolean includeByBloomFilter(String key, T value) {
  35.         Preconditions.checkArgument(bloomFilterHelper != null, "bloomFilterHelper不能为空");
  36.         int[] offset = bloomFilterHelper.murmurHashOffset(value);
  37.         for (int i : offset) {
  38.             if (!redisTemplate.opsForValue().getBit(key, i)) {
  39.                 return false;
  40.             }
  41.         }
  42.         return true;
  43.     }
  44. }

5、redis布隆依赖

  2. import com.google.common.base.Preconditions;
  3. import com.google.common.hash.Funnel;
  4. import com.google.common.hash.Hashing;
  6. /**
  7.  * 算法过程：
  8.  * 1. 首先需要k个hash函数，每个函数可以把key散列成为1个整数
  9.  * 2. 初始化时，需要一个长度为n比特的数组，每个比特位初始化为0
  10.  * 3. 某个key加入集合时，用k个hash函数计算出k个散列值，并把数组中对应的比特位置为1
  11.  * 4. 判断某个key是否在集合时，用k个hash函数计算出k个散列值，并查询数组中对应的比特位，如果所有的比特位都是1，认为在集合中。
  12.  **/
  13. public class BloomFilterHelper<T> {
  14.     private int numHashFunctions;
  16.     private int bitSize;
  18.     private Funnel<T> funnel;
  20.     public BloomFilterHelper(Funnel<T> funnel, int expectedInsertions, double fpp) {
  21.         Preconditions.checkArgument(funnel != null, "funnel不能为空");
  22.         this.funnel = funnel;
  23.         // 计算bit数组长度
  24.         bitSize = optimalNumOfBits(expectedInsertions, fpp);
  25.         // 计算hash方法执行次数
  26.         numHashFunctions = optimalNumOfHashFunctions(expectedInsertions, bitSize);
  27.     }
  29.     public int[] murmurHashOffset(T value) {
  30.         int[] offset = new int[numHashFunctions];
  32.         long hash64 = Hashing.murmur3_128().hashObject(value, funnel).asLong();
  33.         int hash1 = (int) hash64;
  34.         int hash2 = (int) (hash64 >>> 32);
  35.         for (int i = 1; i <= numHashFunctions; i++) {
  36.             int nextHash = hash1 + i * hash2;
  37.             if (nextHash < 0) {
  38.                 nextHash = ~nextHash;
  39.             }
  40.             offset[i - 1] = nextHash % bitSize;
  41.         }
  43.         return offset;
  44.     }
  46.     /**
  47.      * 计算bit数组长度
  48.      */
  49.     private int optimalNumOfBits(long n, double p) {
  50.         if (p == 0) {
  51.             // 设定最小期望长度
  52.             p = Double.MIN_VALUE;
  53.         }
  54.         return (int) (-n * Math.log(p) / (Math.log(2) * Math.log(2)));
  55.     }
  57.     /**
  58.      * 计算hash方法执行次数
  59.      */
  60.     private int optimalNumOfHashFunctions(long n, long m) {
  61.         return Math.max(1, (int) Math.round((double) m / n * Math.log(2)));
  62.     }
  63. }