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

​参考文档

LangChain4j 中文文档 https://docs.langchain4j.info/

https://neo4j.com/labs/genai-ecosystem/spring-ai/

​https://java2ai.com/docs/dev/overview/

企业级存量系统智能化改造的具体步骤

企业级存量系统智能化改造（如接入AI能力、落地AIOps、实现智能业务决策）的核心是**“最小侵入、价值优先、分步落地、持续迭代”**，避免为了“智能化”重构系统，而是围绕业务痛点和运维效率，分阶段将AI能力融入现有体系。以下是可落地的具体步骤，覆盖从前期准备到上线运维的全流程：

一、前期准备阶段：明确目标+现状梳理（1-2周）

1. 核心目标定义（避免无目的改造）

• 聚焦业务价值/运维效率：明确智能化要解决的核心问题（如“客服工单自动分类提效30%”“AIOps异常定位耗时从1小时缩至5分钟”）；
• 量化指标：制定可衡量的KPI（如AI根因定位准确率≥80%、智能推荐转化率提升5%）；
• 范围界定：划定改造边界（如仅改造“交易系统运维模块”，而非全系统；仅对接OpenAI，暂不接入本地大模型）。

2. 存量系统现状梳理

• 技术栈盘点：梳理系统架构（微服务/单体）、核心框架（Spring Boot版本、中间件如ES/Redis）、语言版本、接口规范；
• 痛点分析：
  • 运维痛点：如故障定位慢、告警风暴、人工操作多；
  • 业务痛点：如人工审核耗时、用户体验差、数据决策滞后；
• 依赖关系梳理：明确核心链路（如交易系统→支付系统→数据库）、关键接口、数据流向，标记“不可动”的核心模块（如资金相关）；
• 数据资产盘点：梳理可用于AI的数据源（日志、监控指标、业务数据、知识库），评估数据质量（是否标准化、是否脱敏、是否有标签）。

3. 方案设计（聚焦最小可行方案MVP）

• 技术选型：
  • AI框架：运维场景选SpringAI+LangChain4j（适配Spring生态），业务场景选FastAPI+大模型（灵活）；
  • 数据层：复用现有数据库/中间件，新增AI专用存储（如向量库存知识库、时序库存监控数据）；
• 集成方式：优先选“非侵入式集成”（如接口调用、插件化、中间件代理），避免修改核心业务代码；
• 风险评估：识别改造风险（如AI模型调用延迟影响核心交易、数据脱敏不达标），制定兜底方案（如AI服务故障时降级为人工流程）。

二、方案落地阶段：分步改造+价值验证（2-8周）

阶段1：数据层改造（智能化的基础，优先落地）

核心目标：让存量系统的“数据可被AI使用”

1. 数据标准化：
   • 统一数据格式：如日志改为JSON格式（包含timestamp、service、level、content），监控指标遵循Prometheus规范；
   • 数据清洗：剔除无效数据、脱敏敏感信息（如手机号、银行卡号），补充缺失字段（如服务标签、环境标签）；
2. 数据接入：
   • 新增数据采集插件（如Filebeat采集日志、Micrometer埋点业务指标），复用现有采集通道（如ELK、Prometheus）；
   • 搭建AI专用数据中间层（如向量数据库Chroma/PGVector存储运维知识库、时序数据库InfluxDB存储监控数据），避免直接读写业务库；
3. 数据权限管控：
   • 新增AI数据访问权限规则（如运维AI仅能读取日志/指标，不能操作业务数据），对接企业统一权限系统（如LDAP）。

实操示例（存量Spring Boot系统）：

// 非侵入式新增指标埋点（通过AOP，无需修改业务代码）
@Aspect
@Component
public class MetricAop {
    private final MeterRegistry meterRegistry;
    // 对核心接口新增超时率指标
    @Around("execution(* com.trade.controller.*.*(..))")
    public Object recordApiMetric(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        Object result = joinPoint.proceed();
        long cost = System.currentTimeMillis() - start;
        // 记录超时率（复用Spring Boot Micrometer，无需改业务逻辑）
        if (cost > 1000) {
            meterRegistry.counter("api_timeout_count", "api", joinPoint.getSignature().getName()).increment();
        }
        return result;
    }
}

阶段2：AI能力集成（最小侵入，插件化接入）

核心目标：将AI能力以“非侵入”方式融入存量系统

1. AI服务封装：
   • 搭建独立的AI服务模块（如ai-service），封装大模型调用（SpringAI）、流程编排（LangChain4j）逻辑，对外提供标准化API；
   • 存量系统通过“接口调用”对接AI服务（如Feign、HTTP），核心业务代码无需引入AI依赖；
2. 核心场景落地（MVP）：
   • 优先选“高价值、低改造量”场景（如运维侧：日志异常AI分析；业务侧：工单自动分类）；
   • 集成方式示例：
     • 运维场景：存量监控系统通过HTTP调用AI服务的“根因定位接口”，返回结果展示在原有监控面板；
     • 业务场景：存量客服系统新增“AI辅助回复”按钮，点击后调用AI服务生成回复草稿，人工确认后发送；
3. 兜底逻辑开发：
   • AI服务故障时，自动降级为原有流程（如AI根因定位失败→触发人工排查流程）；
   • 控制AI调用范围（如核心交易链路仅用AI做“辅助分析”，不做自动决策）。

实操示例（存量运维系统集成AI根因定位）：

// 存量运维系统新增AI调用接口（非侵入，新增Controller）
@RestController
@RequestMapping("/ops/ai")
public class AiOpsController {
    @Autowired
    private AiServiceClient aiServiceClient; // 调用独立的AI服务
    @Autowired
    private OpsLogService opsLogService; // 存量日志服务

    // 存量系统调用AI根因定位，结果返回至原有运维面板
    @PostMapping("/locate")
    public Result<RootCauseVO> locateRootCause(@RequestParam String serviceName) {
        // 1. 从存量系统获取日志/指标数据
        String logContent = opsLogService.getRecentErrorLog(serviceName);
        // 2. 调用AI服务（非侵入，通过接口）
        RootCauseDTO aiResult = aiServiceClient.locate(serviceName, logContent);
        // 3. 转换为存量系统的VO，返回至原有前端
        RootCauseVO vo = ConvertUtils.aiResultToVo(aiResult);
        return Result.success(vo);
    }
}

阶段3：功能验证与调优（聚焦MVP，快速迭代）

1. 灰度验证：
   • 选择非核心环境（如测试/预发）或小范围场景（如仅“交易系统”试点）验证AI能力；
   • 对比AI结果与人工结果（如AI根因定位vs运维人工定位、AI工单分类vs人工分类），统计准确率/效率；
2. 参数调优：
   • 优化AI模型参数（如Prompt模板、温度值）、数据采集规则（如调整日志采集频率）；
   • 优化集成方式（如AI调用延迟高→新增缓存、异步调用）；
3. 用户反馈收集：
   • 收集运维/业务人员的使用反馈（如“AI回复的处置建议不落地”“指标采集遗漏关键维度”），快速调整功能。

三、上线推广阶段：全量落地+流程适配（1-2周）

1. 全量上线准备

• 运维保障：新增AI服务的监控（如调用成功率、延迟、模型输出异常率），接入存量监控告警体系；
• 文档与培训：编写操作手册（如“如何使用AI辅助根因定位”），对使用人员做1-2次极简培训；
• 应急预案：制定AI服务故障、数据泄露、结果错误的应急方案（如一键降级、数据回溯）。

2. 全量推广（分批次）

• 先推广至“高意愿、低风险”团队（如运维团队先试用AIOps，再推广至业务团队）；
• 保留“人工+AI”双轨制（如AI生成的处置建议需人工确认，不直接执行），逐步提升自动化比例。

3. 流程适配

• 优化现有工作流程（如运维故障处理流程新增“AI根因定位”步骤，客服工单流程新增“AI分类”节点）；
• 对接存量系统的审批/审计体系（如AI自动处置操作需纳入原有审计日志，符合企业合规要求）。

四、持续迭代阶段：数据驱动+价值放大（长期）

1. 数据闭环优化

• 收集AI使用数据（如调用次数、准确率、业务提效数据），定期复盘KPI达成情况；
• 将线下反馈、故障案例补充至AI知识库（如新增“数据库锁等待”故障案例，提升根因定位准确率）。

2. 功能扩展（基于价值优先级）

• 从“辅助决策”向“有限自动决策”扩展（如低风险异常由AI自动处置，高风险仍需人工确认）；
• 扩展AI场景（如从“日志异常分析”扩展至“链路异常分析”，从“工单分类”扩展至“工单自动回复”）。

3. 技术架构升级

• 逐步替换开源模型为企业私有化模型（如从OpenAI替换为通义千问/文心一言私有化部署）；
• 优化AI服务性能（如引入模型缓存、分布式部署，支撑更高并发）；
• 融合更多数据维度（如将业务数据、用户行为数据融入AI分析，提升决策精准度）。

五、关键注意事项（避免踩坑）

1. 最小侵入原则：能通过接口调用、插件化实现的，绝不修改存量核心代码；能新增模块的，绝不重构原有模块；
2. 价值优先：先落地“1个小场景+可量化价值”（如AI日志分析提效20%），再扩展，避免“大而全”的改造；
3. 数据安全合规：存量系统的敏感数据（如用户信息、交易数据）必须脱敏后再输入AI模型，避免数据泄露；
4. 避免过度依赖AI：核心场景（如资金操作、故障处置）保留人工兜底，AI仅做辅助；
5. 复用现有生态：存量系统基于Spring生态的，优先用SpringAI集成AI能力，减少技术栈切换成本。

六、示例：存量运维系统智能化改造（AIOps）落地路径

阶段	具体动作	耗时	核心输出
前期准备	梳理运维痛点（故障定位慢）、盘点日志/指标数据、定义KPI（定位耗时缩至5分钟）	1周	改造方案、数据标准化规范
数据层改造	日志标准化、新增Prometheus指标采集、搭建向量库存运维知识库	2周	标准化数据采集体系、知识库
AI集成	新增AI服务模块（SpringAI+LangChain4j）、存量系统调用AI根因定位接口	2周	AI根因定位功能（灰度版）
上线推广	运维团队灰度试用、优化Prompt、全量上线、培训使用人员	1周	全量可用的AIOps辅助定位功能
持续迭代	收集故障案例、优化模型、扩展至自动处置（低风险）	长期	定位准确率≥85%、自动处置率30%

总结

企业级存量系统智能化改造的核心不是“技术升级”，而是“价值升级”——以最小的改造成本解决核心痛点，通过“数据层→AI集成→验证→上线→迭代”的步骤，逐步将AI能力融入现有体系，避免为了智能化而智能化。关键是“小步快跑、价值可衡量、风险可控制”，让智能化改造真正服务于业务和运维效率提升。

拓展

非强Spring依赖项目中使用LangChain4j的完整指南

LangChain4j本身是无框架强依赖的纯Java库（核心仅依赖SLF4J等基础组件），并非只能在Spring项目中使用。对于非Spring项目（如纯Java SE、Java EE、Quarkus、Micronaut，甚至传统Servlet项目），核心思路是直接引入LangChain4j核心依赖，手动管理模型客户端、流程编排逻辑，替代Spring的自动配置/依赖注入，以下是具体落地步骤、示例和最佳实践。

一、核心前提：LangChain4j的无框架特性

LangChain4j的核心模块（langchain4j-core）仅依赖：

• Java 8+
• SLF4J（日志）
• Jackson（JSON序列化）
  无任何Spring、Guice等框架依赖，所有核心能力（Chain编排、Prompt模板、工具调用、模型调用）均可通过“手动new对象”实现，这是在非Spring项目中使用的基础。

二、通用步骤（适配所有非Spring项目）

步骤1：引入依赖（Maven/Gradle）

无需引入任何Spring相关依赖，仅需引入LangChain4j核心包+对应大模型的适配包（如OpenAI、通义千问、本地模型如Llama3）。

Maven示例（纯Java项目）

<dependencies>
    <!-- LangChain4j核心包（必选） -->
    <dependency>
        <groupId>dev.langchain4j</groupId>
        <artifactId>langchain4j-core</artifactId>
        <version>0.32.0</version>
    </dependency>

    <!-- 可选：OpenAI适配包（对接商用大模型） -->
    <dependency>
        <groupId>dev.langchain4j</groupId>
        <artifactId>langchain4j-openai</artifactId>
        <version>0.32.0</version>
    </dependency>

    <!-- 可选：本地模型适配包（如Llama3，对接Ollama） -->
    <dependency>
        <groupId>dev.langchain4j</groupId>
        <artifactId>langchain4j-ollama</artifactId>
        <version>0.32.0</version>
    </dependency>

    <!-- 基础依赖（日志+JSON，非Spring项目需手动引入） -->
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-simple</artifactId>
        <version>2.0.9</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.15.2</version>
    </dependency>
</dependencies>

Gradle示例

dependencies {
    implementation 'dev.langchain4j:langchain4j-core:0.32.0'
    implementation 'dev.langchain4j:langchain4j-openai:0.32.0'
    implementation 'org.slf4j:slf4j-simple:2.0.9'
}

步骤2：手动初始化大模型客户端（替代Spring自动配置）

非Spring项目中无@Autowired，需手动创建模型客户端实例，核心是配置API Key、模型名称、请求参数（温度、超时等）。

示例1：对接OpenAI（商用模型）

import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.model.openai.OpenAiChatModelBuilder;

public class ModelClientFactory {
    // 手动创建OpenAI客户端（单例模式，避免重复创建）
    public static OpenAiChatModel createOpenAiClient() {
        return new OpenAiChatModelBuilder()
                .apiKey("你的OpenAI API Key") // 从配置文件/环境变量读取，避免硬编码
                .modelName("gpt-4o")
                .temperature(0.1) // 运维/业务场景建议低温度，保证结果稳定
                .timeout(30_000) // 超时时间30秒
                .build();
    }
}

示例2：对接本地Ollama（Llama3，无网络依赖）

import dev.langchain4j.model.ollama.OllamaChatModel;
import dev.langchain4j.model.ollama.OllamaChatModelBuilder;

public class ModelClientFactory {
    public static OllamaChatModel createOllamaClient() {
        return new OllamaChatModelBuilder()
                .baseUrl("http://localhost:11434") // Ollama本地服务地址
                .modelName("llama3")
                .temperature(0.2)
                .build();
    }
}

步骤3：实现核心能力（Chain编排/Prompt模板/工具调用）

LangChain4j的核心能力（如Chain流程、Prompt模板）均通过纯Java代码实现，无需Spring注解，以下是3个核心场景示例。

场景1：基础Prompt模板+模型调用（极简场景）

适用于“文本生成、日志分析、工单分类”等简单场景，替代Spring项目中@Autowired注入模型的方式。

import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.input.PromptTemplate;

public class SimpleAIAnalysisService {
    // 手动注入模型客户端（非Spring：直接new或工厂方法）
    private final ChatLanguageModel model = ModelClientFactory.createOpenAiClient();

    // 日志异常分析（AIOps核心场景）
    public String analyzeLog(String logContent) {
        // 1. 定义Prompt模板（标准化，可复用）
        PromptTemplate promptTemplate = PromptTemplate.from("""
                分析以下运维日志，输出2部分内容：
                1. 异常类型（仅一句话）；
                2. 处理建议（仅1-2句）；
                日志内容：{{logContent}}
                """);

        // 2. 填充模板参数
        String prompt = promptTemplate.apply(logContent);

        // 3. 调用模型（纯Java方法调用）
        return model.generate(prompt);
    }

    // 测试入口（纯Java SE程序）
    public static void main(String[] args) {
        SimpleAIAnalysisService service = new SimpleAIAnalysisService();
        String log = "2025-12-25 10:05:00 ERROR - MySQL connection timed out after 3000ms";
        String result = service.analyzeLog(log);
        System.out.println("AI分析结果：\n" + result);
    }
}

场景2：Chain流程编排（复杂场景）

适用于“多步骤推理、根因定位”等场景，替代Spring项目中基于注解的Chain编排，手动构建SequentialChain。

import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.chain.ConversationalChain;
import dev.langchain4j.chain.sequential.SequentialChain;
import dev.langchain4j.model.input.PromptTemplate;

public class RootCauseLocateService {
    private final ChatLanguageModel model = ModelClientFactory.createOllamaClient();

    // 根因定位：拆分为「数据整合→异常类型判定→根因推理」3个Step
    public String locateRootCause(String serviceName, String logContent, String metricData) {
        // Step1：异常类型判定
        PromptTemplate step1Template = PromptTemplate.from("""
                判定服务{{serviceName}}的异常类型：
                日志：{{logContent}}
                指标：{{metricData}}
                仅输出异常类型（如数据库超时/线程池耗尽）
                """);
        String step1Prompt = step1Template.apply(serviceName, logContent, metricData);
        String exceptionType = model.generate(step1Prompt);

        // Step2：根因推理（基于Step1结果）
        PromptTemplate step2Template = PromptTemplate.from("""
                异常类型：{{exceptionType}}
                服务名：{{serviceName}}
                输出核心根因+1句话验证方法
                """);
        String step2Prompt = step2Template.apply(exceptionType, serviceName);
        String rootCause = model.generate(step2Prompt);

        // 组装最终结果（手动编排，替代SequentialChain注解）
        return "异常类型：" + exceptionType + "\n根因+验证方法：" + rootCause;
    }

    // 测试：纯Java调用
    public static void main(String[] args) {
        RootCauseLocateService service = new RootCauseLocateService();
        String result = service.locateRootCause(
                "trade-service",
                "ERROR - MySQL query timeout",
                "CPU：90%，接口超时率：8%"
        );
        System.out.println("根因定位结果：\n" + result);
    }
}

场景3：工具调用（AI调用业务接口）

适用于“AI主动查数据库、调接口”等场景，非Spring项目中手动注册工具类，无需@Tool注解（或兼容注解）。

import dev.langchain4j.agent.tool.Tool;
import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.openai.OpenAiChatModel;

// 1. 定义工具类（业务接口：查询订单数据）
public class OrderTool {
    // 标记为工具方法（非Spring项目仍需@Tool注解，LangChain4j核心识别）
    @Tool("查询指定用户的订单数量")
    public int queryOrderCount(String userId) {
        // 模拟调用存量系统的订单接口（非Spring：JDBC/HttpURLConnection调用）
        return userId.equals("1001") ? 5 : 0;
    }
}

// 2. AI调用工具（纯Java实现）
public class AIToolCallService {
    private final ChatLanguageModel model = ModelClientFactory.createOpenAiClient();

    public String aiQueryOrder(String userQuestion) {
        // 手动创建Agent，绑定工具类
        return dev.langchain4j.agent.AgentExecutor.builder()
                .chatLanguageModel(model)
                .tools(new OrderTool()) // 注册工具
                .build()
                .execute(userQuestion);
    }

    // 测试：AI自动调用订单查询工具
    public static void main(String[] args) {
        AIToolCallService service = new AIToolCallService();
        // 用户问题：“查询用户1001的订单数量”
        String result = service.aiQueryOrder("查询用户1001的订单数量");
        System.out.println("AI调用工具结果：" + result);
        // 预期输出："用户1001的订单数量为5"
    }
}

步骤4：配置管理（替代Spring的application.yml）

非Spring项目中需手动管理配置（如API Key、模型参数），推荐2种方式：

方式1：属性文件（.properties）

# ai-config.properties
openai.api.key=sk-xxx
openai.model.name=gpt-4o
ollama.base.url=http://localhost:11434

读取配置：

import java.io.FileInputStream;
import java.util.Properties;

public class ConfigLoader {
    private static final Properties props = new Properties();

    static {
        try {
            props.load(new FileInputStream("ai-config.properties"));
        } catch (Exception e) {
            throw new RuntimeException("加载配置失败", e);
        }
    }

    public static String get(String key) {
        return props.getProperty(key);
    }
}

// 改造模型工厂：从配置读取
public class ModelClientFactory {
    public static OpenAiChatModel createOpenAiClient() {
        return new OpenAiChatModelBuilder()
                .apiKey(ConfigLoader.get("openai.api.key"))
                .modelName(ConfigLoader.get("openai.model.name"))
                .build();
    }
}

方式2：环境变量（推荐，企业级）

public class ModelClientFactory {
    public static OpenAiChatModel createOpenAiClient() {
        return new OpenAiChatModelBuilder()
                .apiKey(System.getenv("OPENAI_API_KEY")) // 从环境变量读取
                .modelName("gpt-4o")
                .build();
    }
}

三、不同非Spring项目的适配细节

1. 纯Java SE项目（无任何框架）

• 核心：直接按上述示例，通过main方法启动，模型客户端单例化（避免重复创建）；
• 日志：引入slf4j-simple，无需配置日志框架；
• 依赖：仅需LangChain4j核心+模型适配包，无额外依赖。

2. Java EE/Servlet项目（Tomcat/Jetty）

• 初始化时机：在ServletContextListener中初始化模型客户端（全局单例）；
• 示例：

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import dev.langchain4j.model.chat.ChatLanguageModel;

public class AIModelListener implements ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        // 初始化模型客户端，存入ServletContext（全局可用）
        ChatLanguageModel model = ModelClientFactory.createOpenAiClient();
        sce.getServletContext().setAttribute("aiModel", model);
    }
}

// Servlet中使用
public class AIAnalysisServlet extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) {
        // 从ServletContext获取模型客户端
        ChatLanguageModel model = (ChatLanguageModel) getServletContext().getAttribute("aiModel");
        // 调用模型处理请求
        String logContent = req.getParameter("logContent");
        String result = model.generate("分析日志：" + logContent);
        resp.getWriter().write(result);
    }
}

3. Quarkus/Micronaut项目（轻量级框架）

• 依赖注入：使用框架原生DI（如Quarkus的@Inject、Micronaut的@Singleton）替代Spring；
• 示例（Quarkus）：

import jakarta.enterprise.context.ApplicationScoped;
import dev.langchain4j.model.chat.ChatLanguageModel;

// 1. 单例模型客户端
@ApplicationScoped
public class AIModelProducer {
    @Produces
    public ChatLanguageModel createModel() {
        return ModelClientFactory.createOllamaClient();
    }
}

// 2. 业务服务中使用（Quarkus原生DI）
@ApplicationScoped
public class QuarkusAIService {
    private final ChatLanguageModel model;

    // 构造器注入（替代Spring的@Autowired）
    public QuarkusAIService(ChatLanguageModel model) {
        this.model = model;
    }

    public String analyzeLog(String log) {
        return model.generate("分析日志：" + log);
    }
}

四、最佳实践（非Spring项目）

1. 模型客户端单例化

• 避免频繁创建模型客户端（如OpenAiChatModel），通过工厂类+单例模式管理，减少资源消耗；
• 示例：

public class ModelClientFactory {
    // 懒汉单例
    private static volatile ChatLanguageModel openAiModel;

    private ModelClientFactory() {} // 私有构造，禁止new

    public static ChatLanguageModel getOpenAiModel() {
        if (openAiModel == null) {
            synchronized (ModelClientFactory.class) {
                if (openAiModel == null) {
                    openAiModel = new OpenAiChatModelBuilder()
                            .apiKey(System.getenv("OPENAI_API_KEY"))
                            .build();
                }
            }
        }
        return openAiModel;
    }
}

2. 异常处理（替代Spring的全局异常）

public class AIService {
    private final ChatLanguageModel model = ModelClientFactory.getOpenAiModel();

    public String safeGenerate(String prompt) {
        try {
            return model.generate(prompt);
        } catch (Exception e) {
            // 降级逻辑：AI调用失败时返回默认结果/触发人工处理
            System.err.println("AI调用失败：" + e.getMessage());
            return "AI分析失败，请人工处理";
        }
    }
}

3. 避免过度封装

• 非Spring项目无需模仿Spring的“Service/Controller”分层，按业务逻辑极简封装；
• 核心逻辑（如Chain编排）直接写在业务类中，减少冗余。

4. 兼容存量系统

• 调用存量系统接口时，优先用原生Java方式（JDBC、HttpURLConnection、OkHttp），避免引入额外框架；
• 工具调用时，直接复用存量系统的DAO/Service类，无需适配Spring Bean。

五、核心总结

非强Spring依赖项目中使用LangChain4j的核心是：

1. 依赖极简：仅引入LangChain4j核心+模型适配包，无需Spring；
2. 手动初始化：通过工厂类创建模型客户端，替代Spring自动配置；
3. 纯Java编排：Chain流程、Prompt模板、工具调用均通过原生Java代码实现，无需Spring注解；
4. 配置自研：通过属性文件/环境变量管理配置，替代Spring的yml配置；
5. 单例+降级：保证模型客户端单例，增加异常降级逻辑，适配非Spring项目的运维特性。

这种方式既保留了LangChain4j的核心能力（流程编排、工具调用），又完全适配非Spring项目的技术栈，是企业级存量系统（如传统Java EE、纯Java SE）智能化改造的最优路径。