1. Redis持久化概述

Redis持久化是将内存中的数据保存到磁盘的过程，确保Redis重启后能够恢复数据。Redis提供了RDB（Redis Database）和AOF（Append Only File）两种持久化方式，以及混合持久化模式。本文将详细介绍Redis持久化的原理、配置、优化策略以及生产环境中的最佳实践。

1.1 Redis持久化的必要性

  1. 数据安全: 防止Redis重启或崩溃时数据丢失
  2. 灾难恢复: 支持从备份文件快速恢复数据
  3. 数据迁移: 便于数据在不同环境间迁移
  4. 性能优化: 通过持久化优化内存使用
  5. 业务连续性: 确保业务服务的高可用性

1.2 Redis持久化方式对比

1
2
3
4
5
6
7
8
9
10
11
12
13
14
┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│   RDB持久化     │    │   AOF持久化     │    │  混合持久化     │
│                 │    │                 │    │                 │
│  ┌───────────┐  │    │  ┌───────────┐  │    │  ┌───────────┐  │
│  │ 快照文件  │  │    │  │ 命令日志  │  │    │  │ RDB+AOF   │  │
│  │ dump.rdb │  │    │  │appendonly │  │    │  │ 混合文件  │  │
│  └───────────┘  │    │  │    .aof   │  │    │  └───────────┘  │
│                 │    │  └───────────┘  │    │                 │
│  • 文件小      │    │                 │    │  • 兼顾性能    │
│  • 恢复快      │    │  • 数据完整     │    │  • 数据安全    │
│  • 性能好      │    │  • 可读性强     │    │  • 恢复快速    │
│  • 数据丢失    │    │  • 文件较大     │    │  • 配置复杂    │
└─────────────────┘    │  • 恢复较慢     │    └─────────────────┘
                       └─────────────────┘

2. RDB持久化实现

2.1 RDB持久化原理

RDB持久化通过创建数据快照的方式保存Redis在某个时间点的数据状态。RDB文件是一个压缩的二进制文件，包含了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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
// RDB持久化管理器
@Component
@Slf4j
public class RDBPersistenceManager {
    
    private final RedisTemplate<String, Object> redisTemplate;
    private final RedisConnectionFactory connectionFactory;
    private final ScheduledExecutorService scheduler;
    
    public RDBPersistenceManager(RedisTemplate<String, Object> redisTemplate,
                               RedisConnectionFactory connectionFactory) {
        this.redisTemplate = redisTemplate;
        this.connectionFactory = connectionFactory;
        this.scheduler = Executors.newScheduledThreadPool(2);
    }
    
    // 手动触发RDB快照
    public void triggerManualSnapshot() {
        try {
            RedisConnection connection = connectionFactory.getConnection();
            connection.bgSave(); // 异步保存
            log.info("Manual RDB snapshot triggered");
        } catch (Exception e) {
            log.error("Error triggering manual snapshot", e);
            throw new RuntimeException("Failed to trigger manual snapshot", e);
        }
    }
    
    // 同步保存RDB快照
    public void triggerSyncSnapshot() {
        try {
            RedisConnection connection = connectionFactory.getConnection();
            connection.save(); // 同步保存
            log.info("Sync RDB snapshot completed");
        } catch (Exception e) {
            log.error("Error triggering sync snapshot", e);
            throw new RuntimeException("Failed to trigger sync snapshot", e);
        }
    }
    
    // 获取RDB持久化状态
    public RDBStatus getRDBStatus() {
        RDBStatus status = new RDBStatus();
        
        try {
            RedisConnection connection = connectionFactory.getConnection();
            Properties persistenceInfo = connection.info("persistence");
            
            status.setRdbChangesSinceLastSave(
                    Long.parseLong(persistenceInfo.getProperty("rdb_changes_since_last_save", "0")));
            status.setRdbBgsaveInProgress(
                    "1".equals(persistenceInfo.getProperty("rdb_bgsave_in_progress")));
            status.setRdbLastSaveTime(
                    Long.parseLong(persistenceInfo.getProperty("rdb_last_save_time", "0")));
            status.setRdbLastBgsaveStatus(
                    persistenceInfo.getProperty("rdb_last_bgsave_status"));
            status.setRdbLastBgsaveTimeSec(
                    Long.parseLong(persistenceInfo.getProperty("rdb_last_bgsave_time_sec", "0")));
            status.setRdbCurrentBgsaveTimeSec(
                    Long.parseLong(persistenceInfo.getProperty("rdb_current_bgsave_time_sec", "0")));
            
        } catch (Exception e) {
            log.error("Error getting RDB status", e);
            status.setError(e.getMessage());
        }
        
        return status;
    }
    
    // 检查RDB文件
    public RDBFileInfo checkRDBFile(String filePath) {
        RDBFileInfo fileInfo = new RDBFileInfo();
        
        try {
            File file = new File(filePath);
            if (file.exists()) {
                fileInfo.setExists(true);
                fileInfo.setSize(file.length());
                fileInfo.setLastModified(file.lastModified());
                fileInfo.setPath(filePath);
                
                // 验证RDB文件完整性
                boolean isValid = validateRDBFile(filePath);
                fileInfo.setValid(isValid);
                
            } else {
                fileInfo.setExists(false);
            }
            
        } catch (Exception e) {
            log.error("Error checking RDB file", e);
            fileInfo.setError(e.getMessage());
        }
        
        return fileInfo;
    }
    
    // 验证RDB文件完整性
    private boolean validateRDBFile(String filePath) {
        try {
            // 使用Redis自带的redis-check-rdb工具验证
            ProcessBuilder pb = new ProcessBuilder("redis-check-rdb", filePath);
            Process process = pb.start();
            
            int exitCode = process.waitFor();
            return exitCode == 0;
            
        } catch (Exception e) {
            log.error("Error validating RDB file", e);
            return false;
        }
    }
    
    // 清理过期的RDB文件
    public void cleanupOldRDBFiles(String directory, int keepDays) {
        try {
            File dir = new File(directory);
            if (!dir.exists() || !dir.isDirectory()) {
                return;
            }
            
            File[] files = dir.listFiles((d, name) -> name.endsWith(".rdb"));
            if (files == null) {
                return;
            }
            
            long cutoffTime = System.currentTimeMillis() - (keepDays * 24L * 60L * 60L * 1000L);
            
            for (File file : files) {
                if (file.lastModified() < cutoffTime) {
                    if (file.delete()) {
                        log.info("Deleted old RDB file: {}", file.getName());
                    } else {
                        log.warn("Failed to delete old RDB file: {}", file.getName());
                    }
                }
            }
            
        } catch (Exception e) {
            log.error("Error cleaning up old RDB files", e);
        }
    }
}

2.2 RDB配置优化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# redis.conf - RDB配置
# RDB持久化配置
save 900 1      # 900秒内至少1个key发生变化时保存
save 300 10     # 300秒内至少10个key发生变化时保存
save 60 10000   # 60秒内至少10000个key发生变化时保存

# RDB文件配置
dbfilename dump.rdb
dir /var/lib/redis

# RDB压缩配置
rdbcompression yes
rdbchecksum yes

# RDB保存配置
stop-writes-on-bgsave-error yes
rdb-save-incremental-fsync yes

# 内存配置
maxmemory 2gb
maxmemory-policy allkeys-lru

2.3 RDB备份策略

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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
// RDB备份策略管理器
@Service
@Slf4j
public class RDBBackupStrategy {
    
    private final RDBPersistenceManager rdbManager;
    private final RedisTemplate<String, Object> redisTemplate;
    
    public RDBBackupStrategy(RDBPersistenceManager rdbManager,
                           RedisTemplate<String, Object> redisTemplate) {
        this.rdbManager = rdbManager;
        this.redisTemplate = redisTemplate;
    }
    
    // 定时备份策略
    @Scheduled(cron = "0 0 2 * * ?") // 每天凌晨2点执行
    public void scheduledBackup() {
        log.info("Starting scheduled RDB backup");
        
        try {
            // 触发RDB快照
            rdbManager.triggerManualSnapshot();
            
            // 等待快照完成
            waitForSnapshotCompletion();
            
            // 复制RDB文件到备份目录
            String backupPath = createBackupPath();
            copyRDBToBackup(backupPath);
            
            // 验证备份文件
            RDBFileInfo backupInfo = rdbManager.checkRDBFile(backupPath);
            if (backupInfo.isValid()) {
                log.info("Scheduled backup completed successfully: {}", backupPath);
            } else {
                log.error("Backup validation failed: {}", backupPath);
            }
            
        } catch (Exception e) {
            log.error("Error during scheduled backup", e);
        }
    }
    
    // 增量备份策略
    public void incrementalBackup() {
        log.info("Starting incremental RDB backup");
        
        try {
            RDBStatus status = rdbManager.getRDBStatus();
            
            // 检查是否有足够的变化触发备份
            if (status.getRdbChangesSinceLastSave() > 1000) {
                rdbManager.triggerManualSnapshot();
                waitForSnapshotCompletion();
                
                String backupPath = createIncrementalBackupPath();
                copyRDBToBackup(backupPath);
                
                log.info("Incremental backup completed: {}", backupPath);
            } else {
                log.info("No significant changes detected, skipping incremental backup");
            }
            
        } catch (Exception e) {
            log.error("Error during incremental backup", e);
        }
    }
    
    // 等待快照完成
    private void waitForSnapshotCompletion() {
        int maxWaitTime = 300; // 5分钟
        int waitInterval = 5; // 5秒
        
        for (int i = 0; i < maxWaitTime; i += waitInterval) {
            try {
                Thread.sleep(waitInterval * 1000);
                
                RDBStatus status = rdbManager.getRDBStatus();
                if (!status.isRdbBgsaveInProgress()) {
                    return;
                }
                
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                throw new RuntimeException("Backup wait interrupted", e);
            }
        }
        
        throw new RuntimeException("Backup timeout");
    }
    
    // 创建备份路径
    private String createBackupPath() {
        String timestamp = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMdd_HHmmss"));
        return String.format("/backup/redis/rdb_backup_%s.rdb", timestamp);
    }
    
    // 创建增量备份路径
    private String createIncrementalBackupPath() {
        String timestamp = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMdd_HHmmss"));
        return String.format("/backup/redis/rdb_incremental_%s.rdb", timestamp);
    }
    
    // 复制RDB文件到备份目录
    private void copyRDBToBackup(String backupPath) {
        try {
            String sourcePath = "/var/lib/redis/dump.rdb";
            File sourceFile = new File(sourcePath);
            File backupFile = new File(backupPath);
            
            // 确保备份目录存在
            backupFile.getParentFile().mkdirs();
            
            // 复制文件
            Files.copy(sourceFile.toPath(), backupFile.toPath(), StandardCopyOption.REPLACE_EXISTING);
            
            log.info("RDB file copied to backup: {}", backupPath);
            
        } catch (Exception e) {
            log.error("Error copying RDB file to backup", e);
            throw new RuntimeException("Failed to copy RDB file", e);
        }
    }
    
    // 恢复RDB备份
    public void restoreFromBackup(String backupPath) {
        log.info("Starting RDB restore from backup: {}", backupPath);
        
        try {
            // 验证备份文件
            RDBFileInfo backupInfo = rdbManager.checkRDBFile(backupPath);
            if (!backupInfo.isValid()) {
                throw new RuntimeException("Invalid backup file: " + backupPath);
            }
            
            // 停止Redis服务（这里需要根据实际部署方式调整）
            stopRedisService();
            
            // 复制备份文件到Redis数据目录
            String targetPath = "/var/lib/redis/dump.rdb";
            Files.copy(new File(backupPath).toPath(), new File(targetPath).toPath(), 
                      StandardCopyOption.REPLACE_EXISTING);
            
            // 启动Redis服务
            startRedisService();
            
            log.info("RDB restore completed successfully");
            
        } catch (Exception e) {
            log.error("Error during RDB restore", e);
            throw new RuntimeException("Failed to restore RDB backup", e);
        }
    }
    
    private void stopRedisService() {
        // 实现停止Redis服务的逻辑
        log.info("Stopping Redis service");
    }
    
    private void startRedisService() {
        // 实现启动Redis服务的逻辑
        log.info("Starting Redis service");
    }
}

3. AOF持久化实现

3.1 AOF持久化原理

AOF持久化通过记录Redis执行的每个写命令来保存数据。AOF文件是一个文本文件，包含了重建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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
// AOF持久化管理器
@Component
@Slf4j
public class AOFPersistenceManager {
    
    private final RedisTemplate<String, Object> redisTemplate;
    private final RedisConnectionFactory connectionFactory;
    
    public AOFPersistenceManager(RedisTemplate<String, Object> redisTemplate,
                                RedisConnectionFactory connectionFactory) {
        this.redisTemplate = redisTemplate;
        this.connectionFactory = connectionFactory;
    }
    
    // 手动触发AOF重写
    public void triggerAOFRewrite() {
        try {
            RedisConnection connection = connectionFactory.getConnection();
            connection.bgRewriteAof(); // 异步重写
            log.info("Manual AOF rewrite triggered");
        } catch (Exception e) {
            log.error("Error triggering AOF rewrite", e);
            throw new RuntimeException("Failed to trigger AOF rewrite", e);
        }
    }
    
    // 获取AOF持久化状态
    public AOFStatus getAOFStatus() {
        AOFStatus status = new AOFStatus();
        
        try {
            RedisConnection connection = connectionFactory.getConnection();
            Properties persistenceInfo = connection.info("persistence");
            
            status.setAofEnabled("1".equals(persistenceInfo.getProperty("aof_enabled")));
            status.setAofRewriteInProgress(
                    "1".equals(persistenceInfo.getProperty("aof_rewrite_in_progress")));
            status.setAofRewriteScheduled(
                    "1".equals(persistenceInfo.getProperty("aof_rewrite_scheduled")));
            status.setAofLastWriteStatus(
                    persistenceInfo.getProperty("aof_last_write_status"));
            status.setAofLastBgrewriteStatus(
                    persistenceInfo.getProperty("aof_last_bgrewrite_status"));
            status.setAofLastRewriteTimeSec(
                    Long.parseLong(persistenceInfo.getProperty("aof_last_rewrite_time_sec", "0")));
            status.setAofCurrentRewriteTimeSec(
                    Long.parseLong(persistenceInfo.getProperty("aof_current_rewrite_time_sec", "0")));
            status.setAofCurrentSize(
                    Long.parseLong(persistenceInfo.getProperty("aof_current_size", "0")));
            status.setAofBaseSize(
                    Long.parseLong(persistenceInfo.getProperty("aof_base_size", "0")));
            status.setAofPendingRewrite(
                    Long.parseLong(persistenceInfo.getProperty("aof_pending_rewrite", "0")));
            status.setAofBufferLength(
                    Long.parseLong(persistenceInfo.getProperty("aof_buffer_length", "0")));
            status.setAofRewriteBufferLength(
                    Long.parseLong(persistenceInfo.getProperty("aof_rewrite_buffer_length", "0")));
            
        } catch (Exception e) {
            log.error("Error getting AOF status", e);
            status.setError(e.getMessage());
        }
        
        return status;
    }
    
    // 检查AOF文件
    public AOFFileInfo checkAOFFile(String filePath) {
        AOFFileInfo fileInfo = new AOFFileInfo();
        
        try {
            File file = new File(filePath);
            if (file.exists()) {
                fileInfo.setExists(true);
                fileInfo.setSize(file.length());
                fileInfo.setLastModified(file.lastModified());
                fileInfo.setPath(filePath);
                
                // 验证AOF文件完整性
                boolean isValid = validateAOFFile(filePath);
                fileInfo.setValid(isValid);
                
                // 分析AOF文件内容
                AOFContentAnalysis analysis = analyzeAOFContent(filePath);
                fileInfo.setAnalysis(analysis);
                
            } else {
                fileInfo.setExists(false);
            }
            
        } catch (Exception e) {
            log.error("Error checking AOF file", e);
            fileInfo.setError(e.getMessage());
        }
        
        return fileInfo;
    }
    
    // 验证AOF文件完整性
    private boolean validateAOFFile(String filePath) {
        try {
            // 使用Redis自带的redis-check-aof工具验证
            ProcessBuilder pb = new ProcessBuilder("redis-check-aof", filePath);
            Process process = pb.start();
            
            int exitCode = process.waitFor();
            return exitCode == 0;
            
        } catch (Exception e) {
            log.error("Error validating AOF file", e);
            return false;
        }
    }
    
    // 分析AOF文件内容
    private AOFContentAnalysis analyzeAOFContent(String filePath) {
        AOFContentAnalysis analysis = new AOFContentAnalysis();
        
        try {
            List<String> lines = Files.readAllLines(Paths.get(filePath));
            
            int commandCount = 0;
            Map<String, Integer> commandFrequency = new HashMap<>();
            long totalSize = 0;
            
            for (String line : lines) {
                if (line.startsWith("*")) {
                    commandCount++;
                } else if (line.startsWith("$")) {
                    totalSize += line.length();
                } else if (line.startsWith("+")) {
                    String command = line.substring(1).split(" ")[0].toUpperCase();
                    commandFrequency.put(command, commandFrequency.getOrDefault(command, 0) + 1);
                }
            }
            
            analysis.setCommandCount(commandCount);
            analysis.setCommandFrequency(commandFrequency);
            analysis.setTotalSize(totalSize);
            analysis.setAverageCommandSize(totalSize / Math.max(commandCount, 1));
            
        } catch (Exception e) {
            log.error("Error analyzing AOF content", e);
            analysis.setError(e.getMessage());
        }
        
        return analysis;
    }
    
    // 清理AOF文件
    public void cleanupAOFFile(String filePath, long maxSize) {
        try {
            File file = new File(filePath);
            if (file.exists() && file.length() > maxSize) {
                // 触发AOF重写
                triggerAOFRewrite();
                
                // 等待重写完成
                waitForAOFRewriteCompletion();
                
                log.info("AOF file cleanup completed");
            }
            
        } catch (Exception e) {
            log.error("Error cleaning up AOF file", e);
        }
    }
    
    // 等待AOF重写完成
    private void waitForAOFRewriteCompletion() {
        int maxWaitTime = 600; // 10分钟
        int waitInterval = 10; // 10秒
        
        for (int i = 0; i < maxWaitTime; i += waitInterval) {
            try {
                Thread.sleep(waitInterval * 1000);
                
                AOFStatus status = getAOFStatus();
                if (!status.isAofRewriteInProgress()) {
                    return;
                }
                
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                throw new RuntimeException("AOF rewrite wait interrupted", e);
            }
        }
        
        throw new RuntimeException("AOF rewrite timeout");
    }
}

3.2 AOF配置优化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# redis.conf - AOF配置
# AOF持久化配置
appendonly yes
appendfilename "appendonly.aof"
appendfsync everysec

# AOF重写配置
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb
aof-rewrite-incremental-fsync yes

# AOF加载配置
aof-load-truncated yes
aof-use-rdb-preamble yes

# AOF缓冲区配置
aof-timestamp-enabled no

3.3 AOF备份策略

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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
// AOF备份策略管理器
@Service
@Slf4j
public class AOFBackupStrategy {
    
    private final AOFPersistenceManager aofManager;
    private final RedisTemplate<String, Object> redisTemplate;
    
    public AOFBackupStrategy(AOFPersistenceManager aofManager,
                           RedisTemplate<String, Object> redisTemplate) {
        this.aofManager = aofManager;
        this.redisTemplate = redisTemplate;
    }
    
    // 定时备份AOF文件
    @Scheduled(cron = "0 0 3 * * ?") // 每天凌晨3点执行
    public void scheduledAOFBackup() {
        log.info("Starting scheduled AOF backup");
        
        try {
            // 触发AOF重写
            aofManager.triggerAOFRewrite();
            
            // 等待重写完成
            waitForAOFCompletion();
            
            // 复制AOF文件到备份目录
            String backupPath = createAOFBackupPath();
            copyAOFToBackup(backupPath);
            
            // 验证备份文件
            AOFFileInfo backupInfo = aofManager.checkAOFFile(backupPath);
            if (backupInfo.isValid()) {
                log.info("Scheduled AOF backup completed successfully: {}", backupPath);
            } else {
                log.error("AOF backup validation failed: {}", backupPath);
            }
            
        } catch (Exception e) {
            log.error("Error during scheduled AOF backup", e);
        }
    }
    
    // 增量AOF备份
    public void incrementalAOFBackup() {
        log.info("Starting incremental AOF backup");
        
        try {
            AOFStatus status = aofManager.getAOFStatus();
            
            // 检查AOF文件大小
            if (status.getAofCurrentSize() > status.getAofBaseSize() * 1.5) {
                aofManager.triggerAOFRewrite();
                waitForAOFCompletion();
                
                String backupPath = createIncrementalAOFBackupPath();
                copyAOFToBackup(backupPath);
                
                log.info("Incremental AOF backup completed: {}", backupPath);
            } else {
                log.info("AOF file size within limits, skipping incremental backup");
            }
            
        } catch (Exception e) {
            log.error("Error during incremental AOF backup", e);
        }
    }
    
    // 等待AOF操作完成
    private void waitForAOFCompletion() {
        int maxWaitTime = 600; // 10分钟
        int waitInterval = 10; // 10秒
        
        for (int i = 0; i < maxWaitTime; i += waitInterval) {
            try {
                Thread.sleep(waitInterval * 1000);
                
                AOFStatus status = aofManager.getAOFStatus();
                if (!status.isAofRewriteInProgress()) {
                    return;
                }
                
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                throw new RuntimeException("AOF backup wait interrupted", e);
            }
        }
        
        throw new RuntimeException("AOF backup timeout");
    }
    
    // 创建AOF备份路径
    private String createAOFBackupPath() {
        String timestamp = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMdd_HHmmss"));
        return String.format("/backup/redis/aof_backup_%s.aof", timestamp);
    }
    
    // 创建增量AOF备份路径
    private String createIncrementalAOFBackupPath() {
        String timestamp = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMdd_HHmmss"));
        return String.format("/backup/redis/aof_incremental_%s.aof", timestamp);
    }
    
    // 复制AOF文件到备份目录
    private void copyAOFToBackup(String backupPath) {
        try {
            String sourcePath = "/var/lib/redis/appendonly.aof";
            File sourceFile = new File(sourcePath);
            File backupFile = new File(backupPath);
            
            // 确保备份目录存在
            backupFile.getParentFile().mkdirs();
            
            // 复制文件
            Files.copy(sourceFile.toPath(), backupFile.toPath(), StandardCopyOption.REPLACE_EXISTING);
            
            log.info("AOF file copied to backup: {}", backupPath);
            
        } catch (Exception e) {
            log.error("Error copying AOF file to backup", e);
            throw new RuntimeException("Failed to copy AOF file", e);
        }
    }
    
    // 恢复AOF备份
    public void restoreFromAOFBackup(String backupPath) {
        log.info("Starting AOF restore from backup: {}", backupPath);
        
        try {
            // 验证备份文件
            AOFFileInfo backupInfo = aofManager.checkAOFFile(backupPath);
            if (!backupInfo.isValid()) {
                throw new RuntimeException("Invalid AOF backup file: " + backupPath);
            }
            
            // 停止Redis服务
            stopRedisService();
            
            // 复制备份文件到Redis数据目录
            String targetPath = "/var/lib/redis/appendonly.aof";
            Files.copy(new File(backupPath).toPath(), new File(targetPath).toPath(), 
                      StandardCopyOption.REPLACE_EXISTING);
            
            // 启动Redis服务
            startRedisService();
            
            log.info("AOF restore completed successfully");
            
        } catch (Exception e) {
            log.error("Error during AOF restore", e);
            throw new RuntimeException("Failed to restore AOF backup", e);
        }
    }
    
    private void stopRedisService() {
        log.info("Stopping Redis service");
    }
    
    private void startRedisService() {
        log.info("Starting Redis service");
    }
}

4. 混合持久化实现

4.1 混合持久化原理

混合持久化结合了RDB和AOF的优点，在AOF重写时，将重写后的数据以RDB格式写入AOF文件的开头，后续的写命令继续以AOF格式追加。

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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
// 混合持久化管理器
@Component
@Slf4j
public class HybridPersistenceManager {
    
    private final RDBPersistenceManager rdbManager;
    private final AOFPersistenceManager aofManager;
    private final RedisTemplate<String, Object> redisTemplate;
    
    public HybridPersistenceManager(RDBPersistenceManager rdbManager,
                                  AOFPersistenceManager aofManager,
                                  RedisTemplate<String, Object> redisTemplate) {
        this.rdbManager = rdbManager;
        this.aofManager = aofManager;
        this.redisTemplate = redisTemplate;
    }
    
    // 获取混合持久化状态
    public HybridPersistenceStatus getHybridStatus() {
        HybridPersistenceStatus status = new HybridPersistenceStatus();
        
        try {
            // 获取RDB状态
            RDBStatus rdbStatus = rdbManager.getRDBStatus();
            status.setRdbStatus(rdbStatus);
            
            // 获取AOF状态
            AOFStatus aofStatus = aofManager.getAOFStatus();
            status.setAofStatus(aofStatus);
            
            // 计算混合持久化指标
            calculateHybridMetrics(status);
            
        } catch (Exception e) {
            log.error("Error getting hybrid persistence status", e);
            status.setError(e.getMessage());
        }
        
        return status;
    }
    
    // 计算混合持久化指标
    private void calculateHybridMetrics(HybridPersistenceStatus status) {
        try {
            RDBStatus rdbStatus = status.getRdbStatus();
            AOFStatus aofStatus = status.getAofStatus();
            
            // 计算数据完整性得分
            double integrityScore = calculateIntegrityScore(rdbStatus, aofStatus);
            status.setIntegrityScore(integrityScore);
            
            // 计算性能影响得分
            double performanceScore = calculatePerformanceScore(rdbStatus, aofStatus);
            status.setPerformanceScore(performanceScore);
            
            // 计算存储效率得分
            double storageScore = calculateStorageScore(rdbStatus, aofStatus);
            status.setStorageScore(storageScore);
            
            // 计算总体得分
            double overallScore = (integrityScore + performanceScore + storageScore) / 3.0;
            status.setOverallScore(overallScore);
            
        } catch (Exception e) {
            log.error("Error calculating hybrid metrics", e);
        }
    }
    
    // 计算数据完整性得分
    private double calculateIntegrityScore(RDBStatus rdbStatus, AOFStatus aofStatus) {
        double score = 0.0;
        
        // RDB完整性（40%权重）
        if ("ok".equals(rdbStatus.getRdbLastBgsaveStatus())) {
            score += 0.4;
        }
        
        // AOF完整性（60%权重）
        if ("ok".equals(aofStatus.getAofLastWriteStatus()) && 
            "ok".equals(aofStatus.getAofLastBgrewriteStatus())) {
            score += 0.6;
        }
        
        return score;
    }
    
    // 计算性能影响得分
    private double calculatePerformanceScore(RDBStatus rdbStatus, AOFStatus aofStatus) {
        double score = 1.0;
        
        // RDB性能影响
        if (rdbStatus.isRdbBgsaveInProgress()) {
            score -= 0.2;
        }
        
        // AOF性能影响
        if (aofStatus.isAofRewriteInProgress()) {
            score -= 0.3;
        }
        
        // AOF缓冲区大小影响
        if (aofStatus.getAofBufferLength() > 1000000) { // 1MB
            score -= 0.1;
        }
        
        return Math.max(0.0, score);
    }
    
    // 计算存储效率得分
    private double calculateStorageScore(RDBStatus rdbStatus, AOFStatus aofStatus) {
        double score = 1.0;
        
        // AOF文件大小效率
        if (aofStatus.getAofCurrentSize() > 0 && aofStatus.getAofBaseSize() > 0) {
            double sizeRatio = (double) aofStatus.getAofCurrentSize() / aofStatus.getAofBaseSize();
            if (sizeRatio > 2.0) {
                score -= 0.3;
            } else if (sizeRatio > 1.5) {
                score -= 0.1;
            }
        }
        
        return Math.max(0.0, score);
    }
    
    // 优化混合持久化配置
    public void optimizeHybridPersistence() {
        log.info("Starting hybrid persistence optimization");
        
        try {
            HybridPersistenceStatus status = getHybridStatus();
            
            // 根据得分调整配置
            if (status.getOverallScore() < 0.7) {
                log.warn("Hybrid persistence score is low: {}", status.getOverallScore());
                
                // 优化RDB配置
                optimizeRDBConfiguration(status);
                
                // 优化AOF配置
                optimizeAOFConfiguration(status);
                
                log.info("Hybrid persistence optimization completed");
            } else {
                log.info("Hybrid persistence is performing well: {}", status.getOverallScore());
            }
            
        } catch (Exception e) {
            log.error("Error optimizing hybrid persistence", e);
        }
    }
    
    // 优化RDB配置
    private void optimizeRDBConfiguration(HybridPersistenceStatus status) {
        try {
            RDBStatus rdbStatus = status.getRdbStatus();
            
            // 如果RDB保存失败，调整保存策略
            if (!"ok".equals(rdbStatus.getRdbLastBgsaveStatus())) {
                log.info("Optimizing RDB save strategy");
                // 这里可以调整Redis配置或触发手动保存
            }
            
        } catch (Exception e) {
            log.error("Error optimizing RDB configuration", e);
        }
    }
    
    // 优化AOF配置
    private void optimizeAOFConfiguration(HybridPersistenceStatus status) {
        try {
            AOFStatus aofStatus = status.getAofStatus();
            
            // 如果AOF文件过大，触发重写
            if (aofStatus.getAofCurrentSize() > aofStatus.getAofBaseSize() * 1.5) {
                log.info("Triggering AOF rewrite due to large file size");
                aofManager.triggerAOFRewrite();
            }
            
        } catch (Exception e) {
            log.error("Error optimizing AOF configuration", e);
        }
    }
    
    // 混合持久化备份
    public void hybridBackup() {
        log.info("Starting hybrid persistence backup");
        
        try {
            // 触发RDB快照
            rdbManager.triggerManualSnapshot();
            
            // 等待RDB完成
            waitForRDBCompletion();
            
            // 触发AOF重写
            aofManager.triggerAOFRewrite();
            
            // 等待AOF完成
            waitForAOFCompletion();
            
            // 创建混合备份
            String backupPath = createHybridBackupPath();
            createHybridBackup(backupPath);
            
            log.info("Hybrid persistence backup completed: {}", backupPath);
            
        } catch (Exception e) {
            log.error("Error during hybrid backup", e);
        }
    }
    
    // 等待RDB完成
    private void waitForRDBCompletion() {
        int maxWaitTime = 300; // 5分钟
        int waitInterval = 5; // 5秒
        
        for (int i = 0; i < maxWaitTime; i += waitInterval) {
            try {
                Thread.sleep(waitInterval * 1000);
                
                RDBStatus status = rdbManager.getRDBStatus();
                if (!status.isRdbBgsaveInProgress()) {
                    return;
                }
                
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                throw new RuntimeException("RDB wait interrupted", e);
            }
        }
        
        throw new RuntimeException("RDB completion timeout");
    }
    
    // 等待AOF完成
    private void waitForAOFCompletion() {
        int maxWaitTime = 600; // 10分钟
        int waitInterval = 10; // 10秒
        
        for (int i = 0; i < maxWaitTime; i += waitInterval) {
            try {
                Thread.sleep(waitInterval * 1000);
                
                AOFStatus status = aofManager.getAOFStatus();
                if (!status.isAofRewriteInProgress()) {
                    return;
                }
                
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                throw new RuntimeException("AOF wait interrupted", e);
            }
        }
        
        throw new RuntimeException("AOF completion timeout");
    }
    
    // 创建混合备份路径
    private String createHybridBackupPath() {
        String timestamp = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMdd_HHmmss"));
        return String.format("/backup/redis/hybrid_backup_%s", timestamp);
    }
    
    // 创建混合备份
    private void createHybridBackup(String backupPath) {
        try {
            // 创建备份目录
            File backupDir = new File(backupPath);
            backupDir.mkdirs();
            
            // 复制RDB文件
            String rdbSource = "/var/lib/redis/dump.rdb";
            String rdbTarget = backupPath + "/dump.rdb";
            Files.copy(new File(rdbSource).toPath(), new File(rdbTarget).toPath());
            
            // 复制AOF文件
            String aofSource = "/var/lib/redis/appendonly.aof";
            String aofTarget = backupPath + "/appendonly.aof";
            Files.copy(new File(aofSource).toPath(), new File(aofTarget).toPath());
            
            // 创建备份元数据
            createBackupMetadata(backupPath);
            
            log.info("Hybrid backup created: {}", backupPath);
            
        } catch (Exception e) {
            log.error("Error creating hybrid backup", e);
            throw new RuntimeException("Failed to create hybrid backup", e);
        }
    }
    
    // 创建备份元数据
    private void createBackupMetadata(String backupPath) {
        try {
            HybridPersistenceStatus status = getHybridStatus();
            
            BackupMetadata metadata = new BackupMetadata();
            metadata.setBackupTime(LocalDateTime.now());
            metadata.setRdbStatus(status.getRdbStatus());
            metadata.setAofStatus(status.getAofStatus());
            metadata.setIntegrityScore(status.getIntegrityScore());
            metadata.setPerformanceScore(status.getPerformanceScore());
            metadata.setStorageScore(status.getStorageScore());
            metadata.setOverallScore(status.getOverallScore());
            
            String metadataPath = backupPath + "/metadata.json";
            ObjectMapper mapper = new ObjectMapper();
            mapper.writeValue(new File(metadataPath), metadata);
            
        } catch (Exception e) {
            log.error("Error creating backup metadata", e);
        }
    }
}

5. 持久化性能优化

5.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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
// 持久化性能监控器
@Component
@Slf4j
public class PersistencePerformanceMonitor {
    
    private final RDBPersistenceManager rdbManager;
    private final AOFPersistenceManager aofManager;
    private final HybridPersistenceManager hybridManager;
    private final MeterRegistry meterRegistry;
    
    public PersistencePerformanceMonitor(RDBPersistenceManager rdbManager,
                                        AOFPersistenceManager aofManager,
                                        HybridPersistenceManager hybridManager,
                                        MeterRegistry meterRegistry) {
        this.rdbManager = rdbManager;
        this.aofManager = aofManager;
        this.hybridManager = hybridManager;
        this.meterRegistry = meterRegistry;
    }
    
    @Scheduled(fixedDelay = 30000) // 每30秒监控一次
    public void monitorPersistencePerformance() {
        try {
            // 监控RDB性能
            monitorRDBPerformance();
            
            // 监控AOF性能
            monitorAOFPerformance();
            
            // 监控混合持久化性能
            monitorHybridPerformance();
            
        } catch (Exception e) {
            log.error("Error monitoring persistence performance", e);
        }
    }
    
    // 监控RDB性能
    private void monitorRDBPerformance() {
        try {
            RDBStatus status = rdbManager.getRDBStatus();
            
            // 记录RDB指标
            meterRegistry.gauge("redis.rdb.changes_since_last_save", 
                    status.getRdbChangesSinceLastSave());
            meterRegistry.gauge("redis.rdb.bgsave_in_progress", 
                    status.isRdbBgsaveInProgress() ? 1 : 0);
            meterRegistry.gauge("redis.rdb.last_save_time", 
                    status.getRdbLastSaveTime());
            meterRegistry.gauge("redis.rdb.last_bgsave_time_sec", 
                    status.getRdbLastBgsaveTimeSec());
            meterRegistry.gauge("redis.rdb.current_bgsave_time_sec", 
                    status.getRdbCurrentBgsaveTimeSec());
            
            // 检查RDB性能问题
            checkRDBPerformanceIssues(status);
            
        } catch (Exception e) {
            log.error("Error monitoring RDB performance", e);
        }
    }
    
    // 监控AOF性能
    private void monitorAOFPerformance() {
        try {
            AOFStatus status = aofManager.getAOFStatus();
            
            // 记录AOF指标
            meterRegistry.gauge("redis.aof.enabled", status.isAofEnabled() ? 1 : 0);
            meterRegistry.gauge("redis.aof.rewrite_in_progress", 
                    status.isAofRewriteInProgress() ? 1 : 0);
            meterRegistry.gauge("redis.aof.current_size", status.getAofCurrentSize());
            meterRegistry.gauge("redis.aof.base_size", status.getAofBaseSize());
            meterRegistry.gauge("redis.aof.buffer_length", status.getAofBufferLength());
            meterRegistry.gauge("redis.aof.rewrite_buffer_length", 
                    status.getAofRewriteBufferLength());
            
            // 检查AOF性能问题
            checkAOFPerformanceIssues(status);
            
        } catch (Exception e) {
            log.error("Error monitoring AOF performance", e);
        }
    }
    
    // 监控混合持久化性能
    private void monitorHybridPerformance() {
        try {
            HybridPersistenceStatus status = hybridManager.getHybridStatus();
            
            // 记录混合持久化指标
            meterRegistry.gauge("redis.hybrid.integrity_score", status.getIntegrityScore());
            meterRegistry.gauge("redis.hybrid.performance_score", status.getPerformanceScore());
            meterRegistry.gauge("redis.hybrid.storage_score", status.getStorageScore());
            meterRegistry.gauge("redis.hybrid.overall_score", status.getOverallScore());
            
            // 检查混合持久化性能问题
            checkHybridPerformanceIssues(status);
            
        } catch (Exception e) {
            log.error("Error monitoring hybrid performance", e);
        }
    }
    
    // 检查RDB性能问题
    private void checkRDBPerformanceIssues(RDBStatus status) {
        // 检查RDB保存时间过长
        if (status.getRdbCurrentBgsaveTimeSec() > 300) { // 5分钟
            log.warn("RDB save is taking too long: {} seconds", 
                    status.getRdbCurrentBgsaveTimeSec());
            alertLongRDBSave(status.getRdbCurrentBgsaveTimeSec());
        }
        
        // 检查RDB保存失败
        if (!"ok".equals(status.getRdbLastBgsaveStatus())) {
            log.error("RDB save failed: {}", status.getRdbLastBgsaveStatus());
            alertRDBSaveFailure(status.getRdbLastBgsaveStatus());
        }
        
        // 检查RDB变化过多
        if (status.getRdbChangesSinceLastSave() > 100000) {
            log.warn("Too many changes since last RDB save: {}", 
                    status.getRdbChangesSinceLastSave());
            alertHighRDBChanges(status.getRdbChangesSinceLastSave());
        }
    }
    
    // 检查AOF性能问题
    private void checkAOFPerformanceIssues(AOFStatus status) {
        // 检查AOF重写时间过长
        if (status.getAofCurrentRewriteTimeSec() > 600) { // 10分钟
            log.warn("AOF rewrite is taking too long: {} seconds", 
                    status.getAofCurrentRewriteTimeSec());
            alertLongAOFRewrite(status.getAofCurrentRewriteTimeSec());
        }
        
        // 检查AOF写入失败
        if (!"ok".equals(status.getAofLastWriteStatus())) {
            log.error("AOF write failed: {}", status.getAofLastWriteStatus());
            alertAOFWriteFailure(status.getAofLastWriteStatus());
        }
        
        // 检查AOF缓冲区过大
        if (status.getAofBufferLength() > 10000000) { // 10MB
            log.warn("AOF buffer is too large: {} bytes", status.getAofBufferLength());
            alertLargeAOFBuffer(status.getAofBufferLength());
        }
        
        // 检查AOF文件过大
        if (status.getAofCurrentSize() > status.getAofBaseSize() * 2) {
            log.warn("AOF file is too large: {} bytes", status.getAofCurrentSize());
            alertLargeAOFFile(status.getAofCurrentSize());
        }
    }
    
    // 检查混合持久化性能问题
    private void checkHybridPerformanceIssues(HybridPersistenceStatus status) {
        // 检查总体得分过低
        if (status.getOverallScore() < 0.6) {
            log.warn("Hybrid persistence overall score is low: {}", 
                    status.getOverallScore());
            alertLowHybridScore(status.getOverallScore());
        }
        
        // 检查性能得分过低
        if (status.getPerformanceScore() < 0.5) {
            log.warn("Hybrid persistence performance score is low: {}", 
                    status.getPerformanceScore());
            alertLowPerformanceScore(status.getPerformanceScore());
        }
    }
    
    // 告警方法
    private void alertLongRDBSave(long duration) {
        log.error("ALERT: RDB save is taking too long: {} seconds", duration);
    }
    
    private void alertRDBSaveFailure(String status) {
        log.error("ALERT: RDB save failed: {}", status);
    }
    
    private void alertHighRDBChanges(long changes) {
        log.warn("ALERT: Too many changes since last RDB save: {}", changes);
    }
    
    private void alertLongAOFRewrite(long duration) {
        log.error("ALERT: AOF rewrite is taking too long: {} seconds", duration);
    }
    
    private void alertAOFWriteFailure(String status) {
        log.error("ALERT: AOF write failed: {}", status);
    }
    
    private void alertLargeAOFBuffer(long size) {
        log.warn("ALERT: AOF buffer is too large: {} bytes", size);
    }
    
    private void alertLargeAOFFile(long size) {
        log.warn("ALERT: AOF file is too large: {} bytes", size);
    }
    
    private void alertLowHybridScore(double score) {
        log.warn("ALERT: Hybrid persistence overall score is low: {}", score);
    }
    
    private void alertLowPerformanceScore(double score) {
        log.warn("ALERT: Hybrid persistence performance score is low: {}", score);
    }
}

5.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
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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
// 持久化性能优化策略
@Service
@Slf4j
public class PersistenceOptimizationStrategy {
    
    private final RDBPersistenceManager rdbManager;
    private final AOFPersistenceManager aofManager;
    private final HybridPersistenceManager hybridManager;
    private final PersistencePerformanceMonitor performanceMonitor;
    
    public PersistenceOptimizationStrategy(RDBPersistenceManager rdbManager,
                                         AOFPersistenceManager aofManager,
                                         HybridPersistenceManager hybridManager,
                                         PersistencePerformanceMonitor performanceMonitor) {
        this.rdbManager = rdbManager;
        this.aofManager = aofManager;
        this.hybridManager = hybridManager;
        this.performanceMonitor = performanceMonitor;
    }
    
    // 自动优化持久化性能
    @Scheduled(fixedDelay = 300000) // 每5分钟检查一次
    public void autoOptimizePersistence() {
        log.info("Starting automatic persistence optimization");
        
        try {
            // 分析当前性能
            PersistencePerformanceAnalysis analysis = analyzePersistencePerformance();
            
            // 根据分析结果进行优化
            if (analysis.needsOptimization()) {
                applyOptimizationStrategy(analysis);
            } else {
                log.info("Persistence performance is optimal");
            }
            
        } catch (Exception e) {
            log.error("Error during automatic optimization", e);
        }
    }
    
    // 分析持久化性能
    private PersistencePerformanceAnalysis analyzePersistencePerformance() {
        PersistencePerformanceAnalysis analysis = new PersistencePerformanceAnalysis();
        
        try {
            // 分析RDB性能
            RDBStatus rdbStatus = rdbManager.getRDBStatus();
            analysis.setRdbAnalysis(analyzeRDBPerformance(rdbStatus));
            
            // 分析AOF性能
            AOFStatus aofStatus = aofManager.getAOFStatus();
            analysis.setAofAnalysis(analyzeAOFPerformance(aofStatus));
            
            // 分析混合持久化性能
            HybridPersistenceStatus hybridStatus = hybridManager.getHybridStatus();
            analysis.setHybridAnalysis(analyzeHybridPerformance(hybridStatus));
            
            // 计算总体优化建议
            calculateOptimizationRecommendations(analysis);
            
        } catch (Exception e) {
            log.error("Error analyzing persistence performance", e);
            analysis.setError(e.getMessage());
        }
        
        return analysis;
    }
    
    // 分析RDB性能
    private RDBPerformanceAnalysis analyzeRDBPerformance(RDBStatus status) {
        RDBPerformanceAnalysis analysis = new RDBPerformanceAnalysis();
        
        // 分析保存频率
        long timeSinceLastSave = System.currentTimeMillis() / 1000 - status.getRdbLastSaveTime();
        analysis.setTimeSinceLastSave(timeSinceLastSave);
        
        // 分析变化量
        analysis.setChangesSinceLastSave(status.getRdbChangesSinceLastSave());
        
        // 分析保存时间
        analysis.setLastSaveDuration(status.getRdbLastBgsaveTimeSec());
        
        // 判断是否需要优化
        boolean needsOptimization = false;
        List<String> recommendations = new ArrayList<>();
        
        if (timeSinceLastSave > 3600 && status.getRdbChangesSinceLastSave() > 10000) {
            needsOptimization = true;
            recommendations.add("Consider adjusting RDB save frequency");
        }
        
        if (status.getRdbLastBgsaveTimeSec() > 300) {
            needsOptimization = true;
            recommendations.add("RDB save is taking too long, consider optimization");
        }
        
        if (status.getRdbChangesSinceLastSave() > 100000) {
            needsOptimization = true;
            recommendations.add("Too many changes since last save, consider more frequent saves");
        }
        
        analysis.setNeedsOptimization(needsOptimization);
        analysis.setRecommendations(recommendations);
        
        return analysis;
    }
    
    // 分析AOF性能
    private AOFPerformanceAnalysis analyzeAOFPerformance(AOFStatus status) {
        AOFPerformanceAnalysis analysis = new AOFPerformanceAnalysis();
        
        // 分析文件大小
        analysis.setCurrentSize(status.getAofCurrentSize());
        analysis.setBaseSize(status.getAofBaseSize());
        
        // 分析缓冲区大小
        analysis.setBufferLength(status.getAofBufferLength());
        analysis.setRewriteBufferLength(status.getAofRewriteBufferLength());
        
        // 分析重写时间
        analysis.setLastRewriteDuration(status.getAofLastRewriteTimeSec());
        
        // 判断是否需要优化
        boolean needsOptimization = false;
        List<String> recommendations = new ArrayList<>();
        
        if (status.getAofCurrentSize() > status.getAofBaseSize() * 2) {
            needsOptimization = true;
            recommendations.add("AOF file is too large, consider triggering rewrite");
        }
        
        if (status.getAofBufferLength() > 10000000) { // 10MB
            needsOptimization = true;
            recommendations.add("AOF buffer is too large, consider optimization");
        }
        
        if (status.getAofLastRewriteTimeSec() > 600) { // 10分钟
            needsOptimization = true;
            recommendations.add("AOF rewrite is taking too long, consider optimization");
        }
        
        analysis.setNeedsOptimization(needsOptimization);
        analysis.setRecommendations(recommendations);
        
        return analysis;
    }
    
    // 分析混合持久化性能
    private HybridPerformanceAnalysis analyzeHybridPerformance(HybridPersistenceStatus status) {
        HybridPerformanceAnalysis analysis = new HybridPerformanceAnalysis();
        
        // 分析各项得分
        analysis.setIntegrityScore(status.getIntegrityScore());
        analysis.setPerformanceScore(status.getPerformanceScore());
        analysis.setStorageScore(status.getStorageScore());
        analysis.setOverallScore(status.getOverallScore());
        
        // 判断是否需要优化
        boolean needsOptimization = false;
        List<String> recommendations = new ArrayList<>();
        
        if (status.getOverallScore() < 0.7) {
            needsOptimization = true;
            recommendations.add("Overall hybrid persistence score is low");
        }
        
        if (status.getPerformanceScore() < 0.6) {
            needsOptimization = true;
            recommendations.add("Performance score is low, consider optimization");
        }
        
        if (status.getStorageScore() < 0.6) {
            needsOptimization = true;
            recommendations.add("Storage efficiency is low, consider optimization");
        }
        
        analysis.setNeedsOptimization(needsOptimization);
        analysis.setRecommendations(recommendations);
        
        return analysis;
    }
    
    // 计算优化建议
    private void calculateOptimizationRecommendations(PersistencePerformanceAnalysis analysis) {
        List<String> overallRecommendations = new ArrayList<>();
        
        // 合并RDB建议
        if (analysis.getRdbAnalysis().isNeedsOptimization()) {
            overallRecommendations.addAll(analysis.getRdbAnalysis().getRecommendations());
        }
        
        // 合并AOF建议
        if (analysis.getAofAnalysis().isNeedsOptimization()) {
            overallRecommendations.addAll(analysis.getAofAnalysis().getRecommendations());
        }
        
        // 合并混合持久化建议
        if (analysis.getHybridAnalysis().isNeedsOptimization()) {
            overallRecommendations.addAll(analysis.getHybridAnalysis().getRecommendations());
        }
        
        analysis.setOverallRecommendations(overallRecommendations);
        analysis.setNeedsOptimization(!overallRecommendations.isEmpty());
    }
    
    // 应用优化策略
    private void applyOptimizationStrategy(PersistencePerformanceAnalysis analysis) {
        log.info("Applying persistence optimization strategy");
        
        try {
            // 应用RDB优化
            if (analysis.getRdbAnalysis().isNeedsOptimization()) {
                applyRDBOptimization(analysis.getRdbAnalysis());
            }
            
            // 应用AOF优化
            if (analysis.getAofAnalysis().isNeedsOptimization()) {
                applyAOFOptimization(analysis.getAofAnalysis());
            }
            
            // 应用混合持久化优化
            if (analysis.getHybridAnalysis().isNeedsOptimization()) {
                applyHybridOptimization(analysis.getHybridAnalysis());
            }
            
            log.info("Persistence optimization strategy applied successfully");
            
        } catch (Exception e) {
            log.error("Error applying optimization strategy", e);
        }
    }
    
    // 应用RDB优化
    private void applyRDBOptimization(RDBPerformanceAnalysis analysis) {
        log.info("Applying RDB optimization");
        
        try {
            // 如果变化量过多，触发手动保存
            if (analysis.getChangesSinceLastSave() > 50000) {
                rdbManager.triggerManualSnapshot();
                log.info("Triggered manual RDB snapshot due to high change count");
            }
            
        } catch (Exception e) {
            log.error("Error applying RDB optimization", e);
        }
    }
    
    // 应用AOF优化
    private void applyAOFOptimization(AOFPerformanceAnalysis analysis) {
        log.info("Applying AOF optimization");
        
        try {
            // 如果文件过大，触发重写
            if (analysis.getCurrentSize() > analysis.getBaseSize() * 1.5) {
                aofManager.triggerAOFRewrite();
                log.info("Triggered AOF rewrite due to large file size");
            }
            
        } catch (Exception e) {
            log.error("Error applying AOF optimization", e);
        }
    }
    
    // 应用混合持久化优化
    private void applyHybridOptimization(HybridPerformanceAnalysis analysis) {
        log.info("Applying hybrid persistence optimization");
        
        try {
            // 触发混合持久化优化
            hybridManager.optimizeHybridPersistence();
            log.info("Applied hybrid persistence optimization");
            
        } catch (Exception e) {
            log.error("Error applying hybrid optimization", e);
        }
    }
}

6. 数据恢复策略

6.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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
// 数据恢复策略管理器
@Service
@Slf4j
public class DataRecoveryStrategyManager {
    
    private final RDBBackupStrategy rdbBackupStrategy;
    private final AOFBackupStrategy aofBackupStrategy;
    private final HybridPersistenceManager hybridManager;
    
    public DataRecoveryStrategyManager(RDBBackupStrategy rdbBackupStrategy,
                                     AOFBackupStrategy aofBackupStrategy,
                                     HybridPersistenceManager hybridManager) {
        this.rdbBackupStrategy = rdbBackupStrategy;
        this.aofBackupStrategy = aofBackupStrategy;
        this.hybridManager = hybridManager;
    }
    
    // 智能数据恢复
    public void intelligentDataRecovery(String backupPath) {
        log.info("Starting intelligent data recovery from: {}", backupPath);
        
        try {
            // 分析备份文件
            BackupAnalysis analysis = analyzeBackupFiles(backupPath);
            
            // 选择最佳恢复策略
            RecoveryStrategy strategy = selectBestRecoveryStrategy(analysis);
            
            // 执行恢复
            executeRecovery(strategy);
            
            // 验证恢复结果
            validateRecovery();
            
            log.info("Intelligent data recovery completed successfully");
            
        } catch (Exception e) {
            log.error("Error during intelligent data recovery", e);
            throw new RuntimeException("Failed to recover data", e);
        }
    }
    
    // 分析备份文件
    private BackupAnalysis analyzeBackupFiles(String backupPath) {
        BackupAnalysis analysis = new BackupAnalysis();
        
        try {
            File backupDir = new File(backupPath);
            if (!backupDir.exists() || !backupDir.isDirectory()) {
                throw new RuntimeException("Backup directory does not exist: " + backupPath);
            }
            
            // 检查RDB文件
            File rdbFile = new File(backupPath + "/dump.rdb");
            if (rdbFile.exists()) {
                RDBFileInfo rdbInfo = new RDBFileInfo();
                rdbInfo.setExists(true);
                rdbInfo.setSize(rdbFile.length());
                rdbInfo.setLastModified(rdbFile.lastModified());
                rdbInfo.setPath(rdbFile.getAbsolutePath());
                analysis.setRdbFile(rdbInfo);
            }
            
            // 检查AOF文件
            File aofFile = new File(backupPath + "/appendonly.aof");
            if (aofFile.exists()) {
                AOFFileInfo aofInfo = new AOFFileInfo();
                aofInfo.setExists(true);
                aofInfo.setSize(aofFile.length());
                aofInfo.setLastModified(aofFile.lastModified());
                aofInfo.setPath(aofFile.getAbsolutePath());
                analysis.setAofFile(aofInfo);
            }
            
            // 检查元数据文件
            File metadataFile = new File(backupPath + "/metadata.json");
            if (metadataFile.exists()) {
                BackupMetadata metadata = loadBackupMetadata(metadataFile);
                analysis.setMetadata(metadata);
            }
            
            // 确定备份类型
            determineBackupType(analysis);
            
        } catch (Exception e) {
            log.error("Error analyzing backup files", e);
            analysis.setError(e.getMessage());
        }
        
        return analysis;
    }
    
    // 加载备份元数据
    private BackupMetadata loadBackupMetadata(File metadataFile) {
        try {
            ObjectMapper mapper = new ObjectMapper();
            return mapper.readValue(metadataFile, BackupMetadata.class);
        } catch (Exception e) {
            log.error("Error loading backup metadata", e);
            return null;
        }
    }
    
    // 确定备份类型
    private void determineBackupType(BackupAnalysis analysis) {
        if (analysis.getRdbFile() != null && analysis.getAofFile() != null) {
            analysis.setBackupType(BackupType.HYBRID);
        } else if (analysis.getRdbFile() != null) {
            analysis.setBackupType(BackupType.RDB);
        } else if (analysis.getAofFile() != null) {
            analysis.setBackupType(BackupType.AOF);
        } else {
            analysis.setBackupType(BackupType.UNKNOWN);
        }
    }
    
    // 选择最佳恢复策略
    private RecoveryStrategy selectBestRecoveryStrategy(BackupAnalysis analysis) {
        RecoveryStrategy strategy = new RecoveryStrategy();
        
        try {
            switch (analysis.getBackupType()) {
                case HYBRID:
                    strategy = createHybridRecoveryStrategy(analysis);
                    break;
                case RDB:
                    strategy = createRDBRecoveryStrategy(analysis);
                    break;
                case AOF:
                    strategy = createAOFRecoveryStrategy(analysis);
                    break;
                default:
                    throw new RuntimeException("Unknown backup type");
            }
            
            // 设置恢复优先级
            setRecoveryPriority(strategy, analysis);
            
        } catch (Exception e) {
            log.error("Error selecting recovery strategy", e);
            strategy.setError(e.getMessage());
        }
        
        return strategy;
    }
    
    // 创建混合恢复策略
    private RecoveryStrategy createHybridRecoveryStrategy(BackupAnalysis analysis) {
        RecoveryStrategy strategy = new RecoveryStrategy();
        strategy.setType(RecoveryType.HYBRID);
        
        List<RecoveryStep> steps = new ArrayList<>();
        
        // 步骤1：恢复RDB
        RecoveryStep rdbStep = new RecoveryStep();
        rdbStep.setStepNumber(1);
        rdbStep.setDescription("Restore RDB file");
        rdbStep.setAction(() -> rdbBackupStrategy.restoreFromBackup(analysis.getRdbFile().getPath()));
        steps.add(rdbStep);
        
        // 步骤2：恢复AOF
        RecoveryStep aofStep = new RecoveryStep();
        aofStep.setStepNumber(2);
        aofStep.setDescription("Restore AOF file");
        aofStep.setAction(() -> aofBackupStrategy.restoreFromAOFBackup(analysis.getAofFile().getPath()));
        steps.add(aofStep);
        
        // 步骤3：验证恢复
        RecoveryStep validationStep = new RecoveryStep();
        validationStep.setStepNumber(3);
        validationStep.setDescription("Validate recovery");
        validationStep.setAction(this::validateRecovery);
        steps.add(validationStep);
        
        strategy.setSteps(steps);
        return strategy;
    }
    
    // 创建RDB恢复策略
    private RecoveryStrategy createRDBRecoveryStrategy(BackupAnalysis analysis) {
        RecoveryStrategy strategy = new RecoveryStrategy();
        strategy.setType(RecoveryType.RDB);
        
        List<RecoveryStep> steps = new ArrayList<>();
        
        // 步骤1：恢复RDB
        RecoveryStep rdbStep = new RecoveryStep();
        rdbStep.setStepNumber(1);
        rdbStep.setDescription("Restore RDB file");
        rdbStep.setAction(() -> rdbBackupStrategy.restoreFromBackup(analysis.getRdbFile().getPath()));
        steps.add(rdbStep);
        
        // 步骤2：验证恢复
        RecoveryStep validationStep = new RecoveryStep();
        validationStep.setStepNumber(2);
        validationStep.setDescription("Validate recovery");
        validationStep.setAction(this::validateRecovery);
        steps.add(validationStep);
        
        strategy.setSteps(steps);
        return strategy;
    }
    
    // 创建AOF恢复策略
    private RecoveryStrategy createAOFRecoveryStrategy(BackupAnalysis analysis) {
        RecoveryStrategy strategy = new RecoveryStrategy();
        strategy.setType(RecoveryType.AOF);
        
        List<RecoveryStep> steps = new ArrayList<>();
        
        // 步骤1：恢复AOF
        RecoveryStep aofStep = new RecoveryStep();
        aofStep.setStepNumber(1);
        aofStep.setDescription("Restore AOF file");
        aofStep.setAction(() -> aofBackupStrategy.restoreFromAOFBackup(analysis.getAofFile().getPath()));
        steps.add(aofStep);
        
        // 步骤2：验证恢复
        RecoveryStep validationStep = new RecoveryStep();
        validationStep.setStepNumber(2);
        validationStep.setDescription("Validate recovery");
        validationStep.setAction(this::validateRecovery);
        steps.add(validationStep);
        
        strategy.setSteps(steps);
        return strategy;
    }
    
    // 设置恢复优先级
    private void setRecoveryPriority(RecoveryStrategy strategy, BackupAnalysis analysis) {
        // 根据备份时间设置优先级
        if (analysis.getMetadata() != null) {
            LocalDateTime backupTime = analysis.getMetadata().getBackupTime();
            long hoursSinceBackup = ChronoUnit.HOURS.between(backupTime, LocalDateTime.now());
            
            if (hoursSinceBackup < 24) {
                strategy.setPriority(RecoveryPriority.HIGH);
            } else if (hoursSinceBackup < 168) { // 1周
                strategy.setPriority(RecoveryPriority.MEDIUM);
            } else {
                strategy.setPriority(RecoveryPriority.LOW);
            }
        } else {
            strategy.setPriority(RecoveryPriority.MEDIUM);
        }
    }
    
    // 执行恢复
    private void executeRecovery(RecoveryStrategy strategy) {
        log.info("Executing recovery strategy: {}", strategy.getType());
        
        try {
            for (RecoveryStep step : strategy.getSteps()) {
                log.info("Executing step {}: {}", step.getStepNumber(), step.getDescription());
                
                try {
                    step.getAction().run();
                    log.info("Step {} completed successfully", step.getStepNumber());
                } catch (Exception e) {
                    log.error("Step {} failed: {}", step.getStepNumber(), e.getMessage());
                    throw new RuntimeException("Recovery step failed", e);
                }
            }
            
            log.info("Recovery strategy executed successfully");
            
        } catch (Exception e) {
            log.error("Error executing recovery strategy", e);
            throw new RuntimeException("Failed to execute recovery", e);
        }
    }
    
    // 验证恢复结果
    private void validateRecovery() {
        log.info("Validating recovery result");
        
        try {
            // 检查Redis服务状态
            if (!isRedisServiceRunning()) {
                throw new RuntimeException("Redis service is not running");
            }
            
            // 检查数据完整性
            if (!validateDataIntegrity()) {
                throw new RuntimeException("Data integrity validation failed");
            }
            
            // 检查持久化状态
            if (!validatePersistenceStatus()) {
                throw new RuntimeException("Persistence status validation failed");
            }
            
            log.info("Recovery validation completed successfully");
            
        } catch (Exception e) {
            log.error("Recovery validation failed", e);
            throw new RuntimeException("Recovery validation failed", e);
        }
    }
    
    // 检查Redis服务状态
    private boolean isRedisServiceRunning() {
        try {
            // 这里需要根据实际的Redis管理方式来实现
            return true;
        } catch (Exception e) {
            log.error("Error checking Redis service status", e);
            return false;
        }
    }
    
    // 验证数据完整性
    private boolean validateDataIntegrity() {
        try {
            // 这里可以实现数据完整性检查逻辑
            return true;
        } catch (Exception e) {
            log.error("Error validating data integrity", e);
            return false;
        }
    }
    
    // 验证持久化状态
    private boolean validatePersistenceStatus() {
        try {
            // 检查RDB状态
            RDBStatus rdbStatus = rdbManager.getRDBStatus();
            if (!"ok".equals(rdbStatus.getRdbLastBgsaveStatus())) {
                log.warn("RDB status is not OK: {}", rdbStatus.getRdbLastBgsaveStatus());
            }
            
            // 检查AOF状态
            AOFStatus aofStatus = aofManager.getAOFStatus();
            if (aofStatus.isAofEnabled() && !"ok".equals(aofStatus.getAofLastWriteStatus())) {
                log.warn("AOF status is not OK: {}", aofStatus.getAofLastWriteStatus());
            }
            
            return true;
        } catch (Exception e) {
            log.error("Error validating persistence status", e);
            return false;
        }
    }
}

7. 监控与告警

7.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
// 持久化监控配置
@Configuration
public class PersistenceMonitoringConfig {
    
    @Bean
    public AlertRule rdbSaveFailureAlertRule() {
        return AlertRule.builder()
                .name("Redis RDB Save Failure")
                .description("Redis RDB save has failed")
                .condition("redis.rdb.last_bgsave_status != 'ok'")
                .severity(AlertSeverity.CRITICAL)
                .enabled(true)
                .build();
    }
    
    @Bean
    public AlertRule aofWriteFailureAlertRule() {
        return AlertRule.builder()
                .name("Redis AOF Write Failure")
                .description("Redis AOF write has failed")
                .condition("redis.aof.last_write_status != 'ok'")
                .severity(AlertSeverity.CRITICAL)
                .enabled(true)
                .build();
    }
    
    @Bean
    public AlertRule longRDBSaveAlertRule() {
        return AlertRule.builder()
                .name("Redis RDB Save Taking Too Long")
                .description("Redis RDB save is taking too long")
                .condition("redis.rdb.current_bgsave_time_sec > 300")
                .severity(AlertSeverity.WARNING)
                .enabled(true)
                .build();
    }
    
    @Bean
    public AlertRule longAOFRewriteAlertRule() {
        return AlertRule.builder()
                .name("Redis AOF Rewrite Taking Too Long")
                .description("Redis AOF rewrite is taking too long")
                .condition("redis.aof.current_rewrite_time_sec > 600")
                .severity(AlertSeverity.WARNING)
                .enabled(true)
                .build();
    }
    
    @Bean
    public AlertRule largeAOFFileAlertRule() {
        return AlertRule.builder()
                .name("Redis AOF File Too Large")
                .description("Redis AOF file is too large")
                .condition("redis.aof.current_size > redis.aof.base_size * 2")
                .severity(AlertSeverity.WARNING)
                .enabled(true)
                .build();
    }
    
    @Bean
    public AlertRule lowHybridScoreAlertRule() {
        return AlertRule.builder()
                .name("Redis Hybrid Persistence Score Low")
                .description("Redis hybrid persistence overall score is low")
                .condition("redis.hybrid.overall_score < 0.6")
                .severity(AlertSeverity.WARNING)
                .enabled(true)
                .build();
    }
}

8. 总结

Redis持久化是确保数据安全和业务连续性的关键技术。通过RDB、AOF和混合持久化三种方式，Redis提供了灵活的数据持久化解决方案。本文详细介绍的Redis持久化实现方案，为企业级Redis部署提供了完整的技术支撑。

8.1 技术优势

  1. 数据安全: 多种持久化方式确保数据不丢失
  2. 性能优化: 通过配置优化提升持久化性能
  3. 灵活配置: 支持多种持久化策略组合
  4. 监控完善: 全面的监控和告警机制
  5. 恢复快速: 智能的数据恢复策略

8.2 实施要点

  1. 配置优化: 根据业务需求选择合适的持久化方式
  2. 性能监控: 建立完善的持久化性能监控体系
  3. 备份策略: 制定合理的备份和恢复策略
  4. 容量规划: 合理规划持久化文件存储空间
  5. 测试验证: 定期进行备份恢复测试

8.3 最佳实践

  1. 混合使用: 生产环境推荐使用混合持久化模式
  2. 定期备份: 建立自动化的备份机制
  3. 性能调优: 根据实际负载调整持久化参数
  4. 监控告警: 设置合理的监控阈值和告警规则
  5. 灾难恢复: 制定完整的灾难恢复预案

通过本文的学习，您应该已经掌握了Redis持久化的核心技术，能够设计和实现高可用的Redis持久化方案，为企业的数据安全提供可靠的技术保障。