20K Java+AI 岗位高频考点 — AI Agent是2025-2026最热门方向,面试高频考察Agent原理、工具调用、记忆系统、多Agent协作。覆盖ReAct模式、Function Calling、Spring AI Agent、多智能体架构。
Agent = LLM + 感知 + 决策 + 行动 + 记忆
vs 传统自动化:
传统:固定规则 → 固定流程
Agent:LLM理解 → 自主决策 → 灵活行动
vs RAG:
RAG:检索 → 生成(固定管道)
Agent:判断是否需要检索 → 决定检索策略 → 评估结果 → 自主调整
核心能力:
1. 自主决策:判断下一步做什么
2. 工具使用:调用外部工具/API
3. 记忆管理:维护上下文和长期知识
4. 自我反思:评估和修正自己的输出
感知 → 推理 → 行动 → 反馈(循环)
User Query → Agent
↓
[分析意图] → 简单问题?→ 直接回答
↓ 复杂
[规划步骤] → Step1, Step2, Step3...
↓
[执行Step1] → 调用工具/检索/计算
↓
[评估结果] → 不满意 → [重新规划]
↓ 满意
[执行Step2] → ...
↓
[综合回答] → 返回最终答案(带引用)
ReAct = Reasoning + Acting 交替执行
循环:
1. Thought(推理):分析当前状态,决定下一步
2. Action(行动):选择并执行工具
3. Observation(观察):获取工具返回结果
4. 重复直到完成任务
示例:
用户:帮我查一下北京到上海的机票,选最便宜的
Thought: 需要搜索机票信息
Action: search_flights(origin="北京", destination="上海", date="2025-06-10")
Observation: 东方航空MU5101 ¥680, 南航CZ3102 ¥720, 国航CA1501 ¥750
Thought: 找到最便宜的是东方航空MU5101,¥680
Action: 无需更多操作
Answer: 最便宜的航班是东方航空MU5101,北京→上海,票价¥680。
vs ReAct:
ReAct:每步都思考→行动→观察(短期规划)
Plan-Execute:先做完整规划→逐步执行(长期规划)
流程:
1. 规划:LLM生成完整任务列表
2. 执行:按计划逐步执行
3. 重规划:如果某步失败,重新规划
适用:
- 复杂多步骤任务
- 需要全局视角的任务
- 任务间有依赖关系
流程:
1. 开发者定义可用工具(名称、描述、参数Schema)
2. 用户提问
3. LLM判断需要调用哪个工具,生成调用参数
4. 应用执行工具,返回结果
5. LLM基于结果生成最终回答
工具定义(OpenAI格式):
{
"name": "search_orders",
"description": "搜索用户的订单",
"parameters": {
"type": "object",
"properties": {
"user_id": {"type": "string", "description": "用户ID"},
"status": {"type": "string", "enum": ["pending", "completed", "cancelled"]}
},
"required": ["user_id"]
}
}
@Configuration
public class AgentToolConfig {
@Bean
public ChatClient agentClient(ChatClient.Builder builder) {
return builder
.defaultSystem("你是订单管理助手,可以查询和管理用户订单。")
.defaultTools(new OrderTools())
.build();
}
}
@Component
public class OrderTools {
@Autowired OrderService orderService;
@Tool(description = "根据用户ID查询订单列表")
public List<OrderDTO> searchOrders(
@ToolParam(description = "用户ID") String userId,
@ToolParam(description = "订单状态") String status
) {
return orderService.findByUserAndStatus(userId, status);
}
@Tool(description = "取消订单")
public String cancelOrder(
@ToolParam(description = "订单ID") String orderId,
@ToolParam(description = "取消原因") String reason
) {
orderService.cancel(orderId, reason);
return "订单已取消";
}
}
好的工具设计:
1. 单一职责:每个工具做一件事
2. 描述清晰:LLM能准确判断何时使用
3. 参数有约束:枚举值、范围限制
4. 返回结构化:方便LLM理解结果
5. 错误处理:返回可理解的错误信息
工具粒度:
- 太粗:search_database(LLM不知道搜什么)
- 太细:search_by_id, search_by_name, search_by_date
- 合适:search_orders(userId, status, dateRange)
安全考虑:
- 只读工具 vs 写操作工具分开
- 写操作需要确认步骤
- 限制调用频率
// Spring AI MCP客户端
@Bean
public MCPClient mcpClient() {
return MCPClient.builder()
.transport(new StdioTransport("npx", "-y", "@anthropic/mcp-server-filesystem", "/data"))
.build();
}
// MCP工具自动注册为Spring AI Tool
@Bean
public ChatClient mcpAgent(ChatClient.Builder builder, MCPClient mcpClient) {
return builder
.defaultTools(mcpClient.getTools())
.build();
}
| 类型 | 说明 | 存储 | 示例 |
|---|---|---|---|
| 短期记忆 | 当前对话上下文 | 内存/Redis | 对话历史 |
| 工作记忆 | 当前任务的中间结果 | 内存 | 工具调用结果 |
| 长期记忆 | 用户偏好/知识 | 向量库/DB | 用户画像 |
| 情景记忆 | 历史交互经历 | 向量库 | 过去的对话 |
// 对话记忆
@Bean
public ChatClient chatClient(ChatClient.Builder builder) {
ChatMemory memory = new InMemoryChatMemory(); // 生产用Redis
return builder
.defaultAdvisors(MessageChatMemoryAdvisor.builder(memory).build())
.build();
}
// 使用
chatClient.prompt()
.user("帮我查一下最近的订单")
.advisors(a -> a.param("chat_memory_conversation_id", "user-123"))
.call().content();
@Service
public class AgentMemoryService {
@Autowired VectorStore vectorStore;
@Autowired ChatClient chatClient;
// 保存重要信息到长期记忆
public void saveImportantFact(String userId, String fact) {
Document doc = new Document(fact, Map.of("userId", userId, "type", "fact"));
vectorStore.add(List.of(doc));
}
// 检索相关记忆
public String recallRelevantMemories(String userId, String query) {
List<Document> memories = vectorStore.search(
SearchRequest.builder().query(query).topK(5)
.filterExpression("userId == '" + userId + "'").build());
return memories.stream().map(Document::getContent).collect(joining("\n"));
}
// 融入Agent上下文
public String chat(String userId, String question) {
String memories = recallRelevantMemories(userId, question);
return chatClient.prompt()
.system("你记得以下关于用户的信息:\n" + memories)
.user(question)
.call().content();
}
}
模式一:主从(Master-Worker)
Master Agent → 分配任务 → Worker Agent 1, 2, 3
适用:任务明确的场景
模式二:辩论(Debate)
Agent A提出方案 → Agent B质疑 → Agent C评审 → 最终决策
适用:需要多角度验证的场景
模式三:层级(Hierarchical)
Manager Agent → Specialist Agents → Worker Agents
适用:复杂任务的分层处理
模式四:黑板(Blackboard)
共享状态空间 → 多Agent并发读写 → 协调器调度
适用:知识密集型协作
@Service
public class MultiAgentService {
@Autowired @Qualifier("planner") ChatClient planner;
@Autowired @Qualifier("coder") ChatClient coder;
@Autowired @Qualifier("reviewer") ChatClient reviewer;
public String developFeature(String requirement) {
// Step 1: Planner规划
String plan = planner.prompt()
.system("你是架构师,根据需求生成技术方案。")
.user(requirement).call().content();
// Step 2: Coder编码
String code = coder.prompt()
.system("你是高级开发,根据方案编写代码。")
.user("方案:\n" + plan).call().content();
// Step 3: Reviewer审查
String review = reviewer.prompt()
.system("你是代码审查专家,检查代码质量。")
.user("代码:\n" + code).call().content();
// Step 4: 根据Review修改(如果需要)
if (review.contains("需要修改")) {
code = coder.prompt()
.user("根据Review修改代码:\n" + review + "\n原代码:\n" + code)
.call().content();
}
return code;
}
}
// 基于消息队列的Agent通信
@Service
public class AgentMessageBus {
@Autowired RedisTemplate<String, String> redisTemplate;
public void send(String fromAgent, String toAgent, String message) {
String payload = Map.of("from", fromAgent, "to", toAgent,
"content", message, "timestamp", Instant.now().toString()).toString();
redisTemplate.opsForList().rightPush("agent:inbox:" + toAgent, payload);
}
public String receive(String agentName) {
return redisTemplate.opsForList().leftPop("agent:inbox:" + agentName);
}
}
核心指标:
1. 任务完成率:成功完成的任务比例
2. 工具调用准确率:选择正确工具的比例
3. 平均步骤数:完成任务所需的步骤数
4. Token消耗:总Token使用量
5. 延迟:端到端响应时间
6. 幻觉率:编造不存在的工具调用结果
评估方法:
1. Golden Set:预定义正确答案集
2. LLM-as-Judge:用LLM评估输出质量
3. 人工评估:专家评审
4. 回归测试:确保改进不引入退化
@Configuration
public class AgentObservability {
@Bean
public ChatClient observableClient(ChatClient.Builder builder) {
return builder
.defaultAdvisors(
SimpleLoggerAdvisor.builder().build(), // 日志
new TokenCountAdvisor() // Token计数
)
.build();
}
}
// 自定义Advisor记录工具调用
@Component
public class ToolCallLoggerAdvisor implements CallAdvisor {
@Override
public AdvisedResponse adviseCall(AdvisedRequest request, CallAdvisorChain chain) {
long start = System.currentTimeMillis();
AdvisedResponse response = chain.nextAdvise(request);
long duration = System.currentTimeMillis() - start;
log.info("Agent call: query={}, tools={}, tokens={}, duration={}ms",
request.userText(),
response.toolCalls(),
response.tokenUsage(),
duration);
return response;
}
}
| 维度 | RAG | Agent | Fine-tuning |
|---|---|---|---|
| 自主性 | 低 | 高 | 无 |
| 知识更新 | 实时 | 实时 | 需重训 |
| 工具使用 | 无 | 有 | 无 |
| 复杂推理 | 弱 | 强 | 中 |
| 成本 | 中 | 高 | 高 |
| 适用 | 知识问答 | 复杂任务 | 风格定制 |
架构分层:
1. 意图识别层:分类用户意图(简单问答/复杂任务)
2. 路由层:分发到对应Agent
3. Agent层:执行具体任务
4. 工具层:外部工具/API调用
5. 记忆层:对话历史/长期知识
6. 安全层:权限控制/审计日志
7. 监控层:质量/成本/性能监控
技术选型:
- 框架:Spring AI 2.0
- 模型:GPT-4o / Claude / 通义千问
- 记忆:Redis + Milvus
- 工具:MCP协议
- 监控:OpenTelemetry + Grafana
风险:
1. 工具滥用:Agent调用不应调用的工具
2. 权限泄露:获取超出范围的权限
3. Prompt注入:通过输入控制Agent行为
4. 数据泄露:Agent访问敏感数据
5. 无限循环:Agent陷入循环不断调用
防御:
1. 工具白名单:限制可用工具
2. 权限最小化:每个Agent只有必要权限
3. 调用次数限制:防止无限循环
4. 人工确认:高危操作需人工审批
5. 审计日志:记录所有Agent操作
1. 自主性增强:从辅助工具→独立执行
2. 多模态Agent:理解图片、音频、视频
3. Agent编排:多Agent自动协作
4. 垂直领域Agent:法律/医疗/金融专用
5. Agent开发平台:低代码/无代码构建
6. 标准化:MCP/ACP等协议统一
Java工程师优势:
- 企业级系统集成经验
- Spring AI生态成熟
- 工程化能力强
- 安全和可观测性经验丰富
Agent四要素:感知(输入) → 推理(思考) → 行动(工具) → 反馈(评估)
>
工具设计三原则:单一职责、描述清晰、参数约束
>
记忆三类型:短期(对话)、工作(任务中间态)、长期(知识库)
>
多Agent四模式:主从、辩论、层级、黑板