springBoot整合redis java整合redis redisTemplate 缓存击穿,缓存穿透,缓存雪崩 setNx分布式锁 高性能高并发高可用

Redis

1.Redis的学习内容

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TpmgyjQO-1596793602611)(C:\Users\86157\AppData\Roaming\Typora\typora-user-images\1596768153110.png)]

2.Redis介绍

什么是redis

redis是一个开源的,内存中的数据结构存储系统,可以用来做数据库,缓存,消息中间件,分布式锁

redis支持的数据结构

字符串string

哈希值 hash

列表 list

集合 set

有序集合 sorted set

常用名词解释:

**高性能：**提供快速的访问体验。

高并发:通过设计保证系统能并行处理很多请求. 常用参数: 响应时间 吞吐量 qps:每秒响应请求数

高可用:站点服务尽可能一直不中断.

可伸缩：通过硬件增加/减少，提高/降低处理能力。

**扩展性：**方便地通过新增/移除方式，增加/减少新的功能/模块。

安全性：提供网站安全访问和数据加密、安全存储等策略。

敏捷性：随需应变，快速响应

怎么提高系统的并发能力

水平扩展:

​ 增加服务器数量

垂直扩展:

1. 提升单机硬件性能 如换用读写更快的ssd 升级网卡 增加cou核心数量
2. 提升单机架构性能:如适用缓存减少IO访问次数,使用异步来自增加访问吞吐量,使用无锁的数据结构减少响应时间

3.下载redis

http://redis.io/

安装参考网络教程

4.关系型数据库和非关系型数据

关系型数据库:

关系模型是一个二维表格,表明就是关系,一行就是一条记录,一列就是一个字段

优点:

• 容易理解
• 使用方便,有通用的sql语言
• 易于维护,降低了数据冗余和数据不一致的概率

缺点:

• 磁盘的i/o是并发的瓶颈
• 海量数据查询效率低下
• 横向扩展困难,无法简单通过添加硬件和服务节点来扩展性能和负载能力,当要对数据进行升级扩展石,需要停机维护和数据迁移
• 多表关联查询以及复杂数据分析类型的复杂sql查询,性能欠佳.因为要保证acid,需要按照三范式进行设计

代表数据库:

Orcale，Sql Server，MySql，DB2

非关系型数据库:

分布式,一般不保证遵循acid原则.键值对存储.

优点:

• 根据需要添加字段，不需要多表联查,只需要id就可取出对应的value
• 适用于sns,如微博
• 严格上不是数据库,而是一种数据结构化存储方法的集合

缺点:

• 只适合存储一些较为简单的数据
• 不适合存储复杂的数据
• 不适合持久存储海量数据

代表数据库

• k-v:Redis Memcache
• 文档:MangoDB
• 搜索:Elasticsearch,Solr
• 可扩展性分布式;Hbase

比较

内容	关系型数据库	非关系型数据库
成本	有些需要收费	基本都是开源
查询数据	存储于硬盘中,速度慢	数据存储于缓存中,读取快
存储格式	只支持基础类型	k-v,文档,图片等
扩展性	有多表查询机制,扩展困难	数据之间没有耦合,容易扩展
持久性	适合持久存储,海量存储	不适用持久存储,海量存储
数据一致性	事务能力强,强调数据的强一致性	事务能力弱,强调数据的最终一致性

强一致性

这种一致性级别是最符合用户直觉的，它要求系统写入什么，读出来的也会是什么，用户体验好，但实现起来往往对系统的性能影响大。

弱一致性

这种一致性级别约束了系统在写入成功后，不承诺立即可以读到写入的值，也不久承诺多久之后数据能够达到一致，但会尽可能地保证到某个时间级别（比如秒级别）后，数据能够达到一致状态。

最终一致性

最终一致性是弱一致性的一个特例，系统会保证在一定时间内，能够达到一个数据一致的状态。这里之所以将最终一致性单独提出来，是因为它是弱一致性中非常推崇的一种一致性模型，也是业界在大型分布式系统的数据一致性上比较推崇的模型。

5.Java操作redis五种数据类型

添加依赖

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!-- commons-pool2 对象池依赖 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

    </dependencies>

配置文件

spring:
               redis:
                 host: 192.168.10.100
                 port: 6379
                 password: root
                 database: 0
                 timeout: 10000ms
                 redis:
                   pool:
                     max-active: 1024
                     max-idle: 200
                     max-wait: 10000ms
                     min-idle: 5

封装JedisUtil对外提供连接对象获取方法

@Configuration public class RedisConfig { 
    //服务器地址
    @Value("${spring.redis.host}")
    private String host; 
    //端口
    @Value("${spring.redis.port}")
    private int port; 
    //密码
    @Value("${spring.redis.password}")
    private String password; 
    //超时时间 
    @Value("${spring.redis.timeout}")
    private String timeout; 
    //最大连接数 
    @Value("${spring.redis.jedis.pool.max-active}")
    private int maxTotal; 
    //最大连接阻塞等待时间
    @Value("${spring.redis.jedis.pool.max-wait}")
    private String maxWaitMillis; 
    //最大空闲连接
    @Value("${spring.redis.jedis.pool.max-idle}") 
    private int maxIdle; 
    //最小空闲连接 
    @Value("${spring.redis.jedis.pool.min-idle}") 
    private int minIdle;
    @Bean 
    public JedisPool redisPoolFactory(){ 
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig(); 
        //注意值的转变 jedisPoolConfig.setMaxWaitMillis(Long.parseLong(maxWaitMillis.substring(0,maxWaitMil lis.length()-2)));
        //注意属性名 
        jedisPoolConfig.setMaxTotal(maxTotal);
        jedisPoolConfig.setMaxIdle(maxIdle);
        jedisPoolConfig.setMinIdle(minIdle);
        JedisPool jedisPool = new JedisPool(jedisPoolConfig, host, port, Integer.parseInt(timeout.substring(0, timeout.length() - 2)), password);
        return jedisPool; } }

连接与释放

@Autowired 
private JedisPool jedisPool;
private Jedis jedis = null;
//初始化jedis对象实例 
@Before 
public void initConn(){ 
jedis = jedisPool.getResource();
}//释放资源
@After 
public void closeConn(){
if (jedis!=null){ jedis.close();
       } 
  }

操作String

// 1.操作String
@Test
public void testString()
{ 
// 添加一条数据 
jedis.set("username", "zhangsan");
jedis.set("age", "18"); 
// 添加多条数据 参数奇数为key 参数偶数为value
jedis.mset("address", "bj", "sex", "1");
// 获取一条数据 
String username = jedis.get("username");
System.out.println(username);
// 获取多条数据
List<String> list = jedis.mget("username", "age", "address", "sex");
for (String str : list) { 
System.out.println(str); }
// 删除 //jedis.del("username");
}

操作hash

// 2.操作Hash
@Test
public void testHash() {
/*
* 添加一条数据 
* 参数一：redis的key
* 参数二：hash的key 
* 参数三：hash的value 
*/ 
    jedis.hset("userInfo", "name", "lisi"); 
// 添加多条数据
    Map<String, String> map = new HashMap<>(); 
    map.put("age", "20"); 
    map.put("sex", "1");
    jedis.hmset("userInfo", map); 
    // 获取一条数据 
    String name = jedis.hget("userInfo", "name"); 
    System.out.println(name); 
    // 获取多条数据 
    List<String> list = jedis.hmget("userInfo", "age", "sex");
for (String str : list) { 
    System.out.println(str);
}
    // 获取Hash类型所有的数据 
    Map<String, String> userMap = jedis.hgetAll("userInfo");
for (Entry<String, String> userInfo : userMap.entrySet()) { System.out.println(userInfo.getKey() + "--" + userInfo.getValue());
                                                          }
    // 删除 用于删除hash类型数据
    //jedis.hdel("userInfo", "name");
}

操作list

// 3.操作list
@Test
public void testList() { 
// 左添加(上) 
// jedis.lpush("students", "Wang Wu", "Li Si");
// 右添加(下) // jedis.rpush("students", "Zhao Liu");
// 获取 start起始下标 end结束下标 包含关系 
List<String> students = jedis.lrange("students", 0, 2);
for (String stu : students) { System.out.println(stu); }
// 获取总条数
    Long total = jedis.llen("students");
    System.out.println("总条数：" + total);
    // 删除单条 删除列表中第一次出现的Li Si 
    // jedis.lrem("students", 1, "Li Si");
    // 删除多条 // jedis.del("students"); }

操作set

// 4.操作set-无序
@Test 
public void testSet() { 
// 添加数据 
jedis.sadd("letters", "aaa", "bbb", "ccc", "ddd", "eee"); 
// 获取数据 
Set<String> letters = jedis.smembers("letters");
for (String letter: letters) { System.out.println(letter); }
//获取总条数 Long total = jedis.scard("letters");
System.out.println(total);
// 删除 
//jedis.srem("letters", "aaa", "bbb");
}

操作sorted set

// 5.操作sorted set-有序
@Test
public void testSortedSet() {
Map<String, Double> scoreMembers = new HashMap<>();
scoreMembers.put("zhangsan", 7D); 
scoreMembers.put("lisi", 3D);
scoreMembers.put("wangwu", 5D);
scoreMembers.put("zhaoliu", 6D);
scoreMembers.put("tianqi", 2D);
// 添加数据 
jedis.zadd("score", scoreMembers); 
// 获取数据
Set<String> scores = jedis.zrange("score", 0, 4);
for (String score: scores) { 
System.out.println(score);
}
// 获取总条数
Long total = jedis.zcard("score"); 
System.out.println("总条数：" + total);
// 删除
//jedis.zrem("score", "zhangsan", "lisi");
}

Redis中以层级关系、目录形式存储数据

// Redis中以层级关系、目录形式存储数据
@Test
public void testdir(){
jedis.set("user:01", "user_zhangsan");
System.out.println(jedis.get("user:01")); }

设置key的失效时间

nx::redis数据库不存在该key时可以设置,已存在的话不可设置

xx:redis数据库存在该key时才可以设置,已存在的话不可以设置

@Test 
public void testExpire() { 
// 方法一：
jedis.set("code", "test"); 
jedis.expire("code", 180);// 180秒 
jedis.pexpire("code", 180000L);// 180000毫秒
jedis.ttl("code");// 获取秒 
// 方法二：
jedis.setex("code", 180, "test");// 180秒 
jedis.psetex("code", 180000L, "test");// 180000毫秒 
jedis.pttl("code");// 获取毫秒
// 方法三：
SetParams setParams = new SetParams();
//不存在的时候才能设置成功 
// setParams.nx();
// 存在的时候才能设置成功 
setParams.xx();
//设置失效时间，单位秒
// setParams.ex(30);
//查看失效时间，单位毫秒
setParams.px(30000); 
jedis.set("code","test",setParams);
}

获取所有key&事务&删除

@Test 
public void testAllKeys() { 
// 当前库key的数量 
System.out.println(jedis.dbSize());
// 当前库key的名称 
Set<String> keys = jedis.keys("*");
for (String key: keys) { 
System.out.println(key); } }
// 操作事务 @Test public void testMulti() { 
Transaction tx = jedis.multi(); 
// 开启事务 
tx.set("tel", "10010"); 
// 提交事务 
// tx.exec(); 
// 回滚事务 
tx.discard();
}
// 删除
@Test public void testDelete() {
// 删除 通用 适用于所有数据类型
jedis.del("score"); 
}

6 Redis搭建主从复用

Redis支持主从复用。数据可以从主服务器向任意数量的从服务器上同步，同步使用的是发布/订阅机制。

Master Slave的模式，从Slave向Master发起SYNC命令。

可以是1 Master 多Slave，可以分层，Slave下可以再接Slave，可扩展成树状结构。

因为没有两台电脑，所以只能在一台机器上搭建两个Redis服务端。

这里使用单机来模拟redis 主从服务器 ，实现读写分离配置。

读写分离

一台master服务器可读可写,其他的slave从服务器只读,如果master宕机,就只能对外提供读的服务,不能提供写的额服务

主备切换

在读写分离的基础上,通过配置哨兵监控服务器状态,当主节点的宕机时,哨兵会进行尝试重新连接,如果半数以上的主节点与A通信超时,从从服务器中选举设为新的主节点,继续对外提供读写服务,待宕机的主服务器修复后成为从服务器提供服务

Redis-Cluster集群

主备切换模式下每台redis服务器都存储相同的数据，很浪费内存，所以在redis3.0上加入了cluster模式，实现的redis的分布式存储，也就是说每台redis节点上存储不同的内容。至少需要三主三从

客户端与redis之间通过节点直连每个节点上都有两个东西 hash槽(0-16383)和cluster管理插件.客户端只需要连接任意一个redis节点即可,当存取的key到达时,redis会通crc16算法计算出一个结果,然后对16384取余得到一个数,这样每个key都会对应上哈希槽上的一个位置,用过这个值可以去查找对应哈希槽上的节点,从而去这个节点上进行对应的存取操作

7.Lettuce和Jedis的区别

Jedis 是一个优秀的基于 Java 语言的 Redis 客户端，但是，其不足也很明显： Jedis 在实现上是直

接连接 Redis-Server，在多个线程间共享一个 Jedis 实例时是线程不安全的，如果想要在多线程场景下

使用 Jedis ，需要使用连接池，每个线程都使用自己的 Jedis 实例，当连接数量增多时，会消耗较多

的物理资源。

Lettuce 则完全克服了其线程不安全的缺点： Lettuce 是基于 Netty 的连接

（StatefulRedisConnection），

Lettuce 是一个可伸缩的线程安全的 Redis 客户端，支持同步、异步和响应式模式。多个线程可以共

享一个连接实例，而不必担心多线程并发问题。它基于优秀 Netty NIO 框架构建，支持 Redis 的高级功

能，如 Sentinel，集群，流水线，自动重新连接和 Redis 数据模型。

8.SpringDataRedis

添加依赖

<dependencies> 
<!-- spring data redis 组件 -->
<dependency> 
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency> 
<!-- commons-pool2 对象池依赖 -->
<dependency> 
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId> 
</dependency>
<!-- web 组件 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency> 
<!-- test 组件 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope> 
</dependency>
</dependencies>

配置application.yml

spring: 
redis:
# Redis服务器地址 
host: 192.168.10.100
# Redis服务器端口
port: 6379
# Redis服务器端口
password: root
# Redis服务器端口
database: 0
# 连接超时时间
timeout: 10000ms lettuce: pool: 
#最大连接数，默认8 
max-active: 1024
# 最大连接阻塞等待时间，单位毫秒，默认-1ms
max-wait: 10000ms 
# 最大空闲连接，默认8
max-idle: 200
# 最小空闲连接，默认0 
min-idle: 5

测试环境测试环境是否搭建成功

@RunWith(SpringRunner.class)
@SpringBootTest(classes = SpringDataRedisApplication.class)
public class SpringDataRedisApplicationTests {
@Autowired
private RedisTemplate redisTemplate;
@Autowired
private StringRedisTemplate stringRedisTemplate;
@Test
public void initconn() {
ValueOperations<String, String> ops = stringRedisTemplate.opsForValue(); ops.set("username","lisi"); 
ValueOperations<String, String> value = redisTemplate.opsForValue(); value.set("name","wangwu");
System.out.println(ops.get("name")); 
} }

自定义模板解决序列化问题

要把 domain object 做为 key-value 对保存在 redis 中，就必须要解决对象的序列化问题。

JdkSerializationRedisSerializer 使用JDK提供的序列化功能。 优点是反序列化时不需要提供

类型信息(class)，但缺点是序列化后的结果非常庞大，是JSON格式的5倍左右，这样就会消耗 Redis 服务

器的大量内存。

Jackson2JsonRedisSerializer 使用 Jackson 库将对象序列化为JSON字符串。优点是速度快，序

列化后的字符串短小精悍。但缺点也非常致命，那就是此类的构造函数中有一个类型参数，必须提供要

序列化对象的类型信息(.class对象)。通过查看源代码，发现其只在反序列化过程中用到了类型信息。

GenericJackson2JsonRedisSerializer 通用型序列化，这种序列化方式不用自己手动指定对象

的 Class。

@Configuration
public class RedisConfig {
@Bean
public RedisTemplate<String,Object> redisTemplate(LettuceConnectionFactory redisConnectionFactory){
RedisTemplate<String,Object> redisTemplate = new RedisTemplate<>(); 
//为string类型key设置序列器
redisTemplate.setKeySerializer(new StringRedisSerializer()); 
//为string类型value设置序列器
redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
//为hash类型key设置序列器 
redisTemplate.setHashKeySerializer(new StringRedisSerializer()); 
//为hash类型value设置序列器 
redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer()); redisTemplate.setConnectionFactory(redisConnectionFactory);
return redisTemplate; 
} }

测试

//序列化 
@Test
public void testSerial(){ 
User user = new User(); 
user.setId(1); 
user.setUsername("张三");
user.setPassword("111");
ValueOperations<String, Object> value = redisTemplate.opsForValue(); value.set("userInfo",user); 
System.out.println(value.get("userInfo")); }

操作string

 // 1.操作String
 @Test
 public void testString() { 
 ValueOperations<String, Object> valueOperations = redisTemplate.opsForValue();
 // 添加一条数据 
 valueOperations.set("username", "zhangsan");
 valueOperations.set("age", "18");
 // redis中以层级关系、目录形式存储数据
 valueOperations.set("user:01", "lisi"); 
 valueOperations.set("user:02", "wangwu"); 
 // 添加多条数据
 Map<String, String> userMap = new HashMap<>(); 
 userMap.put("address", "bj"); userMap.put("sex", "1"); valueOperations.multiSet(userMap); 
 // 获取一条数据 
 Object username = valueOperations.get("username");
 System.out.println(username);
 // 获取多条数据 List<String> keys = new ArrayList<>(); keys.add("username");     keys.add("age");
 keys.add("address");
 keys.add("sex");
 List<Object> resultList = valueOperations.multiGet(keys);
for (Object str : resultList) { System.out.println(str); 
}
// 删除 
redisTemplate.delete("username");

操作hash

// 2.操作Hash 
@Test
public void testHash() {
HashOperations<String, String, String> hashOperations = redisTemplate.opsForHash(); 
/*
* 添加一条数据 
* 参数一：redis的key
* 参数二：hash的key
* 参数三：hash的value 
*/ 
hashOperations.put("userInfo","name","lisi");
// 添加多条数据 
Map<String, String> map = new HashMap();
map.put("age", "20"); map.put("sex", "1");
hashOperations.putAll("userInfo", map); 
// 获取一条数据
String name = hashOperations.get("userInfo", "name");
System.out.println(name);
// 获取多条数据
List<String> keys = new ArrayList<>(); keys.add("age"); 
keys.add("sex"); List<String> resultlist =hashOperations.multiGet("userInfo", keys);
for (String str : resultlist) { 
System.out.println(str); 
}
// 获取Hash类型所有的数据
Map<String, String> userMap = hashOperations.entries("userInfo");
for (Entry<String, String> userInfo : userMap.entrySet()) { System.out.println(userInfo.getKey() + "--" + userInfo.getValue()); }
// 删除 
用于删除hash类型数据 hashOperations.delete("userInfo", "name");
}

操作list

// 3.操作list
@Test
public void testList() {
ListOperations<String, Object> listOperations = redisTemplate.opsForList(); 
// 左添加(上)
// listOperations.leftPush("students", "Wang Wu");
// listOperations.leftPush("students", "Li Si");
// 左添加(上) 把value值放到key对应列表中pivot值的左面，如果pivot值存在的话
//listOperations.leftPush("students", "Wang Wu", "Li Si"); 
// 右添加(下)
// listOperations.rightPush("students", "Zhao Liu");
// 获取 start起始下标 end结束下标 包含关系
List<Object> students = listOperations.range("students", 0,2);
for (Object stu : students) { 
System.out.println(stu);
}
// 根据下标获取 Object stu = listOperations.index("students", 1);
System.out.println(stu);
// 获取总条数 Long total = listOperations.size("students");
System.out.println("总条数：" + total); 
// 删除单条 删除列表中存储的列表中几个出现的Li Si。
listOperations.remove("students", 1, "Li Si");
// 删除多条
redisTemplate.delete("students"); 
}

操作set

// 4.操作set-无序
@Test 
public void testSet() { 
SetOperations<String, Object> setOperations = redisTemplate.opsForSet();
// 添加数据
String[] letters = new String[]{"aaa", "bbb", "ccc", "ddd", "eee"}; //setOperations.add("letters", "aaa", "bbb", "ccc", "ddd", "eee"); setOperations.add("letters", letters);
// 获取数据 
Set<Object> let = setOperations.members("letters");
for (Object letter: let) { 
System.out.println(letter); }
// 删除
setOperations.remove("letters", "aaa", "bbb"); }

操作sorted set

// 5.操作sorted set-有序
@Test
public void testSortedSet() { 
ZSetOperations<String, Object> zSetOperations = redisTemplate.opsForZSet(); ZSetOperations.TypedTuple<Object> objectTypedTuple1 = new DefaultTypedTuple<Object>("zhangsan", 7D);
ZSetOperations.TypedTuple<Object> objectTypedTuple2 = new DefaultTypedTuple<Object>("lisi", 3D); 
ZSetOperations.TypedTuple<Object> objectTypedTuple3 = new DefaultTypedTuple<Object>("wangwu", 5D); 
ZSetOperations.TypedTuple<Object> objectTypedTuple4 = new DefaultTypedTuple<Object>("zhaoliu", 6D); 
ZSetOperations.TypedTuple<Object> objectTypedTuple5 = new DefaultTypedTuple<Object>("tianqi", 2D); 
Set<ZSetOperations.TypedTuple<Object>> tuples = new HashSet<ZSetOperations.TypedTuple<Object>>();
tuples.add(objectTypedTuple1);
tuples.add(objectTypedTuple2);
tuples.add(objectTypedTuple3); 
tuples.add(objectTypedTuple4); 
tuples.add(objectTypedTuple5); 
// 添加数据 
zSetOperations.add("score", tuples); 
// 获取数据 
Set<Object> scores = zSetOperations.range("score", 0, 4);
for (Object score: scores) {
System.out.println(score); }
// 获取总条数 
Long total = zSetOperations.size("score");
System.out.println("总条数：" + total);
// 删除 
zSetOperations.remove("score", "zhangsan", "lisi"); }

获取所有key&删除

// 获取所有key 
@Test
public void testAllKeys() {
// 当前库key的名称 
Set<String> keys = redisTemplate.keys("*");
for (String key: keys) {
System.out.println(key);
} }
// 删除
@Test 
public void testDelete() { 
// 删除 通用 适用于所有数据类型 
redisTemplate.delete("score"); }

设置key的失效时间

@Test
public void testEx() {
ValueOperations<String, Object> valueOperations = redisTemplate.opsForValue(); 
// 方法一：插入一条数据并设置失效时间 
valueOperations.set("code", "abcd", 180, TimeUnit.SECONDS);
// 方法二：给已存在的key设置失效时间
boolean flag = redisTemplate.expire("code", 180, TimeUnit.SECONDS); 
// 获取指定key的失效时间 
Long l = redisTemplate.getExpire("code"); }

SpringDataRedis整合使用哨兵机制

复制注意缩进!!!

spring: 
redis:
# Redis服务器地址 
host: 192.168.10.100
# Redis服务器端口
port: 6379
# Redis服务器端口
password: root
# Redis服务器端口
database: 0
# 连接超时时间
timeout: 10000ms lettuce: pool: 
#最大连接数，默认8 
max-active: 1024
# 最大连接阻塞等待时间，单位毫秒，默认-1ms
max-wait: 10000ms 
# 最大空闲连接，默认8
max-idle: 200
# 最小空闲连接，默认0 
min-idle: 5
#哨兵模式 
sentinel:
#主节点名称 
master: mymaster
#节点
nodes: 192.168.10.100:26379,192.168.10.100:26380,192.168.10.100:26381

bean注解配置

@Bean 
public RedisSentinelConfiguration redisSentinelConfiguration(){ 
RedisSentinelConfiguration sentinelConfig = new RedisSentinelConfiguration() 
// 主节点名称 
.master("mymaster") 
// 主从服务器地址 
.sentinel("192.168.10.100", 26379) 
.sentinel("192.168.10.100", 26380) 
.sentinel("192.168.10.100", 26381);
// 设置密码 
sentinelConfig.setPassword("root");
return sentinelConfig; }

8.如何应对缓存穿透、缓存击穿、缓存雪崩问题

8.1. Key的过期淘汰机制

Redis可以对存储在Redis中的缓存数据设置过期时间，比如我们获取的短信验证码一般十分钟过期，

我们这时候就需要在验证码存进Redis时添加一个key的过期时间，但是这里有一个需要格外注意的问题

就是：并非key过期时间到了就一定会被Redis给删除。

8.1.1. 定期删除

Redis 默认是每隔 100ms 就随机抽取一些设置了过期时间的 Key，检查其是否过期，如果过期就删

除。为什么是随机抽取而不是检查所有key？因为你如果设置的key成千上万，每100毫秒都将所有存在

的key检查一遍，会给CPU带来比较大的压力。

8.1.2. 惰性删除

定期删除由于是随机抽取可能会导致很多过期 Key 到了过期时间并没有被删除。所以用户在从缓存获

取数据的时候，redis会检查这个key是否过期了，如果过期就删除这个key。这时候就会在查询的时候将

过期key从缓存中清除。

8.1.3. 内存淘汰机制

仅仅使用定期删除 + 惰性删除机制还是会留下一个严重的隐患：如果定期删除留下了很多已经过期的

key，而且用户长时间都没有使用过这些过期key，导致过期key无法被惰性删除，从而导致过期key一直

堆积在内存里，最终造成Redis内存块被消耗殆尽。那这个问题如何解决呢？这个时候Redis内存淘汰机

制应运而生了。Redis内存淘汰机制提供了6种数据淘汰策略：

• volatile-lru ：从已设置过期时间的数据集中挑选最近最少使用的数据淘汰。

• volatile-ttl ：从已设置过期时间的数据集中挑选将要过期的数据淘汰。

• volatile-random ：从已设置过期时间的数据集中任意选择数据淘汰。

• allkeys-lru ：当内存不足以容纳新写入数据时移除最近最少使用的key。

• allkeys-random ：从数据集中任意选择数据淘汰。

• no-enviction（默认） ：当内存不足以容纳新写入数据时，新写入操作会报错。

一般情况下，推荐使用 volatile-lru 策略，对于配置信息等重要数据，不应该设置过期时间，这样 Redis就永远不会淘汰这些重要数据。对于一般数据可以添加一个缓存时间，当数据失效则请求会从DB 中获取并重新存入Redis中。

8.2. 缓存击穿

首先我们来看下请求是如何取到数据的：当接收到用户请求，首先先尝试从Redis缓存中获取到数据， 如果缓存中能取到数据则直接返回结果，当缓存中不存在数据时从DB获取数据，如果数据库成功取到数 据，则更新Redis，然后返回数据

定义：高并发的情况下，某个热门key突然过期，导致大量请求在Redis未找到缓存数据，进而全部去 访问DB请求数据，引起DB压力瞬间增大。

解决方案：缓存击穿的情况下一般不容易造成DB的宕机，只是会造成对DB的周期性压力。对缓存击 穿的解决方案一般可以这样：

Redis中的数据不设置过期时间，然后在缓存的对象上添加一个属性标识过期时间，每次获取到数 据时，校验对象中的过期时间属性，如果数据即将过期，则异步发起一个线程主动更新缓存中的数 据。但是这种方案可能会导致有些请求会拿到过期的值，就得看业务能否可以接受， 如果要求数据必须是新数据，则最好的方案则为热点数据设置为永不过期，然后加一个互斥锁保证 缓存的单线程写。

8.3. 缓存穿透

定义：缓存穿透是指查询缓存和DB中都不存在的数据。比如通过id查询商品信息，id一般大于0，攻

击者会故意传id为-1去查询，由于缓存是不命中则从DB中获取数据，这将会导致每次缓存都不命中数据

导致每个请求都访问DB，造成缓存穿透。

解决方案：

• 利用互斥锁，缓存失效的时候，先去获得锁，得到锁了，再去请求数据库。没得到锁，则休眠一段时间重试
• 采用异步更新策略，无论key是否取到值，都直接返回。value值中维护一个缓存失效时间，缓存如 果过期，异步起一个线程去读数据库，更新缓存。需要做缓存预热(项目启动前，先加载缓存)操作。
• 提供一个能迅速判断请求是否有效的拦截机制，比如，利用布隆过滤器，内部维护一系列合法有效 的key。迅速判断出，请求所携带的Key是否合法有效。如果不合法，则直接返回。
• 如果从数据库查询的对象为空，也放入缓存，只是设定的缓存过期时间较短，比如设置为60秒。

8.4. 缓存雪崩

定义：缓存中如果大量缓存在一段时间内集中过期了，这时候会发生大量的缓存击穿现象，所有的请 求都落在了DB上，由于查询数据量巨大，引起DB压力过大甚至导致DB宕机。

解决方案：

给缓存的失效时间，加上一个随机值，避免集体失效。如果Redis是集群部署，将热点数据均匀分 布在不同的Redis库中也能避免全部失效的问题 使用互斥锁，但是该方案吞吐量明显下降了。设置热点数据永远不过期。

双缓存。我们有两个缓存，缓存A和缓存B。缓存A的失效时间为20分钟，缓存B不设失效时间。自 己做缓存预热操作。然后细分以下几个小点

1. 从缓存A读数据库，有则直接返回

2. A没有数据，直接从B读数据，直接返回，并且异步启动一个更新线程。

3. 更新线程同时更新缓存A和缓存B。