Redis读写分离架构与Spring Data Redis实战

1. Redis读写分离架构解析

Redis作为高性能内存数据库，读写分离是提升系统吞吐量的经典方案。其核心思想是将写操作集中在主节点（Master），读操作分散到多个从节点（Slave）。这种架构特别适合读多写少的场景——根据我的实战经验，当系统读请求占比超过70%时，读写分离带来的性能提升尤为明显。

Redis主从同步采用异步复制机制。当客户端向主节点写入数据后，主节点会将写命令通过Redis Replication协议发送给所有从节点。这里有个关键细节：从节点默认以非阻塞方式接收数据变更，这意味着主节点不会等待从节点完成同步才响应客户端。这种设计保证了写入性能，但也带来了数据一致性的时间窗口问题——我在电商秒杀系统中曾遇到过因主从延迟导致库存显示不一致的情况。

读写分离的核心价值体现在三个方面：

1. 负载均衡：将读压力分散到多个从节点，避免单节点过载
2. 高可用：从节点可作为主节点的热备份，故障时快速切换
3. 扩展性：通过增加从节点可线性提升读吞吐量

重要提示：Redis 5.0版本后提供了PSYNC2协议，相比早期的SYNC机制，能在主从切换时实现部分重同步，大幅减少全量同步的发生概率。这是配置读写分离时需要特别注意的版本特性。

2. Spring Data RedisTemplate工作机制

Spring Data Redis通过RedisTemplate抽象了对Redis的操作，其设计哲学是"约定优于配置"。在底层实现上，RedisTemplate将Java对象序列化后通过Jedis/Lettuce客户端与Redis服务端通信。我经常看到开发者直接使用默认配置，这会导致一些隐蔽问题——比如默认的JdkSerializationRedisSerializer会产生兼容性问题。

RedisTemplate的核心组件包括：

• ConnectionFactory：管理物理连接（通常使用LettuceConnectionFactory）
• Serializers：键值序列化策略（建议使用StringRedisSerializer+Jackson2JsonRedisSerializer组合）
• Executor：操作执行器（影响异步操作行为）

实现读写分离的关键在于配置多个连接工厂。主节点连接工厂负责处理写操作，从节点连接工厂集群处理读操作。这里有个实践中的经验：Lettuce客户端相比传统Jedis更适合读写分离场景，因为它原生支持读写路由配置，且连接池管理更高效。

java复制// 典型的主从连接工厂配置示例
@Bean
public LettuceConnectionFactory masterConnectionFactory() {
    RedisStandaloneConfiguration config = new RedisStandaloneConfiguration();
    config.setHostName("master.redis.example.com");
    config.setPort(6379);
    return new LettuceConnectionFactory(config);
}

@Bean
public LettuceConnectionFactory slaveConnectionFactory() {
    RedisStandaloneConfiguration config = new RedisStandaloneConfiguration();
    config.setHostName("slave.redis.example.com");
    config.setPort(6379);
    return new LettuceConnectionFactory(config);
}

3. 读写分离配置实战

3.1 基础环境搭建

首先需要准备至少两个Redis实例：一个主节点和一个从节点。在从节点的redis.conf中需要配置：

code复制replicaof <masterip> <masterport>

这个配置项在Redis 5.0之前使用的是slaveof关键字，这是版本升级时需要注意的兼容点。我建议使用Docker快速搭建测试环境：

bash复制# 主节点
docker run --name redis-master -p 6379:6379 -d redis redis-server --appendonly yes

# 从节点 
docker run --name redis-slave -p 6380:6379 -d redis redis-server --appendonly yes --replicaof redis-master 6379

3.2 Spring Boot集成配置

在application.yml中需要明确区分主从节点配置：

yaml复制spring:
  redis:
    master:
      host: 192.168.1.100
      port: 6379
    slave:
      host: 192.168.1.101
      port: 6379

然后创建路由RedisTemplate，这是实现读写分离的核心：

java复制@Configuration
public class RedisConfig {
    
    @Bean
    @Primary
    public RedisTemplate<String, Object> redisTemplate(
            @Qualifier("masterConnectionFactory") RedisConnectionFactory masterCF,
            @Qualifier("slaveConnectionFactory") RedisConnectionFactory slaveCF) {
        
        // 创建路由连接工厂
        RoutingConnectionFactory routingCF = new RoutingConnectionFactory(masterCF, slaveCF);
        
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(routingCF);
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        return template;
    }
}

// 自定义路由连接工厂
class RoutingConnectionFactory implements RedisConnectionFactory {
    private final RedisConnectionFactory master;
    private final RedisConnectionFactory slave;
    
    public RoutingConnectionFactory(RedisConnectionFactory master, RedisConnectionFactory slave) {
        this.master = master;
        this.slave = slave;
    }
    
    @Override
    public RedisConnection getConnection() {
        // 通过TransactionSynchronizationManager判断当前操作
        boolean isReadOnly = TransactionSynchronizationManager.isCurrentTransactionReadOnly();
        return isReadOnly ? slave.getConnection() : master.getConnection();
    }
    
    // 其他必要方法实现...
}

3.3 读写路由策略优化

基础的路由策略是根据事务的readOnly属性判断，但在实际业务中可能需要更精细的控制。我推荐两种进阶方案：

1. 注解驱动路由：自定义@ReadOnly注解标记只读方法

java复制@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ReadOnly {
}

// 在AOP中根据注解切换数据源
@Around("@annotation(ReadOnly)")
public Object routeToSlave(ProceedingJoinPoint pjp) {
    TransactionSynchronizationManager.setCurrentTransactionReadOnly(true);
    try {
        return pjp.proceed();
    } finally {
        TransactionSynchronizationManager.clear();
    }
}

2. 命令级路由：根据Redis命令类型自动路由

java复制public class CommandBasedRoutingConnectionFactory extends RoutingConnectionFactory {
    private static final Set<CommandType> READ_COMMANDS = Set.of(
        CommandType.GET, CommandType.HGET, CommandType.LRANGE, CommandType.SMEMBERS
        // 其他读命令...
    );
    
    @Override
    public RedisConnection getConnection() {
        if (isReadOperation()) {
            return slave.getConnection();
        }
        return master.getConnection();
    }
    
    private boolean isReadOperation() {
        StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
        // 分析调用栈判断操作类型
        // 实际实现需要更精确的命令解析
    }
}

4. 生产环境注意事项

4.1 主从延迟监控

读写分离最大的风险是主从延迟导致的数据不一致。我建议通过以下方式监控：

1. 定期检查info replication中的master_repl_offset和slave_repl_offset
2. 使用Redis的WAIT命令实现强一致性读取（但会牺牲性能）
3. 关键业务数据可采用双读策略：先读从节点，若数据不存在再读主节点

java复制public <T> T getWithFallback(String key, Class<T> type) {
    T value = redisTemplate.opsForValue().get(key);
    if (value == null) {
        // 从节点无数据时降级到主节点
        try (RedisConnection conn = masterConnectionFactory.getConnection()) {
            byte[] data = conn.get(key.getBytes());
            value = objectMapper.readValue(data, type);
        }
    }
    return value;
}

4.2 故障转移处理

当主节点宕机时，需要处理以下场景：

1. 自动故障检测：通过Redis Sentinel或Cluster模式实现
2. 写操作降级：可将写操作临时路由到从节点（需配置replica-read-only no）
3. 客户端缓存：在故障期间启用本地缓存

java复制@Bean
public SentinelConfiguration sentinelConfiguration() {
    return new SentinelConfiguration()
        .master("mymaster")
        .sentinel("sentinel1", 26379)
        .sentinel("sentinel2", 26379);
}

@Bean
public LettuceConnectionFactory redisConnectionFactory() {
    LettuceClientConfiguration config = LettuceClientConfiguration.builder()
        .readFrom(ReadFrom.REPLICA_PREFERRED)  // 优先从副本读取
        .build();
    return new LettuceConnectionFactory(sentinelConfiguration(), config);
}

4.3 性能调优建议

1. 连接池配置：主从节点应使用独立的连接池

yaml复制spring:
  redis:
    lettuce:
      pool:
        max-active: 8
        max-idle: 8
        min-idle: 2

2. 序列化优化：避免使用Java原生序列化

java复制// 高性能序列化组合
template.setKeySerializer(new StringRedisSerializer());
template.setHashKeySerializer(new StringRedisSerializer());
template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
template.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());

3. 管道批处理：对批量操作使用pipeline

java复制List<Object> results = redisTemplate.executePipelined(
    (RedisCallback<Object>) connection -> {
        for (String key : keys) {
            connection.get(key.getBytes());
        }
        return null;
    }
);

在千万级PV的社交平台项目中，我们通过上述配置将Redis读性能提升了3倍，同时将主节点CPU负载降低了40%。但要注意，读写分离不是银弹——对于写密集型场景，可能需要考虑Redis Cluster分片方案。