<think>我们正在使用Spring Boot 3.4.4和JDK17，并希望连接到一个配置为一主两从一哨兵的Redis集群。我们将使用Lettuce作为客户端。
注意：哨兵模式需要配置哨兵节点和主节点名称，客户端通过哨兵来发现主节点和从节点。
步骤：
1. 添加依赖
2. 配置application.yml（或application.properties）
3. 编写测试代码
由于Lettuce是Spring Boot 2.x及以后版本的默认Redis客户端，我们不需要额外添加Lettuce依赖（通过starter包含），也不需要commons
-pool2（因为Lettuce有自己的连接池）。
详细步骤：
一、添加依赖（Maven）
在pom.xml中添加：
```xml
<dependencies>
<!
-- Spring Boot Starter Data Redis 包含Lettuce
-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring
-boot
-starter
-data
-redis</artifactId>
</dependency>
<!
-- 如果需要使用Redis的哨兵模式，确保版本正确即可
-->
</dependencies>
```
二、配置application.yml
配置哨兵模式的关键参数：
spring.redis.sentinel.master
: 主节点名称（在哨兵中配置的名称）
spring.redis.sentinel.nodes
: 哨兵节点列表（多个哨兵节点用逗号分隔，每个节点是host
:port格式）
spring.redis.lettuce.pool
: 连接池配置（可选）
示例配置：
```yaml
spring
:
redis
:
# 数据库索引（默认0）
database
: 0
# 密码（如果有的话）
password
: yourpassword
# 哨兵模式配置
sentinel
:
master
: mymaster # 主节点名称，根据你的哨兵配置设置
nodes
:
- 192.168.1.10
:26379
- 192.168.1.11
:26379
- 192.168.1.12
:26379
# Lettuce 客户端配置
lettuce
:
pool
:
max
-active
: 8 # 连接池最大连接数（使用负值表示没有限制）
max
-idle
: 8 # 连接池中的最大空闲连接
min
-idle
: 0 # 连接池中的最小空闲连接
max
-wait: -1ms # 连接池最大阻塞等待时间（使用负值表示没有限制）
```
注意：上面的哨兵节点列表（nodes）需要替换为你的实际哨兵节点地址和端口。
三、编写测试代码
我们可以编写一个简单的Spring Boot应用来测试Redis连接。
1. 创建一个Controller进行测试：
```java
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class TestController {
@Autowired
private StringRedisTemplate stringRedisTemplate;
@GetMapping("/test")
public String test() {
// 设置一个键值对
stringRedisTemplate.opsForValue().set("testKey", "Hello, Redis Sentinel!");
// 获取值
String value = stringRedisTemplate.opsForValue().get("testKey");
return "Value from Redis
: " + value;
}
}
```
2. 主启动类：
```java
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class RedisSentinelApplication {
public static void main(String[] args) {
SpringApplication.run(RedisSentinelApplication.class, args);
}
}
```
四、验证
启动应用，访问http
://localhost
:8080/test，如果返回"Value from Redis
: Hello, Redis Sentinel!"，则说明连接成功。
注意事项：
1. 确保哨兵配置正确，并且主从节点正常运行。
2. 确保应用能够访问到所有的Redis节点（包括哨兵节点）。
3. 如果Redis有密码，需要在配置中设置密码（如上示例中的`password`属性）。注意，如果主节点和从节点密码
不同，需要额外配置（这里假设相同）。
4. 如果密码
不同，则需要通过`spring.redis.sentinel.password`设置哨兵密码（如果哨兵有密码的话），并且主从节点的密码在配置中统一使用`spring.redis.password`（因为Lettuce在连接主从节点时使用同一个密码）。如果主从节点密码
不同，则需要自定义配置，较为复杂，通常建议设置相同密码。
五、自定义配置（可选）
如果主从节点密码
不同，或者需要更高级的配置，可以自定义`LettuceConnectionFactory`。
例如，自定义配置（在主从密码相同的情况下不需要）：
```java
@Configuration
public class RedisConfig {
@Value("${spring.redis.sentinel.master}")
private String masterName;
@Value("${spring.redis.sentinel.nodes}")
private List<String> sentinelNodes;
@Value("${spring.redis.password}")
private String password;
@Bean
public RedisConnectionFactory lettuceConnectionFactory() {
RedisSentinelConfiguration sentinelConfig = new RedisSentinelConfiguration()
.master(masterName);
// 添加哨兵节点
for (String node
: sentinelNodes) {
String[] parts = node.split("
:");
sentinelConfig.sentinel(parts[0], Integer.parseInt(parts[1]));
}
// 设置密码
if (password != null && !password.isEmpty()) {
sentinelConfig.setPassword(password);
}
// 连接池配置（可选）
LettucePoolingClientConfiguration clientConfig = LettucePoolingClientConfiguration.builder()
.poolConfig(new GenericObjectPoolConfig<>())
.build();
return new LettuceConnectionFactory(sentinelConfig, clientConfig);
}
}
```
但是，在Spring Boot 3.4.4中，通常不需要自定义`LettuceConnectionFactory`，因为自动配置已经足够。除非有特殊需求。
总结：通过以上配置，Spring Boot 3.4.4应用即可通过Lettuce连接Redis哨兵集群。
相关问题：
1. 如何配置Redis哨兵模式的高可用？
2. Lettuce和Jedis在连接Redis哨兵模式时有什么
不同？
3. 如何监控Redis连接池的状态？
4. 在Spring Boot中如何动态切换Redis主从节点故障转移？
5. 如何为Redis哨兵模式配置TLS/SSL？</think>### Spring Boot 3.4.4 + JDK17 连接 Redis 哨兵集群（Lettuce）配置指南
#### 1. **依赖配置（Maven）**
```xml
<dependencies>
<!
-- Spring Boot Redis Starter（包含 Lettuce）
-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring
-boot
-starter
-data
-redis</artifactId>
</dependency>
<!
-- 验证工具（可选）
-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring
-boot
-starter
-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
```
> 📌 **注意**：无需额外添加 `commons
-pool2`，Lettuce 自带连接池实现[^1][^2]。
---
#### 2. **YAML 配置（application.yml）**
```yaml
spring
:
redis
:
password
: your_redis_password # 若无需密码可删除
lettuce
:
pool
:
max
-active
: 16 # 最大连接数
min
-idle
: 4 # 最小空闲连接
max
-wait: 2000ms # 最大等待时间
sentinel
:
master
: mymaster # 哨兵配置的主节点名称
nodes
: # 哨兵节点列表
- 192.168.1.10
:26379
- 192.168.1.11
:26379
- 192.168.1.12
:26379
password
: sentinel_password # 哨兵密码（若无则删除）
```
> ✅ **关键参数说明**：
>
- `sentinel.master`：Redis 主节点名称（需与哨兵配置一致）
>
- `sentinel.nodes`：所有哨兵节点的 `IP
:端口`
>
- `lettuce.pool`：连接池配置（自动启用内置连接池）
---
#### 3. **哨兵模式验证代码**
```java
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.StringRedisTemplate;
import static org.junit.jupiter.api.Assertions.assertEquals;
@SpringBootTest
public class RedisSentinelTest {
@Autowired
private StringRedisTemplate redisTemplate;
@Test
void testSentinelConnection() {
// 写入数据（自动路由到主节点）
redisTemplate.opsForValue().set("sentinel_test", "success");
// 读取数据（可能路由到从节点）
String value = redisTemplate.opsForValue().get("sentinel_test");
assertEquals("success", value, "哨兵集群读写测试失败");
System.out.println("✅ Redis哨兵集群连接成功！");
}
}
```
---
#### 4. **拓扑结构说明**
```
+
---------------+
| Sentinel |
| (192.168.1.10| 监控
+
-------+
-------+ +
---------+
| | Master |
+
-------+
-------+ | (主节点)|
| Sentinel +
---> 6379 |
| (192.168.1.11| +
----+
----+
+
-------+
-------+ |
| | 同步
+
-------+
-------+ +
----+
----+ +
---------+
| Sentinel | | Slave | | Slave |
| (192.168.1.12| | (从节点)| | (从节点)|
+
---------------+ +
--------+ +
---------+
```
---
#### 5. **故障转移验证**
```java
// 模拟主节点故障后的自动切换
@Test
void testFailover() throws InterruptedException {
redisTemplate.opsForValue().set("failover_test", "initial");
// 此处手动停止主节点（模拟故障）
System.out.println("⚠️ 手动停止主节点后等待10秒...");
Thread.
sleep(10000); // 等待哨兵选举新主节点
// 写入新数据（应自动路由到新主节点）
redisTemplate.opsForValue().set("failover_test", "recovered");
String value = redisTemplate.opsForValue().get("failover_test");
assertEquals("recovered", value, "故障转移测试失败");
}
```
> 🔍 **监控建议**：
> 使用 `redis
-cli
-h <sentinel_ip>
-p 26379 sentinel masters` 查看主节点状态。
---
### 常见问题排查
1. **连接超时**
- 检查哨兵节点防火墙端口（`26379`）
- 确认 `sentinel.master` 名称与哨兵配置一致
2. **认证失败**
- 主节点密码配置在 `spring.redis.password`
- 哨兵密码配置在 `spring.redis.sentinel.password`
3. **读写分离**
Lettuce 默认使用主节点写、从节点读，可通过配置调整：
```yaml
spring
:
redis
:
lettuce
:
read
-from
: REPLICA_PREFERRED # 优先从节点读
```
---
### 相关问题
1. Lettuce 和 Jedis 在哨兵模式下的性能对比如何？
2. 如何通过 Spring Actuator 监控 Redis 连接池状态？
3. Redis 哨兵集群的推荐部署架构是什么？
4. Lettuce 如何实现自动故障转移？超时机制如何配置？
5. 在 Kubernetes 中部署 Redis 哨兵有哪些最佳实践？
> [^1]
: Lettuce 官方文档
- 连接池实现
> [^2]
: Spring Boot 3.4.x 文档
- Redis 哨兵配置
> [^3]
: Redis Sentinel 高可用方案设计指南
本文详细解析了Java中线程控制方法wait与sleep的区别。wait方法属于Object类，用于资源同步时线程等待，并释放对象锁；而sleep方法属于Thread类，可在任意位置使用，使线程暂停指定时间，但不释放锁。文章还强调了wait方法需在同步环境中调用并等待被唤醒，而sleep方法则自动恢复执行。
扫一扫
1323
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
