引言

在Java企业级应用中，Redis作为高性能的内存数据库，广泛应用于缓存、会话管理、分布式锁等场景。为了提高系统的可用性和性能，Redis主从架构成为了不可或缺的技术方案。本文将结合Java实战经验，深入探讨Redis主从架构的原理，并提供完整的搭建和集成指南。

Redis主从架构原理

什么是主从架构

Redis主从架构是一种数据复制方案，通过一个主节点（Master）和多个从节点（Slave）的协作，实现：

  • 数据冗余：多个从节点提供数据备份
  • 读写分离：主节点处理写操作，从节点处理读操作
  • 负载分担：读请求分散到多个从节点
  • 故障恢复：主节点故障时可以快速切换

主从复制流程

1. 建立连接阶段

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// 从节点连接主节点的过程（Java客户端视角）
public class RedisReplicationClient {
    private String masterHost;
    private int masterPort;
    private String masterAuth;
    
    public void connectToMaster() {
        try {
            // 创建到主节点的连接
            Jedis masterJedis = new Jedis(masterHost, masterPort);
            if (masterAuth != null) {
                masterJedis.auth(masterAuth);
            }
            
            // 发送PING命令测试连接
            String pong = masterJedis.ping();
            if ("PONG".equals(pong)) {
                System.out.println("成功连接到主节点");
            }
        } catch (Exception e) {
            System.err.println("连接主节点失败: " + e.getMessage());
        }
    }
}

2. 数据同步阶段

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 数据同步过程模拟
public class DataSyncProcess {
    
    public void syncData(Jedis master, Jedis slave) {
        // 1. 主节点生成RDB快照
        String lastSave = master.lastsave();
        System.out.println("主节点最后保存时间: " + lastSave);
        
        // 2. 从节点接收RDB数据
        // 这个过程由Redis内部完成
        
        // 3. 验证数据同步
        master.set("sync_test", "Hello Master-Slave");
        String value = slave.get("sync_test");
        System.out.println("从节点获取到数据: " + value);
    }
}

3. 命令传播阶段

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 命令传播监控
public class CommandPropagation {
    
    public void monitorReplication(Jedis master, Jedis slave) {
        // 监控主从复制状态
        String masterInfo = master.info("replication");
        String slaveInfo = slave.info("replication");
        
        System.out.println("主节点复制信息:");
        System.out.println(masterInfo);
        System.out.println("从节点复制信息:");
        System.out.println(slaveInfo);
    }
}

Java集成Redis主从架构

Spring Boot配置

1. 添加依赖

1
2
3
4
5
6
7
8
9
10
11
<!-- pom.xml -->
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
    </dependency>
</dependencies>

2. 配置文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# application.yml
spring:
  redis:
    # 主节点配置
    host: 192.168.1.100
    port: 6379
    password: your_password
    timeout: 2000ms
    jedis:
      pool:
        max-active: 20
        max-idle: 10
        min-idle: 5
        max-wait: 2000ms
    # 从节点配置
    cluster:
      nodes:
        - 192.168.1.101:6379
        - 192.168.1.102:6379

3. Redis配置类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
@Configuration
@EnableCaching
public class RedisConfig {
    
    @Value("${spring.redis.host}")
    private String masterHost;
    
    @Value("${spring.redis.port}")
    private int masterPort;
    
    @Value("${spring.redis.password}")
    private String password;
    
    @Value("${spring.redis.jedis.pool.max-active}")
    private int maxActive;
    
    @Value("${spring.redis.jedis.pool.max-idle}")
    private int maxIdle;
    
    @Value("${spring.redis.jedis.pool.min-idle}")
    private int minIdle;
    
    @Value("${spring.redis.jedis.pool.max-wait}")
    private long maxWaitMillis;
    
    // 主节点连接池
    @Bean("masterJedisPool")
    public JedisPool masterJedisPool() {
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxTotal(maxActive);
        config.setMaxIdle(maxIdle);
        config.setMinIdle(minIdle);
        config.setMaxWaitMillis(maxWaitMillis);
        config.setTestOnBorrow(true);
        config.setTestOnReturn(true);
        
        return new JedisPool(config, masterHost, masterPort, 2000, password);
    }
    
    // 从节点连接池
    @Bean("slaveJedisPool")
    public JedisPool slaveJedisPool() {
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxTotal(maxActive);
        config.setMaxIdle(maxIdle);
        config.setMinIdle(minIdle);
        config.setMaxWaitMillis(maxWaitMillis);
        config.setTestOnBorrow(true);
        config.setTestOnReturn(true);
        
        // 这里配置从节点地址
        return new JedisPool(config, "192.168.1.101", 6379, 2000, password);
    }
    
    // RedisTemplate配置
    @Bean
    public RedisTemplate<String, Object> redisTemplate(
            @Qualifier("masterJedisPool") JedisPool masterPool) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        
        // 使用自定义的Jedis连接工厂
        JedisConnectionFactory factory = new JedisConnectionFactory();
        factory.setHostName(masterHost);
        factory.setPort(masterPort);
        factory.setPassword(password);
        factory.setPoolConfig(createPoolConfig());
        factory.afterPropertiesSet();
        
        template.setConnectionFactory(factory);
        
        // 序列化配置
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        
        template.afterPropertiesSet();
        return template;
    }
    
    private JedisPoolConfig createPoolConfig() {
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxTotal(maxActive);
        config.setMaxIdle(maxIdle);
        config.setMinIdle(minIdle);
        config.setMaxWaitMillis(maxWaitMillis);
        config.setTestOnBorrow(true);
        config.setTestOnReturn(true);
        return config;
    }
}

读写分离实现

1. 读写分离服务类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
@Service
public class RedisReadWriteService {
    
    @Autowired
    @Qualifier("masterJedisPool")
    private JedisPool masterPool;
    
    @Autowired
    @Qualifier("slaveJedisPool")
    private JedisPool slavePool;
    
    // 写操作使用主节点
    public void write(String key, String value) {
        try (Jedis jedis = masterPool.getResource()) {
            jedis.set(key, value);
            System.out.println("写入主节点成功: " + key + " = " + value);
        } catch (Exception e) {
            System.err.println("写入主节点失败: " + e.getMessage());
            throw new RuntimeException("写入失败", e);
        }
    }
    
    // 读操作使用从节点
    public String read(String key) {
        try (Jedis jedis = slavePool.getResource()) {
            String value = jedis.get(key);
            System.out.println("从从节点读取: " + key + " = " + value);
            return value;
        } catch (Exception e) {
            System.err.println("从从节点读取失败: " + e.getMessage());
            // 从节点失败时，尝试从主节点读取
            return readFromMaster(key);
        }
    }
    
    // 从主节点读取（降级方案）
    private String readFromMaster(String key) {
        try (Jedis jedis = masterPool.getResource()) {
            String value = jedis.get(key);
            System.out.println("降级从主节点读取: " + key + " = " + value);
            return value;
        } catch (Exception e) {
            System.err.println("从主节点读取也失败: " + e.getMessage());
            throw new RuntimeException("读取失败", e);
        }
    }
    
    // 批量写操作
    public void batchWrite(Map<String, String> keyValues) {
        try (Jedis jedis = masterPool.getResource()) {
            Pipeline pipeline = jedis.pipelined();
            for (Map.Entry<String, String> entry : keyValues.entrySet()) {
                pipeline.set(entry.getKey(), entry.getValue());
            }
            pipeline.sync();
            System.out.println("批量写入完成，共 " + keyValues.size() + " 条记录");
        } catch (Exception e) {
            System.err.println("批量写入失败: " + e.getMessage());
            throw new RuntimeException("批量写入失败", e);
        }
    }
    
    // 批量读操作
    public Map<String, String> batchRead(List<String> keys) {
        Map<String, String> result = new HashMap<>();
        try (Jedis jedis = slavePool.getResource()) {
            Pipeline pipeline = jedis.pipelined();
            List<Response<String>> responses = new ArrayList<>();
            
            for (String key : keys) {
                responses.add(pipeline.get(key));
            }
            pipeline.sync();
            
            for (int i = 0; i < keys.size(); i++) {
                String value = responses.get(i).get();
                if (value != null) {
                    result.put(keys.get(i), value);
                }
            }
            System.out.println("批量读取完成，共 " + result.size() + " 条记录");
        } catch (Exception e) {
            System.err.println("批量读取失败: " + e.getMessage());
            throw new RuntimeException("批量读取失败", e);
        }
        return result;
    }
}

2. 缓存服务实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
@Service
public class CacheService {
    
    @Autowired
    private RedisReadWriteService redisService;
    
    // 缓存用户信息
    public void cacheUserInfo(String userId, UserInfo userInfo) {
        try {
            String key = "user:info:" + userId;
            String value = JSON.toJSONString(userInfo);
            redisService.write(key, value);
            
            // 设置过期时间
            try (Jedis jedis = redisService.getMasterPool().getResource()) {
                jedis.expire(key, 3600); // 1小时过期
            }
        } catch (Exception e) {
            System.err.println("缓存用户信息失败: " + e.getMessage());
        }
    }
    
    // 获取用户信息
    public UserInfo getUserInfo(String userId) {
        try {
            String key = "user:info:" + userId;
            String value = redisService.read(key);
            if (value != null) {
                return JSON.parseObject(value, UserInfo.class);
            }
        } catch (Exception e) {
            System.err.println("获取用户信息失败: " + e.getMessage());
        }
        return null;
    }
    
    // 缓存商品信息
    public void cacheProductInfo(String productId, ProductInfo productInfo) {
        try {
            String key = "product:info:" + productId;
            String value = JSON.toJSONString(productInfo);
            redisService.write(key, value);
            
            // 设置过期时间
            try (Jedis jedis = redisService.getMasterPool().getResource()) {
                jedis.expire(key, 1800); // 30分钟过期
            }
        } catch (Exception e) {
            System.err.println("缓存商品信息失败: " + e.getMessage());
        }
    }
    
    // 获取商品信息
    public ProductInfo getProductInfo(String productId) {
        try {
            String key = "product:info:" + productId;
            String value = redisService.read(key);
            if (value != null) {
                return JSON.parseObject(value, ProductInfo.class);
            }
        } catch (Exception e) {
            System.err.println("获取商品信息失败: " + e.getMessage());
        }
        return null;
    }
}

监控和健康检查

1. 健康检查服务

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
@Component
public class RedisHealthChecker {
    
    @Autowired
    @Qualifier("masterJedisPool")
    private JedisPool masterPool;
    
    @Autowired
    @Qualifier("slaveJedisPool")
    private JedisPool slavePool;
    
    // 检查主节点健康状态
    public boolean checkMasterHealth() {
        try (Jedis jedis = masterPool.getResource()) {
            String pong = jedis.ping();
            if ("PONG".equals(pong)) {
                // 检查复制状态
                String info = jedis.info("replication");
                System.out.println("主节点健康检查通过");
                System.out.println("主节点复制信息: " + info);
                return true;
            }
        } catch (Exception e) {
            System.err.println("主节点健康检查失败: " + e.getMessage());
        }
        return false;
    }
    
    // 检查从节点健康状态
    public boolean checkSlaveHealth() {
        try (Jedis jedis = slavePool.getResource()) {
            String pong = jedis.ping();
            if ("PONG".equals(pong)) {
                // 检查复制状态
                String info = jedis.info("replication");
                System.out.println("从节点健康检查通过");
                System.out.println("从节点复制信息: " + info);
                return true;
            }
        } catch (Exception e) {
            System.err.println("从节点健康检查失败: " + e.getMessage());
        }
        return false;
    }
    
    // 检查主从复制延迟
    public long checkReplicationLag() {
        try (Jedis masterJedis = masterPool.getResource();
             Jedis slaveJedis = slavePool.getResource()) {
            
            // 获取主节点复制信息
            String masterInfo = masterJedis.info("replication");
            String slaveInfo = slaveJedis.info("replication");
            
            // 解析复制延迟
            long masterOffset = parseOffset(masterInfo);
            long slaveOffset = parseOffset(slaveInfo);
            
            long lag = masterOffset - slaveOffset;
            System.out.println("主从复制延迟: " + lag + " bytes");
            
            return lag;
        } catch (Exception e) {
            System.err.println("检查复制延迟失败: " + e.getMessage());
            return -1;
        }
    }
    
    private long parseOffset(String info) {
        // 解析复制偏移量
        String[] lines = info.split("\r\n");
        for (String line : lines) {
            if (line.startsWith("master_repl_offset:")) {
                return Long.parseLong(line.split(":")[1]);
            }
        }
        return 0;
    }
}

2. 定时监控任务

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
@Component
public class RedisMonitorTask {
    
    @Autowired
    private RedisHealthChecker healthChecker;
    
    @Scheduled(fixedRate = 30000) // 每30秒执行一次
    public void monitorRedisHealth() {
        System.out.println("=== Redis健康检查开始 ===");
        
        // 检查主节点
        boolean masterHealthy = healthChecker.checkMasterHealth();
        System.out.println("主节点状态: " + (masterHealthy ? "健康" : "异常"));
        
        // 检查从节点
        boolean slaveHealthy = healthChecker.checkSlaveHealth();
        System.out.println("从节点状态: " + (slaveHealthy ? "健康" : "异常"));
        
        // 检查复制延迟
        long lag = healthChecker.checkReplicationLag();
        if (lag > 0) {
            System.out.println("复制延迟: " + lag + " bytes");
            if (lag > 1024 * 1024) { // 超过1MB
                System.out.println("警告: 复制延迟过大!");
            }
        }
        
        System.out.println("=== Redis健康检查结束 ===\n");
    }
}

故障处理和切换

1. 故障检测

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
@Component
public class RedisFailoverHandler {
    
    @Autowired
    @Qualifier("masterJedisPool")
    private JedisPool masterPool;
    
    @Autowired
    @Qualifier("slaveJedisPool")
    private JedisPool slavePool;
    
    private volatile boolean masterDown = false;
    
    // 检测主节点故障
    public boolean detectMasterFailure() {
        try (Jedis jedis = masterPool.getResource()) {
            jedis.ping();
            masterDown = false;
            return false;
        } catch (Exception e) {
            masterDown = true;
            System.err.println("主节点故障检测: " + e.getMessage());
            return true;
        }
    }
    
    // 故障切换处理
    public void handleFailover() {
        if (detectMasterFailure()) {
            System.out.println("检测到主节点故障，开始故障切换...");
            
            // 1. 停止写入操作
            System.out.println("停止写入操作");
            
            // 2. 通知应用层
            notifyApplicationLayer();
            
            // 3. 等待数据同步完成
            waitForDataSync();
            
            // 4. 提升从节点为主节点
            promoteSlaveToMaster();
            
            System.out.println("故障切换完成");
        }
    }
    
    private void notifyApplicationLayer() {
        // 通知应用层主节点故障
        System.out.println("通知应用层: 主节点故障，切换到只读模式");
    }
    
    private void waitForDataSync() {
        // 等待数据同步完成
        System.out.println("等待数据同步完成...");
        try {
            Thread.sleep(5000); // 等待5秒
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
    
    private void promoteSlaveToMaster() {
        try (Jedis slaveJedis = slavePool.getResource()) {
            // 执行 SLAVEOF NO ONE 命令
            slaveJedis.slaveofNoOne();
            System.out.println("从节点已提升为主节点");
        } catch (Exception e) {
            System.err.println("提升从节点失败: " + e.getMessage());
        }
    }
}

2. 自动故障切换

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Component
public class AutoFailoverService {
    
    @Autowired
    private RedisFailoverHandler failoverHandler;
    
    @Scheduled(fixedRate = 10000) // 每10秒检查一次
    public void checkAndHandleFailover() {
        try {
            failoverHandler.handleFailover();
        } catch (Exception e) {
            System.err.println("自动故障切换检查失败: " + e.getMessage());
        }
    }
}

性能优化

1. 连接池优化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
@Configuration
public class OptimizedRedisConfig {
    
    // 优化的连接池配置
    @Bean("optimizedMasterPool")
    public JedisPool optimizedMasterPool() {
        JedisPoolConfig config = new JedisPoolConfig();
        
        // 连接池大小优化
        config.setMaxTotal(50);           // 最大连接数
        config.setMaxIdle(20);            // 最大空闲连接数
        config.setMinIdle(10);            // 最小空闲连接数
        config.setMaxWaitMillis(3000);    // 最大等待时间
        
        // 连接有效性检测
        config.setTestOnBorrow(true);      // 借用时检测
        config.setTestOnReturn(true);      // 归还时检测
        config.setTestWhileIdle(true);     // 空闲时检测
        
        // 空闲连接检测配置
        config.setTimeBetweenEvictionRunsMillis(30000);  // 30秒检测一次
        config.setMinEvictableIdleTimeMillis(60000);      // 空闲60秒后回收
        config.setNumTestsPerEvictionRun(3);              // 每次检测3个连接
        
        return new JedisPool(config, "192.168.1.100", 6379, 2000, "password");
    }
}

2. 批量操作优化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
@Service
public class OptimizedRedisService {
    
    @Autowired
    @Qualifier("optimizedMasterPool")
    private JedisPool masterPool;
    
    // 优化的批量写入
    public void optimizedBatchWrite(Map<String, String> data) {
        try (Jedis jedis = masterPool.getResource()) {
            Pipeline pipeline = jedis.pipelined();
            
            // 批量设置
            for (Map.Entry<String, String> entry : data.entrySet()) {
                pipeline.set(entry.getKey(), entry.getValue());
            }
            
            // 批量设置过期时间
            for (String key : data.keySet()) {
                pipeline.expire(key, 3600);
            }
            
            // 执行批量操作
            List<Object> results = pipeline.syncAndReturnAll();
            System.out.println("批量操作完成，处理了 " + results.size() + " 个命令");
        } catch (Exception e) {
            System.err.println("批量写入失败: " + e.getMessage());
            throw new RuntimeException("批量写入失败", e);
        }
    }
    
    // 使用Lua脚本优化复杂操作
    public void optimizedComplexOperation(String key, String value) {
        String luaScript = 
            "local key = KEYS[1]\n" +
            "local value = ARGV[1]\n" +
            "local ttl = ARGV[2]\n" +
            "redis.call('SET', key, value)\n" +
            "redis.call('EXPIRE', key, ttl)\n" +
            "return redis.call('GET', key)\n";
        
        try (Jedis jedis = masterPool.getResource()) {
            Object result = jedis.eval(luaScript, 1, key, value, "3600");
            System.out.println("Lua脚本执行结果: " + result);
        } catch (Exception e) {
            System.err.println("Lua脚本执行失败: " + e.getMessage());
        }
    }
}

实际应用案例

1. 电商系统缓存

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
@Service
public class EcommerceCacheService {
    
    @Autowired
    private RedisReadWriteService redisService;
    
    // 缓存商品详情
    public void cacheProductDetail(String productId, ProductDetail product) {
        String key = "product:detail:" + productId;
        String value = JSON.toJSONString(product);
        
        redisService.write(key, value);
        
        // 设置过期时间
        try (Jedis jedis = redisService.getMasterPool().getResource()) {
            jedis.expire(key, 1800); // 30分钟
        }
    }
    
    // 获取商品详情
    public ProductDetail getProductDetail(String productId) {
        String key = "product:detail:" + productId;
        String value = redisService.read(key);
        
        if (value != null) {
            return JSON.parseObject(value, ProductDetail.class);
        }
        
        // 缓存未命中，从数据库加载
        return loadFromDatabase(productId);
    }
    
    // 缓存用户购物车
    public void cacheUserCart(String userId, List<CartItem> cartItems) {
        String key = "user:cart:" + userId;
        String value = JSON.toJSONString(cartItems);
        
        redisService.write(key, value);
        
        // 购物车数据不过期，用户主动清除
    }
    
    // 获取用户购物车
    public List<CartItem> getUserCart(String userId) {
        String key = "user:cart:" + userId;
        String value = redisService.read(key);
        
        if (value != null) {
            return JSON.parseArray(value, CartItem.class);
        }
        
        return new ArrayList<>();
    }
    
    private ProductDetail loadFromDatabase(String productId) {
        // 从数据库加载商品详情
        // 这里省略具体实现
        return new ProductDetail();
    }
}

2. 用户会话管理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
@Service
public class SessionManagementService {
    
    @Autowired
    private RedisReadWriteService redisService;
    
    // 创建用户会话
    public String createUserSession(String userId, UserSession session) {
        String sessionId = UUID.randomUUID().toString();
        String key = "session:" + sessionId;
        String value = JSON.toJSONString(session);
        
        redisService.write(key, value);
        
        // 设置会话过期时间
        try (Jedis jedis = redisService.getMasterPool().getResource()) {
            jedis.expire(key, 1800); // 30分钟
        }
        
        // 记录用户与会话的映射
        String userSessionKey = "user:session:" + userId;
        redisService.write(userSessionKey, sessionId);
        
        return sessionId;
    }
    
    // 获取用户会话
    public UserSession getUserSession(String sessionId) {
        String key = "session:" + sessionId;
        String value = redisService.read(key);
        
        if (value != null) {
            return JSON.parseObject(value, UserSession.class);
        }
        
        return null;
    }
    
    // 延长会话时间
    public void extendSession(String sessionId) {
        String key = "session:" + sessionId;
        
        try (Jedis jedis = redisService.getMasterPool().getResource()) {
            jedis.expire(key, 1800); // 重新设置30分钟
        }
    }
    
    // 销毁用户会话
    public void destroyUserSession(String sessionId) {
        String key = "session:" + sessionId;
        
        try (Jedis jedis = redisService.getMasterPool().getResource()) {
            jedis.del(key);
        }
    }
}

总结

通过本文的详细介绍，我们了解了：

核心要点

  1. Redis主从架构原理：数据复制、读写分离、故障恢复
  2. Java集成方案：Spring Boot配置、连接池管理、读写分离实现
  3. 监控和健康检查：实时监控主从状态、复制延迟检测
  4. 故障处理机制：故障检测、自动切换、降级方案
  5. 性能优化策略：连接池优化、批量操作、Lua脚本

最佳实践

  • 合理配置连接池：根据业务量调整连接池大小
  • 实现读写分离：提高读性能，减轻主节点压力
  • 监控复制延迟：确保数据一致性
  • 准备故障切换：提高系统可用性
  • 优化批量操作：使用Pipeline和Lua脚本

注意事项

  • 主从复制存在延迟，需要根据业务需求评估
  • 故障切换需要手动处理，建议结合Sentinel实现自动切换
  • 监控和告警机制必不可少
  • 定期备份和测试故障恢复流程

掌握Redis主从架构的Java实战应用，将大大提升系统的性能和可靠性，为高并发应用提供强有力的技术支撑。