SpringAI与LangChain4j的智能应用-(实践篇3)

企业级AIOps平台（Spring Boot 3.x + Vue3）核心实现方案

一、项目整体定位

聚焦AIOps核心闭环：数据采集→异常检测→根因定位→自动处置，仅实现核心流程，剔除复盘优化、审计等旁支功能，优先保证核心链路可运行。
技术栈：

• 后端：Spring Boot 3.2.5 + SpringAI 1.0.0-M1 + LangChain4j 0.32.0 + Prometheus Java Client + MyBatis-Plus
• 前端：Vue3 + Element Plus + ECharts（仅核心可视化）

二、工程目录结构

1. 后端目录结构（Maven多模块，聚焦核心）

aiops-platform/
├── aiops-common/                // 通用模块（核心）
│   ├── src/main/java/com/aiops/common/
│   │   ├── constant/            // 常量（异常等级、处置类型）
│   │   ├── dto/                 // 通用DTO（分页、返回结果）
│   │   ├── enums/               // 枚举（异常类型、处置级别）
│   │   ├── exception/           // 全局异常
│   │   └── utils/               // 工具类（JSON、时间、HTTP）
├── aiops-core/                  // 核心业务模块（核心）
│   ├── src/main/java/com/aiops/core/
│   │   ├── collect/             // 数据采集模块
│   │   │   ├── controller/      // 采集配置接口（仅核心）
│   │   │   ├── service/         // 指标/日志采集服务
│   │   │   └── vo/              // 采集入参VO
│   │   ├── detect/              // 异常检测模块
│   │   │   ├── controller/      // 检测规则/结果接口
│   │   │   ├── service/         // 规则+AI检测服务
│   │   │   └── vo/              // 检测入参VO
│   │   ├── locate/              // 根因定位模块
│   │   │   ├── controller/      // 根因定位接口
│   │   │   ├── service/         // LangChain4j编排推理服务
│   │   │   └── vo/              // 定位入参VO
│   │   ├── dispose/             // 自动处置模块
│   │   │   ├── controller/      // 处置规则/执行接口
│   │   │   ├── service/         // 分级处置服务
│   │   │   └── vo/              // 处置入参VO
│   │   └── entity/              // 核心实体（指标、异常、根因、处置记录）
│   └── src/main/resources/
│       ├── mapper/              // MyBatis-Plus映射文件
│       └── application.yml      // 核心配置（AI模型、Prometheus地址）
├── aiops-api/                   // API网关（简化版，仅路由）
│   └── src/main/java/com/aiops/api/
│       └── GatewayApplication.java
└── pom.xml                      // 父依赖（Spring Boot 3.2.5）

2. 前端目录结构（Vue3 + Vite，聚焦核心）

aiops-front/
├── src/
│   ├── api/                     // 接口请求（采集、检测、定位、处置）
│   ├── assets/                  // 静态资源（图标、样式）
│   ├── components/              // 核心组件
│   │   ├── DataCollect.vue      // 数据采集配置组件
│   │   ├── AnomalyDetect.vue    // 异常检测结果组件
│   │   ├── RootCauseLocate.vue  // 根因定位组件
│   │   └── AutoDispose.vue      // 自动处置组件
│   ├── layout/                  // 基础布局（简化版）
│   ├── router/                  // 路由（核心4个页面）
│   ├── store/                   // Pinia状态管理（仅核心数据）
│   ├── views/                   // 核心页面
│   │   ├── collect/             // 数据采集页
│   │   ├── detect/              // 异常检测页
│   │   ├── locate/              // 根因定位页
│   │   └── dispose/             // 自动处置页
│   ├── App.vue                  // 根组件
│   └── main.js                  // 入口文件
├── package.json
└── vite.config.js

三、核心流程梳理（仅核心链路）

流程总览

数据采集（指标/日志）→ 异常检测（规则+AI）→ 根因定位（多源融合+AI推理）→ 自动处置（分级执行）

1. 数据采集阶段（核心实现）

目标

采集核心指标（接口超时率、CPU使用率）和ERROR日志，标准化存储。

核心实现步骤

① 配置采集源：前端配置Prometheus地址、日志文件路径，后端保存采集规则到数据库；
② 定时采集：后端通过@Scheduled定时调用Prometheus API获取指标，通过FileReader读取日志文件；
③ 数据标准化：将指标/日志转换为统一格式（包含serviceName、metricName、value、timestamp），存入MySQL。

核心代码（指标采集服务）

@Service
public class MetricCollectService {
    @Autowired
    private PrometheusApiClient prometheusApiClient; // 自定义Prometheus客户端
    @Autowired
    private MetricMapper metricMapper;

    // 每1分钟采集核心指标
    @Scheduled(cron = "0 */1 * * * ?")
    public void collectMetric() {
        // 1. 获取采集规则（仅核心服务：trade、pay）
        List<CollectRule> rules = collectRuleMapper.selectList(Wrappers.lambdaQuery(CollectRule.class)
                .in(CollectRule::getServiceName, "trade", "pay"));
        
        // 2. 遍历采集
        for (CollectRule rule : rules) {
            // 调用Prometheus API查询指标（如接口超时率）
            String query = "avg(api_timeout_rate{service=\"%s\"})[1m]".formatted(rule.getServiceName());
            BigDecimal value = prometheusApiClient.queryMetric(query);
            
            // 3. 标准化存储
            MetricDO metricDO = new MetricDO();
            metricDO.setServiceName(rule.getServiceName());
            metricDO.setMetricName("api_timeout_rate");
            metricDO.setValue(value);
            metricDO.setTimestamp(LocalDateTime.now());
            metricMapper.insert(metricDO);
        }
    }
}

2. 异常检测阶段（核心实现）

目标

规则初筛+AI复判，识别真异常（接口超时率>5%）。

核心实现步骤

① 规则检测：后端读取指标数据，判断是否超过阈值（如超时率>5%）；
② AI复判：若触发规则，调用SpringAI的ChatClient，整合日志数据判定是否为真异常；
③ 结果存储：将异常结果（服务名、异常类型、判定依据）存入数据库，前端实时展示。

核心代码（异常检测服务）

@Service
public class AnomalyDetectService {
    @Autowired
    private ChatClient chatClient;
    @Autowired
    private MetricMapper metricMapper;
    @Autowired
    private LogMapper logMapper;

    public AnomalyDetectResult detect(String serviceName) {
        AnomalyDetectResult result = new AnomalyDetectResult();
        result.setServiceName(serviceName);

        // 1. 规则检测：查询近5分钟超时率
        BigDecimal timeoutRate = metricMapper.selectAvgTimeoutRate(serviceName, 5);
        if (timeoutRate.compareTo(new BigDecimal("5")) <= 0) {
            result.setIsAnomaly(false);
            return result;
        }

        // 2. AI复判：整合日志数据
        List<LogDO> errorLogs = logMapper.selectRecentErrorLogs(serviceName, 5);
        String logContent = errorLogs.stream().map(LogDO::getContent).collect(Collectors.joining("；"));
        
        String prompt = """
                判定服务%s是否为真异常：
                1. 接口超时率：%s%%
                2. 近5分钟ERROR日志：%s
                要求：仅输出“是/否”+判定依据（≤50字）
                """.formatted(serviceName, timeoutRate, logContent);
        
        String aiResponse = chatClient.call(prompt);
        result.setIsAnomaly(aiResponse.contains("是"));
        result.setReason(aiResponse);
        
        // 3. 存储异常结果
        AnomalyDO anomalyDO = new AnomalyDO();
        BeanUtils.copyProperties(result, anomalyDO);
        anomalyMapper.insert(anomalyDO);
        
        return result;
    }
}

3. 根因定位阶段（核心实现）

目标

LangChain4j编排流程，融合指标+日志数据，定位核心根因。

核心实现步骤

① 数据整合：后端整合异常服务的指标、日志数据，生成故障上下文；
② AI推理：LangChain4j调用大模型，基于模板化Prompt推理根因；
③ 结果返回：前端展示根因+验证方法。

核心代码（根因定位服务）

@Service
public class RootCauseLocateService {
    @Autowired
    private ChatLanguageModel chatModel;

    public RootCauseResult locate(String serviceName) {
        // 1. 整合故障上下文
        String metrics = "接口超时率：8%，数据库CPU：90%";
        String logs = "ERROR - 数据库查询超时（SQL：select * from order where user_id=?）";
        String context = "指标：%s；日志：%s".formatted(metrics, logs);

        // 2. LangChain4j Prompt模板化
        PromptTemplate promptTemplate = PromptTemplate.from("""
                定位服务{{serviceName}}的核心根因：
                {{context}}
                要求：1. 根因仅1个；2. 验证方法1句话
                """);
        
        String prompt = promptTemplate.apply(Map.of("serviceName", serviceName, "context", context));
        String rootCause = chatModel.generate(prompt).content();

        // 3. 组装结果
        RootCauseResult result = new RootCauseResult();
        result.setServiceName(serviceName);
        result.setRootCause(rootCause);
        return result;
    }
}

4. 自动处置阶段（核心实现）

目标

分级处置：低风险自动重启服务，高风险生成建议。

核心实现步骤

① 匹配处置规则：根据根因匹配预设规则（如“数据库慢查询→生成建议”“线程池耗尽→重启服务”）；
② 执行处置：低风险调用Ansible重启服务，高风险返回处置建议；
③ 结果校验：处置后校验指标是否恢复，前端展示处置结果。

核心代码（自动处置服务）

@Service
public class AutoDisposeService {
    @Autowired
    private RootCauseLocateService rootCauseService;
    @Autowired
    private AnsibleClient ansibleClient;

    public DisposeResult dispose(String serviceName) {
        DisposeResult result = new DisposeResult();
        RootCauseResult rootCause = rootCauseService.locate(serviceName);
        
        // 1. 匹配处置规则
        if (rootCause.getRootCause().contains("线程池耗尽")) {
            // 低风险：自动重启服务
            boolean success = ansibleClient.restartService(serviceName);
            result.setDisposeAction("自动重启服务");
            result.setSuccess(success);
        } else {
            // 高风险：生成建议
            result.setDisposeAction("人工处置建议：优化数据库索引");
            result.setSuccess(true);
        }
        
        return result;
    }
}

四、核心流程前端交互（简化版）

1. 数据采集页：输入服务名、Prometheus地址，点击“启动采集”，实时展示采集的指标数据（折线图）；
2. 异常检测页：选择服务名，点击“检测”，展示是否异常+判定依据；
3. 根因定位页：选择异常服务，点击“定位”，展示根因+验证方法；
4. 自动处置页：选择根因结果，点击“处置”，展示处置动作+执行结果。

五、核心配置（application.yml）

spring:
  application:
    name: aiops-core
  # 数据库配置
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/aiops?useUnicode=true&characterEncoding=utf8
    username: root
    password: root123
  # SpringAI配置
  ai:
    openai:
      api-key: ${OPENAI_API_KEY}
      chat:
        model: gpt-4o
        temperature: 0.1
# Prometheus配置
prometheus:
  url: http://localhost:9090
# 定时任务配置
spring:
  task:
    scheduling:
      pool:
        size: 5

六、核心实现注意事项

1. 优先保证核心链路通：采集→检测→定位→处置，暂不考虑高并发、容错、审计；
2. 前端仅实现核心交互，无需复杂样式，聚焦数据展示；
3. AI模型优先用OpenAI（快速验证），本地模型可后续替换；
4. 数据存储仅用MySQL，时序数据库、ES等后续扩展。

此方案聚焦核心流程，剔除所有非必要功能，可快速落地验证AIOps平台的核心能力，后续可基于此扩展复盘、审计、高可用等能力。