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

关注

原创最新推荐文章于 2026-10-02 10:52:49 发布 1k 阅读 AI 写同款· GEO 优化 ›

Spring AI：让ChatGPT成为你的开发助手在当今快速发展的技术世界中，人工智能（AI）正逐渐成为开发者的得力助手。而ChatGPT作为一种强大的自然语言处理模型，已经被广泛应用于聊天机器人、智能助手、自动回复系统等领域。本文将介绍如何使用Spring AI集成ChatGPT，让它成为你的开发助手。Spring AI是一个基于Spring Boot框架的AI应用开发工具包。它旨在简化AI模型的集成和部署，使开发者能够更快地构建智能应用。Spring AI提供了一系列功能，包括对话管理、自然语言处理、图像识别等，其中ChatGPT就是其中之一。阅读详情

AIOps场景下SpringAI与LangChain4j的极简案例+核心区别

AIOps（智能运维）是AI落地的高频场景，核心是用AI分析运维数据（日志、监控指标、告警）、自动定位问题、生成处理方案。下面用**“日志异常分析”** 这个最简单的AIOps场景，拆解SpringAI和LangChain4j的使用案例、实现方式，以及核心区别。

一、先明确场景需求（极简版）

需求：接收一段运维日志文本，AI自动分析日志中的异常类型（比如“数据库连接超时”“内存溢出”），并输出1-2句极简的处理建议。
示例日志：2025-12-25 10:05:00 ERROR [Tomcat-8080] - Connection to MySQL database (192.168.1.100:3306) timed out after 3000ms, retry count: 3

二、SpringAI实现案例（极简版）

核心逻辑

SpringAI的核心是“快速集成AI能力到Spring运维系统，复用Spring生态（配置、依赖注入、监控）”，直接通过标准化接口调用AI模型，聚焦“AI能力快速接入”。

1. 依赖+配置（Spring Boot项目）

<!-- pom.xml 核心依赖 -->
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-openai-spring-boot-starter</artifactId>
    <version>1.0.0-M1</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

# application.yml
spring:
  ai:
    openai:
      api-key: ${OPENAI_API_KEY}
      chat:
        model: gpt-4o
        temperature: 0.1 # 运维场景追求确定性，温度调低

2. 核心代码

import org.springframework.ai.chat.ChatClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/aiops/log")
public class SpringAiLogAnalysisController {

    // 注入SpringAI自动配置的ChatClient
    @Autowired
    private ChatClient chatClient;

    // 日志异常分析接口
    @PostMapping("/analyze")
    public String analyzeLog(@RequestParam String logText) {
        // 1. 构建标准化Prompt（运维场景固定模板）
        String prompt = """
                分析以下运维日志，输出2部分内容：
                1. 异常类型（仅一句话）；
                2. 处理建议（仅1-2句）；
                日志内容：%s
                """.formatted(logText);

        // 2. 统一接口调用AI，无需关注底层模型细节
        return chatClient.call(prompt);
    }
}

3. 调用效果

请求日志文本后，返回结果：

1. 异常类型：MySQL数据库连接超时（重试3次失败）；
2. 处理建议：检查192.168.1.100:3306数据库服务是否正常，或调大连接超时时间。

三、LangChain4j实现案例（极简版）

核心逻辑

LangChain4j的核心是“拆解AI任务为可编排的步骤”，即使极简场景，也能体现“步骤化、可扩展”，聚焦“AI流程的灵活拆解”。

1. 依赖+配置

<!-- pom.xml 核心依赖 -->
<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-spring-boot-starter</artifactId>
    <version>0.32.0</version>
</dependency>
<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-openai</artifactId>
    <version>0.32.0</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

# application.yml
langchain4j:
  openai:
    chat-model:
      api-key: ${OPENAI_API_KEY}
      model-name: gpt-4o
      temperature: 0.1

2. 核心代码

import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.input.PromptTemplate;
import dev.langchain4j.model.output.Response;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/aiops/log")
public class LangChain4jLogAnalysisController {

    // 注入LangChain4j的Chat模型
    @Autowired
    private ChatLanguageModel chatLanguageModel;

    // 日志异常分析接口（拆解为2个步骤）
    @PostMapping("/analyze")
    public String analyzeLog(@RequestParam String logText) {
        // Step1：定义Prompt模板（可复用）
        PromptTemplate promptTemplate = PromptTemplate.from("""
                分析以下运维日志，输出2部分内容：
                1. 异常类型（仅一句话）；
                2. 处理建议（仅1-2句）；
                日志内容：{{logText}}
                """);

        // Step2：填充模板参数
        String prompt = promptTemplate.apply(logText);

        // Step3：调用AI模型（步骤化，可扩展加校验/重试）
        Response<String> response = chatLanguageModel.generate(prompt);

        return response.content();
    }
}

3. 进阶扩展（体现LangChain4j核心优势）

如果要扩展为“日志分析→异常等级判定→生成告警文案”的流程，LangChain4j只需加Step，无需重构核心逻辑：

// 扩展：多步骤Chain编排
public String analyzeLogWithChain(String logText) {
    // Step1：分析异常类型
    PromptTemplate step1Template = PromptTemplate.from("分析日志{{logText}}的异常类型，仅输出类型名称");
    String exceptionType = chatLanguageModel.generate(step1Template.apply(logText)).content();

    // Step2：判定异常等级
    PromptTemplate step2Template = PromptTemplate.from("判定异常类型{{exceptionType}}的等级（高/中/低），仅输出等级");
    String level = chatLanguageModel.generate(step2Template.apply(exceptionType)).content();

    // Step3：生成告警文案
    PromptTemplate step3Template = PromptTemplate.from("异常类型{{exceptionType}}，等级{{level}}，生成1句告警文案");
    return chatLanguageModel.generate(step3Template.apply(exceptionType, level)).content();
}

四、AIOps场景下二者的核心区别（极简总结）

维度	SpringAI	LangChain4j
核心目标	快速将AI能力融入Spring运维系统（比如已有监控平台）	灵活编排AI运维流程，支持多步骤/多分支/扩展
实现方式	标准化接口一键调用，聚焦“AI接入”	拆解任务为Step，聚焦“AI流程”
扩展能力	扩展需手动加逻辑（比如加异常等级判定要改代码）	基于Chain机制，新增Step即可，无需重构
生态适配	无缝复用Spring运维体系（比如接入Spring监控、事务）	无强生态依赖，纯Java运维项目也能用
适合场景	简单AIOps需求（单步日志分析、指标解读）	复杂AIOps需求（多步骤故障定位、动态降级）

五、极简总结

SpringAI：适合已有Spring运维系统（比如基于Spring Boot的监控平台），想快速加AI日志分析/指标解读能力，追求“低侵入、快接入”，不用改现有架构；
LangChain4j：适合需要定制AIOps流程（比如“日志分析→等级判定→告警生成→自动派单”），追求“流程灵活、可扩展”，即使是极简场景，也能为后续扩展留足空间。

新手在AIOps场景落地时，简单需求用SpringAI（一行代码调用），复杂流程用LangChain4j（拆步骤编排），二者配合时，SpringAI负责AI模型的企业级管控（比如权限、监控），LangChain4j负责运维流程的编排，效率最高。

参考案例

企业级AIOps核心流程与规范（附SpringAI+LangChain4j落地案例）

AIOps（智能运维）的企业级落地绝非“AI分析日志”这么简单，而是围绕**“数据采集→异常检测→根因定位→自动处置→复盘优化”** 的闭环流程，且需遵循“可观测、可管控、可回滚、可审计”的企业级规范。本文以「生产环境服务异常智能处置」这一真实核心场景，拆解企业级AIOps的标准流程，并结合SpringAI+LangChain4j落地，体现框架的适配逻辑。

一、企业级AIOps核心场景：生产服务异常智能处置

场景背景

某电商平台基于Spring Cloud构建核心交易系统，要求：

7×24小时监控系统指标（CPU、内存、接口响应时间）、应用日志、数据库慢查询；
异常发生时（如接口超时率＞5%、日志出现OOM），5分钟内完成“异常检测→根因定位→自动处置（或生成处置建议）”；
所有操作留痕，支持审计和复盘；
处置失败可快速回滚，避免扩大故障。

企业级AIOps核心流程（闭环）

阶段	核心目标	企业级规范要求	技术落地关键点
1. 数据采集	全维度、实时采集运维数据	① 覆盖指标/日志/链路/告警4类数据；② 数据标准化（统一格式、时间戳、服务标识）；③ 采集不影响业务性能	用Prometheus采集指标、ELK采集日志、SkyWalking采集链路，数据统一存入时序数据库（InfluxDB）
2. 异常检测	精准识别异常（减少误报）	① 结合静态阈值（如CPU＞80%）+ AI异常检测（如指标趋势异常）；② 支持自定义规则；③ 误报率＜1%	传统规则（Prometheus Alert）+ AI检测（识别非阈值类异常，如指标突增/突降）
3. 根因定位	快速定位故障根源	① 关联多维度数据（日志+指标+链路）；② 输出可验证的根因（而非模糊结论）；③ 定位耗时＜3分钟	AI整合多源数据推理根因，结合运维知识库验证
4. 自动处置	降低人工介入成本	① 分级处置（低风险自动处置，高风险人工确认）；② 处置前校验；③ 支持一键回滚；④ 操作审计	低风险（如重启轻量服务）自动执行，高风险（如扩容）生成建议并触发审批
5. 复盘优化	沉淀经验、迭代模型	① 记录故障全流程；② 复盘根因定位准确率、处置成功率；③ 优化AI模型和检测规则	定期将故障案例纳入AI训练集，调整检测阈值和处置规则

二、企业级AIOps核心流程落地（SpringAI+LangChain4j）

以下基于上述流程，落地“接口超时异常智能处置”子场景，体现框架分工和企业级规范。

前置准备（企业级基础）

技术栈：Spring Boot 3.2（运维平台基础）+ SpringAI（AI能力集成+企业级管控）+ LangChain4j（AI流程编排）+ Prometheus（指标采集）+ ELK（日志）；
核心规范落地：
- 配置外部化：AI模型参数、检测规则存入Nacos配置中心；
- 权限管控：Spring Security管控AIOps接口（仅运维角色可操作）；
- 事务/审计：AI处置建议+操作记录纳入Spring事务，审计日志存入MySQL；
- 可观测：Spring Boot Actuator监控AI调用指标，Prometheus监控处置成功率。

步骤1：数据采集（标准化）

// 数据采集服务（企业级：异步采集、数据校验）
@Service
public class DataCollectService {
    // 采集Prometheus指标（接口超时率）
    @Async // 异步采集，不阻塞业务
    public MetricData collectApiTimeoutMetric(String serviceName) {
        // 调用Prometheus API获取指标，标准化为统一格式
        MetricData data = new MetricData();
        data.setServiceName(serviceName);
        data.setMetricType("api_timeout_rate");
        data.setValue(prometheusClient.query("api_timeout_rate{service=\"" + serviceName + "\"}"));
        data.setTimestamp(LocalDateTime.now());
        // 数据校验（非空、格式合法）
        validateData(data);
        return data;
    }

    // 采集ELK中的异常日志
    @Async
    public LogData collectExceptionLog(String serviceName) {
        // 调用ELK API获取日志，标准化格式
        LogData data = new LogData();
        // ... 省略标准化逻辑
        validateData(data);
        return data;
    }
}

步骤2：异常检测（规则+AI双检）

核心：先通过传统规则过滤（减少AI调用成本），规则无法判定时用AI检测。

@Service
public class AnomalyDetectService {
    @Autowired
    private ChatClient chatClient; // SpringAI注入的AI客户端
    @Autowired
    private DataCollectService dataCollectService;

    // 异常检测（规则+AI）
    @Transactional // 检测结果入库，事务管控
    public AnomalyDetectResult detect(String serviceName) {
        AnomalyDetectResult result = new AnomalyDetectResult();
        result.setServiceName(serviceName);
        result.setDetectTime(LocalDateTime.now());

        // Step1：传统规则检测（接口超时率＞5%）
        MetricData metric = dataCollectService.collectApiTimeoutMetric(serviceName);
        if (Float.parseFloat(metric.getValue()) <= 5) {
            result.setIsAnomaly(false);
            result.setReason("接口超时率≤5%，无异常");
            saveDetectResult(result); // 存入审计库
            return result;
        }

        // Step2：AI检测（判定是否为“真异常”，排除偶发波动）
        LogData log = dataCollectService.collectExceptionLog(serviceName);
        String prompt = """
                结合以下数据判定服务%s是否为真异常：
                1. 接口超时率：%s
                2. 异常日志：%s
                要求：
                - 输出是否为真异常（是/否）；
                - 输出判定依据（不超过50字）；
                - 排除偶发网络波动导致的假异常。
                """.formatted(serviceName, metric.getValue(), log.getContent());

        // SpringAI标准化调用AI，复用Spring配置（模型、温度等）
        String aiResult = chatClient.call(prompt);
        // 解析AI结果
        result.setIsAnomaly(aiResult.contains("是"));
        result.setReason(aiResult);
        saveDetectResult(result); // 审计入库
        return result;
    }
}

步骤3：根因定位（LangChain4j流程编排）

核心：拆解为“数据整合→根因推理→知识库验证”3个Step，体现Chain的编排能力。

@Service
public class RootCauseLocateService {
    @Autowired
    private ChatLanguageModel chatModel; // LangChain4j注入的模型
    @Autowired
    private KnowledgeBaseService knowledgeBaseService; // 运维知识库服务

    // 根因定位Chain
    public RootCauseResult locate(String serviceName) {
        // Step1：整合多源数据（指标+日志+链路）
        String integratedData = integrateData(serviceName);

        // Step2：AI推理根因（LangChain4j Prompt模板化）
        PromptTemplate step2Template = PromptTemplate.from("""
                基于以下数据推理服务{{serviceName}}接口超时的根因：
                {{integratedData}}
                要求：
                1. 根因仅输出1个（如数据库慢查询/线程池耗尽/网络延迟）；
                2. 输出验证方法（1句话）。
                """);
        String rootCause = chatModel.generate(step2Template.apply(
                Map.of("serviceName", serviceName, "integratedData", integratedData)
        )).content();

        // Step3：知识库验证根因（匹配历史故障案例）
        String verifyResult = knowledgeBaseService.verify(rootCause);

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

    // 整合多源数据（指标+日志+链路）
    private String integrateData(String serviceName) {
        MetricData metric = dataCollectService.collectApiTimeoutMetric(serviceName);
        LogData log = dataCollectService.collectExceptionLog(serviceName);
        TraceData trace = dataCollectService.collectTraceData(serviceName);
        return "指标：" + metric.getValue() + "；日志：" + log.getContent() + "；链路：" + trace.getContent();
    }
}

步骤4：自动处置（分级+可回滚）

核心：企业级规范——低风险自动处置，高风险人工确认，操作可回滚。

@Service
public class AutoDisposeService {
    @Autowired
    private RootCauseLocateService rootCauseService;
    @Autowired
    private ServiceOperationService operationService; // 服务操作（重启/扩容）
    @Autowired
    private AuditLogService auditLogService; // 审计日志

    // 自动处置（分级）
    @Transactional(rollbackFor = Exception.class) // 处置+审计原子性
    public DisposeResult dispose(String serviceName) {
        DisposeResult result = new DisposeResult();
        RootCauseResult rootCause = rootCauseService.locate(serviceName);

        // 分级处置：低风险（线程池耗尽）→ 自动重启；高风险（数据库慢查询）→ 生成建议
        if (rootCause.getRootCause().contains("线程池耗尽")) {
            // 低风险：自动重启服务
            boolean operateSuccess = operationService.restartService(serviceName);
            result.setDisposeAction("自动重启服务");
            result.setSuccess(operateSuccess);
            // 可回滚：记录操作ID，失败则回滚
            if (!operateSuccess) {
                operationService.rollbackRestart(serviceName);
                result.setReason("重启失败，已回滚");
            }
        } else {
            // 高风险：生成处置建议，触发人工审批
            result.setDisposeAction("人工处置建议：" + rootCause.getRootCause() + "，建议优化数据库索引");
            result.setSuccess(true);
            result.setReason("高风险操作，需人工确认");
        }

        // 审计日志（企业级必做）
        auditLogService.saveLog(AuditLog.builder()
                .serviceName(serviceName)
                .disposeAction(result.getDisposeAction())
                .operator("AIOps系统")
                .operateTime(LocalDateTime.now())
                .build());
        return result;
    }
}

步骤5：复盘优化（AI模型迭代）

@Service
public class ReviewOptimizeService {
    @Autowired
    private ChatClient chatClient;
    @Autowired
    private FaultCaseRepository faultCaseRepo; // 故障案例库

    // 每周复盘：优化AI检测规则和模型Prompt
    @Scheduled(cron = "0 0 0 ? * MON") // 每周一凌晨执行
    public void weeklyReview() {
        // 1. 统计本周故障数据（检测准确率、处置成功率）
        String statData = statWeeklyFaultData();

        // 2. AI生成优化建议（SpringAI调用）
        String prompt = """
                基于本周AIOps运行数据：%s
                优化建议：
                1. 调整异常检测阈值（1条）；
                2. 优化根因定位Prompt（1条）；
                3. 新增处置规则（1条）。
                """.formatted(statData);
        String optimizeSuggest = chatClient.call(prompt);

        // 3. 落地优化（更新配置中心、训练模型）
        updateDetectRule(optimizeSuggest);
        updatePromptTemplate(optimizeSuggest);
        // 4. 沉淀故障案例到知识库
        saveFaultCaseToKnowledgeBase(optimizeSuggest);
    }
}

三、企业级AIOps核心规范落地要点

可管控：
- 所有AI调用通过SpringAI集成，复用Spring Security（仅运维角色可触发处置）、Spring事务（处置+审计原子性）；
- 配置统一存入Nacos，支持动态调整（如AI模型温度、检测阈值），无需重启。
可观测：
- 用Spring Boot Actuator监控AI调用次数、耗时、失败率；
- 用Prometheus监控“异常检测准确率”“根因定位准确率”“处置成功率”3个核心指标。
可回滚：
- 所有自动处置操作记录ID，失败时触发回滚（如重启服务失败则恢复到重启前状态）；
- AI模型输出异常时，自动降级为“纯规则处置”。
可审计：
- 每一步操作（检测、定位、处置）记录审计日志（操作人、时间、内容、结果），保留6个月以上；
- 支持审计日志查询和导出，满足合规要求。

四、SpringAI与LangChain4j的分工逻辑（企业级视角）

框架	核心分工	适配的流程阶段	企业级价值
SpringAI	AI能力集成+企业级管控	异常检测、复盘优化	保证AI调用的稳定性、安全性、可管控
LangChain4j	AI流程编排+多步骤推理	根因定位	提升复杂场景下根因定位的灵活性、可扩展