企业官网建设流程全解析

1. RedisTemplate读写分离配置实战指南

在分布式系统架构中，Redis作为高性能缓存数据库的典型应用场景就是读写分离。Spring生态下的RedisTemplate虽然提供了便捷的操作接口，但官方默认实现并不直接支持读写分离配置。本文将基于实际生产经验，详细拆解如何改造RedisTemplate实现真正的读写分离架构。

2. 核心架构设计思路

2.1 读写分离的本质需求

Redis读写分离的核心价值在于：

• 写操作：通常由主节点(Master)处理，保证数据一致性
• 读操作：分散到多个从节点(Slave)执行，提高整体吞吐量
• 故障隔离：读写分离后，读操作不会影响写操作性能

2.2 Spring Data Redis的局限

原生RedisTemplate的典型问题：

// 传统配置方式无法区分读写连接 @Bean public RedisTemplate<String, Object> redisTemplate() { RedisTemplate<String, Object> template = new RedisTemplate<>(); template.setConnectionFactory(lettuceConnectionFactory()); return template; }

这种配置方式无论读写都会使用同一个连接工厂，无法实现真正的读写分离。

3. 完整实现方案

3.1 基础环境准备

3.1.1 Redis主从集群配置

建议至少采用1主2从架构：

主节点：192.168.1.10:6379 从节点1：192.168.1.11:6379 从节点2：192.168.1.12:6379

3.1.2 依赖引入

确保pom.xml包含：

<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <dependency> <groupId>io.lettuce</groupId> <artifactId>lettuce-core</artifactId> <version>6.2.4.RELEASE</version> </dependency>

3.2 核心配置类实现

3.2.1 读写连接工厂定义

@Configuration public class RedisConfig { @Value("${spring.redis.master.host}") private String masterHost; @Value("${spring.redis.slave.hosts}") private List<String> slaveHosts; // 主节点连接工厂 @Bean public LettuceConnectionFactory masterConnectionFactory() { RedisStandaloneConfiguration config = new RedisStandaloneConfiguration(); config.setHostName(masterHost.split(":")[0]); config.setPort(Integer.parseInt(masterHost.split(":")[1])); return new LettuceConnectionFactory(config); } // 从节点连接工厂(轮询) @Bean public AbstractRoutingConnectionFactory slaveConnectionFactory() { LettucePoolingClientConfiguration poolConfig = LettucePoolingClientConfiguration.builder() .poolConfig(new GenericObjectPoolConfig<>()) .build(); Map<Object, LettuceConnectionFactory> factories = new HashMap<>(); for (String slave : slaveHosts) { RedisStandaloneConfiguration config = new RedisStandaloneConfiguration(); config.setHostName(slave.split(":")[0]); config.setPort(Integer.parseInt(slave.split(":")[1])); factories.put(slave, new LettuceConnectionFactory(config, poolConfig)); } DynamicRoutingConnectionFactory routingFactory = new DynamicRoutingConnectionFactory(); routingFactory.setTargetConnectionFactories(factories); routingFactory.setDefaultTargetConnection(factories.values().iterator().next()); return routingFactory; } }

3.2.2 动态路由连接工厂

public class DynamicRoutingConnectionFactory extends AbstractRoutingConnectionFactory { private static final ThreadLocal<Boolean> readOnly = ThreadLocal.withInitial(() -> false); public static void setReadOnly(boolean flag) { readOnly.set(flag); } @Override protected Object determineCurrentLookupKey() { if (readOnly.get()) { // 从节点选择策略：简单轮询 return getResolvedSlaves().get(ThreadLocalRandom.current().nextInt(getResolvedSlaves().size())); } return "master"; } }

3.3 增强版RedisTemplate实现

3.3.1 读写分离模板类

public class ReadWriteRedisTemplate extends RedisTemplate<String, Object> { @Override public <T> T execute(RedisCallback<T> action, boolean exposeConnection, boolean pipeline) { try { if (isReadOperation(action)) { DynamicRoutingConnectionFactory.setReadOnly(true); } return super.execute(action, exposeConnection, pipeline); } finally { DynamicRoutingConnectionFactory.setReadOnly(false); } } private boolean isReadOperation(RedisCallback<?> action) { // 根据方法名判断读操作（实际项目应更完善） String methodName = action.getClass().getEnclosingMethod().getName(); return methodName.startsWith("get") || methodName.startsWith("exists"); } }

3.3.2 模板配置

@Bean public RedisTemplate<String, Object> redisTemplate() { ReadWriteRedisTemplate template = new ReadWriteRedisTemplate(); template.setConnectionFactory(masterConnectionFactory()); template.setDefaultSerializer(new Jackson2JsonRedisSerializer<>(Object.class)); template.setEnableTransactionSupport(true); return template; }

4. 高级优化策略

4.1 从节点负载均衡策略

建议实现更智能的负载策略：

public class WeightedRoundRobinSlaveSelector { private final List<SlaveNode> slaves; private final AtomicInteger counter = new AtomicInteger(0); public String selectSlave() { int index = counter.getAndIncrement() % slaves.size(); SlaveNode selected = slaves.get(index); if (selected.getCurrentLoad() > threshold) { return selectSlave(); // 递归选择 } return selected.getAddress(); } }

4.2 读写操作监控

通过AOP实现操作监控：

@Aspect @Component public class RedisOperationMonitor { @Around("execution(* org.springframework.data.redis.core.RedisOperations.*(..))") public Object monitor(ProceedingJoinPoint pjp) throws Throwable { long start = System.currentTimeMillis(); try { return pjp.proceed(); } finally { long cost = System.currentTimeMillis() - start; Metrics.record(pjp.getSignature().getName(), cost); } } }

5. 生产环境注意事项

5.1 主从延迟问题处理

典型解决方案：

1. 强制读主开关：

public Object getWithMasterFallback(String key) { try { return redisTemplate.opsForValue().get(key); } catch (ReadFromSlaveException e) { DynamicRoutingConnectionFactory.setReadOnly(false); return redisTemplate.opsForValue().get(key); } }

2. 延迟监控机制：

@Scheduled(fixedRate = 5000) public void checkReplicationDelay() { Long masterTime = getServerTime(masterClient); Long slaveTime = getServerTime(slaveClient); if (slaveTime - masterTime > 1000) { alertService.notify("Redis主从延迟超过1s"); } }

5.2 连接池优化参数

建议配置（基于Lettuce）：

spring: redis: lettuce: pool: max-active: 16 max-idle: 8 min-idle: 4 max-wait: 1000 time-between-eviction-runs: 30000

6. 性能对比测试

测试环境：3节点Redis集群（1主2从）

实测表明读写分离对读密集场景提升显著，写性能基本不受影响。