• Redis的BitMap实现分布式布隆过滤器

    布隆过滤器（Bloom Filter）是一种高效的概率型数据结构，用于判断一个元素是否属于一个集合。它通过使用哈希函数和位数组来存储和查询数据，具有较快的插入和查询速度，并且占用空间相对较少。

    引入依赖

    1. <!--切面-->
    2. <dependency>
    3.    <groupId>org.springframework.boot</groupId>
    4.    <artifactId>spring-boot-starter-aop</artifactId>
    5. </dependency>
    6.  <dependency>
    7.    <groupId>org.springframework.boot</groupId>
    8.    <artifactId>spring-boot-starter-data-redis</artifactId>
    9. </dependency>
    10.  <!-- 数据库-->
    11. <dependency>
    12.    <groupId>mysql</groupId>
    13.    <artifactId>mysql-connector-java</artifactId>
    14.    <version>${mysql.version}</version>
    15. </dependency>
    16. <dependency>
    17.    <groupId>com.baomidou</groupId>
    18.    <artifactId>mybatis-plus-boot-starter</artifactId>
    19.    <version>3.5.1</version>
    20. </dependency>

    properties配置

    1. spring.datasource.url=jdbc:mysql://127.0.0.1:3306/itcast?serverTimezone=GMT%2B8&useUnicode=true&logger=Slf4JLogger&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true
    2. spring.datasource.username=root
    3. spring.datasource.password=root123
    4. spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
    5. spring.datasource.hikari.pool-name=HikariCPDatasource
    6. spring.datasource.hikari.minimum-idle=5
    7. spring.datasource.hikari.idle-timeout=180000
    8. spring.datasource.hikari.maximum-pool-size=10
    9. spring.datasource.hikari.auto-commit=true
    10. spring.datasource.hikari.max-lifetime=1800000
    11. spring.datasource.hikari.connection-timeout=30000
    12. spring.datasource.hikari.connection-test-query=SELECT 1
    13. mybatis-plus.configuration.log-impl= org.apache.ibatis.logging.stdout.StdOutImpl
    14. spring.redis.host=127.0.0.1
    15. spring.redis.port=6379
    16. spring.redis.timeout=10s
    17. spring.redis.password=123

    自定义注解

    1.  
    2. import java.lang.annotation.Documented;
    3. import java.lang.annotation.ElementType;
    4. import java.lang.annotation.Inherited;
    5. import java.lang.annotation.Retention;
    6. import java.lang.annotation.RetentionPolicy;
    7. import java.lang.annotation.Target;
    8.  
    9. /**
    10.  * 此注解可作用于控制器方法，或者服务类方法
    11.  *
    12.  * 使用示例，在目标方法上添加如下注解
    13.  * 
    14.  *     BitMap(key = "user", id = "#id")
    15.  * 
  •  **/
  • @Target(ElementType.METHOD)
  • @Retention(RetentionPolicy.RUNTIME)
  • @Documented
  • @Inherited
  • public @interface BitMap {
  •     /**
  •      * 
    同一类集合的唯一标识符 商品表、订单表分别设置不同key
  •      */
  •     String key();
  •  
  •     /**
  •      * 支持{@code SPEL}表达式
  •      * 含义是以被调用方法参数id的值作为主键ID
  •      */
  •     String id() default "#id";
  • }
    •  

    切面
     

    1. import com.example.demo.annotation.BitMap;
    2. import com.example.demo.util.ParserUtils;
    3. import com.example.demo.util.RedisBitMapUtils;
    4. import com.example.demo.util.ResponseResult;
    5. import org.aspectj.lang.ProceedingJoinPoint;
    6. import org.aspectj.lang.annotation.Around;
    7. import org.aspectj.lang.annotation.Aspect;
    8. import org.aspectj.lang.annotation.Pointcut;
    9. import org.aspectj.lang.reflect.MethodSignature;
    10. import org.slf4j.Logger;
    11. import org.slf4j.LoggerFactory;
    12. import org.springframework.stereotype.Component;
    13.  
    14.  
    15. import javax.annotation.Resource;
    16. import java.lang.reflect.Method;
    17. import java.util.TreeMap;
    18.  
    19. /**
    20.  * Redis BitMap AOP
    21.  **/
    22. @Aspect
    23. @Component
    24. public class BitMapAspect {
    25.     private static final Logger logger = LoggerFactory.getLogger(BitMapAspect.class);
    26.  
    27.     @Resource
    28.     private RedisBitMapUtils redisBitMapUtils;
    29.  
    30.     @Pointcut("@annotation(com.example.demo.annotation.BitMap)")
    31.     public void aspect() {
    32.  
    33.     }
    34.  
    35.     @Around("aspect()")
    36.     public Object doAround(ProceedingJoinPoint point) throws Throwable {
    37.         // 通过 point 对象获取方法签名信息。
    38.         MethodSignature signature = (MethodSignature) point.getSignature();
    39.         // 通过方法签名获取当前方法对象。
    40.         Method method = signature.getMethod();
    41.         // 获取当前方法上的 BitMap 注解。
    42.         BitMap annotation = method.getAnnotation(BitMap.class);
    43.         // 获取方法参数名和参数值的映射关系，并将结果保存到TreeMap中。
    44.         TreeMap map = ParserUtils.createTreeMap(point, signature);
    45.         // 从参数映射中获取 id 参数对应的值。
    46.         String idString = ParserUtils.parse(annotation.id(), map);
    47.         if (idString != null) {
    48.             long id = Long.parseLong(idString);
    49.  
    50.             if (redisBitMapUtils.isPresent(annotation.key(), id)) {
    51.                 return point.proceed();
    52.             } else {
    53.                 logger.info(String.format("当前主键ID{%d}不存在", id));
    54.                 return method.getReturnType().equals(ResponseResult.class) ? ResponseResult.okResult() : null;
    55.             }
    56.         }
    57.         throw new RuntimeException("主键ID解析不正确，请按照参考格式书写");
    58.     }
    59.  
    60. }
     

    RedisBitMap工具类
     

    1. import org.slf4j.Logger;
    2. import org.slf4j.LoggerFactory;
    3. import org.springframework.data.redis.core.StringRedisTemplate;
    4. import org.springframework.data.redis.core.ValueOperations;
    5. import org.springframework.stereotype.Component;
    6.  
    7. import javax.annotation.PostConstruct;
    8. import javax.annotation.Resource;
    9. import java.io.Serializable;
    10. import java.util.Collection;
    11. import java.util.Collections;
    12. import java.util.List;
    13. import java.util.Objects;
    14. import java.util.function.Function;
    15. import java.util.function.Supplier;
    16. import java.util.stream.Collectors;
    17.  
    18. /**
    19.  * {@link RedisBitMapUtils}工具类
    20.  */
    21. @Component
    22. public class RedisBitMapUtils {
    23.     private static final Logger logger = LoggerFactory.getLogger(RedisBitMapUtils.class);
    24.     @Resource
    25.     private   StringRedisTemplate stringRedisTemplate ;
    26.     ValueOperations opsForValue;
    27.  
    28.     @PostConstruct
    29.     public  void init() {
    30.         opsForValue= stringRedisTemplate.opsForValue();
    31.     }
    32.  
    33.  
    34.     /**
    35.      * 该方法可以方便地将一个集合中的每个元素根据给定的映射函数进行转换，
    36.      * 并返回一个新的列表。如果集合为空或为null，则返回一个空列表。
    37.      * @param list
    38.      * @param action
    39.      * @return
    40.      * @param 
    41.      * @param 
    42.      */
    43.     public   List toList(final Collection list, final Functionsuper T, ? extends R> action) {
    44.         Objects.requireNonNull(action);
    45.         if (Objects.nonNull(list)) {
    46.             return list.stream().map(action).collect(Collectors.toList());
    47.         }
    48.         return Collections.emptyList();
    49.     }
    50.     /**
    51.      * 
      本方法在首次初始化以{@code key}为参数的BitMap时执行
    52.      * 
      首先删除Key 然后重新构建BitMap
    53.      *
    54.      * @param  主键类型
    55.      * @param key 每种业务分别对应不同的Key名称
    56.      * @param ids 主键ID
    57.      */
    58.     public  extends Serializable> void init(String key, Collection ids) {
    59.         remove(key);
    60.         setBit(key, ids);
    61.     }
    62.  
    63.     /**
    64.      * 
      本方法在首次初始化以{@code key}为参数的BitMap时执行
    65.      * 
      首先删除Key 然后重新构建BitMap
    66.      *
    67.      * @param key    每种业务分别对应不同的Key名称
    68.      * @param list   实体类对象集合
    69.      * @param action 主键列（方法引用表示）
    70.      * @param     实体类泛型
    71.      * @param     主键列泛型
    72.      */
    73.     public  extends Serializable> void init(String key, Collection list, Function action) {
    74.         List ids = toList(list, action);
    75.         init(key, ids);
    76.     }
    77.  
    78.     /**
    79.      * 检查当前主键ID在Redis BitMap中是否存在 如果存在则执行函数式回调
    80.      *
    81.      * @param key 每种业务分别对应不同的Key名称
    82.      * @param id  主键ID
    83.      * @return {@code R}实例
    84.      */
    85.     public  extends Serializable, R> R ifPresent(String key, T id, Function action) {
    86.         if (getBit(key, id)) {
    87.             return action.apply(id);
    88.         }
    89.         return null;
    90.     }
    91.  
    92.     /**
    93.      * 检查当前主键ID在Redis BitMap中是否存在 如果存在则执行函数式回调
    94.      *
    95.      * @param key 每种业务分别对应不同的Key名称
    96.      * @param id  主键ID
    97.      * @return {@code R}实例
    98.      */
    99.     public  extends Serializable, R> R ifPresent(String key, T id, Supplier supplier) {
    100.         if (getBit(key, id)) {
    101.             return supplier.get();
    102.         }
    103.         return null;
    104.     }
    105.  
    106.     /**
    107.      * 检查当前主键ID在Redis BitMap中是否存在 如果存在则返回true
    108.      *
    109.      * @param key 每种业务分别对应不同的Key名称
    110.      * @param id  主键ID
    111.      * @return 如果存在则返回true
    112.      */
    113.     public  extends Serializable> boolean isPresent(String key, T id) {
    114.         return getBit(key, id);
    115.     }
    116.  
    117.     /**
    118.      * 检查当前主键ID在Redis BitMap中是否存在 如果存在则返回true
    119.      * 本方法是{@link RedisBitMapUtils#getBit(String, Serializable)}的别名方法 方便对外调用
    120.      *
    121.      * @param key 每种业务分别对应不同的Key名称
    122.      * @param id  主键ID
    123.      * @return 如果存在则返回true
    124.      */
    125.     public  extends Serializable> boolean checkId(String key, T id) {
    126.         return getBit(key, id);
    127.     }
    128.  
    129.  
    130.     /**
    131.      * 检查当前主键ID（集合）在Redis BitMap中是否存在 只返回存在的主键ID
    132.      * 本方法是{@link RedisBitMapUtils#getBit(String, Serializable)}的别名方法 方便对外调用
    133.      *
    134.      * @param key 每种业务分别对应不同的Key名称
    135.      * @param ids 主键ID
    136.      * @return 返回存在的主键ID
    137.      */
    138.     public  extends Serializable> List checkIds(String key, Collection ids) {
    139.         return ids.stream().filter(e -> checkId(key, e)).collect(Collectors.toList());
    140.     }
    141.  
    142.     /**
    143.      * 向Redis BitMap中保存主键ID
    144.      *
    145.      * @param key 每种业务分别对应不同的Key名称
    146.      * @param id  主键ID
    147.      */
    148.     public  extends Serializable> void setBit(String key, T id) {
    149.         ifOffsetValid(Objects.hash(id), e -> opsForValue.setBit(key, e, true));
    150.     }
    151.  
    152.     /**
    153.      * 向Redis BitMap中批量保存主键ID
    154.      *
    155.      * @param  主键类型
    156.      * @param key 每种业务分别对应不同的Key名称
    157.      * @param ids 主键ID
    158.      */
    159.     public  extends Serializable> void setBit(String key, Collection ids) {
    160.         ids.forEach(id -> ifOffsetValid(Objects.hash(id), e -> opsForValue.setBit(key, e, true)));
    161.     }
    162.  
    163.     /**
    164.      * 检查当前主键ID在Redis BitMap中是否存在 如果存在则返回true
    165.      *
    166.      * @param key 每种业务分别对应不同的Key名称
    167.      * @param id  主键ID
    168.      * @return 如果存在则返回true
    169.      */
    170.     public  extends Serializable> boolean getBit(String key, T id) {
    171.         return ifOffsetValid(Objects.hash(id), e -> opsForValue.getBit(key, e));
    172.     }
    173.  
    174.  
    175.     /**
    176.      * 从Redis BitMap中删除当前主键ID
    177.      *
    178.      * @param key 每种业务分别对应不同的Key名称
    179.      * @param id  主键ID
    180.      */
    181.     public  extends Serializable> void removeBit(String key, T id) {
    182.         ifOffsetValid(Objects.hash(id), e -> opsForValue.setBit(key, e, false));
    183.     }
    184.  
    185.     /**
    186.      * 从Redis BitMap中批量删除主键ID
    187.      *
    188.      * @param key 每种业务分别对应不同的Key名称
    189.      * @param ids 主键ID
    190.      * @param  主键类型
    191.      */
    192.     public  extends Serializable> void removeBit(String key, Collection ids) {
    193.         ids.forEach(id -> ifOffsetValid(Objects.hash(id), e -> opsForValue.setBit(key, e, false)));
    194.     }
    195.  
    196.  
    197.     /**
    198.      * 将当前分类下的BitMap Key删除
    199.      * 清空该Key下所有数据
    200.      */
    201.     public  void remove(String key) {
    202.         stringRedisTemplate.delete(key);
    203.  
    204.     }
    205.  
    206.     /**
    207.      * 
      检查偏移量是否合法
    208.      * 
      Redis字符串支持字符串最大长度512M，因此支持offset的最大值为(2^32)-1
    209.      *
    210.      * @param offset 偏移量
    211.      * @param action 映射规则
    212.      */
    213.     private static extends Number> Boolean ifOffsetValid(N offset, Function action) {
    214.         Objects.requireNonNull(action);
    215.  
    216.         //如果ID用整型表示 那么正整数范围内所有的ID均有效 最大正整数值为2147483647 约为20亿
    217.         long max = (1L << 32) - 1;
    218.         if (offset.intValue() >= 0 && offset.intValue() < Integer.MAX_VALUE) {
    219.             return action.apply(offset);
    220.         } else {
    221.             // 如果偏移量类型为长整型，或者整型范围内的最大值小于0且 offset 的值小于等于 max
    222.             if (Integer.MAX_VALUE >= 0 && offset.longValue() <= max) {
    223.                 return action.apply(offset);
    224.             } else {
    225.                 logger.info(String.format("偏移量{%d}越界[0,%s]，本次操作不成功！", offset.longValue(), max));
    226.                 return false;
    227.             }
    228.         }
    229.  
    230.     }
    231. }
     

    response工具类
     

    1.  
    2. import lombok.Data;
    3.  
    4. import java.io.Serializable;
    5. @Data
    6. public class ResponseResult implements Serializable {
    7.     private Boolean success;
    8.     private Integer code;
    9.     private String msg;
    10.     private T data;
    11.  
    12.     public ResponseResult() {
    13.         this.success=true;
    14.         this.code = HttpCodeEnum.SUCCESS.getCode();
    15.         this.msg = HttpCodeEnum.SUCCESS.getMsg();
    16.     }
    17.  
    18.     public ResponseResult(Integer code, T data) {
    19.         this.code = code;
    20.         this.data = data;
    21.     }
    22.  
    23.     public ResponseResult(Integer code, String msg, T data) {
    24.         this.code = code;
    25.         this.msg = msg;
    26.         this.data = data;
    27.     }
    28.  
    29.     public ResponseResult(Integer code, String msg) {
    30.         this.code = code;
    31.         this.msg = msg;
    32.     }
    33.  
    34.     public static ResponseResult errorResult(int code, String msg) {
    35.         ResponseResult result = new ResponseResult();
    36.         return result.error(code, msg);
    37.     }
    38.  
    39.     public static ResponseResult okResult() {
    40.         ResponseResult result = new ResponseResult();
    41.         return result;
    42.     }
    43.  
    44.     public static ResponseResult okResult(int code, String msg) {
    45.         ResponseResult result = new ResponseResult();
    46.         return result.ok(code, null, msg);
    47.     }
    48.  
    49.  
    50.  
    51.  
    52.     public static ResponseResult setHttpCodeEnum(HttpCodeEnum enums) {
    53.         return okResult(enums.getCode(), enums.getMsg());
    54.     }
    55.  
    56.     public static  ResponseResult error(String message) {
    57.         return new ResponseResult(HttpCodeEnum.SYSTEM_ERROR.getCode(),  message);
    58.     }
    59.  
    60.     public ResponseResult error(Integer code, String msg) {
    61.         this.success=false;
    62.         this.code = code;
    63.         this.msg = msg;
    64.         return this;
    65.     }
    66.  
    67.     public ResponseResult ok(Integer code, T data) {
    68.         this.success=true;
    69.         this.code = code;
    70.         this.data = data;
    71.         return this;
    72.     }
    73.  
    74.     public ResponseResult ok(Integer code, T data, String msg) {
    75.         this.success=true;
    76.         this.code = code;
    77.         this.data = data;
    78.         this.msg = msg;
    79.         return this;
    80.     }
    81.  
    82.     public static ResponseResult ok(Object data) {
    83.         ResponseResult result = new ResponseResult();
    84.         result.setData(data);
    85.         return result;
    86.     }
    87.  
    88.  
    89. }
     

    controller
     

    1.  
    2. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
    3. import com.example.demo.annotation.BitMap;
    4. import com.example.demo.annotation.PreventRepeatSubmit;
    5. import com.example.demo.mapper.StuMapper;
    6. import com.example.demo.model.ResponseResult;
    7. import com.example.demo.model.Student;
    8. import com.example.demo.util.RedisBitMapUtils;
    9. import org.springframework.data.redis.core.ListOperations;
    10. import org.springframework.data.redis.core.RedisTemplate;
    11. import org.springframework.data.redis.core.StringRedisTemplate;
    12. import org.springframework.data.redis.core.ValueOperations;
    13. import org.springframework.data.redis.core.script.DefaultRedisScript;
    14. import org.springframework.validation.annotation.Validated;
    15. import org.springframework.web.bind.annotation.*;
    16. import javax.annotation.Resource;
    17. import java.util.ArrayList;
    18. import java.util.List;
    19. import java.util.Random;
    20.  
    21. @RestController
    22. @RequestMapping("/test")
    23. @Validated
    24. public class TestController {
    25.  
    26.     @Resource
    27.     private StuMapper stuMapper;
    28.     @Resource
    29.     private StringRedisTemplate stringRedisTemplate;
    30.  
    31.     private static final String BITMAP_STU="bitmap_stu";
    32.  
    33.     @Resource
    34.     private RedisBitMapUtils redisBitMapUtils;
    35.  
    36.  
    37.     @GetMapping("init")
    38.     public com.example.demo.util.ResponseResult init(){
    39.         List studentList = stuMapper.selectList(new QueryWrapper());
    40.  
    41.         redisBitMapUtils.init(BITMAP_STU,studentList,Student::getId);
    42.         return com.example.demo.util.ResponseResult.okResult();
    43.     }
    44.     /**
    45.      * 编程式
    46.      */
    47.     @GetMapping("selectStu1/{id}")
    48.     @BitMap(key = BITMAP_STU,id = "#id")
    49.     public com.example.demo.util.ResponseResult selectStu1(@PathVariable Integer id){
    50.  
    51.         return com.example.demo.util.ResponseResult.ok(stuMapper.selectById(id));
    52.     }
    53.      /**
    54.      * 注解式
    55.      */
    56.     @GetMapping("selectStu2/{id}")
    57.     public com.example.demo.util.ResponseResult selectStu2(@PathVariable Integer id){
    58.         if (redisBitMapUtils.getBit(BITMAP_STU,id)){
    59.             return com.example.demo.util.ResponseResult.ok(stuMapper.selectById(id));
    60.         }
    61.         return com.example.demo.util.ResponseResult.okResult();
    62.     }
    63.  
    64.  
    65. }
     

    测试
     

    初始化biemap数据,从数据库种获取所有id并导入redis的key为bitmap_stu的数据
     

     

    测试数据库存在的数据id：1，走数据库获取数据 
     

     

    测试数据库的数据id：200，因为id为200不存在在数据库中，所以没有走数据库，减少了数据库压力 
     

     注解式也生效
     

    达到了使用redis的bitmap实现分布式的布隆过滤器，过滤掉bitmap不存在的数据 
    
                

                    

                

                
  • 

                    相关阅读:
    
                    
手写一个简单的web服务器（B/S架构）                            
    
海上生明月，天涯共此时 ------#征文｜程序员过中秋的一百种方式#                            
    
springcloudalibaba架构(6):Sentinel热点规则                            
    
【数据结构】F:B DS图_课程表 拓扑排序实现                            
    
评价聚类的方法                            
    
python科研做图系列之雷达图                            
    
c-实用调试技巧-day5                            
    
让Maven在你这里得心应手                            
    
IDEA常用快捷键大全                            
    
腾讯安全联合发布《2022年上半年DDoS攻击威胁报告》：游戏和视频直播行业是重灾区                            
    
                        
                
    • 
                
  • 
                    原文地址：https://blog.csdn.net/qq_63431773/article/details/133884053
                
    •