目录

• 1. 引言
• 2. Java 做 LLM 开发的现实需求
• 3. Spring AI（Spring 官方的 AI 中间件）
  • 3.1 核心特性
  • 3.2 示例：从对话到工具调用
  • 3.3 示例：基于向量库的问答（RAG）
  • 3.4 适用场景与局限
• 4. LangChain4j（Java 版的 LangChain 生态）
  • 4.1 核心特性
  • 4.2 示例：AiServices 结构化输出
  • 4.3 示例：带记忆的对话链
  • 4.4 社区与成熟度
• 5. Agents-Flex（轻量级、面向 Agent 的框架）
  • 5.1 核心特性
  • 5.2 示例：构建一个带工具的多步 Agent
  • 5.3 示例：使用 AgentGraph 编排多 Agent
  • 5.4 适用场景
• 6. 其他值得关注的框架
  • 6.1 Quarkus LangChain4j 扩展
  • 6.2 Java-LangChain
  • 6.3 阿里灵积 DashScope Java SDK
  • 6.4 JAI 与新兴框架
• 7. 框架对比与选型建议
• 8. 总结

1. 引言

过去两年，大语言模型（LLM）已从实验室走向企业核心业务，ChatGPT 的爆火引发了全球性的 AI 应用浪潮。在 Python 生态中，LangChain、LlamaIndex 等框架迅速崛起，成为构建 LLM 应用的标配。然而，在企业级市场中，Java 仍然是后端服务的主力语言——全球超过 90% 的财富 500 强企业运行着 Java 系统。当这些企业希望将 LLM 能力集成到现有微服务、数据管道和业务逻辑中时，直接在 Java 侧开发 AI 应用就成为刚性需求。

本文将系统梳理当前主流的 Java LLM 开发框架——从 Spring 官方的 Spring AI，到社区最活跃的 LangChain4j，再到国内轻量级新秀 Agents-Flex，同时涵盖 Quarkus LangChain4j、JAI 等新兴力量。我们将深入解析它们的核心特性、编程模型、集成能力，并结合实际代码示例给出选型建议，帮助开发者在企业 AI 应用落地时做出最优选择。

2. Java 做 LLM 开发的现实需求

当企业尝试将 LLM 集成到现有系统中时，面临的挑战远不止“调用一个 API”那么简单：

• 安全与合规：金融、医疗等行业要求数据不出内网，私有化部署是刚需；API 密钥管理、内容审核、审计日志缺一不可。
• 遗留系统集成：大量核心业务逻辑已经用 Java 写成，重写成本极高。最务实的做法是在 Java 服务中“嵌入” AI 能力。
• 性能与稳定性：Java 虚拟机的成熟 GC、完善的监控体系（Micrometer、Prometheus）、强类型系统，让生产环境更可控。
• 团队技能栈：企业内部 Java 开发者占据绝大多数，重新培训 Python 的成本和风险往往难以承受。

这些需求催生了一批 Java LLM 框架，它们在以下维度上展开竞争：

• 统一模型接入：屏蔽 OpenAI、Azure、Ollama、本地模型（如 vLLM）等的差异，支持灵活切换。
• 链式调用与 Agent：Prompt 模板、多步推理链（Chain）、工具调用（Function Calling）、记忆管理（Memory）。
• RAG（检索增强生成）：向量数据库（Pinecone、Milvus、Elasticsearch）、文档解析、嵌入模型管理。
• 企业级特性：可观测性、安全、多租户、流式响应（SSE/WebSocket）、AOT 编译（GraalVM 原生镜像）等。

下面我们逐一剖析当前最值得关注的框架。

3. Spring AI（Spring 官方的 AI 中间件）

Spring AI 是 Spring 官方推出的统一 AI 编程模型，目标是为 Java 开发者提供类似 Spring Data、Spring Security 的 AI 抽象。它的设计哲学非常“Spring”：通过自动配置和接口抽象，让开发者以最小的学习成本接入各类大模型。整个项目由多个子模块构成：spring-ai-core 定义核心接口，spring-ai-openai、spring-ai-ollama 等提供具体模型实现，spring-ai-pgvector-store、spring-ai-redis-store 等提供存储适配。

3.1 核心特性

• 多模型适配：通过 ChatModel 接口统一接入 OpenAI、Azure OpenAI、Ollama、Anthropic、Mistral AI、Google Vertex AI 等，只需切换依赖和配置。同时还支持图像生成（ImageModel）和语音转录（AudioTranscriptionModel）。
• Prompt 模板：支持类似 StringTemplate 的占位符机制，可与 ChatClient 配合使用，还内置了 PromptTemplate 和 OutputParser 的组合。
• 输出解析：可将 LLM 响应自动转换为 Bean 或 List<Bean>，极大简化 JSON 解析，支持泛型类型。
• RAG 支持：内置 VectorStore 抽象，支持 Pinecone、Weaviate、Chroma、Redis、PostgreSQL（pgvector）等向量库；提供 QuestionAnswerAdvisor、RetrievalAugmentationAdvisor 等 Advisor 组件实现基于检索的问答。
• 函数调用：通过 @Tool 注解将普通 Java 方法暴露为 LLM 工具，并由框架自动处理参数 JSON Schema 的生成与解析。
• 可观测性：深度集成 Micrometer 和 OpenTelemetry，可以监控 Token 用量、延迟、错误率等指标，并提供 Spring Boot Actuator 端点。
• Spring Boot 原生支持：提供一系列 starter，自动装配、属性绑定（application.yml 即可配置模型参数），与 Spring 生态无缝融合。

3.2 示例：从对话到工具调用

依赖（pom.xml）：

<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-openai-spring-boot-starter</artifactId>
    <version>1.0.0-M8</version>
</dependency>

配置（application.yml）：

spring:
  ai:
    openai:
      api-key: ${OPENAI_API_KEY}
      chat:
        options:
          model: gpt-4o-mini

代码：

@RestController
public class ChatController {

    private final ChatClient chatClient;

    public ChatController(ChatClient.Builder builder) {
        this.chatClient = builder.build();
    }

    @GetMapping("/chat")
    public String chat(@RequestParam String message) {
        return chatClient.prompt()
                .user(message)
                .call()
                .content();
    }
}

若要启用函数调用，只需定义一个 @Component 并注解方法：

@Component
public class WeatherTools {

    @Tool(description = "获取指定城市的实时天气")
    public String getWeather(String city) {
        // 模拟调用天气 API
        return city + "：26℃，多云";
    }
}

然后在 Controller 中注入 WeatherTools，并通过 .tools(weatherTools) 将其绑定到 ChatClient。Spring AI 会自动将 getWeather 方法的签名、参数说明和描述转换为 LLM 可理解的 Function Schema，并在对话中自动决策是否调用该工具。

3.3 示例：基于向量库的问答（RAG）

Spring AI 的 RAG 集成非常简单。以下示例使用 PgVector 作为向量存储，从文档中检索相关知识片断辅助模型回答。

依赖（额外添加）：

<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-pgvector-store</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-tika-document-reader</artifactId>
</dependency>

代码：

@Bean
public VectorStore vectorStore(JdbcTemplate jdbcTemplate) {
    return new PgVectorStore(jdbcTemplate);
}

@RestController
public class RagController {

    private final ChatClient chatClient;

    public RagController(ChatClient.Builder builder, VectorStore vectorStore) {
        this.chatClient = builder
            .defaultAdvisors(new RetrievalAugmentationAdvisor(
                vectorStore, SearchRequest.defaults()))
            .build();
    }

    @GetMapping("/rag")
    public String rag(@RequestParam String question) {
        return chatClient.prompt()
                .user(question)
                .call()
                .content();
    }
}

框架会在每次请求时自动根据 question 从向量库中检索相关文档，并将其注入 Prompt 上下文，从而实现“带着教材回答”的效果。

3.4 适用场景与局限

Spring AI 非常适合已有 Spring 技术栈的团队，尤其是企业内部工具、数据查询类 ChatBot、以及需要快速从 AI 中台接入多种模型的项目。但目前仍处于 1.0 里程碑之前的快速变化阶段，API 还不完全稳定，高级编排能力（如复杂有状态链、Agent 多步规划、条件分支）较弱。如果你的场景需要自定义 Agent 工作流（例如先检索再判断再调用工具再汇总），Spring AI 当前的原生支持还不够灵活。

4. LangChain4j（Java 版的 LangChain 生态）

LangChain4j 是 LangChain 在 Java 社区的“精神继承者”，它试图将 Python LangChain 的核心概念（Chain、Tool、Memory、RAG）原汁原味地带入 Java，同时融入 Java 的强类型和同步/异步模型。它的模块化设计非常清晰：langchain4j-core 定义抽象，langchain4j-open-ai、langchain4j-ollama 等提供模型实现，langchain4j-elasticsearch、langchain4j-pinecone 等提供存储集成。

4.1 核心特性

• 丰富的模型适配：支持 OpenAI、Azure OpenAI、Google Vertex AI、HuggingFace、Ollama、Claude 等 20+ 模型供应商，并且对国产模型（如智谱 AI、百度千帆）也有社区适配。
• 流式响应：通过 StreamingChatModel 和回调机制原生支持 SSE（Server-Sent Events），可以逐 token 推送给前端，提升用户体验。
• 结构化输出：借助 AiServices 将 LLM 输出直接映射为 Java 接口，通过动态代理生成实现，类似 Retrofit 的风格。支持返回复杂对象、列表，甚至配合 JSON Schema 约束。
• 链（Chain）与路由器：提供 SequentialChain、RouterChain、MapReduceChain 等模式，支持多步骤 Prompt 编排；用户可以自定义 Chain 实现任意流程。
• 工具集成：支持声明式工具（@Tool）和程序化注册（ToolSpecification），内置搜索引擎、数据库查询、文件系统等常用工具。
• 记忆管理：提供 ChatMemory 和 ChatMemoryStore 抽象，支持 MessageWindowChatMemory（滑动窗口）和 TokenWindowChatMemory，且可以持久化到数据库，适合长时间对话。
• 嵌入式 & 向量存储：支持多种 Embedding 模型和向量存储（Pinecone、Milvus、Elasticsearch、Weaviate 等），并提供 ContentRetriever 和 RetrievalAugmentor 构建检索链。
• AI Gateway 兼容：可通过 langchain4j-ai-gateway 附加安全、限流、审计等功能，适合在企业中台统一管控。

4.2 示例：AiServices 结构化输出

依赖：

<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-open-ai</artifactId>
    <version>1.0.0-beta1</version>
</dependency>

定义接口：

public interface MusicAgent {

    @SystemMessage("你是一个音乐推荐专家，请用不超过100字回答。")
    String recommendGenre(@V("mood") String mood);
}

使用：

OpenAiChatModel model = OpenAiChatModel.builder()
        .apiKey(System.getenv("OPENAI_API_KEY"))
        .modelName("gpt-4o-mini")
        .build();

MusicAgent agent = AiServices.create(MusicAgent.class, model);
String result = agent.recommendGenre("疲惫的周五");
System.out.println(result);

对于更复杂的工具调用，可以直接将方法返回值定义为工具的输出，LangChain4j 会自动将接口方法注册为工具并使用模型的选择机制来决定是否调用。

4.3 示例：带记忆的对话链

LangChain4j 的链式调用可以轻松加入记忆组件。以下例子演示了一个连续对话服务，能够记住之前的上下文。

ChatMemory chatMemory = MessageWindowChatMemory.withMaxMessages(10);

ConversationalChain chain = ConversationalChain.builder()
        .chatLanguageModel(model)
        .chatMemory(chatMemory)
        .build();

String answer1 = chain.execute("我叫张三");
String answer2 = chain.execute("我叫什么名字？"); // 模型会记住“张三”

ConversationalChain 内部会自动将历史消息按窗口大小附加到 Prompt 中，无需手动拼接。

4.4 社区与成熟度

LangChain4j 是目前 Java LLM 框架中 star 数最高、社区最活跃的项目之一（GitHub 30k+）。它的迭代速度快，文档相对完善，示例丰富，且生态覆盖了主流的模型和向量库。适合希望从 Python LangChain 迁移到 Java 的团队，也适合需要快速构建包含多种组件（数据库、文件、搜索引擎）的复杂 Agent 应用。唯一的挑战是：框架版本还在快速演进中，偶尔会有 API 不兼容的情况，升级时需要关注 Release Notes。

5. Agents-Flex（轻量级、面向 Agent 的框架）

Agents-Flex 是一个专注于 LLM Agent 编程的 Java 框架，由国内开发者维护，设计目标是提供轻量、直观的 Agent 编排体验，与 Spring Boot 深度集成。与 LangChain4j 的“大而全”不同，Agents-Flex 刻意保持核心库的精简，强调“Agent 优先”。

5.1 核心特性

• 声明式 Agent 定义：通过 @Agent、@Tool 等注解快速构建 Agent，支持异步和流式输出，且内置了对话管理。
• 灵活的任务编排：内置 AgentChain（顺序执行）和 AgentGraph（有向无环图），支持顺序、并行、条件分支等流程，可以构建复杂的多 Agent 协作。
• 多模型支持：深度适配智谱AI、月之暗面、阿里百炼、Ollama 等国内模型，也支持 OpenAI 标准接口，模型切换非常简便。
• 记忆与上下文：提供 ChatMemory 和可插拔的持久化方案（支持 Redis、数据库等）。
• Web 集成：提供 agents-flex-spring-boot-starter，内置 Swagger 接口和 SSE 通道，开箱即用。
• 轻量无侵入：核心依赖极小，可以与现有 MVC 项目快速整合，无需引入重量级依赖。

5.2 示例：构建一个带工具的多步 Agent

依赖：

<dependency>
    <groupId>com.agentsflex</groupId>
    <artifactId>agents-flex-spring-boot-starter</artifactId>
    <version>1.0.0</version>
</dependency>

配置：

agents:
  flex:
    model: zhipu:glm-4
    api-key: ${ZHIPU_API_KEY}

定义工具：

@Component
public class CalculatorTools {

    @Tool(name = "计算器", description = "执行两个数的四则运算")
    public double calculate(String operand,
                            @ToolParam(description = "操作符，支持+、-、*、/") String operator,
                            @ToolParam(description = "第二个操作数") double b) {
        return switch (operator) {
            case "+" -> Double.parseDouble(operand) + b;
            case "-" -> Double.parseDouble(operand) - b;
            case "*" -> Double.parseDouble(operand) * b;
            case "/" -> Double.parseDouble(operand) / b;
            default -> 0.0;
        };
    }
}

Agent 定义：

@Agent(name = "math-agent", description = "数学助手",
       tools = CalculatorTools.class,
       prompt = "你是一个数学专家，需要利用计算器工具回答用户问题。")
@RestController
public class MathAgent {

    @PostMapping("/agent/chat")
    public Mono<String> chat(@RequestBody String input) {
        return agentsFlex().chat(input)
                .onNext(System.out::println)
                .onComplete(s -> "完成")
                .start();
    }
}

5.3 示例：使用 AgentGraph 编排多 Agent

对于更复杂的场景，可以用 AgentGraph 将多个 Agent 串联起来，形成工作流。例如：先用一个“意图识别 Agent”判断用户问题类型，再路由给不同的专业 Agent 处理。

AgentGraph graph = new AgentGraph();

graph.addNode("intent", intentAgent);
graph.addNode("weather", weatherAgent);
graph.addNode("calculator", mathAgent);
graph.addNode("fallback", fallbackAgent);

graph.addConditionalEdge("intent",
    ctx -> ctx.getLastOutput().contains("天气") ? "weather" : "calculator"
);
graph.addEdge("weather", "fallback");
graph.addEdge("calculator", "fallback");
graph.setEntryPoint("intent");

String result = graph.execute("今天北京天气怎么样？");

这种图模式极大提升了 Agent 应用的可组合性和复用性，而 Agents-Flex 的 API 设计让开发者无需理解复杂的 DAG 底层实现即可快速搭建。

5.4 适用场景

Agents-Flex 非常适合需要快速构建 Agent 化应用的小型团队，尤其是主要使用国内大模型生态的场景。它的学习成本低，注解驱动的方式与 Spring 结合紧密，AgentGraph 的设计也使其在多 Agent 协作方面有一定优势。但框架整体成熟度略低于 LangChain4j，生态和文档丰富度有待提升，对于需要深度定制链式逻辑的场景可能还需要更多轮子。

6. 其他值得关注的框架

6.1 Quarkus LangChain4j 扩展

Quarkus 社区已提供对 LangChain4j 的官方扩展，支持原生编译和响应式编程。它利用了 Quarkus 的构建时特性，可以在 GraalVM 中实现毫秒级启动和极低内存占用。适合对资源敏感、需要云原生 Serverless 部署的场景。

6.2 Java-LangChain

一个纯 Java 实现的 LangChain 移植项目，目标是保持与 Python LangChain API 的高度一致，让熟悉 Python 版的开发者可以几乎无痛迁移。但目前社区活跃度较低，尚未大面积流行，不建议在生产环境核心链路中使用。

6.3 阿里灵积 DashScope Java SDK

阿里云灵积（DashScope）提供了官方 Java SDK，允许直接调用通义系列模型（如通义千问、通义万相等），支持流式对话、工具调用、多模态等，虽非通用框架，但在阿里云生态中集成度很高，适合全栈使用阿里云服务的企业。

6.4 JAI 与新兴框架

JAI（Java AI）是一个较新的项目，目标是定义一套类似 JPA 的标准化 AI API（JSR 风格），让不同的框架实现可以相互替换。目前还处于早期阶段，但值得关注。此外，像 Semantic Kernel for Java（微软）、Google Gen AI Java SDK 等官方 SDK 也在快速发展，它们虽不是框架，但在特定生态中提供了最直接的集成方式。

7. 框架对比与选型建议

下表从更多维度对主要框架进行对比：

维度	Spring AI	LangChain4j	Agents-Flex
社区活跃度	中（Spring 官方维护）	高（30k+ stars，社区驱动）	中（国内新兴）
抽象层次	中等，Spring 风格	高，类似 Python LangChain	轻量，Agent 优先
模型支持范围	10+	20+	国内主流 + OpenAI 标准
结构化输出	内置 BeanConverter	AiServices 动态代理	手动解析或注解
工具调用/Agent	@Tool，需手动绑定	@Tool + AiServices	@Tool、AgentGraph 编排
RAG 支持	VectorStore 抽象 + Advisor	ContentRetriever + 链	基础检索集成
流式响应	支持 SSE	原生 StreamingChatModel	支持 Reactive Stream
可观测性	Micrometer/OTel 深度集成	可通过 AI Gateway	有限
生态兼容	Spring Boot Starter	独立，也可集成 Spring	Spring Boot Starter
学习曲线	平缓（Spring 开发者友好）	中等（概念较多）	较低（注解驱动）
生产就绪	里程碑版，API 仍在变化	1.0-beta，相对稳定	早期版本，谨慎用于核心链路

选型建议：

• 如果你的团队以 Spring Boot 为技术底座，需要统一的 AI 中间件来对接多个模型，并且能接受 API 的短期波动，Spring AI 是自然的选择。
• 如果你追求功能最全面的 LLM 编排，需要复杂的链式调用、丰富的工具集成和最高的社区活跃度，LangChain4j 当前综合实力最强。
• 如果你的项目偏向国内大模型，或者你希望用最轻量的方式快速构建多 Agent 工作流，并且对注解驱动的方式情有独钟，Agents-Flex 值得尝试。
• 对于 Quarkus 用户，优先考虑 Quarkus LangChain4j，可以获得更优的性能和原生编译支持。
• 若主要使用阿里云通义系列，可直接使用 DashScope Java SDK，以获得最佳的兼容性和性能。

8. 总结

Java LLM 开发框架正从“有没有”走向“好不好”的阶段。Spring AI 代表官方标准化力量，LangChain4j 继承社区丰富经验，Agents-Flex 则展现了国内开发者的创新活力，而 Quarkus、DashScope 等又在特定场景下提供了差异化优势。企业选型时，除了对比表格中的维度，还应结合自身的模型供应商绑定、基础设施现状、团队技能和长期维护成本进行决策。

展望未来，随着 LLM 应用从“单模型对话”向“多 Agent 协作 + 多模态”演进，Java 框架必然要支持更复杂的推理链路、更灵活的模型路由以及跨语言互操作。我们甚至可能看到一个类似 JPA 的统一抽象层出现，让企业在不同框架之间更自由地迁移。但无论怎样，Java 在 AI 应用落地中的工程优势会越来越明显。希望本文能帮助你在众多框架中找到最适合自己项目的那一个，并在企业 AI 化的浪潮中抢占先机。