Spring Boot中Redis读写分离架构实现与优化-平芜编程栈

1. Redis读写分离架构解析

Redis作为高性能内存数据库，在实际生产环境中常常面临读多写少的场景。当单节点Redis实例无法满足业务需求时，读写分离架构成为提升系统吞吐量的有效方案。这种架构通过将写操作集中在主节点(Master)，读操作分散到多个从节点(Slave)，可以显著降低主节点压力，提高系统整体性能。

在Spring生态中，RedisTemplate是操作Redis的核心组件。默认配置下，RedisTemplate会向同一个Redis实例发送所有读写请求。要实现读写分离，我们需要对RedisTemplate进行深度定制，使其能够自动识别命令类型并路由到正确的节点。

2. 环境准备与基础配置

2.1 依赖引入

首先确保项目中已包含必要的Spring Data Redis依赖。对于Maven项目，pom.xml需要添加：

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

注意：Spring Boot 2.x版本默认使用Lettuce作为Redis客户端，相比Jedis具有更好的性能和线程安全特性。如需使用Jedis，需要显式排除Lettuce并引入Jedis依赖。

2.2 Redis主从节点配置

在application.yml中配置主从节点信息：

spring: redis: master: host: 192.168.1.100 port: 6379 slaves: - host: 192.168.1.101 port: 6379 - host: 192.168.1.102 port: 6379

这种配置方式清晰地区分了主节点和从节点，为后续的读写分离实现奠定了基础。

3. 读写分离核心实现

3.1 自定义连接工厂

实现读写分离的关键在于创建能够区分读写操作的连接工厂：

public class MasterSlaveRedisConnectionFactory extends LettuceConnectionFactory { private final RedisStandaloneConfiguration masterConfig; private final List<RedisStandaloneConfiguration> slaveConfigs; private LettucePoolingClientConfiguration poolConfig; // 构造函数接收主从配置 public MasterSlaveRedisConnectionFactory( RedisStandaloneConfiguration masterConfig, List<RedisStandaloneConfiguration> slaveConfigs, LettucePoolingClientConfiguration poolConfig) { super(masterConfig, poolConfig); this.masterConfig = masterConfig; this.slaveConfigs = slaveConfigs; this.poolConfig = poolConfig; } @Override public RedisConnection getConnection() { // 默认返回主节点连接 return super.getConnection(); } public RedisConnection getSlaveConnection() { // 随机选择一个从节点 RedisStandaloneConfiguration slaveConfig = slaveConfigs.get( ThreadLocalRandom.current().nextInt(slaveConfigs.size())); LettuceClientConfiguration clientConfig = LettucePoolingClientConfiguration.builder() .poolConfig(poolConfig.getPoolConfig()) .build(); return new LettuceConnectionFactory(slaveConfig, clientConfig).getConnection(); } }

3.2 自定义RedisTemplate

创建支持读写分离的RedisTemplate子类：

public class MasterSlaveRedisTemplate<K, V> extends RedisTemplate<K, V> { private final MasterSlaveRedisConnectionFactory connectionFactory; public MasterSlaveRedisTemplate(MasterSlaveRedisConnectionFactory connectionFactory) { this.connectionFactory = connectionFactory; setConnectionFactory(connectionFactory); afterPropertiesSet(); } @Override protected RedisConnection preProcessConnection(RedisConnection connection, boolean existingConnection) { // 根据命令类型决定使用主节点还是从节点 RedisCommand command = RedisCommand.of(getRequiredConnectionFactory() .getConnection() .getNativeConnection() .getState() .getCommand()); if (command != null && command.isReadOnly()) { return connectionFactory.getSlaveConnection(); } return connection; } }

4. 配置与使用

4.1 Spring配置类实现

创建配置类将自定义组件注入Spring容器：

@Configuration public class RedisConfig { @Value("${spring.redis.master.host}") private String masterHost; @Value("${spring.redis.master.port}") private int masterPort; @Value("#{'${spring.redis.slaves}'.split(',')}") private List<String> slaveNodes; @Bean public MasterSlaveRedisConnectionFactory redisConnectionFactory() { // 主节点配置 RedisStandaloneConfiguration masterConfig = new RedisStandaloneConfiguration(); masterConfig.setHostName(masterHost); masterConfig.setPort(masterPort); // 从节点配置 List<RedisStandaloneConfiguration> slaveConfigs = slaveNodes.stream() .map(node -> { String[] parts = node.split(":"); RedisStandaloneConfiguration cfg = new RedisStandaloneConfiguration(); cfg.setHostName(parts[0]); cfg.setPort(Integer.parseInt(parts[1])); return cfg; }) .collect(Collectors.toList()); // 连接池配置 GenericObjectPoolConfig<Object> poolConfig = new GenericObjectPoolConfig<>(); poolConfig.setMaxTotal(8); poolConfig.setMaxIdle(8); poolConfig.setMinIdle(0); LettucePoolingClientConfiguration clientConfig = LettucePoolingClientConfiguration.builder() .poolConfig(poolConfig) .build(); return new MasterSlaveRedisConnectionFactory(masterConfig, slaveConfigs, clientConfig); } @Bean public RedisTemplate<String, Object> redisTemplate( MasterSlaveRedisConnectionFactory connectionFactory) { MasterSlaveRedisTemplate<String, Object> template = new MasterSlaveRedisTemplate<>(connectionFactory); // 设置序列化方式 template.setKeySerializer(new StringRedisSerializer()); template.setValueSerializer(new GenericJackson2JsonRedisSerializer()); template.setHashKeySerializer(new StringRedisSerializer()); template.setHashValueSerializer(new GenericJackson2JsonRedisSerializer()); return template; } }

4.2 业务层使用示例

在Service层可以直接注入配置好的RedisTemplate：

@Service public class UserService { @Autowired private RedisTemplate<String, User> redisTemplate; public void saveUser(User user) { // 写操作会自动路由到主节点 redisTemplate.opsForValue().set("user:" + user.getId(), user); } public User getUser(String userId) { // 读操作会自动路由到从节点 return redisTemplate.opsForValue().get("user:" + userId); } }

5. 高级特性与优化

5.1 读写分离策略定制

默认的读写分离策略可能不满足所有业务场景，我们可以通过实现RoutingConnectionFactory接口来定制更复杂的路由逻辑：

public class CustomRoutingConnectionFactory implements RoutingConnectionFactory { private final RedisConnectionFactory master; private final List<RedisConnectionFactory> slaves; private final ThreadLocal<Boolean> forceMaster = new ThreadLocal<>(); // 强制使用主节点 public void forceMaster() { forceMaster.set(true); } // 清除强制标志 public void clearForce() { forceMaster.remove(); } @Override public RedisConnection getConnection() { if (Boolean.TRUE.equals(forceMaster.get())) { return master.getConnection(); } // 根据命令类型决定路由 // 这里可以扩展更复杂的路由逻辑 // ... } }

5.2 从节点负载均衡策略

默认的随机选择从节点策略可能导致负载不均衡，我们可以实现更智能的负载均衡：

public class LoadBalancedSlaveConnectionFactory { private final List<RedisConnectionFactory> slaves; private final AtomicInteger counter = new AtomicInteger(0); public RedisConnection getConnection() { int index = counter.getAndIncrement() % slaves.size(); return slaves.get(index).getConnection(); } }

6. 性能监控与问题排查

6.1 监控指标收集

实现读写分离后，需要监控各节点的负载情况：

public class RedisMetrics { private final RedisConnectionFactory master; private final List<RedisConnectionFactory> slaves; public Map<String, Object> getMetrics() { Map<String, Object> metrics = new HashMap<>(); // 主节点指标 RedisConnection masterConn = master.getConnection(); metrics.put("master.connected", masterConn.isOpen()); // 添加更多指标... // 从节点指标 for (int i = 0; i < slaves.size(); i++) { RedisConnection slaveConn = slaves.get(i).getConnection(); metrics.put("slave." + i + ".connected", slaveConn.isOpen()); // 添加更多指标... } return metrics; } }