Redis 工具类 与 Redis 布隆过滤器

已于 2024-02-22 00:28:28 修改
阅读量797 收藏 4
点赞数 2
分类专栏： 后端进阶实践 文章标签： redis 数据库 缓存
于 2024-02-22 00:12:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Carefree_State/article/details/136223241
版权

Redis 工具类

1. 核心依赖

<!--redis-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>31.1-jre</version>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.31</version>
</dependency>

2. 序列化

public class FastJsonRedisSerializer<T> implements RedisSerializer<T> {
 
    public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
 
    private Class<T> clazz;
 
    static {
        ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
    }
 
    public FastJsonRedisSerializer(Class<T> clazz) {
        super();
        this.clazz = clazz;
    }
 
    @Override
    public byte[] serialize(T t) throws SerializationException {
        if (t == null) {
            return new byte[0];
        }
        return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);
    }
 
    @Override
    public T deserialize(byte[] bytes) throws SerializationException {
        if (bytes == null || bytes.length <= 0) {
            return null;
        }
        String str = new String(bytes, DEFAULT_CHARSET);
        return JSON.parseObject(str, clazz);
    }

    protected JavaType getJavaType(Class<?> clazz)
    {
        return TypeFactory.defaultInstance().constructType(clazz);
    }
}

@Configuration
public class RedisSerializeConfig {

    @Bean
    @SuppressWarnings(value = { "unchecked", "rawtypes" })
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<Object, Object> template = new RedisTemplate<Object, Object>();
        template.setConnectionFactory(connectionFactory);
        FastJsonRedisSerializer serializer = new FastJsonRedisSerializer(Object.class);
        // 使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(serializer);
        // Hash的key也采用StringRedisSerializer的序列化方式
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(serializer);
        template.afterPropertiesSet();
        return template;
    }
}

3. 布隆过滤器

/**
 * 算法过程：
 * 1. 首先需要k个hash函数，每个函数可以把key散列成为1个整数
 * 2. 初始化时，需要一个长度为n比特的数组，每个比特位初始化为0
 * 3. 某个key加入集合时，用k个hash函数计算出k个散列值，并把数组中对应的比特位置为1
 * 4. 判断某个key是否在集合时，用k个hash函数计算出k个散列值，并查询数组中对应的比特位，如果所有的比特位都是1，认为在集合中。
 **/
@Component
public class BloomFilterHelper<T> {

    private int numHashFunctions;

    private int bitSize;

    private Funnel<T> funnel;

    private static final int NUM_BITS = (int) 1e4;
    private static final double RATE = 0.03;//不存在误判为存在的概率

    private static void funnel(@Nullable Object o, PrimitiveSink primitiveSink) {
        primitiveSink.putBytes(o.toString().getBytes());
    }

    public BloomFilterHelper() {
        this((Funnel) BloomFilterHelper::funnel, NUM_BITS, RATE);
    }
    public BloomFilterHelper(Funnel<T> funnel, int expectedInsertions, double fpp) {
        this.funnel = funnel;
        // 计算bit数组长度
        bitSize = optimalNumOfBits(expectedInsertions, fpp);
        // 计算hash方法执行次数
        numHashFunctions = optimalNumOfHashFunctions(expectedInsertions, bitSize);
    }

    public int[] getHashOffset() {
        return new int[numHashFunctions];
    }

    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;
        }
        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)));
    }
}

@Component
@RequiredArgsConstructor
public class RedisBloomFilter {

    private final RedisTemplate redisTemplate;

    private final BloomFilterHelper bloomFilterHelper;

    public void init(String bloomFilterName) {
        int[] offset = bloomFilterHelper.getHashOffset();
        for (int i : offset) {
            redisTemplate.opsForValue().setBit(bloomFilterName, i, true);
        }
    }

    /**
     * 根据给定的布隆过滤器添加值
     */
    public <T> void add(String bloomFilterName, T value) {
        int[] offset = bloomFilterHelper.murmurHashOffset(value);
        for (int i : offset) {
            redisTemplate.opsForValue().setBit(bloomFilterName, i, true);
        }
    }

    /**
     * 根据给定的布隆过滤器判断值是否存在
     */
    public <T> boolean contains(String bloomFilterName, T value) {
        int[] offset = bloomFilterHelper.murmurHashOffset(value);
        for (int i : offset) {
            if (!redisTemplate.opsForValue().getBit(bloomFilterName, i)) {
                return false;
            }
        }
        return true;
    }

}

4. Redis工具类

@Component
@RequiredArgsConstructor
@Slf4j
@SuppressWarnings(value = { "unchecked", "rawtypes" })
public class RedisCache {

    private final RedisTemplate redisTemplate;

    private final RedisBloomFilter redisBloomFilter;

    /**
     * 设置有效时间
     *
     * @param key Redis键
     * @param timeout 超时时间
     * @return true=设置成功；false=设置失败
     */
    public Boolean expire(final String key, final long timeout, final TimeUnit timeUnit) {
        log.info("为 Redis 的键值设置超时时间\t[{}]-[{}  {}]", key, timeout, timeUnit.name());
        return redisTemplate.expire(key, timeout, timeUnit);
    }

    /**
     * 原子设置过期时间
     * @param key
     * @param value
     * @param timeout
     */
    public <T> void execute(final String key, final T value, final long timeout, final TimeUnit timeUnit) {
        log.info("尝试存入 Redis\t[{}]-[{}]，超时时间:[{}  {}]", key, value, timeout, timeUnit.name());
        redisTemplate.execute(new SessionCallback() {
            @Override
            public Object execute(RedisOperations redisOperations) throws DataAccessException {
                redisOperations.multi();
                redisOperations.opsForValue().set(key, value);
                redisOperations.expire(key, timeout, timeUnit);
                return redisOperations.exec();
            }
        });
    }

    /**
     *  获得对象的剩余存活时间
     * @param key 键
     * @return 剩余存活时间
     */
    public long getKeyTTL(final String key, final TimeUnit timeUnit) {
        int ttl = Math.toIntExact(redisTemplate.opsForValue().getOperations().getExpire(key));
        String message = null;
        switch (ttl) {
            case -1:
                message = "没有设置过期时间";
                break;
            case -2:
                message = "key不存在";
                break;
            default:
                message = ttl + "  " + TimeUnit.SECONDS.name();
                break;
        }
        log.info("查询 Redis key[{}] 剩余存活时间:{}", key, message);
        return TimeUnit.SECONDS.convert(ttl, timeUnit);
    }

    /**
     * 缓存基本的对象，Integer、String、实体类等
     *
     * @param key 缓存的键值
     * @param value 缓存的值
     */
    public <T> void setCacheObject(final String key, final T value) {
        log.info("存入 Redis\t[{}]-[{}]", key, value);
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * 缓存基本的对象，Integer、String、实体类等
     *
     * @param key 缓存的键值
     * @param value 缓存的值
     * @param timout 超时时间
     */
    public <T> void setCacheObject(final String key, final T value, final long timout, final TimeUnit timeUnit) {
        log.info("存入 Redis\t[{}]-[{}]，超时时间:[{}  {}]", key, value, timout, timeUnit.name());
        redisTemplate.opsForValue().set(key, value, timout, timeUnit);
    }

    /**
     * 获取键值
     * @param key 键
     * @return 键对应的值，并封装成 Optional 对象
     * @param <T>
     */
    public <T> Optional<T> getCacheObject(final String key) {
        T value = (T) redisTemplate.opsForValue().get(key);
        log.info("查询 Redis\t[{}]-[{}]", key, value);
        return Optional.ofNullable(value);
    }

    /**
     * 让指定 Redis 键值进行自减
     * @param key 键
     * @return 自减后的值
     */
    public long decrementCacheNumber(final String key) {
        long number = redisTemplate.opsForValue().decrement(key);
        log.info("Redis key[{}] 自减后：{}", key, number);
        return number;
    }

    /**
     * 让指定 Redis 键值进行自增
     * @param key 键
     * @return 自增后的值
     */
    public long incrementCacheNumber(final String key) {
        long number = redisTemplate.opsForValue().increment(key);
        log.info("Redis key[{}] 自增后：{}", key, number);
        return number;
    }

    /**
     * 初始化布隆过滤器
     * @param bloomFilterName
     */
    public void initBloomFilter(final String bloomFilterName) {
        log.info("初始化布隆过滤器[{}]", bloomFilterName);
        redisTemplate.execute(new SessionCallback() {
            @Override
            public Object execute(RedisOperations redisOperations) throws DataAccessException {
                redisOperations.multi();
                redisBloomFilter.init(bloomFilterName);
                return redisOperations.exec();
            }
        });
    }

    /**
     * 初始化布隆过滤器
     * @param bloomFilterName
     * @param timeout
     * @param timeUnit
     */
    public void initBloomFilter(final String bloomFilterName, final long timeout, final TimeUnit timeUnit) {
        redisTemplate.execute(new SessionCallback() {
            @Override
            public Object execute(RedisOperations redisOperations) throws DataAccessException {
                redisOperations.multi();
                redisBloomFilter.init(bloomFilterName);
                expire(bloomFilterName, timeout, timeUnit);
                return redisOperations.exec();
            }
        });
    }

    /**
     * 加入布隆过滤器
     * @param bloomFilterName 隆过滤器的名字
     * @param key key 键
     */
    public <T> void addToBloomFilter(final String bloomFilterName, final T key) {
        log.info("加入布隆过滤器[{}]\tkey[{}]", bloomFilterName, key);
        redisTemplate.execute(new SessionCallback() {
            @Override
            public Object execute(RedisOperations redisOperations) throws DataAccessException {
                redisOperations.multi();
                redisBloomFilter.add(bloomFilterName, key);
                return redisOperations.exec();
            }
        });
    }

    /**
     * 布隆过滤器是否存在该键值
     * @param bloomFilterName 布隆过滤器的名字
     * @param key 键
     * @return 键是否存在
     */
    public <T> boolean containsInBloomFilter(final String bloomFilterName, final T key) {
        boolean flag = redisBloomFilter.contains(bloomFilterName, key);
        log.info("key[{}]\t是否存在于布隆过滤器[{}]:\t{}", key, bloomFilterName, flag);
        return flag;
    }

    /**
     * 缓存Map
     *
     * @param key
     * @param data
     */
    public <K, T> void setCacheMap(final String key, final Map<K, T> data) {
        if (Objects.nonNull(data)) {
            log.info("Map 存入 Redis\t[{}]-[{}]", key, data);
            redisTemplate.opsForHash().putAll(key, data);
        }
    }

    /**
     * 缓存Map
     *
     * @param key
     * @param data
     */
    public <K, T> void setCacheMap(final String key, final Map<K, T> data, long timeout, final TimeUnit timeUnit) {
        if (Objects.nonNull(data)) {
            Map<String, T> map = new HashMap<>();
            data.entrySet().stream().parallel().forEach(entry -> {
                map.put(entry.getKey().toString(), entry.getValue());
            });
            log.info("尝试存入 Redis\t[{}]-[{}] 超时时间:[{}  {}]", key, map, timeout, timeUnit.name());
            redisTemplate.execute(new SessionCallback() {
                @Override
                public Object execute(RedisOperations redisOperations) throws DataAccessException {
                    redisOperations.multi();
                    redisTemplate.opsForHash().putAll(key, map);
                    expire(key, timeout, timeUnit);
                    return redisOperations.exec();
                }
            });
        }
    }

    /**
     * 获得缓存的Map
     *
     * @param key
     * @return
     */
    public <K, T> Optional<Map<K, T>> getCacheMap(final String key) {
        Map<K, T> data = redisTemplate.opsForHash().entries(key);
        data = data.size() == 0 ? null: data;
        log.info("获取 Redis 中的 Map 缓存\t[{}]-[{}]", key, data);
        return Optional.ofNullable(data);
    }

    /**
     * 往Hash中存入数据
     *
     * @param key Redis键
     * @param hashKey Hash键
     * @param value 值
     */
    public <K, T> void setCacheMapValue(final String key, final K hashKey, final T value) {
        log.info("存入 Redis 的某个 Map\t[{}.{}]-[{}]", key, hashKey, value);
        redisTemplate.opsForHash().put(key, hashKey.toString(), value);
    }

    /**
     * 获取Hash中的数据
     *
     * @param key Redis键
     * @param hashKey Hash键
     * @return Hash中的对象
     */
    public <K, T> Optional<T> getCacheMapValue(final String key, final K hashKey) {
        T value = (T) redisTemplate.opsForHash().get(key, hashKey.toString());
        log.info("获取 Redis 中的 Map 的键值\t[{}.{}]-[{}]", key, hashKey, value);
        return Optional.ofNullable(value);
    }

    /**
     * 删除Hash中的数据
     *
     * @param key
     * @param hashKey
     */
    public <K> void delCacheMapValue(final String key, final K hashKey) {
        log.info("删除 Redis 中的 Map 的键值\tkey[{}.{}]", key, hashKey);
        redisTemplate.opsForHash().delete(key, hashKey.toString());
    }

    /**
     * 让指定 HashMap 的键值进行自减
     * @param key HashMap的名字
     * @param hashKey HashMap的一个键
     * @return 自减后的值
     */
    public <K> long decrementCacheMapNumber(final String key, final K hashKey) {
        long number = redisTemplate.opsForHash().increment(key, hashKey.toString(), -1);
        log.info("Redis key[{}.{}] 自减后：{}", key, hashKey, number);
        return number;
    }

    /**
     * 让指定 HashMap 的键值进行自增
     * @param key HashMap的名字
     * @param hashKey HashMap的一个键
     * @return 自增后的值
     */
    public <K> long incrementCacheMapNumber(final String key, final K hashKey) {
        long number = redisTemplate.opsForHash().increment(key, hashKey.toString(), +1);
        log.info("Redis key[{}.{}] 自增后：{}", key, hashKey, number);
        return number;
    }

    /**
     * 删除单个对象
     * @param key
     */
    public boolean deleteObject(final String key) {
        log.info("删除 Redis 的键值\tkey[{}]", key);
        return redisTemplate.delete(key);
    }

}

5. 查询Redis与Redis设置缓存的技巧

伪代码：

redisCache.getCacheObject(redisKey)
    .orElseGet(() -> {
        /* balabala ....*/
        // 可能查询有误，所以这里也可能没法获取到data（为null），也就可能没必要设置缓存
        redisCache.setCacheObject(redisKey, data, ttl, unit); 
        /* balabala ....*/
        return data;
    }));

现实示例：

在这里插入图片描述

s:103
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
布隆过滤器工具类，拿来直接用
08-15
布隆过滤器工具类，拿来直接用
redis工具方法万能put
12-18
"redis工具方法万能put"指的是一个自定义的Redis工具类，它提供了一个通用的put方法，能够简化向Redis中插入数据的过程，无需依赖特定的MVC框架。 这个工具类的使用非常简单，只需将源码导入到项目中，然后调用其...
Redis布隆过滤器
pointer_y的博客
08-08 1356
布隆过滤器（Bloom filter）是一种非常节省空间的概率数据结构，运行速度快，占用内存小，但是有一定的误判率且无法删除元素。本质上由一个很长的二进制向量和一系列随机映射函数组成。
Redis-布隆过滤器解决穿透详解
Wzill
02-04 1064
布隆过滤器可以帮助我们解决Redis缓存雪崩的问题，那什么是布隆过滤器、布隆过滤器又是如何使用如何解决缓存雪崩的问题的，让我们带着这一系列的问题去详细了解布隆过滤器。布隆过滤器适用于需要快速判断一个元素是否可能存在于集合中的场景，例如网络爬虫中的去重、缓存中的数据判断等。但需要注意的是，布隆过滤器无法删除元素，也无法准确地判断一个元素是否存在于集合中，因此在一些场景下可能会产生误判。🎯🎯。
redis是整合google guava的布隆过滤器
♾️
08-11 1841
为什么要使用布隆过滤器？ 布隆过滤器（bloomfilter）有两大作用，一是为了防止缓存穿透，二是为了在百万级数据里快速高效的去重 什么是布隆过滤器？ 1，布隆过滤器是用来判断一个元素是否出现在给定集合中的重要工具，具有快速，比哈希表更节省空间等优点，而缺点在于有一定的误识别率（false-positive，假阳性），亦即，它可能会把不是集合内的元素判定为存在于集合内，不过这样的概率相当小，在大部分的生产环境中是可以接受的； 2，其原理比较简单，假设S集合中有n个元素，利用k个哈希函数，将S中的每个元素映
Redis 工具类，基本 Redis 工具类 + Redisson 布隆过滤器
半亩方糖
03-10 672
因为每次配置 redis 总是要去翻之前的代码，这里写个工具博客方便查找 基本 redis 工具类 Redisson 实现布隆过滤器 1. 基本 redis 工具类 1.1 pom.xml 基于 SpringBoot 就直接继承父依赖即可 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis
【Redis】布隆过滤器
人类所有真实的快乐，一定是恒久的努力
03-05 2127
布隆过滤器的简介、Redis的布隆过滤器的实现
java 使用redis布隆过滤器
u013658068的专栏
07-13 2753
布隆过滤器的原理 其本质就是一个只包含0和1的数组。具体操作当一个元素被加入到集合里面后，该元素通过K个Hash函数运算得到K个hash后的值，然后将K个值映射到这个位数组对应的位置，把对应位置的值设置为1。查询是否存在时，我们就看对应的映射点位置如果全是1，他就很可能存在（跟hash函数的个数和hash函数的设计有关），如果有一个位置是0，那这个元素就一定不存在。 Redis 中的布隆过滤器 Redis 官方提供的布隆过滤器到了 Redis 4.0 提供了插件功能之后才正式登场。布隆过滤器作为一个插
Redis集群实现布隆过滤器
晏霖/胖虎的博客
05-07 7125
前言 其实，在这之前我还真的不知道布隆过滤器是个啥，感谢群里一位大神网友，提供了相关代码和资料，至此我才知道什么叫布隆过滤器，本文就是为了指导很多像我一样的人，初识布隆过滤器，并可以结合 redis 及代码实现。 正文 本文分两部分讲解 第一部分让读者知道什么是布隆过滤器，以及适用的场景。 第二部分我们结合 redis集群实现一个简单布隆过滤器，并测试达到过滤的效果，本文的封装的代码可以...
Redis_25_Redis中的布隆过滤器
毛毛的专栏
09-19 1660
文章目录一、前言二、Bloom Filter 概念三、Bloom Filter 原理 + Bloom Filter优点3.1 布隆过滤器的原理3.2 布隆过滤器的原理深入，为什么检索集合时，如果这些点有任何一个0，则被检元素一定不在；如果都是1，则被检元素很可能在？3.3 布隆过滤器怎样处理缓存击穿四、Bloom Filter的缺点五、Bloom Filter 实现与使用5.1 Guava：提供了一种Bloom Filter的实现5.1 布隆过滤器的使用Bloom Filter的应用错误率越大，所需空间和时
redis布隆过滤器（Bloom）详细使用教程
鹏鹏2077
02-03 3212
的过滤器，这个过滤器的配置都是一些基础的配置，比如初始容量是100 错误率是0.01也就是百分之一的错误率，这个过滤明显不能满足我们的需要因为过滤器的工作原理就是通过多个哈希函数对key进行计算然后记录下来，那么容量就决定了在计算的过程中发生碰撞的概率大小了，所以我们在使用的时候一定要去手动创建过滤器以确保满足自己的需要。它以较小的空间占用和高效的查询时间著称。解释一下：bf.add 是安装布隆过滤器后才可以使用的命令，这是添加一个key的命令，user是过滤器的名字，而tese就是我们要去添加的key。
framework-redis.zip111
05-06
在“简单的redis工具类”中，我们通常会看到以下功能： 1. 连接管理：工具类会提供连接Redis服务器的方法，可能包括初始化配置、创建连接池、关闭连接等功能，确保资源的有效管理和释放。 2. 基本操作：如设置...
Redis6.0.9版本win10 64位
12-02
在实际应用中，Redis常与Java客户端Redisson配合使用，Redisson提供了丰富的API，简化了与Redis的交互，支持分布式锁、发布订阅、布隆过滤器等功能。 总之，Redis 6.0.9在Windows 10环境下提供了稳定的服务，结合其...
Redis 缓存代码
07-01
11. **缓存穿透和雪崩问题**：防止缓存穿透可以通过布隆过滤器检查键是否存在；缓存雪崩可能由于大量缓存同时失效导致，解决方案包括设置不同的过期时间、使用互斥锁等。 12. **数据持久化**：Redis提供RDB（快照）...
读书笔记 - 《Redis 深度历险：核心原理与应用实践》
风中的默默
07-17 1118
不过你也不必过于担心，因为 Redis 对 HyperLogLog 的存储进行了优化，在计数比较小时，它的存储空间采用稀疏矩阵存储，空间占用很小，仅仅在计数慢慢变大、稀疏矩阵占用空间渐渐超过了阎值时，才会一次性转变成稠密矩阵，才会占用 12KB的空间。数据段是由很多操作系统的页面组合而成，当父进程对其中一个页面的数据进行修改时，会将被共享的页面复制一份分离出来，然后对这个复制的页面进行修改，每个页面的大小只有 4KB。用户看到错误对话框后，会先阅读对话框的内容，再点击重试，这样就可以起到人工延时的效果。
redis setnx使用方法
servepeople的博客
07-17 350
SETNX是Redis中的一个命令，用于设置键的值，只有当键不存在时才进行设置。如果键已经存在，则不进行任何操作。
Redis初识
qq_61422622的博客
07-17 904
为了明确分布式系统，我们先来了解单机架构，那么什么是单机架构呢？所谓的单机架构，即只有一台服务器，这个服务器负责所有的工作。如上图一个简单的电商网站的组成，有一个单机服务器完成所有功能，单机服务器主要用有两个服务一个是应用服务（服务端程序），一个是数据库服务（数据存储）。此时一台主机能满足业务需求，这就是单价架构。但是我们一台主机上的硬件资源是有限的，当同一时刻处理的请求多了，就可能会导致某个硬件资源不够用了，从而导致访问时间变长，甚至出错，一般遇到这种场景我们会进行优化：开源节流，软件上的优化。
Redis新数据类型
最新发布
爱吃Java的羊的博客
07-18 230
命令Bitmaps与set对比
redis的bitmap类型如何实现布隆过滤器
05-20
布隆过滤器是一种快速判断一个元素是否存在于一个集合中的数据结构，它可以高效地过滤掉一些不可能存在于集合中的元素，而对于可能存在于集合中的元素，它会返回一个概率值。 Redis 的 Bitmap 类型可以实现布隆过滤器。具体实现如下： 1. 首先选择合适的 bitmap 大小，可以根据需要添加的元素数量和期望的误判率来确定。一般来说，误判率越低，需要的空间就越大。 2. 初始化 bitmap，将所有位都设置为 0。 3. 对于要添加的元素，计算出多个哈希值，然后将对应的位设置为 1。哈希函数的选择很重要，它应该能够将元素均匀地映射到不同的位上，并且不同元素的哈希值应该尽量不重复。 4. 判断一个元素是否存在于集合中时，同样计算出它的哈希值，然后判断对应的位是否都为 1。如果存在一个位为 0，那么该元素一定不存在；如果所有位都为 1，那么该元素可能存在（误判率取决于哈希函数个数和位数）。 需要注意的是，Redis 的 Bitmap 类型只支持位操作，因此需要自己实现哈希函数。另外，布隆过滤器的误判率随着添加的元素数量增加而增加，因此需要定期重新计算 bitmap 大小，或者清空 bitmap 并重新添加元素。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

s:103

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值