非关系数据库Redis

最新推荐文章于 2024-01-02 13:35:22 发布
最新推荐文章于 2024-01-02 13:35:22 发布
阅读量182 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TL19970/article/details/109290227
版权

什么是Redis
Redis 是开源免费的，遵守BSD协议，是一个高性能的key-value非关系型数据库。

非关系数据库redis

redis是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，redis支持各种不同方式的排序。与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。

redis单线程问题

所谓的单线程指的是网络请求模块使用了一个线程（所以不需考虑并发安全性），即一个线程处理所有网络请求，其他模块仍用了多个线程。

redis采用多路复用机制：即多个网络socket复用一个io线程，实际是单个线程通过记录跟踪每一个Sock(I/O流)的状态来同时管理多个I/O流.

Redis特点：

Redis支持数据的持久化，可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进行使用。

Redis不仅仅支持简单的key-value类型的数据，同时还提供String，list，set，zset，hash等数据结构的存储。

Redis支持数据的备份，即master-slave模式的数据备份。

性能极高 – Redis能读的速度是110000次/s,写的速度是81000次/s 。

原子 – Redis的所有操作都是原子性的，同时Redis还支持对几个操作全并后的原子性执行。

丰富的特性 – Redis还支持 publish/subscribe, 通知, 设置key有效期等等特性。

redis语法

redis语法
          通用命令： key-val
         设置过期时间： setex key (seconds) (value)  
         删除： del key
 如：set user zy;  //key-->user, val-zy.          setex user   10 zy   //设置key为user 值为zy ，10秒后过期

1）String 类型

   set key   val  //添加
    get key   //获取
    del key //删除
 注意：可以存储二进制，需要把key 和val 转换为byte[];

2)hash

  Redis hash 是一个string类型的field和value的映射表，hash特别适合用于存储对象。 
  hset key  filed val   //添加
  hmset key filed1 val1  [filed2] [val2] //批量添加
  hget key filed //获取一个字段的值
  hmget key  filed [filed2] //获取多个字段的值
  hgetall key //获取所有字段的值
  hdel key filed [filed2] //删除1个或多个字段

3）List（注意不是集合而是相当于JAVA中的队列）

Redis列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素到列表的头部（左边）或者尾部（右边） 
rpush key value1 [value2]  //右边添加多个值
lpush key value1 [value2]  //左边添加多个值
rpop key  //右边取一个
lpop key  //左边取一个
llen key  //获取链表长度
br[l]pop key  timeout //设置阻塞设计 单位为：秒

4）Set（集合）

  Redis的Set是string类型的无序集合。集合成员是唯一的，这就意味着集合中不能出现重复的数据。 
sadd key member1 [member2]  //添加一个或多个成员
srem key member1 [member2]   //移除一个或多个成员
scard key  //获取集合成员数
sdiff  key  ke1  //返回两个集合的差集
sinter key key1 //返回两个集合的交集
smembers key //返回集合的所有成员

5）sorted set（有序集合）

Redis 有序集合和集合一样也是string类型元素的集合,且不允许重复的成员。 不同的是每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。 有序集合的成员是唯一的,但分数(score)却可以重复。 
zadd key score1 member1 [score2 member2]    //添加一个或多个成员
zcard key //获取成员数
zcount key min max   // 计算在有序集合中指定区间分数的成员数 
zincrby  key increment member  //有序集合中对指定成员的分数加上增量 incremen
zrem key member [member ...]   //移除有序集合中的一个或多个成员
zrank key member  //返回有序集合中指定成员的索引  
zrange key  start stop [WITHSCORES]    返回有序集中指定区间内的成员，通过索引，分数从低到高 
zrangebyscore key max min [WITHSCORES]  返回有序集中指定分数区间内的成员，分数从低到高排序 
zrevrange key start stop [WITHSCORES]  返回有序集中指定区间内的成员，通过索引，分数从高到底 
zrevrangebyscore key max min [WITHSCORES]  返回有序集中指定分数区间内的成员，分数从高到低排序

6）Redis 发布订阅

Redis 发布订阅(pub/sub)是一种消息通信模式：发送者(pub)发送消息，订阅者(sub)接收消息。 Redis 客户端可以订阅任意数量的频道
publish channel message  将信息发送到指定的频道。
punsubscribe [pattern [pattern ...]]  退订所有给定模式的频道。
subSCRIBE channel [channel ...]  订阅给定的一个或多个频道的信息。
unsubscribe [channel [channel ...]]  指退订给定的频道。

Redis运用场景

  1. 显示最新的项目列表
  2. 删除与过滤
  3. 排行榜相关
  4. 按照用户投票和时间排序
  5. 过期项目处理
  6. 计数
  7. 特定时间内的特定项目
  8. 实时分析正在发生的情况，用于数据统计与防止垃圾邮件等
  9. Pub/Sub
  10. 队列
  11. 缓存

springboot整合redis

1、 pom

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <!-- 排除lettuce包，使用jedis代替-->
    <exclusions>
        <exclusion>
            <groupId>io.lettuce</groupId>
            <artifactId>lettuce-core</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>2.9.0</version>
</dependency>

2、配置文件yaml

#服务器的端口号
server:
  port: 8011
spring:
  redis:
    host: 127.0.0.1
    port: 8001

3、配置类


@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        // 使用Jackson2JsonRedisSerialize 替换默认的jdkSerializeable序列化
        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);
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的value序列化方式采用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
}

4、工具类

@Service(value = "redisCacheUtil")
public class RedisCacheUtil {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 指定缓存失效时间
     *
     * @param key  键
     * @param time 时间(秒)
     * @return
     */
    public boolean expire(String key, long time) {
        try {
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据key 获取过期时间
     *
     * @param key 键 不能为null
     * @return 时间(秒) 返回0代表为永久有效
     */
    public long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    /**
     * 判断key是否存在
     *
     * @param key 键
     * @return true 存在 false不存在
     */
    public boolean hasKey(String key) {

        try {

            return redisTemplate.hasKey(key);

        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 删除缓存
     *
     * @param key 可以传一个值 或多个
     */
    public void del(String... key) {

        if (key != null && key.length > 0) {

            if (key.length == 1) {

                redisTemplate.delete(key[0]);

            } else {

                redisTemplate.delete(CollectionUtils.arrayToList(key));

            }

        }

    }

    /**
     * 普通缓存获取
     *
     * @param key 键
     * @return 值
     */
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * 普通缓存放入
     *
     * @param key   键
     * @param value 值
     * @return true成功 false失败
     */
    public boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 普通缓存放入并设置时间
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    public boolean set(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }


    /**
     * 递增
     * @param key 键
     * @param delta 要增加几(大于0)
     * @return
     */
    public Long incr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }
    /**
     * 递减
     * @param key 键
     * @param delta 要减少几(小于0)
     * @return
     */
    public long decr(String key,long delta) {
        if (delta < 0) {
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }

    /**
     * HashGet
     * @param key 键 不能为null
     * @param item 项 不能为null
     * @return 值
     */
    public Object hget(String key, String item) {
        return redisTemplate.opsForHash().get(key, item);

    }
    /**
     * 获取hashKey对应的所有键值
     * @param key 键
     * @return 对应的多个键值
     */
    public Map<Object, Object> hmget(String key) {
        return redisTemplate.opsForHash().entries(key);

    }

    /**
     * HashSet
     * @param key 键
     * @param map 对应多个键值
     * @return true 成功 false 失败
     */
    public boolean hmset(String key, Map<String, Object> map) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * HashSet 并设置时间
     * @param key 键
     * @param map 对应多个键值
     * @param time 时间(秒)
     * @return true成功 false失败
     */
    public boolean hmset(String key, Map<String, Object> map, long time) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     * @param key 键
     * @param item 项
     * @param value 值
     * @return true 成功 false失败
     */
    public boolean hset(String key, String item, Object value) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     * @param key 键
     * @param item 项
     * @param value 值
     * @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
     * @return true 成功 false失败
     */
    public boolean hset(String key, String item, Object value, long time) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除hash表中的值
     * @param key 键 不能为null
     * @param item 项 可以使多个 不能为null
     */
    public void hdel(String key, Object... item) {
        redisTemplate.opsForHash().delete(key, item);
    }
    /**
     * 判断hash表中是否有该项的值
     * @param key 键 不能为null
     * @param item 项 不能为null
     * @return true 存在 false不存在
     */
    public boolean hHasKey(String key, String item) {
        return redisTemplate.opsForHash().hasKey(key, item);
    }

    /**
     * hash递增 如果不存在,就会创建一个 并把新增后的值返回
     * @param key 键
     * @param item 项
     * @param by 要增加几(大于0)
     * @return
     */

    public double hincr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, by);
    }

    /**
     * hash递减
     * @param key 键
     * @param item 项
     * @param by 要减少记(小于0)
     * @return
     */
    public double hdecr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, -by);
    }

    /**
     * 根据key获取Set中的所有值
     * @param key 键
     * @return
     */
    public Set<Object> sGet(String key) {
        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 根据value从一个set中查询,是否存在
     * @param key 键
     * @param value 值
     * @return true 存在 false不存在
     */
    public boolean sHasKey(String key, Object value) {
        try {
            return redisTemplate.opsForSet().isMember(key, value);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将数据放入set缓存
     * @param key 键
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSet(String key, Object... values) {
        try {
            return redisTemplate.opsForSet().add(key, values);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 将set数据放入缓存
     * @param key 键
     * @param time 时间(秒)
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSetAndTime(String key, long time, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().add(key, values);
            if (time > 0)
                expire(key, time);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
    /**
     * 获取set缓存的长度
     * @param key 键
     * @return
     */
    public long sGetSetSize(String key) {
        try {
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 移除值为value的
     * @param key 键
     * @param values 值 可以是多个
     * @return 移除的个数
     */
    public long setRemove(String key, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().remove(key, values);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 获取list缓存的内容
     * @param key 键
     * @param start 开始
     * @param end 结束 0 到 -1代表所有值
     * @return
     */
    public List<Object> lGet(String key, long start, long end) {
        try {
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    /**
     * 获取list缓存的长度
     * @param key 键
     * @return
     */
    public long lGetListSize(String key) {
        try {
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 通过索引 获取list中的值
     * @param key 键
     * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
     * @return
     */
    public Object lGetIndex(String key, long index) {
        try {
            return redisTemplate.opsForList().index(key, index);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     * @return
     */
    public boolean lSet(String key, Object value) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     * @param time 时间(秒)
     * @return
     */
    public boolean lSet(String key, Object value, long time) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            if (time > 0)
                expire(key, time);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }

    }

    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     * @return
     */

    public boolean lSet(String key, List<Object> value) {

        try {

            redisTemplate.opsForList().rightPushAll(key, value);

            return true;

        } catch (Exception e) {

            e.printStackTrace();

            return false;
        }
    }

    /**
     484
     * 将list放入缓存
     *
     * @param key 键
     * @param value 值
     * @param time 时间(秒)
     * @return
     */
    public boolean lSet(String key, List<Object> value, long time) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            if (time > 0)
                expire(key, time);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据索引修改list中的某条数据
     * @param key 键
     * @param index 索引
     * @param value 值
     * @return
     */
    public boolean lUpdateIndex(String key, long index, Object value) {
        try {
            redisTemplate.opsForList().set(key, index, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 移除N个值为value
     * @param key 键
     * @param count 移除多少个
     * @param value 值
     * @return 移除的个数
     */
    public long lRemove(String key, long count, Object value) {
        try {
            Long remove = redisTemplate.opsForList().remove(key, count, value);
            return remove;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
}
.、流年
关注
非关系数据库 redis之持久化（RDB、AOF）
m0_71521555的博客
09-29 373
redis之持久化（RDB、AOF）
非关系型数据库redis
02-23
redis是一种nosql数据库,他的数据是保存在内存中，同时redis可以定时把内存数据同步到磁盘，即可以将数据持久化，并且他比memcached支持更多的数据结构(string,list列表[队列和栈],set[集合],sortedset[有序集合],...
《redis学习》-- 缓存穿透和缓存雪崩的预防和解决
热门推荐
04-02 1万+
redis缓存穿透和缓存失效的预防和解决缓存穿透： 认识 缓存穿透是指查询一个一定不存在的数据，由于缓存是不命中时需要从数据库查询，查不到数据则不写入缓存，这将导致这个不存在的数据每次请求都要到数据库去查询，造成缓存穿透。解决办法： 对所有可能查询的参数以hash形式存储，在控制层先进行校验，不符合则丢弃。还有最常见的则是采用布隆过滤器，将所有可能存在的数据哈希到一个足够大的bitmap
redis防止击穿
weixin_43887958的博客
04-29 93
如果是分布式项目就用redis创建一个分布式锁(不是分布式就用jdk自带的锁): pubic Object query(QueryParam params){ Object result = null; String lockKey = "lock:" + JSON.toJSONString(params); result = redis.get(JSON.toJSONString(params)); if(result == null){ redis.lock(lockKey) try{
Redis的三种集群方式+穿透与雪崩的预防和解决
cc_05207的博客
06-19 465
Redis的三种集群方式概述 1、主从复制 原理 从服务器连接主服务器，发送SYNC（同步）命令； 主服务器接收到SYNC命名后，开始执行BGSAVE命令生成RDB文件并使用缓冲区记录此后执行的所有写命令； 主服务器BGSAVE执行完后，向所有从服务器发送快照文件，并在发送期间继续记录被执行的写命令； 从服务器收到快照文件后丢弃所有旧数据，载入收到的快照； 主服务器快照发送完毕后开始向从服务器...
redis 缓存防止击穿
NICE_square的博客
01-05 1089
缓存为何被击穿! 何为击穿?
如何避免缓存雪崩、缓存击穿、缓存穿透
qq_27146535的博客
06-08 638
如何避免缓存雪崩、缓存击穿、缓存穿透 记录这个主要是自己缓存击穿和缓存穿透这两个概念容易混淆。 文章目录如何避免缓存雪崩、缓存击穿、缓存穿透缓存雪崩概念解决方案缓存击穿概念解决方案缓存穿透概念解决方案布隆过滤器概念缺点 首先了解一下什么是缓存雪崩、缓存击穿、缓存穿透。 缓存雪崩 概念 缓存雪崩：是指缓存层出现了错误，不能正常工作了。于是所有的请求都会达到存储层，存储层的调用量会暴增，造成存储层也会挂掉的情况。 解决方案 随机key过期时间，避免数据同时过期 请求数据库时加锁，只允许一条请求访问
非关系型缓存数据库redis
10-29
Redis，英文全称是Remote Dictionary Server（远程字典服务），是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。 与MySQL数据库不同的是，Redis的...
非关系型数据库Redis和MongoDB面试专题及答案
11-01
MySQL 和 MongoDB 两者都是免费开源的数据库。MySQL 和 MongoDB 有许多基本差别包括数据的表示(data representation)，查询，关系，事务，schema 的设计和定义，标准化(normalization)，速度和性能。
Redis布隆防击穿实战
lifetragedy的专栏
01-10 1162
生产实战级redis bloomfilter防绕开varnish、防绕开redis打击DB的实用教程。
redis 锁机制实现防穿透
sm_Bo的博客
10-31 2871
参考 http://huoding.com/2015/09/14/463/comment-page-2 http://www.open-open.com/lib/view/open1419576824109.html
高频面试题-如何避免Redis中缓存穿透、缓存雪崩问题？
uuuyy_的博客
02-09 498
Redis，因为其速度快等各方面的原因，被开发人员一直应用于企业级开发。 而一旦开始使用Redis，就必然要考虑的问题就当属缓存穿透、缓存雪崩的问题了，这也是面试过程中很容易问到的点了，下面我们就来聊一下这些吧。 1. 什么是缓存穿透？ 缓存穿透是指当查询一个不存在的数据，由于无法命中对应的值，就会一直需要去数据库中查询；所以这个时候Redis并没有起到减少查询的次数，失去了使用Redis的初心，反而性能方面有了更大的消耗，就会造成整体的性能下降。 2. 如何解决缓存穿透问题？ 一句话答案
Redis穿透，雪崩的解决办法
SuperHBo的博客
03-04 384
Redis是开发过程中经常使用到的工具，这里简单说一下如何解决穿透，雪崩的问题。 穿透： 1、利用互斥锁。缓存失效的时候，得到了锁，再请求数据库。没得到锁，休眠一段时间重试。 2、采用异步更新策略。无论key是否取到值，都直接返回。value值中维护一个缓存失效时间，缓存如果过期，异步一个线程去读数据库，跟新缓存。需要缓存预热（项目启动前，先加载缓存）。 3、提供一个能迅速判断请求是否有效拦截机制...
redis缓存穿透、雪崩、击穿及解决方案
m0_38087224的博客
11-28 117
Redis缓存穿透和缓存雪崩以及解决方案（问题结构清晰） https://www.cnblogs.com/George1994/p/10668889.html REDIS缓存穿透，缓存击穿，缓存雪崩原因+解决方案（解决方案更详细） https://www.cnblogs.com/xichji/p/11286443.html ...
redis缓存穿透和缓存雪崩的原因和解决办法
东城庞太师
05-31 545
缓存穿透： 缓存穿透的概念很简单，用户想要查询一个数据，发现redis内存数据库没有，也就是缓存没有命中，于是向持久层数据库查询。发现也没有，于是本次查询失败。当用户很多的时候，缓存都没有命中，于是都去请求了持久层数据库。这会给持久层数据库造成很大的压力，这时候就相当于出现了缓存穿透。 解决方案： 布隆过滤器 布隆过滤器是一种数据结构，垃圾网站和正常网站加起来全世界据统计也有几十亿个。网警要过滤这些垃圾网站，总不能到数据库里面一个一个去比较吧，这就可以使用布隆过滤器。假设我们存储一亿个垃圾网站地址。
redis-缓存穿透与缓存雪崩
YQAG
07-31 1万+
缓存穿透 缓存系统，按照KEY去查询VALUE,当KEY对应的VALUE一定不存在的时候并对KEY并发请求量很大的时候，就会对后端造成很大的压力。 如何避免 1.对查询机构为空的情况也进行缓存，缓存的时间设置端一点，或者对该KEY对应的数据insert之后清理缓存。 2.对一定不存在的key进行过滤，可以把所有存在的key放到一个大bitmap中，查询时通过该bitmap过滤。
如何解决Redis缓存雪崩、缓存穿透、缓存并发等5大难题
wq_wangqiang的博客
04-06 1136
如何解决Redis缓存雪崩、缓存穿透、缓存并发
如何避免雪崩
weixin_42608299的博客
01-19 194
避免雪崩的方法有很多，一些常用的方法如下： 了解雪崩的危险性：要了解雪崩的危险性和发生雪崩的原因。 选择安全的滑雪区域：选择安全的滑雪区域，避开高风险区域。 遵循安全规则：遵循滑雪场的安全规则，不要在禁止滑雪的区域滑雪。 使用安全装备：使用雪崩报警器和其他安全装备。 了解天气预报：了解当天的天气预报，避免在恶劣天气条件下滑雪。 与伙伴合作：如果发生雪崩，与伙伴合作可以更快地找到安全出路...
Redis缓存雪崩：预防、应对和解决方案【redis问题 二】
todoitbo的博客
01-02 6076
本文深入探讨了Redis缓存雪崩现象及其对系统性能的影响。我们将详细介绍缓存雪崩的原因，它如何影响你的应用，以及可以采取哪些预防措施和解决策略来避免这种情况。文章旨在为开发者提供一系列实用的技巧和方法，帮助构建更加健壮和高效的Redis缓存系统。
非关系型数据库Redis
最新发布
05-09
Redis是一款开源的非关系型内存数据库，它支持多种数据结构（包括字符串、哈希、列表、集合、有序集合等），可以满足各种应用场景下的数据存储需求。Redis的数据存储在内存中，因此访问速度非常快，特别适用于高性能...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值