第294集Java业务自动巡检架构实战：智能巡检、异常检测与企业级业务监控解决方案

/**
 * 业务自动巡检核心组件
 */
@Component
public class BusinessInspectionEngine {

    @Autowired
    private InspectionTaskScheduler taskScheduler;

    @Autowired
    private InspectionExecutor executor;

    @Autowired
    private ExceptionDetector exceptionDetector;

    @Autowired
    private AlertNotifier alertNotifier;

    @Autowired
    private InspectionResultStorage resultStorage;

    /**
     * 启动巡检引擎
     */
    public void startInspectionEngine() {
        try {
            // 1. 初始化巡检任务
            initializeInspectionTasks();

            // 2. 启动任务调度器
            taskScheduler.startScheduler();

            // 3. 启动巡检执行器
            executor.startExecutor();

            // 4. 启动异常检测器
            exceptionDetector.startDetector();

            log.info("业务巡检引擎启动成功");

        } catch (Exception e) {
            log.error("业务巡检引擎启动失败", e);
            throw new InspectionEngineException("巡检引擎启动失败", e);
        }
    }

    /**
     * 停止巡检引擎
     */
    public void stopInspectionEngine() {
        try {
            // 1. 停止异常检测器
            exceptionDetector.stopDetector();

            // 2. 停止巡检执行器
            executor.stopExecutor();

            // 3. 停止任务调度器
            taskScheduler.stopScheduler();

            log.info("业务巡检引擎停止成功");

        } catch (Exception e) {
            log.error("业务巡检引擎停止失败", e);
        }
    }

    /**
     * 初始化巡检任务
     */
    private void initializeInspectionTasks() {
        // 1. 加载巡检配置
        List<InspectionConfig> configs = loadInspectionConfigs();

        // 2. 创建巡检任务
        for (InspectionConfig config : configs) {
            InspectionTask task = createInspectionTask(config);
            taskScheduler.scheduleTask(task);
        }

        log.info("初始化巡检任务完成，任务数量: {}", configs.size());
    }

    /**
     * 创建巡检任务
     */
    private InspectionTask createInspectionTask(InspectionConfig config) {
        InspectionTask task = new InspectionTask();
        task.setTaskId(config.getTaskId());
        task.setTaskName(config.getTaskName());
        task.setTaskType(config.getTaskType());
        task.setCronExpression(config.getCronExpression());
        task.setCheckPoints(config.getCheckPoints());
        task.setEnabled(config.isEnabled());

        return task;
    }

    /**
     * 加载巡检配置
     */
    private List<InspectionConfig> loadInspectionConfigs() {
        // 实现配置加载逻辑
        return new ArrayList<>();
    }
}

/**
 * 巡检任务调度器
 */
@Component
public class InspectionTaskScheduler {

    private final ScheduledExecutorService scheduler;
    private final Map<String, ScheduledFuture<?>> scheduledTasks;
    private final Map<String, InspectionTask> taskMap;

    public InspectionTaskScheduler() {
        this.scheduler = Executors.newScheduledThreadPool(10);
        this.scheduledTasks = new ConcurrentHashMap<>();
        this.taskMap = new ConcurrentHashMap<>();
    }

    /**
     * 启动调度器
     */
    public void startScheduler() {
        log.info("巡检任务调度器启动");
    }

    /**
     * 停止调度器
     */
    public void stopScheduler() {
        try {
            // 取消所有任务
            scheduledTasks.values().forEach(future -> future.cancel(true));
            scheduledTasks.clear();

            // 关闭调度器
            scheduler.shutdown();
            if (!scheduler.awaitTermination(30, TimeUnit.SECONDS)) {
                scheduler.shutdownNow();
            }

            log.info("巡检任务调度器停止");

        } catch (Exception e) {
            log.error("巡检任务调度器停止失败", e);
        }
    }

    /**
     * 调度巡检任务
     */
    public void scheduleTask(InspectionTask task) {
        try {
            if (!task.isEnabled()) {
                log.info("任务已禁用，跳过调度: {}", task.getTaskName());
                return;
            }

            // 解析Cron表达式
            CronExpression cronExpression = new CronExpression(task.getCronExpression());

            // 计算下次执行时间
            Date nextExecutionTime = cronExpression.getNextValidTimeAfter(new Date());

            if (nextExecutionTime == null) {
                log.warn("无法计算下次执行时间: {}", task.getTaskName());
                return;
            }

            // 计算延迟时间
            long delay = nextExecutionTime.getTime() - System.currentTimeMillis();

            // 调度任务
            ScheduledFuture<?> future = scheduler.scheduleAtFixedRate(
                () -> executeInspectionTask(task),
                delay,
                calculatePeriod(task.getCronExpression()),
                TimeUnit.MILLISECONDS
            );

            // 记录调度信息
            scheduledTasks.put(task.getTaskId(), future);
            taskMap.put(task.getTaskId(), task);

            log.info("巡检任务调度成功: {}, 下次执行时间: {}", 
                    task.getTaskName(), nextExecutionTime);

        } catch (Exception e) {
            log.error("巡检任务调度失败: {}", task.getTaskName(), e);
        }
    }

    /**
     * 执行巡检任务
     */
    private void executeInspectionTask(InspectionTask task) {
        try {
            log.info("开始执行巡检任务: {}", task.getTaskName());

            // 创建巡检上下文
            InspectionContext context = createInspectionContext(task);

            // 执行巡检
            InspectionResult result = executeInspection(context);

            // 处理巡检结果
            handleInspectionResult(result);

            log.info("巡检任务执行完成: {}", task.getTaskName());

        } catch (Exception e) {
            log.error("巡检任务执行失败: {}", task.getTaskName(), e);
        }
    }

    /**
     * 创建巡检上下文
     */
    private InspectionContext createInspectionContext(InspectionTask task) {
        InspectionContext context = new InspectionContext();
        context.setTaskId(task.getTaskId());
        context.setTaskName(task.getTaskName());
        context.setTaskType(task.getTaskType());
        context.setStartTime(System.currentTimeMillis());
        context.setCheckPoints(task.getCheckPoints());

        return context;
    }

    /**
     * 执行巡检
     */
    private InspectionResult executeInspection(InspectionContext context) {
        InspectionResult result = new InspectionResult();
        result.setTaskId(context.getTaskId());
        result.setTaskName(context.getTaskName());
        result.setStartTime(context.getStartTime());

        List<CheckPointResult> checkPointResults = new ArrayList<>();

        // 执行各个检查点
        for (CheckPoint checkPoint : context.getCheckPoints()) {
            try {
                CheckPointResult checkPointResult = executeCheckPoint(checkPoint);
                checkPointResults.add(checkPointResult);

            } catch (Exception e) {
                log.error("检查点执行失败: {}", checkPoint.getName(), e);

                CheckPointResult errorResult = new CheckPointResult();
                errorResult.setCheckPointName(checkPoint.getName());
                errorResult.setStatus(CheckPointStatus.FAILED);
                errorResult.setErrorMessage(e.getMessage());
                checkPointResults.add(errorResult);
            }
        }

        result.setCheckPointResults(checkPointResults);
        result.setEndTime(System.currentTimeMillis());
        result.setDuration(result.getEndTime() - result.getStartTime());

        return result;
    }

    /**
     * 执行检查点
     */
    private CheckPointResult executeCheckPoint(CheckPoint checkPoint) {
        CheckPointResult result = new CheckPointResult();
        result.setCheckPointName(checkPoint.getName());
        result.setStartTime(System.currentTimeMillis());

        try {
            // 根据检查点类型执行不同的检查逻辑
            switch (checkPoint.getType()) {
                case DATA_CHECK:
                    result = executeDataCheck(checkPoint);
                    break;
                case INTERFACE_CHECK:
                    result = executeInterfaceCheck(checkPoint);
                    break;
                case PERFORMANCE_CHECK:
                    result = executePerformanceCheck(checkPoint);
                    break;
                case BUSINESS_LOGIC_CHECK:
                    result = executeBusinessLogicCheck(checkPoint);
                    break;
                default:
                    throw new UnsupportedOperationException("不支持的检查点类型: " + checkPoint.getType());
            }

        } catch (Exception e) {
            result.setStatus(CheckPointStatus.FAILED);
            result.setErrorMessage(e.getMessage());
        }

        result.setEndTime(System.currentTimeMillis());
        result.setDuration(result.getEndTime() - result.getStartTime());

        return result;
    }

    /**
     * 计算执行周期
     */
    private long calculatePeriod(String cronExpression) {
        try {
            CronExpression cron = new CronExpression(cronExpression);
            Date now = new Date();
            Date next1 = cron.getNextValidTimeAfter(now);
            Date next2 = cron.getNextValidTimeAfter(next1);

            return next2.getTime() - next1.getTime();

        } catch (Exception e) {
            log.error("计算执行周期失败", e);
            return 60000; // 默认1分钟
        }
    }
}

/**
 * 检查点执行器
 */
@Component
public class CheckPointExecutor {

    @Autowired
    private DataCheckExecutor dataCheckExecutor;

    @Autowired
    private InterfaceCheckExecutor interfaceCheckExecutor;

    @Autowired
    private PerformanceCheckExecutor performanceCheckExecutor;

    @Autowired
    private BusinessLogicCheckExecutor businessLogicCheckExecutor;

    /**
     * 执行数据检查
     */
    public CheckPointResult executeDataCheck(CheckPoint checkPoint) {
        return dataCheckExecutor.execute(checkPoint);
    }

    /**
     * 执行接口检查
     */
    public CheckPointResult executeInterfaceCheck(CheckPoint checkPoint) {
        return interfaceCheckExecutor.execute(checkPoint);
    }

    /**
     * 执行性能检查
     */
    public CheckPointResult executePerformanceCheck(CheckPoint checkPoint) {
        return performanceCheckExecutor.execute(checkPoint);
    }

    /**
     * 执行业务逻辑检查
     */
    public CheckPointResult executeBusinessLogicCheck(CheckPoint checkPoint) {
        return businessLogicCheckExecutor.execute(checkPoint);
    }
}

/**
 * 数据检查执行器
 */
@Component
public class DataCheckExecutor {

    @Autowired
    private DataSource dataSource;

    @Autowired
    private DataValidator dataValidator;

    /**
     * 执行数据检查
     */
    public CheckPointResult execute(CheckPoint checkPoint) {
        CheckPointResult result = new CheckPointResult();
        result.setCheckPointName(checkPoint.getName());
        result.setStartTime(System.currentTimeMillis());

        try {
            // 1. 解析检查配置
            DataCheckConfig config = parseDataCheckConfig(checkPoint.getConfig());

            // 2. 执行数据查询
            List<Map<String, Object>> data = executeDataQuery(config);

            // 3. 执行数据验证
            ValidationResult validationResult = dataValidator.validate(data, config.getValidationRules());

            // 4. 设置检查结果
            if (validationResult.isValid()) {
                result.setStatus(CheckPointStatus.PASSED);
                result.setMessage("数据检查通过");
            } else {
                result.setStatus(CheckPointStatus.FAILED);
                result.setMessage("数据检查失败: " + validationResult.getErrorMessage());
                result.setErrorDetails(validationResult.getErrorDetails());
            }

            // 5. 记录检查数据
            result.setCheckData(data);

        } catch (Exception e) {
            result.setStatus(CheckPointStatus.FAILED);
            result.setErrorMessage("数据检查异常: " + e.getMessage());
            log.error("数据检查执行失败: {}", checkPoint.getName(), e);
        }

        result.setEndTime(System.currentTimeMillis());
        result.setDuration(result.getEndTime() - result.getStartTime());

        return result;
    }

    /**
     * 解析数据检查配置
     */
    private DataCheckConfig parseDataCheckConfig(String configJson) {
        try {
            ObjectMapper mapper = new ObjectMapper();
            return mapper.readValue(configJson, DataCheckConfig.class);
        } catch (Exception e) {
            throw new ConfigurationException("数据检查配置解析失败", e);
        }
    }

    /**
     * 执行数据查询
     */
    private List<Map<String, Object>> executeDataQuery(DataCheckConfig config) {
        try {
            String sql = config.getSql();
            List<Object> parameters = config.getParameters();

            if (parameters == null || parameters.isEmpty()) {
                return dataSource.queryForList(sql);
            } else {
                return dataSource.queryForList(sql, parameters.toArray());
            }

        } catch (Exception e) {
            throw new DataQueryException("数据查询失败", e);
        }
    }

    /**
     * 数据检查配置类
     */
    public static class DataCheckConfig {
        private String sql;
        private List<Object> parameters;
        private List<ValidationRule> validationRules;

        // getter和setter方法
        public String getSql() {
            return sql;
        }

        public void setSql(String sql) {
            this.sql = sql;
        }

        public List<Object> getParameters() {
            return parameters;
        }

        public void setParameters(List<Object> parameters) {
            this.parameters = parameters;
        }

        public List<ValidationRule> getValidationRules() {
            return validationRules;
        }

        public void setValidationRules(List<ValidationRule> validationRules) {
            this.validationRules = validationRules;
        }
    }
}

/**
 * 接口检查执行器
 */
@Component
public class InterfaceCheckExecutor {

    @Autowired
    private RestTemplate restTemplate;

    @Autowired
    private InterfaceValidator interfaceValidator;

    /**
     * 执行接口检查
     */
    public CheckPointResult execute(CheckPoint checkPoint) {
        CheckPointResult result = new CheckPointResult();
        result.setCheckPointName(checkPoint.getName());
        result.setStartTime(System.currentTimeMillis());

        try {
            // 1. 解析接口检查配置
            InterfaceCheckConfig config = parseInterfaceCheckConfig(checkPoint.getConfig());

            // 2. 执行接口调用
            InterfaceResponse response = executeInterfaceCall(config);

            // 3. 验证接口响应
            ValidationResult validationResult = interfaceValidator.validate(response, config.getValidationRules());

            // 4. 设置检查结果
            if (validationResult.isValid()) {
                result.setStatus(CheckPointStatus.PASSED);
                result.setMessage("接口检查通过");
            } else {
                result.setStatus(CheckPointStatus.FAILED);
                result.setMessage("接口检查失败: " + validationResult.getErrorMessage());
                result.setErrorDetails(validationResult.getErrorDetails());
            }

            // 5. 记录响应数据
            result.setResponseData(response);

        } catch (Exception e) {
            result.setStatus(CheckPointStatus.FAILED);
            result.setErrorMessage("接口检查异常: " + e.getMessage());
            log.error("接口检查执行失败: {}", checkPoint.getName(), e);
        }

        result.setEndTime(System.currentTimeMillis());
        result.setDuration(result.getEndTime() - result.getStartTime());

        return result;
    }

    /**
     * 解析接口检查配置
     */
    private InterfaceCheckConfig parseInterfaceCheckConfig(String configJson) {
        try {
            ObjectMapper mapper = new ObjectMapper();
            return mapper.readValue(configJson, InterfaceCheckConfig.class);
        } catch (Exception e) {
            throw new ConfigurationException("接口检查配置解析失败", e);
        }
    }

    /**
     * 执行接口调用
     */
    private InterfaceResponse executeInterfaceCall(InterfaceCheckConfig config) {
        try {
            String url = config.getUrl();
            HttpMethod method = config.getMethod();
            Map<String, String> headers = config.getHeaders();
            Object requestBody = config.getRequestBody();
            int timeout = config.getTimeout();

            // 设置请求头
            HttpHeaders httpHeaders = new HttpHeaders();
            if (headers != null) {
                headers.forEach(httpHeaders::set);
            }

            // 创建请求实体
            HttpEntity<?> requestEntity = new HttpEntity<>(requestBody, httpHeaders);

            // 设置超时
            restTemplate.getRequestFactory().setConnectTimeout(timeout);
            restTemplate.getRequestFactory().setReadTimeout(timeout);

            // 执行请求
            ResponseEntity<String> responseEntity = restTemplate.exchange(
                url, method, requestEntity, String.class
            );

            // 构建响应对象
            InterfaceResponse response = new InterfaceResponse();
            response.setStatusCode(responseEntity.getStatusCodeValue());
            response.setHeaders(responseEntity.getHeaders().toSingleValueMap());
            response.setBody(responseEntity.getBody());
            response.setResponseTime(System.currentTimeMillis());

            return response;

        } catch (Exception e) {
            throw new InterfaceCallException("接口调用失败", e);
        }
    }

    /**
     * 接口检查配置类
     */
    public static class InterfaceCheckConfig {
        private String url;
        private HttpMethod method;
        private Map<String, String> headers;
        private Object requestBody;
        private int timeout;
        private List<ValidationRule> validationRules;

        // getter和setter方法
        public String getUrl() {
            return url;
        }

        public void setUrl(String url) {
            this.url = url;
        }

        public HttpMethod getMethod() {
            return method;
        }

        public void setMethod(HttpMethod method) {
            this.method = method;
        }

        public Map<String, String> getHeaders() {
            return headers;
        }

        public void setHeaders(Map<String, String> headers) {
            this.headers = headers;
        }

        public Object getRequestBody() {
            return requestBody;
        }

        public void setRequestBody(Object requestBody) {
            this.requestBody = requestBody;
        }

        public int getTimeout() {
            return timeout;
        }

        public void setTimeout(int timeout) {
            this.timeout = timeout;
        }

        public List<ValidationRule> getValidationRules() {
            return validationRules;
        }

        public void setValidationRules(List<ValidationRule> validationRules) {
            this.validationRules = validationRules;
        }
    }
}

/**
 * 异常检测器
 */
@Component
public class ExceptionDetector {

    @Autowired
    private InspectionResultAnalyzer resultAnalyzer;

    @Autowired
    private ExceptionClassifier exceptionClassifier;

    @Autowired
    private AlertRuleEngine alertRuleEngine;

    private final ScheduledExecutorService detectorScheduler;

    public ExceptionDetector() {
        this.detectorScheduler = Executors.newScheduledThreadPool(5);
    }

    /**
     * 启动异常检测器
     */
    public void startDetector() {
        // 启动定期检测任务
        detectorScheduler.scheduleAtFixedRate(
            this::detectExceptions,
            0,
            30,
            TimeUnit.SECONDS
        );

        log.info("异常检测器启动成功");
    }

    /**
     * 停止异常检测器
     */
    public void stopDetector() {
        try {
            detectorScheduler.shutdown();
            if (!detectorScheduler.awaitTermination(30, TimeUnit.SECONDS)) {
                detectorScheduler.shutdownNow();
            }

            log.info("异常检测器停止成功");

        } catch (Exception e) {
            log.error("异常检测器停止失败", e);
        }
    }

    /**
     * 检测异常
     */
    private void detectExceptions() {
        try {
            // 1. 获取最近的巡检结果
            List<InspectionResult> recentResults = getRecentInspectionResults();

            // 2. 分析巡检结果
            List<ExceptionDetection> detections = resultAnalyzer.analyzeResults(recentResults);

            // 3. 分类异常
            for (ExceptionDetection detection : detections) {
                ExceptionType type = exceptionClassifier.classify(detection);
                detection.setExceptionType(type);
            }

            // 4. 检查告警规则
            for (ExceptionDetection detection : detections) {
                List<AlertRule> triggeredRules = alertRuleEngine.checkRules(detection);

                if (!triggeredRules.isEmpty()) {
                    // 触发告警
                    triggerAlerts(detection, triggeredRules);
                }
            }

        } catch (Exception e) {
            log.error("异常检测失败", e);
        }
    }

    /**
     * 获取最近的巡检结果
     */
    private List<InspectionResult> getRecentInspectionResults() {
        // 实现获取最近巡检结果的逻辑
        return new ArrayList<>();
    }

    /**
     * 触发告警
     */
    private void triggerAlerts(ExceptionDetection detection, List<AlertRule> triggeredRules) {
        try {
            for (AlertRule rule : triggeredRules) {
                Alert alert = createAlert(detection, rule);
                sendAlert(alert);
            }

        } catch (Exception e) {
            log.error("告警触发失败", e);
        }
    }

    /**
     * 创建告警
     */
    private Alert createAlert(ExceptionDetection detection, AlertRule rule) {
        Alert alert = new Alert();
        alert.setAlertId(generateAlertId());
        alert.setAlertType(rule.getAlertType());
        alert.setSeverity(rule.getSeverity());
        alert.setTitle(rule.getTitle());
        alert.setMessage(buildAlertMessage(detection, rule));
        alert.setDetection(detection);
        alert.setRule(rule);
        alert.setTimestamp(System.currentTimeMillis());

        return alert;
    }

    /**
     * 发送告警
     */
    private void sendAlert(Alert alert) {
        // 实现告警发送逻辑
        log.warn("发送告警: {}", alert.getTitle());
    }

    /**
     * 生成告警ID
     */
    private String generateAlertId() {
        return "alert-" + System.currentTimeMillis() + "-" + Thread.currentThread().getId();
    }

    /**
     * 构建告警消息
     */
    private String buildAlertMessage(ExceptionDetection detection, AlertRule rule) {
        StringBuilder message = new StringBuilder();
        message.append("检测到异常: ").append(detection.getDescription()).append("\n");
        message.append("异常类型: ").append(detection.getExceptionType()).append("\n");
        message.append("检查点: ").append(detection.getCheckPointName()).append("\n");
        message.append("检测时间: ").append(new Date(detection.getTimestamp())).append("\n");
        message.append("告警规则: ").append(rule.getName());

        return message.toString();
    }
}

/**
 * 巡检结果分析器
 */
@Component
public class InspectionResultAnalyzer {

    @Autowired
    private InspectionResultStorage resultStorage;

    @Autowired
    private TrendAnalyzer trendAnalyzer;

    /**
     * 分析巡检结果
     */
    public List<ExceptionDetection> analyzeResults(List<InspectionResult> results) {
        List<ExceptionDetection> detections = new ArrayList<>();

        try {
            // 1. 分析单个结果
            for (InspectionResult result : results) {
                List<ExceptionDetection> resultDetections = analyzeSingleResult(result);
                detections.addAll(resultDetections);
            }

            // 2. 分析趋势
            List<ExceptionDetection> trendDetections = analyzeTrends(results);
            detections.addAll(trendDetections);

            // 3. 分析模式
            List<ExceptionDetection> patternDetections = analyzePatterns(results);
            detections.addAll(patternDetections);

        } catch (Exception e) {
            log.error("巡检结果分析失败", e);
        }

        return detections;
    }

    /**
     * 分析单个结果
     */
    private List<ExceptionDetection> analyzeSingleResult(InspectionResult result) {
        List<ExceptionDetection> detections = new ArrayList<>();

        // 分析失败的检查点
        for (CheckPointResult checkPointResult : result.getCheckPointResults()) {
            if (checkPointResult.getStatus() == CheckPointStatus.FAILED) {
                ExceptionDetection detection = new ExceptionDetection();
                detection.setDetectionId(generateDetectionId());
                detection.setTaskId(result.getTaskId());
                detection.setTaskName(result.getTaskName());
                detection.setCheckPointName(checkPointResult.getCheckPointName());
                detection.setDescription(checkPointResult.getErrorMessage());
                detection.setSeverity(calculateSeverity(checkPointResult));
                detection.setTimestamp(result.getStartTime());
                detection.setDetectionType(DetectionType.SINGLE_FAILURE);

                detections.add(detection);
            }
        }

        return detections;
    }

    /**
     * 分析趋势
     */
    private List<ExceptionDetection> analyzeTrends(List<InspectionResult> results) {
        List<ExceptionDetection> detections = new ArrayList<>();

        try {
            // 按任务分组
            Map<String, List<InspectionResult>> groupedResults = results.stream()
                .collect(Collectors.groupingBy(InspectionResult::getTaskId));

            for (Map.Entry<String, List<InspectionResult>> entry : groupedResults.entrySet()) {
                String taskId = entry.getKey();
                List<InspectionResult> taskResults = entry.getValue();

                // 分析失败率趋势
                TrendAnalysis failureRateTrend = trendAnalyzer.analyzeFailureRateTrend(taskResults);

                if (failureRateTrend.isIncreasing() && failureRateTrend.getChangeRate() > 0.2) {
                    ExceptionDetection detection = new ExceptionDetection();
                    detection.setDetectionId(generateDetectionId());
                    detection.setTaskId(taskId);
                    detection.setTaskName(taskResults.get(0).getTaskName());
                    detection.setDescription("失败率持续上升");
                    detection.setSeverity(Severity.HIGH);
                    detection.setTimestamp(System.currentTimeMillis());
                    detection.setDetectionType(DetectionType.TREND_ANALYSIS);
                    detection.setTrendAnalysis(failureRateTrend);

                    detections.add(detection);
                }

                // 分析响应时间趋势
                TrendAnalysis responseTimeTrend = trendAnalyzer.analyzeResponseTimeTrend(taskResults);

                if (responseTimeTrend.isIncreasing() && responseTimeTrend.getChangeRate() > 0.3) {
                    ExceptionDetection detection = new ExceptionDetection();
                    detection.setDetectionId(generateDetectionId());
                    detection.setTaskId(taskId);
                    detection.setTaskName(taskResults.get(0).getTaskName());
                    detection.setDescription("响应时间持续增长");
                    detection.setSeverity(Severity.MEDIUM);
                    detection.setTimestamp(System.currentTimeMillis());
                    detection.setDetectionType(DetectionType.TREND_ANALYSIS);
                    detection.setTrendAnalysis(responseTimeTrend);

                    detections.add(detection);
                }
            }

        } catch (Exception e) {
            log.error("趋势分析失败", e);
        }

        return detections;
    }

    /**
     * 分析模式
     */
    private List<ExceptionDetection> analyzePatterns(List<InspectionResult> results) {
        List<ExceptionDetection> detections = new ArrayList<>();

        try {
            // 分析异常模式
            Map<String, Integer> errorPatterns = new HashMap<>();

            for (InspectionResult result : results) {
                for (CheckPointResult checkPointResult : result.getCheckPointResults()) {
                    if (checkPointResult.getStatus() == CheckPointStatus.FAILED) {
                        String errorPattern = checkPointResult.getErrorMessage();
                        errorPatterns.merge(errorPattern, 1, Integer::sum);
                    }
                }
            }

            // 检查频繁出现的错误模式
            for (Map.Entry<String, Integer> entry : errorPatterns.entrySet()) {
                String errorPattern = entry.getKey();
                int count = entry.getValue();

                if (count >= 3) { // 出现3次以上认为是模式
                    ExceptionDetection detection = new ExceptionDetection();
                    detection.setDetectionId(generateDetectionId());
                    detection.setDescription("频繁出现错误模式: " + errorPattern);
                    detection.setSeverity(Severity.MEDIUM);
                    detection.setTimestamp(System.currentTimeMillis());
                    detection.setDetectionType(DetectionType.PATTERN_ANALYSIS);
                    detection.setPatternCount(count);

                    detections.add(detection);
                }
            }

        } catch (Exception e) {
            log.error("模式分析失败", e);
        }

        return detections;
    }

    /**
     * 计算严重程度
     */
    private Severity calculateSeverity(CheckPointResult checkPointResult) {
        String errorMessage = checkPointResult.getErrorMessage();

        if (errorMessage.contains("数据库") || errorMessage.contains("连接")) {
            return Severity.CRITICAL;
        } else if (errorMessage.contains("超时") || errorMessage.contains("性能")) {
            return Severity.HIGH;
        } else if (errorMessage.contains("数据") || errorMessage.contains("业务")) {
            return Severity.MEDIUM;
        } else {
            return Severity.LOW;
        }
    }

    /**
     * 生成检测ID
     */
    private String generateDetectionId() {
        return "detection-" + System.currentTimeMillis() + "-" + Thread.currentThread().getId();
    }
}

/**
 * 告警规则引擎
 */
@Component
public class AlertRuleEngine {

    private final Map<String, AlertRule> alertRules;

    public AlertRuleEngine() {
        this.alertRules = new HashMap<>();
        initializeDefaultRules();
    }

    /**
     * 初始化默认规则
     */
    private void initializeDefaultRules() {
        // 严重异常规则
        AlertRule criticalRule = new AlertRule();
        criticalRule.setRuleId("critical-exception");
        criticalRule.setName("严重异常告警");
        criticalRule.setDescription("检测到严重异常时立即告警");
        criticalRule.setSeverity(Severity.CRITICAL);
        criticalRule.setAlertType(AlertType.IMMEDIATE);
        criticalRule.setConditions(Arrays.asList(
            "exceptionType == 'CRITICAL'",
            "severity == 'CRITICAL'"
        ));
        alertRules.put(criticalRule.getRuleId(), criticalRule);

        // 高频异常规则
        AlertRule frequencyRule = new AlertRule();
        frequencyRule.setRuleId("high-frequency-exception");
        frequencyRule.setName("高频异常告警");
        frequencyRule.setDescription("短时间内出现大量异常时告警");
        frequencyRule.setSeverity(Severity.HIGH);
        frequencyRule.setAlertType(AlertType.BATCH);
        frequencyRule.setConditions(Arrays.asList(
            "exceptionCount > 10",
            "timeWindow == '5min'"
        ));
        alertRules.put(frequencyRule.getRuleId(), frequencyRule);

        // 趋势异常规则
        AlertRule trendRule = new AlertRule();
        trendRule.setRuleId("trend-exception");
        trendRule.setName("趋势异常告警");
        trendRule.setDescription("异常趋势持续恶化时告警");
        trendRule.setSeverity(Severity.MEDIUM);
        trendRule.setAlertType(AlertType.TREND);
        trendRule.setConditions(Arrays.asList(
            "trendDirection == 'INCREASING'",
            "changeRate > 0.2"
        ));
        alertRules.put(trendRule.getRuleId(), trendRule);
    }

    /**
     * 检查告警规则
     */
    public List<AlertRule> checkRules(ExceptionDetection detection) {
        List<AlertRule> triggeredRules = new ArrayList<>();

        for (AlertRule rule : alertRules.values()) {
            if (evaluateRule(rule, detection)) {
                triggeredRules.add(rule);
            }
        }

        return triggeredRules;
    }

    /**
     * 评估规则
     */
    private boolean evaluateRule(AlertRule rule, ExceptionDetection detection) {
        try {
            for (String condition : rule.getConditions()) {
                if (!evaluateCondition(condition, detection)) {
                    return false;
                }
            }
            return true;

        } catch (Exception e) {
            log.error("规则评估失败: {}", rule.getName(), e);
            return false;
        }
    }

    /**
     * 评估条件
     */
    private boolean evaluateCondition(String condition, ExceptionDetection detection) {
        // 简单的条件评估实现
        if (condition.contains("exceptionType == 'CRITICAL'")) {
            return detection.getExceptionType() == ExceptionType.CRITICAL;
        }

        if (condition.contains("severity == 'CRITICAL'")) {
            return detection.getSeverity() == Severity.CRITICAL;
        }

        if (condition.contains("exceptionCount > 10")) {
            return detection.getPatternCount() > 10;
        }

        if (condition.contains("trendDirection == 'INCREASING'")) {
            return detection.getTrendAnalysis() != null && 
                   detection.getTrendAnalysis().isIncreasing();
        }

        if (condition.contains("changeRate > 0.2")) {
            return detection.getTrendAnalysis() != null && 
                   detection.getTrendAnalysis().getChangeRate() > 0.2;
        }

        return false;
    }

    /**
     * 添加告警规则
     */
    public void addRule(AlertRule rule) {
        alertRules.put(rule.getRuleId(), rule);
    }

    /**
     * 删除告警规则
     */
    public void removeRule(String ruleId) {
        alertRules.remove(ruleId);
    }

    /**
     * 获取所有规则
     */
    public List<AlertRule> getAllRules() {
        return new ArrayList<>(alertRules.values());
    }
}

/**
 * 巡检配置管理服务
 */
@Service
public class InspectionConfigService {

    @Autowired
    private ConfigurationRepository configRepository;

    /**
     * 获取巡检配置
     */
    public InspectionConfig getConfig(String configId) {
        return configRepository.findById(configId)
            .orElseThrow(() -> new ConfigNotFoundException("巡检配置不存在: " + configId));
    }

    /**
     * 保存巡检配置
     */
    public void saveConfig(InspectionConfig config) {
        try {
            // 验证配置
            validateConfig(config);

            // 保存配置
            configRepository.save(config);

            log.info("巡检配置保存成功: {}", config.getConfigId());

        } catch (Exception e) {
            log.error("巡检配置保存失败", e);
            throw new ConfigSaveException("巡检配置保存失败", e);
        }
    }

    /**
     * 更新巡检配置
     */
    public void updateConfig(String configId, InspectionConfig config) {
        try {
            // 检查配置是否存在
            if (!configRepository.existsById(configId)) {
                throw new ConfigNotFoundException("巡检配置不存在: " + configId);
            }

            // 验证配置
            validateConfig(config);

            // 更新配置
            config.setConfigId(configId);
            configRepository.save(config);

            log.info("巡检配置更新成功: {}", configId);

        } catch (Exception e) {
            log.error("巡检配置更新失败", e);
            throw new ConfigUpdateException("巡检配置更新失败", e);
        }
    }

    /**
     * 删除巡检配置
     */
    public void deleteConfig(String configId) {
        try {
            if (!configRepository.existsById(configId)) {
                throw new ConfigNotFoundException("巡检配置不存在: " + configId);
            }

            configRepository.deleteById(configId);

            log.info("巡检配置删除成功: {}", configId);

        } catch (Exception e) {
            log.error("巡检配置删除失败", e);
            throw new ConfigDeleteException("巡检配置删除失败", e);
        }
    }

    /**
     * 获取所有配置
     */
    public List<InspectionConfig> getAllConfigs() {
        return configRepository.findAll();
    }

    /**
     * 验证配置
     */
    private void validateConfig(InspectionConfig config) {
        if (config.getConfigId() == null || config.getConfigId().isEmpty()) {
            throw new ConfigValidationException("配置ID不能为空");
        }

        if (config.getTaskName() == null || config.getTaskName().isEmpty()) {
            throw new ConfigValidationException("任务名称不能为空");
        }

        if (config.getCronExpression() == null || config.getCronExpression().isEmpty()) {
            throw new ConfigValidationException("Cron表达式不能为空");
        }

        if (config.getCheckPoints() == null || config.getCheckPoints().isEmpty()) {
            throw new ConfigValidationException("检查点不能为空");
        }

        // 验证Cron表达式
        try {
            new CronExpression(config.getCronExpression());
        } catch (Exception e) {
            throw new ConfigValidationException("Cron表达式格式错误", e);
        }
    }
}

/**
 * 巡检结果存储服务
 */
@Service
public class InspectionResultStorageService {

    @Autowired
    private InspectionResultRepository resultRepository;

    @Autowired
    private CheckPointResultRepository checkPointResultRepository;

    /**
     * 存储巡检结果
     */
    public void storeResult(InspectionResult result) {
        try {
            // 1. 存储主结果
            resultRepository.save(result);

            // 2. 存储检查点结果
            for (CheckPointResult checkPointResult : result.getCheckPointResults()) {
                checkPointResult.setInspectionResultId(result.getResultId());
                checkPointResultRepository.save(checkPointResult);
            }

            log.info("巡检结果存储成功: {}", result.getResultId());

        } catch (Exception e) {
            log.error("巡检结果存储失败", e);
            throw new ResultStorageException("巡检结果存储失败", e);
        }
    }

    /**
     * 获取巡检结果
     */
    public InspectionResult getResult(String resultId) {
        return resultRepository.findById(resultId)
            .orElseThrow(() -> new ResultNotFoundException("巡检结果不存在: " + resultId));
    }

    /**
     * 获取最近的巡检结果
     */
    public List<InspectionResult> getRecentResults(int limit) {
        return resultRepository.findRecentResults(limit);
    }

    /**
     * 获取指定任务的巡检结果
     */
    public List<InspectionResult> getResultsByTask(String taskId, int limit) {
        return resultRepository.findByTaskIdOrderByStartTimeDesc(taskId, limit);
    }

    /**
     * 获取巡检统计信息
     */
    public InspectionStatistics getStatistics(String taskId, Date startTime, Date endTime) {
        InspectionStatistics statistics = new InspectionStatistics();

        try {
            // 获取统计期间的结果
            List<InspectionResult> results = resultRepository.findByTaskIdAndStartTimeBetween(
                taskId, startTime, endTime
            );

            // 计算统计信息
            statistics.setTotalCount(results.size());
            statistics.setSuccessCount((int) results.stream()
                .filter(result -> result.getStatus() == InspectionStatus.SUCCESS)
                .count());
            statistics.setFailureCount((int) results.stream()
                .filter(result -> result.getStatus() == InspectionStatus.FAILURE)
                .count());

            // 计算成功率
            if (statistics.getTotalCount() > 0) {
                statistics.setSuccessRate((double) statistics.getSuccessCount() / statistics.getTotalCount());
            }

            // 计算平均执行时间
            double avgDuration = results.stream()
                .mapToLong(InspectionResult::getDuration)
                .average()
                .orElse(0.0);
            statistics.setAverageDuration(avgDuration);

            // 计算最大执行时间
            long maxDuration = results.stream()
                .mapToLong(InspectionResult::getDuration)
                .max()
                .orElse(0L);
            statistics.setMaxDuration(maxDuration);

            // 计算最小执行时间
            long minDuration = results.stream()
                .mapToLong(InspectionResult::getDuration)
                .min()
                .orElse(0L);
            statistics.setMinDuration(minDuration);

        } catch (Exception e) {
            log.error("获取巡检统计信息失败", e);
            throw new StatisticsException("获取巡检统计信息失败", e);
        }

        return statistics;
    }
}

/**
 * 巡检报告生成服务
 */
@Service
public class InspectionReportService {

    @Autowired
    private InspectionResultStorageService resultStorageService;

    @Autowired
    private ReportTemplateService templateService;

    /**
     * 生成巡检报告
     */
    public InspectionReport generateReport(String taskId, Date startTime, Date endTime) {
        InspectionReport report = new InspectionReport();

        try {
            // 1. 设置报告基本信息
            report.setReportId(generateReportId());
            report.setTaskId(taskId);
            report.setStartTime(startTime);
            report.setEndTime(endTime);
            report.setGenerateTime(new Date());

            // 2. 获取巡检结果
            List<InspectionResult> results = resultStorageService.getResultsByTask(taskId, 100);

            // 3. 生成统计信息
            InspectionStatistics statistics = resultStorageService.getStatistics(taskId, startTime, endTime);
            report.setStatistics(statistics);

            // 4. 生成趋势分析
            TrendAnalysis trendAnalysis = generateTrendAnalysis(results);
            report.setTrendAnalysis(trendAnalysis);

            // 5. 生成异常分析
            ExceptionAnalysis exceptionAnalysis = generateExceptionAnalysis(results);
            report.setExceptionAnalysis(exceptionAnalysis);

            // 6. 生成建议
            List<Recommendation> recommendations = generateRecommendations(statistics, trendAnalysis, exceptionAnalysis);
            report.setRecommendations(recommendations);

            // 7. 生成报告摘要
            String summary = generateSummary(report);
            report.setSummary(summary);

            log.info("巡检报告生成成功: {}", report.getReportId());

        } catch (Exception e) {
            log.error("巡检报告生成失败", e);
            throw new ReportGenerationException("巡检报告生成失败", e);
        }

        return report;
    }

    /**
     * 生成趋势分析
     */
    private TrendAnalysis generateTrendAnalysis(List<InspectionResult> results) {
        TrendAnalysis analysis = new TrendAnalysis();

        try {
            // 按时间排序
            results.sort(Comparator.comparing(InspectionResult::getStartTime));

            // 分析成功率趋势
            List<Double> successRates = new ArrayList<>();
            for (InspectionResult result : results) {
                double successRate = calculateSuccessRate(result);
                successRates.add(successRate);
            }

            analysis.setSuccessRateTrend(analyzeTrend(successRates));

            // 分析执行时间趋势
            List<Long> durations = results.stream()
                .map(InspectionResult::getDuration)
                .collect(Collectors.toList());

            analysis.setDurationTrend(analyzeTrend(durations));

            // 分析异常趋势
            List<Integer> exceptionCounts = results.stream()
                .map(result -> (int) result.getCheckPointResults().stream()
                    .filter(cp -> cp.getStatus() == CheckPointStatus.FAILED)
                    .count())
                .collect(Collectors.toList());

            analysis.setExceptionTrend(analyzeTrend(exceptionCounts));

        } catch (Exception e) {
            log.error("趋势分析生成失败", e);
        }

        return analysis;
    }

    /**
     * 生成异常分析
     */
    private ExceptionAnalysis generateExceptionAnalysis(List<InspectionResult> results) {
        ExceptionAnalysis analysis = new ExceptionAnalysis();

        try {
            // 统计异常类型
            Map<String, Integer> exceptionTypeCount = new HashMap<>();
            Map<String, Integer> exceptionMessageCount = new HashMap<>();

            for (InspectionResult result : results) {
                for (CheckPointResult checkPointResult : result.getCheckPointResults()) {
                    if (checkPointResult.getStatus() == CheckPointStatus.FAILED) {
                        String errorMessage = checkPointResult.getErrorMessage();

                        // 统计异常消息
                        exceptionMessageCount.merge(errorMessage, 1, Integer::sum);

                        // 统计异常类型
                        String exceptionType = classifyException(errorMessage);
                        exceptionTypeCount.merge(exceptionType, 1, Integer::sum);
                    }
                }
            }

            analysis.setExceptionTypeCount(exceptionTypeCount);
            analysis.setExceptionMessageCount(exceptionMessageCount);

            // 找出最常见的异常
            String mostCommonException = exceptionMessageCount.entrySet().stream()
                .max(Map.Entry.comparingByValue())
                .map(Map.Entry::getKey)
                .orElse("无");

            analysis.setMostCommonException(mostCommonException);

        } catch (Exception e) {
            log.error("异常分析生成失败", e);
        }

        return analysis;
    }

    /**
     * 生成建议
     */
    private List<Recommendation> generateRecommendations(InspectionStatistics statistics, 
                                                        TrendAnalysis trendAnalysis, 
                                                        ExceptionAnalysis exceptionAnalysis) {
        List<Recommendation> recommendations = new ArrayList<>();

        try {
            // 基于成功率生成建议
            if (statistics.getSuccessRate() < 0.8) {
                Recommendation rec = new Recommendation();
                rec.setType(RecommendationType.SUCCESS_RATE);
                rec.setPriority(Priority.HIGH);
                rec.setTitle("提升巡检成功率");
                rec.setDescription("当前巡检成功率为" + String.format("%.2f", statistics.getSuccessRate() * 100) + "%，建议检查系统稳定性");
                recommendations.add(rec);
            }

            // 基于执行时间生成建议
            if (statistics.getAverageDuration() > 30000) { // 30秒
                Recommendation rec = new Recommendation();
                rec.setType(RecommendationType.PERFORMANCE);
                rec.setPriority(Priority.MEDIUM);
                rec.setTitle("优化巡检性能");
                rec.setDescription("平均执行时间为" + statistics.getAverageDuration() + "ms，建议优化检查点性能");
                recommendations.add(rec);
            }

            // 基于异常分析生成建议
            if (exceptionAnalysis.getMostCommonException() != null && 
                !exceptionAnalysis.getMostCommonException().equals("无")) {
                Recommendation rec = new Recommendation();
                rec.setType(RecommendationType.EXCEPTION_HANDLING);
                rec.setPriority(Priority.MEDIUM);
                rec.setTitle("处理常见异常");
                rec.setDescription("最常见的异常是：" + exceptionAnalysis.getMostCommonException() + "，建议优先处理");
                recommendations.add(rec);
            }

        } catch (Exception e) {
            log.error("建议生成失败", e);
        }

        return recommendations;
    }

    /**
     * 生成报告摘要
     */
    private String generateSummary(InspectionReport report) {
        StringBuilder summary = new StringBuilder();

        summary.append("巡检报告摘要\n");
        summary.append("任务ID: ").append(report.getTaskId()).append("\n");
        summary.append("统计期间: ").append(report.getStartTime()).append(" - ").append(report.getEndTime()).append("\n");
        summary.append("总执行次数: ").append(report.getStatistics().getTotalCount()).append("\n");
        summary.append("成功率: ").append(String.format("%.2f", report.getStatistics().getSuccessRate() * 100)).append("%\n");
        summary.append("平均执行时间: ").append(report.getStatistics().getAverageDuration()).append("ms\n");

        if (!report.getRecommendations().isEmpty()) {
            summary.append("主要建议: ").append(report.getRecommendations().get(0).getTitle()).append("\n");
        }

        return summary.toString();
    }

    /**
     * 计算成功率
     */
    private double calculateSuccessRate(InspectionResult result) {
        int totalCheckPoints = result.getCheckPointResults().size();
        int successCheckPoints = (int) result.getCheckPointResults().stream()
            .filter(cp -> cp.getStatus() == CheckPointStatus.PASSED)
            .count();

        return totalCheckPoints > 0 ? (double) successCheckPoints / totalCheckPoints : 0.0;
    }

    /**
     * 分析趋势
     */
    private TrendDirection analyzeTrend(List<? extends Number> values) {
        if (values.size() < 2) {
            return TrendDirection.STABLE;
        }

        // 简单趋势分析
        double firstHalf = values.subList(0, values.size() / 2).stream()
            .mapToDouble(Number::doubleValue)
            .average()
            .orElse(0.0);

        double secondHalf = values.subList(values.size() / 2, values.size()).stream()
            .mapToDouble(Number::doubleValue)
            .average()
            .orElse(0.0);

        if (secondHalf > firstHalf * 1.1) {
            return TrendDirection.INCREASING;
        } else if (secondHalf < firstHalf * 0.9) {
            return TrendDirection.DECREASING;
        } else {
            return TrendDirection.STABLE;
        }
    }

    /**
     * 分类异常
     */
    private String classifyException(String errorMessage) {
        if (errorMessage.contains("数据库") || errorMessage.contains("SQL")) {
            return "数据库异常";
        } else if (errorMessage.contains("网络") || errorMessage.contains("连接")) {
            return "网络异常";
        } else if (errorMessage.contains("超时")) {
            return "超时异常";
        } else if (errorMessage.contains("权限") || errorMessage.contains("认证")) {
            return "权限异常";
        } else {
            return "其他异常";
        }
    }

    /**
     * 生成报告ID
     */
    private String generateReportId() {
        return "report-" + System.currentTimeMillis() + "-" + Thread.currentThread().getId();
    }
}