Java Agent 框架深度对比报告

1. Java Agent 框架在企业应用中的优势

1.1. Java vs Python：语言层面大规模企业应用开发对比

1.2. Java Agent 框架在企业应用中的优势

1.3. AI Agent场景Java更具工程优势

总结：Python强于实验速度，Java胜在工程确定性。当AI Agent从个人项目走向服务千万用户的企业应用时，Java在语言层面提供的类型安全、并发性能、维护效率和生态成熟度，构成了不可替代的工程地基。

最佳实践路径：Python快速验证AI原型 → Java构建高可用、可商用的生产级Agent应用。

2. Java Agent 框架汇总对比

2.1. 基本信息

2.2. 核心能力对比

标注说明：✅ 完整支持 ⚠️ 部分/有限支持 ❌ 不支持

3. 架构设计

3.1. AgentScope Java 2.0 架构

来源：AgentScope Java 2.0 README — “What is AgentScope Java 2.0?” 和 “Key Design” 章节 [ref:4]

AgentScope Java 2.0 采用双层 Agent 架构：底层 ReActAgent 是无状态推理核心，上层 HarnessAgent 通过 Middleware 和 Toolkit 通道叠加工程化基础设施。

┌───────────────────────────────────────────────────────────────────┐
│                      Application / Channel IM                     │
│                   (DingTalk / Feishu / WeCom)                     │
├───────────────────────────────────────────────────────────────────┤
│                     HarnessAgent (工程化层)                       │
│  ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ ┌────────────┐ │
│  │  Workspace  │ │   Memory    │ │   Sandbox   │ │   Skills   │ │
│  │ Persona/    │ │ 短期+长期+  │ │ Local/      │ │ Classpath/ │ │
│  │ MEMORY.md/  │ │ 自动压缩   │ │ Docker/K8s/ │ │ FileSystem/│ │
│  │ Skills/     │ │             │ │ E2B Cloud   │ │ Nacos/     │ │
│  │ Subagents   │ │             │ │             │ │ Marketplace│ │
│  └─────────────┘ └─────────────┘ └─────────────┘ └────────────┘ │
├───────────────────────────────────────────────────────────────────┤
│          Middleware (五阶段洋葱+管道混合模型)                       │
│    onAgent → onReasoning → onActing → onModelCall → onSystemPrompt│
├───────────────────────────────────────────────────────────────────┤
│               ReActAgent (Stateless Reasoning Core)                │
│               推理 → 工具调用 → 回复 (ReAct Loop)                   │
├───────────────────────────────────────────────────────────────────┤
│ Event Stream (28 typed events)  │  Permission Engine (三态决策)     │
│ Multi-Agent (agent_spawn/send)  │  Plan Mode (只读规划)             │
├───────────────────────────────────────────────────────────────────┤
│ Distributed Backend │ MCP Protocol │ A2A & AG-UI Protocol           │
│  Redis/MySQL/PG/    │              │                                │
│  OSS/COS            │              │                                │
└───────────────────────────────────────────────────────────────────┘

核心设计要点（直接来自 README）[ref:4]：
设计哲学：双层 Agent 架构——ReActAgent 作为无状态推理核心，HarnessAgent 通过 Middleware 和 Toolkit 两个扩展通道叠加工程化基础设施。核心理念是"让智能体稳定完成任务"。

1. Harness Engineering — 面向长时运行的复杂任务：

   • Self-evolution & Skill Repository：成功模式自动保存为 Markdown skills，跨会话共享，按需加载
   • Layered Memory：In-context 对话 + agent-curated MEMORY.md + 磁盘事实日志，带自动压缩以控制 Prompt 长度
   • Sub-agents：通过 Markdown 声明子 Agent 规格，运行时 agent_spawn/agent_send，支持同步或后台委派
   • Auto Context Management：结构化压缩保留目标/状态/发现/下一步；超大工具结果卸载到磁盘
   • Plan Mode：只读规划状态，plan 文件持久化并驱动执行

2. Enterprise-grade Distributed Deployment：

   • Multi-tenant Isolation：session/user/agent/org 多维度隔离
   • Secure Sandbox：local subprocess / Docker / Kubernetes / E2B cloud sandbox，支持快照和恢复
   • Permission Control：三态引擎（allow / approve / deny），敏感工具需要 HITL 审批
   • Session Recovery：AgentStateStore 支持零停机滚动部署

3. Foundation Framework：

   • Event Stream：28 种类型化事件，覆盖模型调用、文本增量、工具执行和用户确认的实时流
   • Middleware：五阶段 onAgent/onReasoning/onActing/onModelCall/onSystemPrompt
   • HITL First Class：确认工具参数、批准敏感操作、与外部系统交互

3.2. LangChain4j 架构

来源：LangChain4j README — “Introduction” 章节 [ref:1]

LangChain4j 是一个惯用的 Java 库（Library），非框架。其核心是统一 API：在 LLM 提供商和向量存储之上提供可移植的抽象层。

┌───────────────────────────────────────────────────────────────────┐
│                       Application Code                            │
│            (Chatbot / RAG / Agent / Workflow)                     │
├───────────────────────────────────────────────────────────────────┤
│  ┌─────────────────────────┐   ┌─────────────────────────┐       │
│  │    AI Services (声明式)   │   │   Agentic Framework     │       │
│  │  @AiService / @Agentic   │   │ SupervisorAgent / BDI / │       │
│  │  动态代理 + 类型安全      │   │  Debate / Blackboard /  │       │
│  │  接口驱动                 │   │  Voting                │       │
│  └─────────────────────────┘   └─────────────────────────┘       │
├───────────────────────────────────────────────────────────────────┤
│                     Comprehensive Toolbox                         │
│  ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────────────┐    │
│  │ Prompt   │ │ Chat     │ │ Function │ │ RAG Pipeline     │    │
│  │ Templates│ │ Memory   │ │ Calling  │ │ (Embed→Store→    │    │
│  │          │ │ (Window/ │ │ (Tools)  │ │  Retrieve)       │    │
│  │          │ │  Token)  │ │          │ │                  │    │
│  └──────────┘ └──────────┘ └──────────┘ └──────────────────┘    │
├───────────────────────────────────────────────────────────────────┤
│              Unified Model API (ChatLanguageModel)                │
│    OpenAI │ Anthropic │ Gemini │ Ollama │ Azure │ 20+ providers  │
├───────────────────────────────────────────────────────────────────┤
│              Unified Embedding Store API                          │
│  Pinecone │ Milvus │ Chroma │ Weaviate │ Qdrant │ 30+ stores     │
├───────────────────────────────────────────────────────────────────┤
│    Framework Integrations: Spring Boot / Quarkus / Helidon /      │
│                          Micronaut / Camel                        │
└───────────────────────────────────────────────────────────────────┘

核心设计要点（直接来自 README）[ref:1]：

设计哲学：库（Library）而非框架，高度模块化，每个功能独立为模块按需引入。以 LLM 为中心，注重灵活性和可组合性。

• 两层抽象：低层提供原语（ChatModel、EmbeddingStore 等）供自由组合；高层通过 AI Services 隐藏复杂度，以声明式方式交互。使用 Java 惯用风格（Builder 模式、强类型、注解驱动、接口优先）。
• 不是 LangChain（Python）的 Java 移植 — 它是为 Java 从零设计的惯用库，围绕 Java 惯例构建：类型安全、POJO、注解、接口、依赖注入、Fluent API
• 统一 API：避免需要学习和实现每个提供商的特定 API，在提供商之间切换无需重写代码
• 全面的工具箱：从低层 prompt templating、chat memory 管理、function calling 到高层模式如 Agents 和 RAG
• 框架中立：不绑定特定框架，可在 Spring Boot、Quarkus、Helidon、Micronaut 等环境中使用

3.3. Spring AI 架构

来源：Spring AI README — 项目概述 [ref:2]

Spring AI 的核心目标是将 Spring 生态系统的设计原则应用于 AI 领域，连接企业的 Data 和 API 与 AI Models。

┌───────────────────────────────────────────────────────────────────┐
│                      Spring Boot Application                      │
├───────────────────────────────────────────────────────────────────┤
│  ┌─────────────────────────────────────────────────────────────┐ │
│  │               ChatClient API (Fluent Builder)               │ │
│  │         类似 WebClient / RestClient 的编程体验               │ │
│  └─────────────────────────────────────────────────────────────┘ │
│  ┌─────────────────────────────────────────────────────────────┐ │
│  │        Advisors API (拦截器模式 — 封装通用 AI 模式)          │ │
│  │   Memory │ RAG │ Logging │ Custom                           │ │
│  └─────────────────────────────────────────────────────────────┘ │
├───────────────────────────────────────────────────────────────────┤
│  ┌──────────┐ ┌──────────────┐ ┌──────────┐ ┌──────────────┐   │
│  │  Tool    │ │  MCP         │ │   ETL    │ │  Structured  │   │
│  │ Calling  │ │  Client +    │ │ Pipeline │ │  Output      │   │
│  │          │ │  Server      │ │          │ │  (POJO映射)  │   │
│  │          │ │  STDIO/SSE/  │ │          │ │              │   │
│  │          │ │  HTTP        │ │          │ │              │   │
│  └──────────┘ └──────────────┘ └──────────┘ └──────────────┘   │
├───────────────────────────────────────────────────────────────────┤
│  ChatMemory Repository    │    Vector Store Abstraction           │
│  JDBC/Cassandra/Mongo/    │    20+ stores (Pinecone/Milvus/       │
│  Neo4j/Redis              │    Chroma/Weaviate/... )              │
├───────────────────────────────────────────────────────────────────┤
│          Model Abstraction (ChatModel / EmbeddingModel)           │
│  OpenAI │ Anthropic │ Gemini │ Ollama │ Bedrock │ DeepSeek │ ... │
│  支持 Chat / Embedding / Image / Audio / Moderation 等多种模态     │
├───────────────────────────────────────────────────────────────────┤
│     Spring Boot Auto-Configuration & Starters (start.spring.io)   │
│          (Micrometer / Spring Security / Spring Data)             │
└───────────────────────────────────────────────────────────────────┘

核心设计要点（直接来自 README）[ref:2]：

设计哲学：框架（Framework），遵循 Spring 的"约定优于配置"原则，与 Spring 生态无缝集成。核心挑战是"连接企业 Data 和 APIs 与 AI Models"。所有核心组件均为 Spring Bean，深度依赖 Spring IOC 容器。提供一站式解决方案，企业级稳定。定位为 AI 工程框架而非 Agent 框架，通过 ChatClient + Advisors + Tool Calling 组合实现类 Agent 行为。

• 可移植性：跨 AI 提供商的统一 API，同步和流式选项
• 模块化设计：各组件解耦，按需组合（从 2.0 开始拆分为 commons/model/vector-store/client-chat/rag 等独立模块）
• 强类型：使用强类型数据结构和 API（Structured Outputs 映射为 POJO）
• Spring Boot 原生集成：所有组件通过 Auto-Configuration 和 Starters 一键集成
• 无原生 Agent 类型：Spring AI 定位为 AI 工程框架，通过 ChatClient + Advisors + Tool Calling 组合实现类 Agent 行为

3.4. Spring AI Alibaba 架构

来源：Spring AI Alibaba README — “架构设计 (Architecture)” 章节 [ref:3]

Spring AI Alibaba 采用三层架构：平台层（Admin）→ 框架层（Agent Framework）→ 运行时层（Graph）。

┌───────────────────────────────────────────────────────────────────┐
│                        Platform Layer                             │
│              Spring AI Alibaba Admin (一站式 Agent 平台)           │
│   可视化 Agent 开发 │ 可观测性 │ 评估 │ MCP 管理                   │
│   与 Dify 等低代码平台集成，支持 DSL 迁移                           │
├───────────────────────────────────────────────────────────────────┤
│                      Framework Layer                              │
│               Spring AI Alibaba Agent Framework                   │
│  ┌─────────────────────────────────────────────────────────────┐ │
│  │  ReactAgent (多模态：文本 + 图像理解，基于工具的图像/音频生成)  │ │
│  ├─────────────────────────────────────────────────────────────┤ │
│  │  Multi-Agent Orchestration (内置四种编排模式)                 │ │
│  │  SequentialAgent │ ParallelAgent │ RoutingAgent │ LoopAgent  │ │
│  ├─────────────────────────────────────────────────────────────┤ │
│  │  Context Engineering (上下文工程最佳实践)                     │ │
│  │  HITL │ Compaction │ Editing │ Limits │ Retry │ Planning    │ │
│  │  Dynamic Tool Selection                                       │ │
│  └─────────────────────────────────────────────────────────────┘ │
├───────────────────────────────────────────────────────────────────┤
│                       Runtime Layer                               │
│                Spring AI Alibaba Graph                            │
│  ┌─────────────────────────────────────────────────────────────┐ │
│  │  Graph-Based Workflow (DAG 引擎)                             │ │
│  │  条件路由 │ 嵌套图 │ 并行执行 │ 状态管理                     │ │
│  │  导出 PlantUML / Mermaid                                     │ │
│  ├─────────────────────────────────────────────────────────────┤ │
│  │  A2A (Nacos 集成) │ MCP Registry │ Sandbox                   │ │
│  └─────────────────────────────────────────────────────────────┘ │
├───────────────────────────────────────────────────────────────────┤
│              Spring AI Core (模型 / 工具 / 向量存储)               │
│         DashScope │ OpenAI │ DeepSeek │ 智谱AI │ ...             │
├───────────────────────────────────────────────────────────────────┤
│              Spring Boot Auto-Configuration                        │
│            (Nacos / ARMS / Langfuse / Alibaba Cloud)              │
└───────────────────────────────────────────────────────────────────┘

核心设计要点（直接来自 README）[ref:3]：

设计哲学：基于 Spring AI 构建的 Agentic AI 框架。

• 三层架构：
  • 平台层（Admin）：一站式可视化平台，支持无代码构建和部署 Agent，可导出为独立 Java 项目
  • 框架层（Agent Framework）：内置上下文工程最佳实践和 HITL 支持
  • 运行时层（Graph）：提供长运行有状态 Agent 所需的持久化、工作流编排和流式处理
• 多 Agent 编排：SequentialAgent（顺序）/ ParallelAgent（并行）/ RoutingAgent（路由）/ LoopAgent（循环）
• Graph-Based Workflow：基于图的工作流运行时，支持条件路由、嵌套图、并行执行、状态管理，可导出 PlantUML/Mermaid。以 DAG Graph 为核心理念，实现单 Agent、多 Agent 和复杂工作流编排。
• Context Engineering：HITL、上下文压缩、上下文编辑、模型与工具调用限制、工具重试、规划、动态工具选择
• A2A 支持：通过 Nacos 实现分布式 Agent 协调
• 官方明确指出：“ReactAgent 实际上运行在 Graph Runtime 之上”，如需更高级的 ReactAgent 范式驱动智能体，推荐使用 AgentScope。深度集成阿里云生态。

3.5. OpenJiuWen Core Java 架构

来源：OpenJiuWen Core Java README.zh — “架构设计” 和 “项目结构” 章节 [ref:5]

OpenJiuWen Core Java 架构分为三层：SDK 接口层 → Agent 引擎 → 高性能图执行引擎。

┌───────────────────────────────────────────────────────────────────┐
│                    SDK Interface Layer (SDK 接口层)                │
│   开发接口：Agent 创建 │ 工作流设计/编排 │ LLM 调用 │ 工具调用     │
│   目标：Java SDK 接口，关注开发者需求                               │
├───────────────────────────────────────────────────────────────────┤
│                    Agent Engine (智能体引擎)                      │
│   ┌─────────────────────────────────────────────────────────┐    │
│   │  Application Layer (application/)                       │    │
│   │  ┌───────────────┐    ┌─────────────────────┐          │    │
│   │  │ ReActAgent    │    │ WorkflowAgent        │          │    │
│   │  │ (Think→Act→  │    │ (预定义工作流 +      │          │    │
│   │  │  Observe 循环)│    │  任务切换 +          │          │    │
│   │  │  自我修正     │    │  断点续传)           │          │    │
│   │  └───────────────┘    └─────────────────────┘          │    │
│   │  schema/ (配置 Schema)                                  │    │
│   ├─────────────────────────────────────────────────────────┤    │
│   │  Controller Layer (controller/)                         │    │
│   │  Agent 控制器：任务规划 / 工具选择调用 / 工作流切换       │    │
│   │  内置标准化组件：意图识别 │ 提问器 │ LLM 调用 │ 工具     │    │
│   ├─────────────────────────────────────────────────────────┤    │
│   │  Foundation Layer (foundation/)                         │    │
│   │  llm/ (盘古/Qwen/DeepSeek) │ tool/ (工具系统)           │    │
│   │  store/ (存储系统)         │ prompt/ (模板)             │    │
│   └─────────────────────────────────────────────────────────┘    │
├───────────────────────────────────────────────────────────────────┤
│   High-Performance Graph Execution Engine (高性能图执行引擎)       │
│  ┌─────────────────────────────────────────────────────────────┐ │
│  │  Pregel 模型 — 异步并行图执行器                              │ │
│  │  组件并发执行 │ 异步 I/O 处理 │ 结构化上下文管理             │ │
│  │  流批一体传值 │ 动态跳转     │ 状态中断与恢复                │ │
│  │  流式数据传输 │ 多工作流并行处理                             │ │
│  └─────────────────────────────────────────────────────────────┘ │
├───────────────────────────────────────────────────────────────────┤
│                     Storage Backends                               │
│  Vector │ Milvus / Chroma / pgvector / 内存向量                    │
│  Graph  │ 内存图数据存储                                          │
│  KV     │ 数据库 KV + 内存 KV                                      │
│  Object │ 本地对象存储                                            │
├───────────────────────────────────────────────────────────────────┤
│  开放能力：Memory (记忆系统) │ Context (上下文管理) │              │
│           Runner (运行器) │ Session (会话管理)                    │
└───────────────────────────────────────────────────────────────────┘

核心设计要点（直接来自 README）[ref:5]：

设计哲学：以"CLI as New POSIX, Skill as New Library, Agent as New Service"为设计理念。

• SDK 接口层：聚焦大模型应用的开发需求，覆盖 Agent 创建、工作流编排、LLM 调用、提示词模板等
• Agent 引擎：两大场景——ReAct 智能交互与工作流自动跳转，通过 Agent 控制器支撑复杂任务规划
• 高性能图执行引擎：基于 Pregel 模型的异步并行图执行器，支持组件并发执行、状态中断与恢复、流式数据传输
• 开箱即用组件：意图识别、提问器、LLM 调用、工具组件等标准化组件，降低开发门槛
• 多工作流切换：单会话内管理多个工作流，支持自由切换，框架保障被打断工作流的断点接续
• 多存储后端：向量（Milvus/Chroma/pgvector）、图、KV、对象存储

3.6. 架构差异总结

4. 详细比较

4.1. Agent 支持类型与扩展机制

4.2. Session 实现方式

4.3. 工作流实现方式

4.4. 记忆实现机制

4.5. Skill 技能系统

Skill（技能）系统是衡量 Agent 框架复用性、可组合性和自演进能力的重要指标。

• 说明：AgentScope Java 的 Skill 系统设计最为系统化。其 README 明确描述了 “Self-evolution & skill repository”——成功模式自动保存为 Markdown skills，跨会话共享，按需加载 [ref:4]。OpenJiuWen README 文档索引中提到了 “Skills” 作为高阶用法的模块之一 [ref:5]，但具体能力描述尚不完整。LangChain4j、Spring AI 和 Spring AI Alibaba 均未在 README 中提及 “Skill” 概念，其类似能力通过工具注册机制实现。

4.5.1. AgentScope Java Skill 体系

AgentScope Java 是五个框架中 Skill 体系最为完善的框架，其设计核心理念是"技能作为 Agent 的可积累、可复用、可进化的资产"。

4.5.1.1. 四层 Skill 加载机制

┌─────────────────────────────────────────────────────────────┐
│                    Skill Loading Architecture                │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  ┌─────────────────────────────────────────────────────┐   │
│  │  ① Classpath Skill（内置技能）                       │   │
│  │  框架自带的核心技能，随 JAR 包分发                     │   │
│  │  例：文件操作、HTTP 请求、代码执行                     │   │
│  └─────────────────────────────────────────────────────┘   │
│                          ↓                                  │
│  ┌─────────────────────────────────────────────────────┐   │
│  │  ② FileSystem Skill（本地文件技能）                   │   │
│  │  本地文件系统中的 Markdown/YAML 声明技能               │   │
│  │  例：业务流程模板、行业解决方案                       │   │
│  └─────────────────────────────────────────────────────┘   │
│                          ↓                                  │
│  ┌─────────────────────────────────────────────────────┐   │
│  │  ③ Nacos Skill（远程配置技能）                        │   │
│  │  从 Nacos 配置中心动态加载技能                        │   │
│  │  支持热更新、版本管理                                 │   │
│  └─────────────────────────────────────────────────────┘   │
│                          ↓                                  │
│  ┌─────────────────────────────────────────────────────┐   │
│  │  ④ Marketplace Skill（市场技能）                      │   │
│  │  技能市场中的共享技能                                 │   │
│  │  社区贡献、第三方集成                                 │   │
│  └─────────────────────────────────────────────────────┘   │
│                                                             │
│  ┌─────────────────────────────────────────────────────┐   │
│  │  SkillFilter（技能过滤器）                            │   │
│  │  按标签、权限、场景过滤可用技能                       │   │
│  └─────────────────────────────────────────────────────┘   │
│                                                             │
└─────────────────────────────────────────────────────────────┘

4.5.1.2. Skill 自学习闭环

                    ┌─────────────┐
                    │  Propose    │  Agent 自主提议新技能
                    │  (提议)     │  成功模式自动提取
                    └──────┬──────┘
                           ↓
                    ┌─────────────┐
                    │  Curate     │  人工审核/筛选
                    │  (筛选)     │  质量评估与优化
                    └──────┬──────┘
                           ↓
                    ┌─────────────┐
                    │  Promote    │  升级为正式 Skill
                    │  (推广)     │  入库并跨会话共享
                    └─────────────┘

Skill 声明示例（Markdown 格式）：

---
name: data-analysis
version: 1.0.0
tags: [data, analysis, report]
description: 数据分析与报告生成技能
---

# Data Analysis Skill

# 能力描述
对输入数据进行统计分析、趋势识别和可视化报告生成。

# 触发条件
当用户请求数据分析、统计报表、趋势分析时激活。

# 执行步骤
1. 接收数据源
2. 执行统计分析
3. 生成可视化图表
4. 输出分析报告

4.5.2. OpenJiuWen Skill 体系

OpenJiuWen 以"Skill as New Library"为核心理念，将技能视为新时代的软件库。

┌─────────────────────────────────────────────────────────────┐
│              OpenJiuWen Skill Architecture                   │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  ┌─────────────────────────────────────────────────────┐   │
│  │  SkillHub（技能仓库）                                │   │
│  │  集中管理所有技能组件                                │   │
│  │  支持技能注册、版本管理、依赖解析                     │   │
│  └─────────────────────────────────────────────────────┘   │
│                                                             │
│  ┌─────────────────────────────────────────────────────┐   │
│  │  Team Skills Hub（团队技能中心）                      │   │
│  │  跨 Agent 技能共享与复用                             │   │
│  │  一个 Leader 带队多个 Teammate 协同作战               │   │
│  │  例：JiuwenSwarm 群体智能"养蜂"模式                  │   │
│  └─────────────────────────────────────────────────────┘   │
│                                                             │
│  ┌─────────────────────────────────────────────────────┐   │
│  │  Skill Plugin（技能插件）                            │   │
│  │  JiuwenClaw 等技能插件                               │   │
│  │  例：代码编程助手、个人助理                          │   │
│  └─────────────────────────────────────────────────────┘   │
│                                                             │
│  ┌─────────────────────────────────────────────────────┐   │
│  │  Self-Evolving（自演进）                              │   │
│  │  技能运行轨迹分析                                    │   │
│  │  自动优化与进化                                      │   │
│  │  "越用越聪明"                                        │   │
│  └─────────────────────────────────────────────────────┘   │
│                                                             │
└─────────────────────────────────────────────────────────────┘

4.5.3. LangChain4j — 工具组合模式

// 通过 @Tool 注解声明技能
public class DataAnalysisTools {
    
    @Tool(description = "对销售数据进行季度趋势分析")
    public SalesTrend analyzeQuarterlySales(String data) {
        // ...
    }
    
    @Tool(description = "生成可视化报表")
    public Report generateVisualization(SalesTrend trend) {
        // ...
    }
}

// 通过 A2A 复用远程 Agent 能力
A2ARemoteAgent skill = A2ARemoteAgent.builder()
    .url("https://remote-agent.example.com")
    .capability("data-analysis")
    .build();

4.5.4. Spring AI — 函数调用模式

// 通过 @Tool 注解声明技能
@Tool(description = "查询客户订单历史")
public List<Order> getCustomerOrders(String customerId) {
    // ...
}

// 通过 MCP 注解声明服务级技能
@McpTool(name = "order-service", description = "订单管理服务")
@McpResource(uri = "order://{id}")
@McpPrompt(name = "order-summary")
public class OrderService {
    // ...
}

4.5.5. Spring AI Alibaba — 策略节点模式

// Context Engineering 策略作为技能
ReactAgent agent = ReactAgent.builder()
    .contextEngineering(ContextEngineering.builder()
        .hitl(true)              // 人类在环
        .compaction(true)        // 上下文压缩
        .planning(true)          // 规划模式
        .toolRetry(3)            // 工具重试
        .dynamicToolSelection()  // 动态工具选择
        .build())
    .build();

// Graph 节点作为技能单元
StateGraph graph = StateGraph.builder()
    .addNode("analyze", analyzeSkill)
    .addNode("report", reportSkill)
    .addEdge("analyze", "report")
    .build();

4.5.6. Skill 维度总结

5. 总结与选型建议

5.1. 框架定位总结

5.2. 选型建议

6. 总体评价

Java Agent 框架已经形成清晰的格局，各框架定位互补：

• LangChain4j 是 Java 生态最成熟的 LLM 应用开发库，强调"惯用 Java 设计"，明确并非 LangChain（Python）的 Java 移植，而是从零为 Java 构建。框架中立，7 种 Agent 模式覆盖广泛场景 [ref:1]。
• Spring AI 是 Spring 官方 AI 工程框架，核心定位是"将 Spring 设计原则应用于 AI 领域"，连接企业 Data 和 API 与 AI Models。无原生 Agent 类型，通过 ChatClient + Advisors 组合实现类 Agent 行为 [ref:2]。
• Spring AI Alibaba 定位为"生产级框架，用于构建 Agentic、Workflow 和 Multi-agent 应用"，采用三层架构（Admin → Agent Framework → Graph）。其 Graph 层作为 Agent Framework 的底层运行时，支持 PlantUML/Mermaid 导出 [ref:3]。
• AgentScope Java 2.0 定位为"生产就绪的框架，用于构建分布式企业级 Agent"，HarnessAgent 层提供 Self-evolution & skill repository、Layered memory、Multi-Agent orchestration 等关键工程能力 [ref:4]。
• OpenJiuWen Core Java 定位为"大模型应用 Java SDK + 高性能运行时"，内置 Pregel 模型异步并行图执行器，核心特色是单会话内多工作流自由切换和被打断工作流的断点接续能力 [ref:5]。

在 Skill 维度：五个框架中，

• AgentScope Java 的 Skill 系统最为系统化——其 README 明确将 “Self-evolution & skill repository” 作为 Harness Engineering 的核心特性之一：“successful patterns auto-save as Markdown skills, shared across sessions and loaded on demand” [ref:4]。
• OpenJiuWen 文档索引中提到了 “Skills” 作为高阶用法模块 [ref:5]。LangChain4j 通过 @Tool 注解实现工具注册，Spring AI 通过 @Bean Function + MCP Tool 扩展能力，Spring AI Alibaba 通过 Graph 节点 + A2A 远程 Agent 扩展，三者均未在 README 中提及 “Skill” 作为独立抽象概念。

7. 参考文献

1. LangChain4j GitHub Repository — https://github.com/langchain4j/langchain4j
2. Spring AI GitHub Repository — https://github.com/spring-projects/spring-ai
3. Spring AI Alibaba GitHub Repository — https://github.com/alibaba/spring-ai-alibaba
4. AgentScope Java GitHub Repository — https://github.com/agentscope-ai/agentscope-java
5. OpenJiuWen Core Java GitCode Repository — https://gitcode.com/openJiuwen/agent-core-java ；GitHub Mirror — https://github.com/openJiuwen-ai/agent-core-java
6. Spring AI 官方参考文档
7. Spring AI Alibaba 官方文档（Java2AI）
8. AgentScope Java 2.0 官方文档
9. LangChain4j 官方文档
10. openJiuwen 社区 — https://gitcode.com/openJiuwen/community
11. Microsoft and LangChain4j Partnership
12. Spring AI 2.0 模块重构
13. Spring AI 1.1 GA Release