AI Agent 开发实战（5）：Java 生态 Agent 框架横评

前四篇我们把 Agent 的三大基石（LLM 调用、记忆系统、工具调用）逐个拆透了。从这篇开始进入实战阶段——选哪个框架来搭 Agent？

Python 阵营有 LangChain、CrewAI、AutoGen，但你是 Java 开发者，公司技术栈跑在 Spring 上，不想为了搞 Agent 再起一个 Python 服务。今天把 Java 生态主流的 Agent 框架横评一遍，帮你做出选择。

---

一、为什么 Java 生态需要自己的 Agent 框架？

先看一个真实场景：

企业级 Agent 部署架构（无额外语言）

┌─────────────────────────────────────────────────┐
│                企业基础设施                        │
│  ┌──────────┐ ┌──────────┐ ┌───────────────┐    │
│  │ 配置中心  │ │ 注册中心  │ │ 统一认证网关  │    │
│  └────┬─────┘ └────┬─────┘ └───────┬───────┘    │
│       │            │               │             │
│  ┌────▼────────────▼───────────────▼─────────┐  │
│  │         Spring Cloud 微服务集群             │  │
│  │  ┌─────────────┐  ┌───────────────────┐   │  │
│  │  │ 业务服务 A   │  │ Agent 服务（Java） │   │  │
│  │  └─────────────┘  │ Spring AI + 工具  │   │  │
│  │                   └───────────────────┘   │  │
│  └──────────────────────────────────────────┘  │
└─────────────────────────────────────────────────┘

Python Agent 方案：

┌──────────────────────┐     ┌──────────────┐
│  Spring Cloud 集群    │ ←→  │ Python Agent │
│                      │ HTTP │  LangChain   │
│                      │     │  额外运维成本 │
└──────────────────────┘     └──────────────┘
  ↑ 需要额外：Python 运维、虚拟环境、依赖管理、跨语言鉴权

Java 生态做 Agent 的核心诉求：

• 不引入新语言栈：复用 Spring 生态的配置中心、注册中心、认证网关
• 企业级特性：线程池、连接池、安全审计开箱即用
• 团队技能复用：Java 开发者不需要学 Python

---

二、四个主流框架一览

目前 Java 生态做 Agent 主要有四个选择：

框架	背后组织	定位	核心抽象	协议支持	成熟度
Spring AI	VMware/Broadcom	Spring 生态原生 AI 框架	ChatClient + Advisor	OpenAI 兼容	⭐⭐⭐⭐ 生产可用
LangChain4j	独立社区	LangChain 的 Java 版	AiServices + Tool	OpenAI 兼容	⭐⭐⭐ 快速迭代中
Apache Camel AI	Apache	集成生态的 AI 扩展	Camel Route + AI Component	多协议	⭐⭐⭐ 路线图推进中
JLangChain	个人项目	轻量级链式调用	Chain + Agent	OpenAI 兼容	⭐⭐ 早期阶段

下面逐个拆解。

---

三、Spring AI：Spring 生态的原生方案

核心架构

Spring AI 架构

┌─────────────────────────────────────────────┐
│               应用层                         │
│  ┌────────────┐   ┌──────────────────────┐  │
│  │ ChatClient │   │ Advisor Chain        │  │
│  │ (统一入口) │──→│ Request → Advisor    │  │
│  │            │   │  ├─ LoggingAdvisor   │  │
│  │            │   │  ├─ MemoryAdvisor    │  │
│  │            │   │  └─ ToolCallAdvisor  │  │
│  └─────┬──────┘   └──────────┬───────────┘  │
│        │                     │              │
│  ┌─────▼─────────────────────▼───────────┐  │
│  │           Model 抽象层                 │  │
│  │  ChatModel  EmbeddingModel  ImageModel│  │
│  └─────┬─────────────────────────────────┘  │
│        │                                    │
│  ┌─────▼─────────────────────────────────┐  │
│  │          Provider 实现层               │  │
│  │ OpenAI  Azure  Ollama  Zhipu  ...     │  │
│  └───────────────────────────────────────┘  │
└─────────────────────────────────────────────┘

关键代码：一个带工具的 Agent

// 1. 定义工具
@Component
public class WeatherTools {

    @Tool(description = "获取指定城市的当前天气")
    public String getCurrentWeather(@Param("city") String city) {
        // 调用天气 API
        return weatherService.fetch(city);
    }

    @Tool(description = "获取城市未来3天天气预报")
    public String getForecast(@Param("city") String city) {
        return weatherService.forecast(city);
    }
}

// 2. 构建 ChatClient
@Bean
public ChatClient chatClient(ChatClient.Builder builder, WeatherTools tools) {
    return builder
        .defaultSystem("你是一个天气助手，用中文回答")
        .defaultTools(tools)
        .defaultAdvisors(
            new MessageChatMemoryAdvisor(chatMemory),
            new SimpleLoggerAdvisor()
        )
        .build();
}

// 3. 使用
String response = chatClient.prompt()
    .user("苏州明天天气怎么样？")
    .call()
    .content();

优势与不足

维度	优势	不足
Spring 集成	自动配置、Properties 绑定、Actuator 监控	仅限 Spring 项目
模型支持	20+ Provider，统一 API 切换模型	部分国产模型需自适配
工具调用	声明式 @Tool，Advisor 链式增强	Agent 循环需自己编排
记忆	内置 ChatMemory（窗口/向量）	长期记忆方案偏简单
社区	Spring 官方支持，迭代快	文档有时滞后于版本

---

四、LangChain4j：LangChain 思路的 Java 实现

核心架构

LangChain4j 架构

┌─────────────────────────────────────────┐
│  AiServices（声明式接口）                │
│  ┌───────────────────────────────────┐  │
│  │  @UserMessage / @SystemMessage    │  │
│  │  + @Tool 方法自动注册             │  │
│  └───────────────┬───────────────────┘  │
│                  │                      │
│  ┌───────────────▼───────────────────┐  │
│  │  Chain / Agent 编排层             │  │
│  │  ┌─────────┐  ┌────────────────┐  │  │
│  │  │ RAG Chain│  │ ReAct Agent   │  │  │
│  │  └─────────┘  └────────────────┘  │  │
│  └───────────────┬───────────────────┘  │
│                  │                      │
│  ┌───────────────▼───────────────────┐  │
│  │  Model + Store 层                 │  │
│  │  ChatLanguageModel                │  │
│  │  EmbeddingStore / ChatMemoryStore │  │
│  └───────────────────────────────────┘  │
└─────────────────────────────────────────┘

关键代码：声明式 Agent

// 1. 定义 Agent 接口（声明式，像 MyBatis Mapper）
interface WeatherAssistant {

    @SystemMessage("你是一个天气助手，用中文回答，温度用摄氏度")
    String chat(@UserMessage String userMessage);
}

// 2. 定义工具类
class WeatherTools {

    @Tool("获取城市当前天气")
    public String getCurrentWeather(String city) {
        return weatherService.fetch(city);
    }
}

// 3. 构建 Agent
WeatherAssistant agent = AiServices.builder(WeatherAssistant.class)
    .chatLanguageModel(model)
    .chatMemory(MessageWindowChatMemory.withMaxMessages(20))
    .tools(new WeatherTools())
    .build();

// 4. 使用
String response = agent.chat("苏州明天天气怎么样？");

优势与不足

维度	优势	不足
API 风格	声明式接口，上手快	过度封装，调试困难
Spring 支持	langchain4j-spring-boot-starter	非 Spring 原生，集成度不如 Spring AI
RAG	内置 RAG Pipeline	向量存储适配器较少
Agent 编排	内置 ReAct、Tool Chain	多 Agent 协作尚缺
模型	30+ Provider	部分适配质量一般

---

五、Apache Camel AI：集成优先的方案

核心架构

Camel AI 架构

┌───────────────────────────────────────────────┐
│  Camel Route DSL                              │
│                                               │
│  from("direct:ask")                           │
│    .to("openai:chat")        ← 模型调用       │
│    .to("log:response")                        │
│    .to("elasticsearch:insert") ← 存向量       │
│                                               │
│  内置 AI 组件：                                │
│  ┌────────┐ ┌────────┐ ┌────────┐            │
│  │openai  │ │ollama  │ │pinecone│            │
│  └────────┘ └────────┘ └────────┘            │
└───────────────────────────────────────────────┘

关键代码：Route 式 Agent

// Camel Route 方式调用 LLM
from("direct:chat")
    .setHeader("CamelOpenAiModel", constant("gpt-4o"))
    .to("openai:chat?model=gpt-4o&maxTokens=500")
    .to("log:ai-response");

// RAG 流程
from("direct:rag")
    .to("elasticsearch:search?index=knowledge")  // 检索
    .process(this::buildPromptWithContext)         // 构建 Prompt
    .to("openai:chat")                            // 调用模型
    .to("log:rag-response");

优势与不足

维度	优势	不足
集成能力	300+ Component，打通一切系统	AI 不是核心，能力偏基础
EIP 模式	成熟的路由、过滤、聚合模式	Agent 编排能力弱
企业集成	事务、补偿、监控全有	做 Agent 不如前两个自然
学习成本	Camel 开发者友好	非 Camel 用户门槛高

---

六、四个框架对比总结

功能维度对比

能力	Spring AI	LangChain4j	Camel AI	JLangChain
LLM 调用	⭐⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐	⭐⭐⭐
工具调用	⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐	⭐⭐
记忆系统	⭐⭐⭐	⭐⭐⭐⭐	⭐⭐	⭐⭐
RAG	⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐	⭐⭐
Agent 编排	⭐⭐⭐	⭐⭐⭐	⭐⭐	⭐⭐
Spring 集成	⭐⭐⭐⭐⭐	⭐⭐⭐	⭐⭐	⭐
多模型切换	⭐⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐	⭐⭐
可观测性	⭐⭐⭐⭐	⭐⭐⭐	⭐⭐⭐⭐	⭐
文档质量	⭐⭐⭐⭐	⭐⭐⭐	⭐⭐⭐	⭐⭐

选型决策树

你需要 Java Agent 框架？
│
├─ 项目是 Spring Boot / Spring Cloud？
│   ├─ 是 → Spring AI（原生集成，生产级）
│   └─ 否 → 继续 ↓
│
├─ 需要快速原型 / 偏好声明式 API？
│   ├─ 是 → LangChain4j
│   └─ 否 → 继续 ↓
│
├─ 已有 Camel 集成链路，需要接 AI？
│   ├─ 是 → Camel AI
│   └─ 否 → 继续 ↓
│
└─ 轻量级、学习为主 → JLangChain

---

七、实战：同一个需求，四种写法

需求：做一个"智能客服 Agent"，能查订单状态、查物流、回答退货政策。

Spring AI 写法

@Component
public class CustomerServiceTools {

    @Tool("查询订单状态")
    public String queryOrder(@Param("orderId") String orderId) {
        return orderService.getStatus(orderId);
    }

    @Tool("查询物流信息")
    public String queryLogistics(@Param("orderId") String orderId) {
        return logisticsService.track(orderId);
    }

    @Tool("退货政策")
    public String returnPolicy() {
        return "7天无理由退货，30天质量问题包换";
    }
}

@Configuration
public class AgentConfig {

    @Bean
    public ChatClient customerServiceAgent(
            ChatClient.Builder builder,
            CustomerServiceTools tools,
            ChatMemory chatMemory) {

        return builder
            .defaultSystem("""
                你是智能客服，帮客户查订单、物流和退货政策。
                回答要简洁专业，不确定时请客户确认订单号。
                """)
            .defaultTools(tools)
            .defaultAdvisors(new MessageChatMemoryAdvisor(chatMemory))
            .build();
    }
}

// 调用
String answer = chatClient.prompt()
    .user("我的订单 ORD-2024-001 到哪了？")
    .call()
    .content();

LangChain4j 写法

interface CustomerServiceAgent {

    @SystemMessage("你是智能客服，帮客户查订单、物流和退货政策。回答简洁专业。")
    String chat(@UserMessage String message);
}

// 构建
CustomerServiceAgent agent = AiServices.builder(CustomerServiceAgent.class)
    .chatLanguageModel(model)
    .tools(new CustomerServiceTools())
    .chatMemory(MessageWindowChatMemory.withMaxMessages(20))
    .build();

// 调用
String answer = agent.chat("我的订单 ORD-2024-001 到哪了？");

Camel AI 写法

from("direct:customer-service")
    .choice()
        .when(simple("${header.question} contains '订单'"))
            .to("bean:orderService?method=queryStatus")
        .when(simple("${header.question} contains '物流'"))
            .to("bean:logisticsService?method=track")
        .when(simple("${header.question} contains '退货'"))
            .setBody(constant("7天无理由退货，30天质量问题包换"))
        .otherwise()
            .to("openai:chat?model=gpt-4o")
    .end();

写法对比

维度	Spring AI	LangChain4j	Camel AI
代码量	中等	最少	最多
灵活性	高（Advisor 链可自由组合）	中（声明式限制）	高（Route DSL）
工具注册	@Tool 注解	@Tool 注解	Bean 引用
记忆管理	Advisor 模式	内置 ChatMemory	需手动
可测试性	好	好	一般

---

八、MCP 协议：跨框架工具互操作的新可能

不管选哪个框架，都有一个现实问题：工具怎么共享？

MCP（Model Context Protocol）是 Anthropic 提出的开放协议，定义了 LLM 与外部工具的标准化交互方式。Java 生态正在跟进：

MCP 架构

┌──────────────┐     MCP 协议     ┌──────────────┐
│  LLM 客户端   │ ←──────────────→ │  MCP Server  │
│ (任何框架)    │    JSON-RPC     │  ┌─────────┐ │
│              │                  │  │ 工具定义  │ │
│ Spring AI    │                  │  │ 资源列表  │ │
│ LangChain4j  │                  │  │ Prompt   │ │
│ 其他         │                  │  └─────────┘ │
└──────────────┘                  └──────────────┘

Spring AI MCP 支持（1.0+）：
- 内置 McpClient，可直接连接 MCP Server
- MCP 工具自动映射为 @Tool

LangChain4j MCP 支持（0.36+）：
- 社区贡献的 MCP 集成模块
- 可消费 MCP Server 提供的工具

MCP 的价值：工具定义一次，所有框架都能用。企业内部把数据库查询、API 调用、文件操作都封装成 MCP Server，任何 Agent 框架直接消费。

---

九、我的推荐策略

根据实际场景给出选择建议：

场景 1：Spring Boot 项目内嵌 Agent

推荐：Spring AI

理由：
├── 零额外依赖冲突，自动配置开箱即用
├── Properties 绑定管理模型参数，环境隔离自然支持
├── Actuator 暴露 AI 调用指标，运维友好
└── Advisor 链式架构扩展性强

场景 2：独立 Agent 服务，快速迭代

推荐：LangChain4j

理由：
├── 声明式接口写起来快
├── 内置 RAG Pipeline，少写胶水代码
├── 不依赖 Spring，轻量启动
└── 社区活跃，跟 LangChain 生态思路对齐

场景 3：企业集成平台，AI 只是其中一环

推荐：Camel AI

理由：
├── 已有 Camel 路由，接 AI 只是加一个 Component
├── 300+ 集成组件，打通 ERP/CRM/消息队列
└── EIP 模式处理复杂路由逻辑

场景 4：混合策略（推荐）

推荐：Spring AI 为主 + MCP 共享工具

┌─────────────────┐
│  Spring AI Agent │ ← 核心业务 Agent
│  (主框架)        │
└────────┬────────┘
         │ MCP 协议
┌────────▼────────┐
│  MCP Tool Server│ ← 工具集中管理
│  ┌────────────┐ │
│  │ 订单查询   │ │
│  │ 物流追踪   │ │
│  │ 知识检索   │ │
│  └────────────┘ │
└─────────────────┘
         ↑ MCP 协议
┌────────┴────────┐
│  其他框架 Agent  │ ← 未来扩展
│  LangChain4j    │
│  甚至 Python    │
└─────────────────┘

这样既用 Spring AI 充分利用 Spring 生态，又通过 MCP 保持工具层解耦，未来换框架或混用都有弹性。

---

十、总结

关键结论	说明
Spring AI 是 Java Agent 的首选	Spring 生态原生集成，生产级支持
LangChain4j 是快速原型利器	声明式 API 上手快，RAG 内置
Camel AI 适合集成场景	已有 Camel 基础时顺带接 AI
MCP 是未来的互操作标准	工具定义一次，多框架消费
不要被框架绑架	选框架看生态契合度，不是功能列表

下一篇我们用 Spring AI 从零搭建一个完整的 Agent，把 LLM 调用、工具注册、记忆管理和 Advisor 链串起来，跑通一个端到端的流程。

---

本文是「AI Agent 开发实战」系列第 5 篇，系列目录：

1. AI Agent 核心概念与架构
2. 三大基石之 LLM 调用与 Prompt 工程
3. 三大基石之记忆系统
4. 三大基石之工具调用
5. 本文：Java 生态 Agent 框架横评