第91集Redis运维监控与优化实战

/**
 * Redis监控数据实体类
 */
@Data
@TableName("redis_monitor_data")
public class RedisMonitorData {
    
    @TableId(type = IdType.AUTO)
    private Long id;                    // 主键ID
    
    private String hostname;             // 主机名
    
    private String ip;                   // IP地址
    
    private Integer port;                 // 端口
    
    private String redisVersion;          // Redis版本
    
    private String redisMode;             // Redis模式
    
    private Long usedMemory;              // 已使用内存
    
    private Long maxMemory;               // 最大内存
    
    private Double memoryUsage;           // 内存使用率
    
    private Long connectedClients;        // 连接客户端数
    
    private Long totalCommandsProcessed;  // 总处理命令数
    
    private Long instantaneousOpsPerSec; // 每秒操作数
    
    private Long keyspaceHits;            // 键空间命中数
    
    private Long keyspaceMisses;          // 键空间未命中数
    
    private Double hitRate;               // 命中率
    
    private Long expiredKeys;             // 过期键数
    
    private Long evictedKeys;             // 驱逐键数
    
    private Long slowLogCount;            // 慢查询数量
    
    private String replicationRole;       // 复制角色
    
    private String masterHost;            // 主节点主机
    
    private Integer masterPort;           // 主节点端口
    
    private Long masterLinkStatus;        // 主链接状态
    
    private Date collectTime;            // 采集时间
    
    private Date createTime;             // 创建时间
}

/**
 * Redis集群节点实体类
 */
@Data
@TableName("redis_cluster_node")
public class RedisClusterNode {
    
    @TableId(type = IdType.AUTO)
    private Long id;                    // 主键ID
    
    private String nodeId;               // 节点ID
    
    private String hostname;             // 主机名
    
    private String ip;                   // IP地址
    
    private Integer port;                 // 端口
    
    private String nodeRole;             // 节点角色
    
    private String nodeState;            // 节点状态
    
    private String masterNodeId;         // 主节点ID
    
    private Integer slotStart;           // 槽位开始
    
    private Integer slotEnd;              // 槽位结束
    
    private Long connectedClients;        // 连接客户端数
    
    private Long usedMemory;              // 已使用内存
    
    private String nodeFlags;             // 节点标志
    
    private Date lastHeartbeat;          // 最后心跳
    
    private Date createTime;             // 创建时间
}

/**
 * Redis监控服务
 * 负责Redis数据的采集、存储和分析
 */
@Service
public class RedisMonitorService {

    @Autowired
    private RedisMonitorDataMapper redisMonitorDataMapper;
    
    @Autowired
    private RedisClusterNodeMapper redisClusterNodeMapper;
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Autowired
    private AlertService alertService;
    
    @Autowired
    private JedisPool jedisPool;

    /**
     * 采集Redis数据
     * 定期采集Redis性能指标
     */
    @Scheduled(fixedRate = 5000) // 每5秒执行一次
    public void collectRedisData() {
        try {
            // 1. 获取Redis信息
            RedisInfo redisInfo = getRedisInfo();
            
            // 2. 创建Redis监控数据
            RedisMonitorData monitorData = createRedisMonitorData(redisInfo);
            
            // 3. 保存到数据库
            redisMonitorDataMapper.insert(monitorData);
            
            // 4. 更新缓存
            updateRedisCache(monitorData);
            
            // 5. 检查Redis告警
            checkRedisAlert(monitorData);
            
            log.debug("采集Redis数据: hostname={}, memoryUsage={}%, hitRate={}%", 
                    monitorData.getHostname(), monitorData.getMemoryUsage(), monitorData.getHitRate());
                    
        } catch (Exception e) {
            log.error("采集Redis数据失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 获取Redis信息
     */
    private RedisInfo getRedisInfo() {
        RedisInfo redisInfo = new RedisInfo();
        
        try (Jedis jedis = jedisPool.getResource()) {
            // 获取Redis服务器信息
            String info = jedis.info();
            Map<String, String> infoMap = parseRedisInfo(info);
            
            // 设置基本信息
            redisInfo.setRedisVersion(infoMap.get("redis_version"));
            redisInfo.setRedisMode(infoMap.get("redis_mode"));
            redisInfo.setUsedMemory(Long.parseLong(infoMap.getOrDefault("used_memory", "0")));
            redisInfo.setMaxMemory(Long.parseLong(infoMap.getOrDefault("maxmemory", "0")));
            redisInfo.setConnectedClients(Long.parseLong(infoMap.getOrDefault("connected_clients", "0")));
            redisInfo.setTotalCommandsProcessed(Long.parseLong(infoMap.getOrDefault("total_commands_processed", "0")));
            redisInfo.setInstantaneousOpsPerSec(Long.parseLong(infoMap.getOrDefault("instantaneous_ops_per_sec", "0")));
            redisInfo.setKeyspaceHits(Long.parseLong(infoMap.getOrDefault("keyspace_hits", "0")));
            redisInfo.setKeyspaceMisses(Long.parseLong(infoMap.getOrDefault("keyspace_misses", "0")));
            redisInfo.setExpiredKeys(Long.parseLong(infoMap.getOrDefault("expired_keys", "0")));
            redisInfo.setEvictedKeys(Long.parseLong(infoMap.getOrDefault("evicted_keys", "0")));
            
            // 计算内存使用率
            if (redisInfo.getMaxMemory() > 0) {
                redisInfo.setMemoryUsage((double) redisInfo.getUsedMemory() / redisInfo.getMaxMemory() * 100);
            }
            
            // 计算命中率
            long totalHits = redisInfo.getKeyspaceHits() + redisInfo.getKeyspaceMisses();
            if (totalHits > 0) {
                redisInfo.setHitRate((double) redisInfo.getKeyspaceHits() / totalHits * 100);
            }
            
            // 获取复制信息
            redisInfo.setReplicationRole(infoMap.get("role"));
            redisInfo.setMasterHost(infoMap.get("master_host"));
            redisInfo.setMasterPort(Integer.parseInt(infoMap.getOrDefault("master_port", "0")));
            redisInfo.setMasterLinkStatus(Long.parseLong(infoMap.getOrDefault("master_link_status", "0")));
            
            // 获取慢查询信息
            redisInfo.setSlowLogCount(getSlowLogCount(jedis));
            
        } catch (Exception e) {
            log.error("获取Redis信息失败: {}", e.getMessage(), e);
        }
        
        return redisInfo;
    }

    /**
     * 解析Redis信息
     */
    private Map<String, String> parseRedisInfo(String info) {
        Map<String, String> infoMap = new HashMap<>();
        
        String[] lines = info.split("\r\n");
        for (String line : lines) {
            if (line.contains(":")) {
                String[] parts = line.split(":", 2);
                if (parts.length == 2) {
                    infoMap.put(parts[0], parts[1]);
                }
            }
        }
        
        return infoMap;
    }

    /**
     * 获取慢查询数量
     */
    private Long getSlowLogCount(Jedis jedis) {
        try {
            List<Object> slowLogs = jedis.slowlogGet(10);
            return (long) slowLogs.size();
        } catch (Exception e) {
            return 0L;
        }
    }

    /**
     * 创建Redis监控数据
     */
    private RedisMonitorData createRedisMonitorData(RedisInfo redisInfo) {
        RedisMonitorData monitorData = new RedisMonitorData();
        
        // 设置基本信息
        monitorData.setHostname(getHostname());
        monitorData.setIp(getLocalIpAddress());
        monitorData.setPort(6379);
        monitorData.setCollectTime(new Date());
        monitorData.setCreateTime(new Date());
        
        // 设置Redis信息
        monitorData.setRedisVersion(redisInfo.getRedisVersion());
        monitorData.setRedisMode(redisInfo.getRedisMode());
        monitorData.setUsedMemory(redisInfo.getUsedMemory());
        monitorData.setMaxMemory(redisInfo.getMaxMemory());
        monitorData.setMemoryUsage(redisInfo.getMemoryUsage());
        monitorData.setConnectedClients(redisInfo.getConnectedClients());
        monitorData.setTotalCommandsProcessed(redisInfo.getTotalCommandsProcessed());
        monitorData.setInstantaneousOpsPerSec(redisInfo.getInstantaneousOpsPerSec());
        monitorData.setKeyspaceHits(redisInfo.getKeyspaceHits());
        monitorData.setKeyspaceMisses(redisInfo.getKeyspaceMisses());
        monitorData.setHitRate(redisInfo.getHitRate());
        monitorData.setExpiredKeys(redisInfo.getExpiredKeys());
        monitorData.setEvictedKeys(redisInfo.getEvictedKeys());
        monitorData.setSlowLogCount(redisInfo.getSlowLogCount());
        monitorData.setReplicationRole(redisInfo.getReplicationRole());
        monitorData.setMasterHost(redisInfo.getMasterHost());
        monitorData.setMasterPort(redisInfo.getMasterPort());
        monitorData.setMasterLinkStatus(redisInfo.getMasterLinkStatus());
        
        return monitorData;
    }

    /**
     * 更新Redis缓存
     */
    private void updateRedisCache(RedisMonitorData monitorData) {
        try {
            String cacheKey = "redis:realtime:" + monitorData.getHostname();
            redisTemplate.opsForValue().set(cacheKey, monitorData, Duration.ofMinutes(5));
            
            // 更新历史数据缓存
            String historyKey = "redis:history:" + monitorData.getHostname();
            redisTemplate.opsForList().leftPush(historyKey, monitorData);
            redisTemplate.opsForList().trim(historyKey, 0, 99);
            redisTemplate.expire(historyKey, Duration.ofHours(1));
            
        } catch (Exception e) {
            log.warn("更新Redis缓存失败: {}", e.getMessage());
        }
    }

    /**
     * 检查Redis告警
     */
    private void checkRedisAlert(RedisMonitorData monitorData) {
        try {
            String alertType = null;
            String alertLevel = null;
            String alertMessage = null;
            
            // 检查内存使用率告警
            if (monitorData.getMemoryUsage() >= 95) {
                alertType = "REDIS_MEMORY_CRITICAL";
                alertLevel = "CRITICAL";
                alertMessage = String.format("Redis内存使用率过高: %.2f%%", monitorData.getMemoryUsage());
            } else if (monitorData.getMemoryUsage() >= 85) {
                alertType = "REDIS_MEMORY_HIGH";
                alertLevel = "WARNING";
                alertMessage = String.format("Redis内存使用率较高: %.2f%%", monitorData.getMemoryUsage());
            }
            
            // 检查连接数告警
            if (monitorData.getConnectedClients() > 1000) {
                alertType = "REDIS_CONNECTION_HIGH";
                alertLevel = "WARNING";
                alertMessage = String.format("Redis连接数过多: %d", monitorData.getConnectedClients());
            }
            
            // 检查命中率告警
            if (monitorData.getHitRate() < 80) {
                alertType = "REDIS_HIT_RATE_LOW";
                alertLevel = "WARNING";
                alertMessage = String.format("Redis命中率过低: %.2f%%", monitorData.getHitRate());
            }
            
            // 检查慢查询告警
            if (monitorData.getSlowLogCount() > 10) {
                alertType = "REDIS_SLOW_LOG_HIGH";
                alertLevel = "WARNING";
                alertMessage = String.format("Redis慢查询过多: %d", monitorData.getSlowLogCount());
            }
            
            // 检查主从复制告警
            if ("slave".equals(monitorData.getReplicationRole()) && monitorData.getMasterLinkStatus() == 0) {
                alertType = "REDIS_REPLICATION_DOWN";
                alertLevel = "CRITICAL";
                alertMessage = "Redis主从复制断开";
            }
            
            // 发送告警
            if (alertType != null) {
                sendRedisAlert(monitorData, alertType, alertLevel, alertMessage);
            }
            
        } catch (Exception e) {
            log.error("检查Redis告警失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 发送Redis告警
     */
    private void sendRedisAlert(RedisMonitorData monitorData, String alertType, String alertLevel, String alertMessage) {
        try {
            // 检查是否已经发送过相同告警
            String alertKey = "redis:alert:" + monitorData.getHostname() + ":" + alertType;
            Boolean hasAlert = redisTemplate.hasKey(alertKey);
            
            if (hasAlert == null || !hasAlert) {
                // 创建告警记录
                RedisAlertRecord alertRecord = new RedisAlertRecord();
                alertRecord.setHostname(monitorData.getHostname());
                alertRecord.setIp(monitorData.getIp());
                alertRecord.setPort(monitorData.getPort());
                alertRecord.setAlertType(alertType);
                alertRecord.setAlertLevel(alertLevel);
                alertRecord.setAlertMessage(alertMessage);
                alertRecord.setAlertStatus("ACTIVE");
                alertRecord.setAlertTime(new Date());
                
                // 发送告警通知
                alertService.sendRedisAlert(alertRecord);
                
                // 设置告警缓存
                redisTemplate.opsForValue().set(alertKey, "1", Duration.ofMinutes(5));
                
                log.warn("发送Redis告警: hostname={}, type={}, level={}", 
                        monitorData.getHostname(), alertType, alertLevel);
            }
            
        } catch (Exception e) {
            log.error("发送Redis告警失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 获取实时Redis数据
     */
    public RedisMonitorData getRealTimeRedisData(String hostname) {
        String cacheKey = "redis:realtime:" + hostname;
        return (RedisMonitorData) redisTemplate.opsForValue().get(cacheKey);
    }

    /**
     * 获取Redis历史数据
     */
    public List<RedisMonitorData> getRedisHistoryData(String hostname, Date startTime, Date endTime) {
        return redisMonitorDataMapper.selectByHostnameAndTimeRange(hostname, startTime, endTime);
    }

    /**
     * 获取主机名
     */
    private String getHostname() {
        try {
            return InetAddress.getLocalHost().getHostName();
        } catch (UnknownHostException e) {
            return "unknown";
        }
    }

    /**
     * 获取本地IP地址
     */
    private String getLocalIpAddress() {
        try {
            return InetAddress.getLocalHost().getHostAddress();
        } catch (UnknownHostException e) {
            return "127.0.0.1";
        }
    }
}

/**
 * Redis信息实体类
 */
@Data
public class RedisInfo {
    private String redisVersion;          // Redis版本
    private String redisMode;             // Redis模式
    private Long usedMemory;              // 已使用内存
    private Long maxMemory;               // 最大内存
    private Double memoryUsage;           // 内存使用率
    private Long connectedClients;        // 连接客户端数
    private Long totalCommandsProcessed;  // 总处理命令数
    private Long instantaneousOpsPerSec; // 每秒操作数
    private Long keyspaceHits;            // 键空间命中数
    private Long keyspaceMisses;          // 键空间未命中数
    private Double hitRate;               // 命中率
    private Long expiredKeys;             // 过期键数
    private Long evictedKeys;             // 驱逐键数
    private Long slowLogCount;            // 慢查询数量
    private String replicationRole;      // 复制角色
    private String masterHost;            // 主节点主机
    private Integer masterPort;           // 主节点端口
    private Long masterLinkStatus;        // 主链接状态
}

/**
 * Redis优化服务
 * 提供Redis性能优化和调优功能
 */
@Service
public class RedisOptimizationService {

    @Autowired
    private RedisMonitorService redisMonitorService;
    
    @Autowired
    private AlertService alertService;
    
    @Autowired
    private JedisPool jedisPool;

    /**
     * 自动Redis优化
     * 根据Redis性能情况自动进行优化
     */
    @Scheduled(fixedRate = 300000) // 每5分钟执行一次
    public void autoOptimizeRedis() {
        try {
            String hostname = getHostname();
            RedisMonitorData redisData = redisMonitorService.getRealTimeRedisData(hostname);
            
            if (redisData == null) {
                return;
            }
            
            // 检查内存使用率
            if (redisData.getMemoryUsage() > 90) {
                // 内存使用率过高，执行紧急优化
                executeEmergencyOptimization(redisData);
            } else if (redisData.getMemoryUsage() > 80) {
                // 内存使用率较高，执行预防性优化
                executePreventiveOptimization(redisData);
            }
            
            // 检查命中率
            if (redisData.getHitRate() < 80) {
                // 命中率过低，执行缓存优化
                executeCacheOptimization(redisData);
            }
            
        } catch (Exception e) {
            log.error("自动Redis优化失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 执行紧急优化
     */
    private void executeEmergencyOptimization(RedisMonitorData redisData) {
        log.warn("执行紧急Redis优化: memoryUsage={}%", redisData.getMemoryUsage());
        
        try {
            // 1. 清理过期键
            cleanupExpiredKeys();
            
            // 2. 执行内存回收
            performMemoryReclaim();
            
            // 3. 调整内存策略
            adjustMemoryPolicy();
            
            // 4. 清理大键
            cleanupBigKeys();
            
            // 5. 发送优化通知
            sendOptimizationNotification(redisData, "EMERGENCY_OPTIMIZATION");
            
        } catch (Exception e) {
            log.error("执行紧急优化失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 执行预防性优化
     */
    private void executePreventiveOptimization(RedisMonitorData redisData) {
        log.info("执行预防性Redis优化: memoryUsage={}%", redisData.getMemoryUsage());
        
        try {
            // 1. 优化内存配置
            optimizeMemoryConfig();
            
            // 2. 调整连接池配置
            adjustConnectionPoolConfig();
            
            // 3. 优化持久化配置
            optimizePersistenceConfig();
            
            // 4. 发送优化通知
            sendOptimizationNotification(redisData, "PREVENTIVE_OPTIMIZATION");
            
        } catch (Exception e) {
            log.error("执行预防性优化失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 执行缓存优化
     */
    private void executeCacheOptimization(RedisMonitorData redisData) {
        log.info("执行Redis缓存优化: hitRate={}%", redisData.getHitRate());
        
        try {
            // 1. 分析键空间
            analyzeKeyspace();
            
            // 2. 优化键过期策略
            optimizeKeyExpiration();
            
            // 3. 调整缓存策略
            adjustCacheStrategy();
            
            // 4. 发送优化通知
            sendOptimizationNotification(redisData, "CACHE_OPTIMIZATION");
            
        } catch (Exception e) {
            log.error("执行缓存优化失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 清理过期键
     */
    private void cleanupExpiredKeys() {
        log.info("清理Redis过期键");
        
        try (Jedis jedis = jedisPool.getResource()) {
            // 执行过期键清理
            jedis.eval("return redis.call('del', unpack(redis.call('keys', '*')) for k,v in pairs(redis.call('keys', '*')) do if redis.call('ttl', k) == -1 then redis.call('del', k) end end");
            
            log.info("过期键清理完成");
            
        } catch (Exception e) {
            log.error("清理过期键失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 执行内存回收
     */
    private void performMemoryReclaim() {
        log.info("执行Redis内存回收");
        
        try (Jedis jedis = jedisPool.getResource()) {
            // 执行内存回收
            jedis.memoryPurge();
            
            log.info("内存回收完成");
            
        } catch (Exception e) {
            log.error("执行内存回收失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 调整内存策略
     */
    private void adjustMemoryPolicy() {
        log.info("调整Redis内存策略");
        
        try (Jedis jedis = jedisPool.getResource()) {
            // 设置内存淘汰策略为allkeys-lru
            jedis.configSet("maxmemory-policy", "allkeys-lru");
            
            log.info("内存策略调整完成");
            
        } catch (Exception e) {
            log.error("调整内存策略失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 清理大键
     */
    private void cleanupBigKeys() {
        log.info("清理Redis大键");
        
        try (Jedis jedis = jedisPool.getResource()) {
            // 查找大键
            List<String> bigKeys = findBigKeys(jedis);
            
            // 清理大键
            for (String key : bigKeys) {
                try {
                    jedis.del(key);
                    log.info("删除大键: {}", key);
                } catch (Exception e) {
                    log.warn("删除大键失败: {}, error={}", key, e.getMessage());
                }
            }
            
        } catch (Exception e) {
            log.error("清理大键失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 查找大键
     */
    private List<String> findBigKeys(Jedis jedis) {
        List<String> bigKeys = new ArrayList<>();
        
        try {
            // 使用SCAN命令查找大键
            String cursor = "0";
            do {
                ScanResult<String> result = jedis.scan(cursor, new ScanParams().count(100));
                cursor = result.getCursor();
                
                for (String key : result.getResult()) {
                    try {
                        long memoryUsage = jedis.memoryUsage(key);
                        if (memoryUsage > 1024 * 1024) { // 大于1MB
                            bigKeys.add(key);
                        }
                    } catch (Exception e) {
                        // 忽略错误
                    }
                }
            } while (!"0".equals(cursor));
            
        } catch (Exception e) {
            log.error("查找大键失败: {}", e.getMessage(), e);
        }
        
        return bigKeys;
    }

    /**
     * 优化内存配置
     */
    private void optimizeMemoryConfig() {
        log.info("优化Redis内存配置");
        
        try (Jedis jedis = jedisPool.getResource()) {
            // 设置内存使用限制
            jedis.configSet("maxmemory", "2gb");
            
            // 设置内存淘汰策略
            jedis.configSet("maxmemory-policy", "allkeys-lru");
            
            // 设置内存回收阈值
            jedis.configSet("active-defrag-threshold-lower", "10");
            jedis.configSet("active-defrag-threshold-upper", "100");
            
            log.info("内存配置优化完成");
            
        } catch (Exception e) {
            log.error("优化内存配置失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 调整连接池配置
     */
    private void adjustConnectionPoolConfig() {
        log.info("调整Redis连接池配置");
        
        try (Jedis jedis = jedisPool.getResource()) {
            // 设置最大连接数
            jedis.configSet("maxclients", "10000");
            
            // 设置连接超时
            jedis.configSet("timeout", "300");
            
            log.info("连接池配置调整完成");
            
        } catch (Exception e) {
            log.error("调整连接池配置失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 优化持久化配置
     */
    private void optimizePersistenceConfig() {
        log.info("优化Redis持久化配置");
        
        try (Jedis jedis = jedisPool.getResource()) {
            // 设置RDB保存策略
            jedis.configSet("save", "900 1 300 10 60 10000");
            
            // 设置AOF策略
            jedis.configSet("appendonly", "yes");
            jedis.configSet("appendfsync", "everysec");
            
            log.info("持久化配置优化完成");
            
        } catch (Exception e) {
            log.error("优化持久化配置失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 分析键空间
     */
    private void analyzeKeyspace() {
        log.info("分析Redis键空间");
        
        try (Jedis jedis = jedisPool.getResource()) {
            // 获取键空间信息
            String info = jedis.info("keyspace");
            log.info("键空间信息: {}", info);
            
            // 分析键的分布
            analyzeKeyDistribution(jedis);
            
        } catch (Exception e) {
            log.error("分析键空间失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 分析键的分布
     */
    private void analyzeKeyDistribution(Jedis jedis) {
        try {
            Map<String, Integer> keyTypes = new HashMap<>();
            String cursor = "0";
            
            do {
                ScanResult<String> result = jedis.scan(cursor, new ScanParams().count(100));
                cursor = result.getCursor();
                
                for (String key : result.getResult()) {
                    try {
                        String type = jedis.type(key);
                        keyTypes.put(type, keyTypes.getOrDefault(type, 0) + 1);
                    } catch (Exception e) {
                        // 忽略错误
                    }
                }
            } while (!"0".equals(cursor));
            
            log.info("键类型分布: {}", keyTypes);
            
        } catch (Exception e) {
            log.error("分析键分布失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 优化键过期策略
     */
    private void optimizeKeyExpiration() {
        log.info("优化Redis键过期策略");
        
        try (Jedis jedis = jedisPool.getResource()) {
            // 设置过期键清理策略
            jedis.configSet("hz", "10");
            
            log.info("键过期策略优化完成");
            
        } catch (Exception e) {
            log.error("优化键过期策略失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 调整缓存策略
     */
    private void adjustCacheStrategy() {
        log.info("调整Redis缓存策略");
        
        try (Jedis jedis = jedisPool.getResource()) {
            // 设置缓存策略
            jedis.configSet("maxmemory-policy", "allkeys-lru");
            
            log.info("缓存策略调整完成");
            
        } catch (Exception e) {
            log.error("调整缓存策略失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 发送优化通知
     */
    private void sendOptimizationNotification(RedisMonitorData redisData, String optimizationType) {
        try {
            AlertMessage alert = new AlertMessage();
            alert.setType("REDIS_OPTIMIZATION");
            alert.setLevel("INFO");
            alert.setMessage(String.format("Redis优化完成: 类型=%s, 内存使用率=%.2f%%, 命中率=%.2f%%", 
                    optimizationType, redisData.getMemoryUsage(), redisData.getHitRate()));
            alert.setTimestamp(new Date());
            
            alertService.sendAlert(alert);
            
        } catch (Exception e) {
            log.error("发送优化通知失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 获取主机名
     */
    private String getHostname() {
        try {
            return InetAddress.getLocalHost().getHostName();
        } catch (UnknownHostException e) {
            return "unknown";
        }
    }
}