Spring Boot整合Redis Cluster集群Slot迁移异常修复方案

大家好，今天我们来聊聊Spring Boot整合Redis Cluster集群时，Slot迁移过程中可能遇到的异常，以及相应的修复方案。Redis Cluster作为分布式缓存的优秀解决方案，在应对高并发、大数据量场景下发挥着重要作用。而Slot迁移是Redis Cluster集群扩容、缩容以及节点故障恢复的关键环节。在Slot迁移过程中，如果配置不当或者环境存在问题，很容易出现异常，导致数据丢失甚至服务中断。

一、Redis Cluster Slot迁移原理

在深入探讨异常修复方案之前，我们先简单回顾一下Redis Cluster的Slot迁移原理。

Slot概念: Redis Cluster将所有数据划分为16384个Slot。每个Key通过CRC16算法计算后对16384取模，得到该Key对应的Slot。节点与Slot的对应关系: 每个Redis节点负责一部分Slot。集群通过维护一个Slot和节点的映射关系表来定位Key所在的节点。迁移过程: Slot迁移指的是将某个或某些Slot从一个节点迁移到另一个节点的过程。这个过程通常发生在集群扩容或者缩容时。迁移过程包含以下步骤：
目标节点准备: 目标节点进入IMPORTING状态，表示准备接收来自源节点的Slot数据。源节点准备: 源节点进入MIGRATING状态，表示准备将指定Slot的数据迁移到目标节点。数据迁移: 源节点将Slot中的Key逐个发送给目标节点。在发送过程中，如果客户端请求的Key已经迁移到目标节点，源节点会返回ASK重定向命令，引导客户端到目标节点去获取数据。完成迁移: 当源节点将Slot中的所有Key都迁移完毕后，源节点和目标节点都会更新Slot和节点的映射关系表。

二、常见Slot迁移异常及原因分析

在实际应用中，Slot迁移过程中可能出现多种异常，以下列举一些常见的异常及其原因：

异常类型	原因分析
`CLUSTERDOWN`	集群处于下线状态，通常是由于某个节点宕机，导致集群无法达到多数派原则。
`BUSYKEY`	目标节点上已经存在相同的Key，导致迁移失败。这种情况通常是由于数据重复或者Slot分配错误引起。
`NOAUTH`	集群启用了密码验证，而迁移命令没有提供正确的密码。
`READONLY`	源节点是只读节点（Slave节点），无法执行迁移操作。
`ASK`重定向循环	客户端在执行`ASK`重定向时，由于某些原因，无法正确跳转到目标节点，导致循环重定向。
网络连接异常	节点之间的网络连接不稳定，导致数据传输中断。
超时异常	在迁移过程中，某个操作（例如连接、数据传输）超时。
内存不足	在迁移过程中，某个节点的内存不足，导致迁移失败。
`MOVED`重定向错误（不常见，但可能存在）	客户端收到的`MOVED`重定向信息指向错误的节点，这可能是由于集群元数据更新不及时导致的。在迁移过程中，如果客户端直接访问了源节点，且源节点已经完成了Slot迁移，但客户端的缓存信息没有更新，就会收到`MOVED`重定向。

三、Spring Boot整合Redis Cluster

首先展示Spring Boot 整合 Redis Cluster 的配置以及简单使用。

1. 添加依赖



<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
 
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
</dependency>

2. 配置文件 (application.properties 或 application.yml)


spring.redis.cluster.nodes=192.168.1.101:7000,192.168.1.102:7001,192.168.1.103:7002
spring.redis.cluster.max-redirects=6
spring.redis.password=your_redis_password  # 如果Redis集群设置了密码
spring.redis.timeout=5000 # 单位毫秒

#连接池配置（可选，但推荐）
spring.redis.lettuce.pool.max-active=8
spring.redis.lettuce.pool.max-idle=8
spring.redis.lettuce.pool.min-idle=0
spring.redis.lettuce.pool.max-wait= -1 # 阻塞等待最大时长，负数表示没有限制

3. RedisConfig 配置类 (可选，用于更细粒度的配置)



import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisClusterConfiguration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisPassword;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import java.util.Arrays;
import java.util.List;
 
@Configuration
public class RedisConfig {
 
    @Value("${spring.redis.cluster.nodes:}") // 允许为空，单机模式时使用
    private String clusterNodes;
 
    @Value("${spring.redis.password:}") //允许为空，没有密码时使用
    private String password;
 
    @Bean
    public RedisConnectionFactory redisConnectionFactory() {
        if (clusterNodes != null && !clusterNodes.isEmpty()) {
            RedisClusterConfiguration redisClusterConfiguration = new RedisClusterConfiguration(Arrays.asList(clusterNodes.split(",")));
            if (password != null && !password.isEmpty()) {
                redisClusterConfiguration.setPassword(RedisPassword.of(password));
            }
            return new LettuceConnectionFactory(redisClusterConfiguration);
        } else {
            // 单机模式
            RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
            redisStandaloneConfiguration.setHostName("localhost"); // 修改为你的Redis地址
            redisStandaloneConfiguration.setPort(6379);
            if (password != null && !password.isEmpty()) {
                redisStandaloneConfiguration.setPassword(RedisPassword.of(password));
            }
            return new LettuceConnectionFactory(redisStandaloneConfiguration);
        }
    }
 
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer()); // 或者使用 Jackson2JsonRedisSerializer
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

4. 使用 RedisTemplate



import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
 
@Service
public class RedisService {
 
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
 
    public void set(String key, Object value) {
        redisTemplate.opsForValue().set(key, value);
    }
 
    public Object get(String key) {
        return redisTemplate.opsForValue().get(key);
    }
 
    public boolean delete(String key) {
        return redisTemplate.delete(key);
    }
}

四、Slot迁移异常修复方案

针对上述常见的Slot迁移异常，我们提供以下修复方案：

1. CLUSTERDOWN 异常

原因： 集群中有节点宕机，导致集群无法达到多数派原则，进入下线状态。修复方案：
检查节点状态： 使用 redis-cli -c -h <any_node_ip> -p <any_node_port> cluster info 命令查看集群状态，确认哪个节点宕机。恢复宕机节点： 尝试重启宕机节点。如果节点无法恢复，需要将其从集群中移除，并添加新的节点。手动故障转移 (如果节点无法恢复): 如果宕机节点是Master节点，需要进行手动故障转移，将Slave节点提升为Master节点。可以使用 redis-cli -c -h <any_node_ip> -p <any_node_port> cluster failover 命令。 注意： 在执行 cluster failover 命令之前，需要确保目标Slave节点的数据与Master节点同步。检查网络连接： 确保所有节点之间的网络连接正常。

2. BUSYKEY 异常

原因： 目标节点上已经存在相同的Key，导致迁移失败。修复方案：
数据排查： 确认目标节点上是否存在与要迁移的Key相同的Key。可以使用 redis-cli -c -h <target_node_ip> -p <target_node_port> keys <key_pattern> 命令。数据清理： 如果目标节点上的Key是不需要的，可以将其删除。可以使用 redis-cli -c -h <target_node_ip> -p <target_node_port> del <key> 命令。 注意： 删除Key之前，请务必确认该Key不再被使用。调整Slot分配： 如果Key的Slot分配错误，需要重新分配Slot。这种情况比较复杂，需要谨慎操作，避免数据丢失。通常不建议手动调整Slot分配，而是应该通过Redis Cluster的管理工具来完成。跳过冲突Key (谨慎使用): 在某些情况下，如果可以接受数据丢失，可以选择跳过冲突的Key。但是，这种方法不推荐使用，因为它会导致数据不一致。

3. NOAUTH 异常

原因： 集群启用了密码验证，而迁移命令没有提供正确的密码。修复方案：
确认密码： 确认Redis集群的密码是否正确。提供密码： 在执行迁移命令时，提供正确的密码。可以通过以下两种方式提供密码：
命令行参数： 在 redis-cli 命令中使用 -a <password> 参数。例如：redis-cli -c -h <any_node_ip> -p <any_node_port> -a <password> cluster rebalance ...环境变量： 设置 REDISCLI_AUTH 环境变量。例如：export REDISCLI_AUTH=<password>

在Spring Boot配置中，确保 spring.redis.password 属性配置了正确的密码。

4. READONLY 异常

原因： 源节点是只读节点（Slave节点），无法执行迁移操作。修复方案：
选择Master节点： 确保从Master节点发起迁移操作。提升Slave节点为Master节点： 如果需要从某个Slave节点发起迁移操作，可以先将其提升为Master节点。可以使用 redis-cli -c -h <slave_node_ip> -p <slave_node_port> cluster failover 命令。

5. ASK重定向循环异常

原因： 客户端在执行ASK重定向时，由于某些原因，无法正确跳转到目标节点，导致循环重定向。修复方案：
检查网络连接： 确保客户端与所有节点之间的网络连接正常。更新客户端缓存： 客户端需要维护一个Slot和节点的映射关系表。如果客户端的缓存信息没有及时更新，可能会导致ASK重定向循环。确保客户端使用最新版本的Redis客户端，并配置合理的缓存刷新策略。在Spring Boot中，LettuceConnectionFactory 会自动管理连接和缓存，通常不需要手动处理。但如果遇到此问题，可以尝试重启应用，强制刷新缓存。检查集群状态： 确保集群状态正常，没有节点处于异常状态。增加 max-redirects: 适当增加客户端允许的最大重定向次数。在Spring Boot中，可以通过 spring.redis.cluster.max-redirects 属性配置。但增加 max-redirects 可能会掩盖真正的问题，因此应该优先排查其他原因。

6. 网络连接异常

原因： 节点之间的网络连接不稳定，导致数据传输中断。修复方案：
检查网络配置： 检查防火墙、路由等网络配置，确保节点之间的网络连接正常。使用稳定的网络： 尽量使用稳定的网络环境，避免使用公共Wi-Fi等不稳定的网络。调整网络参数： 可以尝试调整TCP连接的Keepalive参数，例如 tcp_keepalive_time、tcp_keepalive_intvl、tcp_keepalive_probes，以保持连接的活跃性。

7. 超时异常

原因： 在迁移过程中，某个操作（例如连接、数据传输）超时。修复方案：
调整超时时间： 适当增加超时时间。在Spring Boot中，可以通过 spring.redis.timeout 属性配置连接超时时间。优化网络： 优化网络环境，减少网络延迟。优化迁移策略： 调整迁移策略，例如减小每次迁移的数据量，或者使用更快的迁移算法。

8. 内存不足

原因： 在迁移过程中，某个节点的内存不足，导致迁移失败。修复方案：
增加内存： 增加节点的内存。清理内存： 清理节点上不必要的数据，释放内存空间。调整迁移策略： 调整迁移策略，例如减小每次迁移的数据量，或者使用更快的迁移算法。

9. MOVED重定向错误

原因： 客户端收到的MOVED重定向信息指向错误的节点。修复方案：
更新客户端缓存： 客户端需要维护一个Slot和节点的映射关系表。如果客户端的缓存信息没有及时更新，可能会导致MOVED重定向错误。确保客户端使用最新版本的Redis客户端，并配置合理的缓存刷新策略。检查集群状态： 确保集群状态正常，所有节点都已同步最新的Slot和节点的映射关系表。可以使用 redis-cli -c -h <any_node_ip> -p <any_node_port> cluster info 命令查看集群状态。重启客户端： 重启客户端可以强制刷新缓存，解决由于客户端缓存过期导致的MOVED重定向错误。

五、预防措施

除了上述修复方案，我们还应该采取一些预防措施，以减少Slot迁移异常的发生：

充分的压力测试： 在进行Slot迁移之前，进行充分的压力测试，模拟真实环境下的负载，评估迁移过程的稳定性和性能。监控： 建立完善的监控体系，实时监控集群的状态、性能指标，及时发现潜在的问题。可以使用Redis自带的 INFO 命令获取监控数据，或者使用第三方监控工具，例如 Prometheus、Grafana。备份： 在进行Slot迁移之前，对数据进行备份，以防止数据丢失。灰度发布： 采用灰度发布策略，逐步将流量迁移到新的节点，降低风险。选择合适的迁移工具： 选择合适的迁移工具，例如 redis-trib.rb、redis-cli，或者使用第三方迁移工具。

六、代码示例：监控迁移进度

以下是一个使用Java代码监控Slot迁移进度的示例，使用了Spring Data Redis。



import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.RedisClusterConnection;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.stereotype.Service;
 
import java.util.List;
import java.util.Map;
 
@Service
public class MigrationMonitorService {
 
    @Autowired
    private RedisConnectionFactory redisConnectionFactory;
 
    public void monitorMigration(String host, int port) {
        RedisClusterConnection connection = redisConnectionFactory.getClusterConnection();
        try {
            Map<String, Object> clusterInfo = connection.clusterInfo();
            System.out.println("Cluster Info: " + clusterInfo);
 
            // 获取MIGRATING 状态的 slots
            List<Integer> migratingSlots = connection.clusterGetKeysInSlot(0, 16383); // 获取全部 Slots
 
            if (migratingSlots != null && !migratingSlots.isEmpty()) {
                System.out.println("Migrating Slots: " + migratingSlots);
 
                // 获取正在 migrating 的 slot 详细信息，例如源节点、目标节点等
                for (Integer slot : migratingSlots) {
                  //  ClusterSlotInfo slotInfo = connection.clusterGetSlotInfo(slot); // Spring Data Redis没有直接提供获取SlotInfo的接口，需要自己实现或者使用redis-cli命令获取
                    System.out.println("Slot " + slot + " is migrating.");
                }
            } else {
                System.out.println("No slots are currently migrating.");
            }
 
        } catch (Exception e) {
            System.err.println("Error monitoring migration: " + e.getMessage());
        } finally {
            connection.close();
        }
    }
 
}

注意:

clusterGetKeysInSlot 方法只是获取指定 Slot 中的 Key，并不能直接判断 Slot 是否正在迁移。需要结合 CLUSTER INFO 命令返回的信息判断。Spring Data Redis 没有提供直接获取 Slot 详细信息的接口，需要自己实现或者使用 redis-cli 命令获取。实际应用中，可以结合定时任务，定期执行 monitorMigration 方法，并将监控结果输出到日志或者监控系统。

七、补充说明：使用redis-cli进行Slot迁移和监控

虽然Spring Data Redis 提供了操作 Redis Cluster 的 API，但在某些情况下，使用 redis-cli 命令更加方便和灵活。

1. Slot迁移

可以使用 redis-cli cluster rebalance 命令进行 Slot 迁移。


redis-cli -c -h <any_node_ip> -p <any_node_port> cluster rebalance --cluster-use-empty-masters --cluster-weight <node_id>=<weight>

参数说明：

--cluster-use-empty-masters: 允许将Slot迁移到空的Master节点。--cluster-weight <node_id>=<weight>: 设置节点的权重，权重越高，迁移到该节点的Slot就越多。

2. 监控迁移进度

可以使用 redis-cli cluster info 命令查看集群状态，包括正在迁移的Slot数量、迁移进度等。


redis-cli -c -h <any_node_ip> -p <any_node_port> cluster info

输出示例：



cluster_state:ok
cluster_slots_assigned:16384
cluster_slots_ok:16384
cluster_slots_pfail:0
cluster_slots_fail:0
cluster_known_nodes:6
cluster_size:3
cluster_current_epoch:7
cluster_my_epoch:7
cluster_stats_messages_ping_sent:1789
cluster_stats_messages_pong_sent:1776
cluster_stats_messages_sent:3565
cluster_stats_messages_ping_received:1776
cluster_stats_messages_pong_received:1789
cluster_stats_messages_meet_received:1
cluster_stats_messages_received:3566

可以通过监控 cluster_slots_assigned、cluster_slots_ok、cluster_slots_pfail、cluster_slots_fail 等指标来了解迁移进度和集群健康状况。