← 返回首页 ❓ 面试题库
📑 本篇章节导航 (共9章,点击直达)
一、Spring AI 2.0架构二、Advisors机制三、Tool Calling四、RAG集成五、MCP协议六、Structured Output七、Observability八、面试高频综合题面试速记口诀

Q111 Spring AI 2.0与MCP协议深度实战

20K Java+AI 岗位2025-2026最热考点 — Spring AI是Java生态AI应用开发的标准框架,MCP是连接AI与外部世界的协议标准。覆盖Spring AI 2.0架构、ChatClient/Advisors/VectorStore、MCP Server/Client、Tool Calling、Multi-Agent、Observability。

一、Spring AI 2.0架构

1. Spring AI 2.0的核心架构?


应用层: ChatClient / ChatModel
编排层: Advisors(拦截器链) + Tool Calling
集成层: VectorStore / Embedding / Image / Audio
传输层: OpenAI/Azure/Ollama/Bedrock/ZhiPu等Provider

2. Spring AI vs LangChain4j对比?

维度Spring AILangChain4j
生态Spring生态,无缝集成Boot独立框架,轻量接入
模型支持OpenAI/Azure/Ollama/Bedrock等更多Provider覆盖
向量库Milvus/Redis/PgVector/Chroma等更多选择
MCP原生支持(官方实现)社区支持
编排Advisor链式架构Chain/Agent模式
适用Spring Boot项目首选轻量/非Spring项目

选型建议:Spring Boot项目用Spring AI,非Spring项目或需要更多Provider选LangChain4j。

3. ChatClient的使用?


// 构建ChatClient
ChatClient chatClient = ChatClient.builder(chatModel)
    .defaultSystem("你是Java技术专家,回答要简洁准确")
    .defaultAdvisors(new MessageChatMemoryAdvisor(chatMemory))
    .build();

// 同步调用
String response = chatClient.prompt()
    .user("什么是AQS?请简要说明")
    .call()
    .content();

// 流式调用
Flux<String> stream = chatClient.prompt()
    .user("解释Java线程池核心参数")
    .stream()
    .content();

核心要点:ChatClient是高层API,底层委托给ChatModel。支持同步/流式两种调用模式,defaultSystem设置系统提示,defaultAdvisors注册拦截器。

4. Spring AI的Model抽象体系?


Model接口层级:
  Model<TReq, TRes>
    ├── ChatModel          → 文本对话(GPT-4o/Qwen/DeepSeek)
    ├── EmbeddingModel     → 文本向量化(text-embedding-3)
    ├── ImageModel         → 图片生成(DALL-E/Stable Diffusion)
    ├── AudioModel         → 语音处理(Whisper/TTS)
    └── ToolCallingModel   → 工具调用(函数调用能力)

5. Spring AI的配置方式?


spring:
  ai:
    openai:
      api-key: ${OPENAI_API_KEY}
      base-url: https://api.openai.com  # 可换成国内代理
      chat:
        options:
          model: gpt-4o
          temperature: 0.7
          max-tokens: 2048
      embedding:
        options:
          model: text-embedding-3-small
    # 国产模型配置示例(智谱AI)
    zhipuai:
      api-key: ${ZHIPU_API_KEY}
      chat:
        options:
          model: glm-4-plus

多Provider切换:改spring.ai.*前缀即可。OpenAI/ZhiPu/Ollama/Azure/Bedrock配置结构类似。生产环境api-key走配置中心或环境变量,不硬编码。


二、Advisors机制

6. Advisor是什么?

7. 如何自定义Advisor?


public class LoggingAdvisor implements CallAroundAdvisor {

    @Override
    public String getName() {
        return "LoggingAdvisor";
    }

    @Override
    public int getOrder() {
        return 100; // 数字越小优先级越高
    }

    @Override
    public AdvisedResponse aroundCall(AdvisedRequest request,
                                       CallAroundAdvisorChain chain) {
        log.info("[AI请求] user: {}", request.userText());
        long start = System.currentTimeMillis();

        AdvisedResponse response = chain.nextAroundCall(request);

        long cost = System.currentTimeMillis() - start;
        String content = response.response().getResult().getOutput().getText();
        log.info("[AI响应] cost={}ms, content={}", cost,
                content.length() > 200 ? content.substring(0, 200) + "..." : content);
        return response;
    }
}

关键点:实现CallAroundAdvisor接口,chain.nextAroundCall()调用下一个Advisor。getOrder()控制执行顺序。

8. 内置Advisor有哪些?

Advisor作用典型场景
MessageChatMemoryAdvisor对话记忆管理多轮对话保持上下文
SimpleLoggerAdvisor请求/响应日志开发调试
SafeGuardAdvisor安全过滤防止敏感信息泄露
QuestionAnswerAdvisorRAG检索增强基于文档的问答
RetryAdvisor重试机制模型调用失败自动重试

组合使用:多个Advisor按order值排序,形成完整的处理链。生产环境通常组合记忆+日志+安全+RAG。

9. 如何实现对话记忆?


@Bean
ChatClient chatClient(ChatModel model) {
    // 开发环境用内存存储
    ChatMemory memory = new InMemoryChatMemory();

    // 生产环境用Redis持久化
    // ChatMemory memory = new RedisChatMemory(redisTemplate);

    return ChatClient.builder(model)
        .defaultSystem("你是客服助手")
        .defaultAdvisors(new MessageChatMemoryAdvisor(memory))
        .build();
}

// 调用时指定会话ID,自动维护历史
String response = chatClient.prompt()
    .user("我想查一下我的订单")
    .advisors(a -> a.param("chat_memory_conversation_id", "user-123"))
    .call()
    .content();

原理:MessageChatMemoryAdvisor在请求前从存储加载历史消息,在响应后将新消息存入存储。conversationId隔离不同会话。

10. Advisor的执行顺序?


请求方向(正序):
  LoggingAdvisor → MemoryAdvisor → SafeGuardAdvisor → LLM

响应方向(倒序):
  LLM → SafeGuardAdvisor → MemoryAdvisor → LoggingAdvisor

类似Filter链:
  A.before → B.before → C.before → 实际调用 → C.after → B.after → A.after

三、Tool Calling

11. 什么是Tool Calling?

12. Spring AI的Tool Calling实现?


// 定义工具类
@Service
public class OrderTools {

    @Tool(description = "查询用户订单列表,返回订单摘要信息")
    public List<OrderVO> queryOrders(
            @ToolParam(description = "用户ID") Long userId,
            @ToolParam(description = "订单状态:PAID/SHIPPED/COMPLETED") String status) {
        return orderService.findByUserAndStatus(userId, status);
    }

    @Tool(description = "取消指定订单")
    public String cancelOrder(
            @ToolParam(description = "订单号") String orderId,
            @ToolParam(description = "取消原因") String reason) {
        orderService.cancel(orderId, reason);
        return "订单" + orderId + "已取消";
    }
}

// 注册到ChatClient
ChatClient chatClient = ChatClient.builder(model)
    .defaultTools(orderTools)
    .build();

// 用户问"帮我查一下用户1001的待发货订单"→LLM自动调用queryOrders(1001, "PAID")

13. Tool Calling的完整流程?


1. 用户: "北京今天天气怎么样?"
2. LLM决策: 需要调用getWeather工具,参数={city: "北京"}
3. 应用执行: getWeather("北京") → "晴天,25°C"
4. 工具结果返回LLM
5. LLM生成最终回答: "北京今天天气晴朗,气温25度,适合外出。"

14. 如何实现数据库查询Tool?


@Service
public class DatabaseTools {

    private final JdbcTemplate jdbcTemplate;

    @Tool(description = "执行SQL查询,返回JSON结果。仅支持SELECT语句。")
    public String executeQuery(
            @ToolParam(description = "SQL查询语句,只允许SELECT") String sql) {
        // 安全校验:只允许SELECT
        String trimmed = sql.trim().toUpperCase();
        if (!trimmed.startsWith("SELECT")) {
            return "错误:只允许查询操作(SELECT)";
        }
        // 禁止危险操作
        if (trimmed.contains("DROP") || trimmed.contains("DELETE") ||
            trimmed.contains("UPDATE") || trimmed.contains("INSERT")) {
            return "错误:检测到不允许的SQL操作";
        }
        try {
            List<Map<String, Object>> result = jdbcTemplate.queryForList(sql);
            return new ObjectMapper().writeValueAsString(result);
        } catch (Exception e) {
            return "查询执行失败:" + e.getMessage();
        }
    }
}

15. Tool的安全注意事项?


四、RAG集成

16. Spring AI的RAG架构?


离线写入流程:
  文档(Document) → TextSplitter(分块) → EmbeddingModel(向量化) → VectorStore(存储)

在线查询流程:
  用户问题 → Embedding(向量化) → VectorStore.similaritySearch(检索)
           → QuestionAnswerAdvisor(注入上下文) → LLM(生成回答)

17. VectorStore的使用?


// 配置PgVector向量库
@Bean
VectorStore vectorStore(JdbcTemplate jdbcTemplate, EmbeddingModel embeddingModel) {
    return new PgVectorStore(jdbcTemplate, embeddingModel);
}

// 添加文档
List<Document> documents = List.of(
    new Document("Java并发编程中,synchronized是内置锁...", Map.of("source", "java-guide")),
    new Document("volatile保证可见性但不保证原子性...", Map.of("source", "juc-notes"))
);
vectorStore.add(documents);

// 相似度检索
List<Document> results = vectorStore.similaritySearch(
    SearchRequest.builder()
        .query("Java锁机制")
        .topK(5)
        .similarityThreshold(0.7)
        .build()
);
// results即为与"Java锁机制"最相关的5个文档片段

18. Spring AI支持的向量库?

向量库特点适用场景
PgVectorPostgreSQL扩展,SQL生态已有PG库的项目首选
Milvus高性能分布式大规模向量检索
Redis基于RediSearch缓存+向量一体化
Chroma轻量级Python向量库开发测试
Pinecone全托管云服务免运维场景
Weaviate语义搜索引擎复杂语义查询
Elasticsearch向量+全文混合检索已有ES基础设施

Java项目推荐:PgVector(简单)或Milvus(大规模)。

19. Document ETL Pipeline?


// 1. 读取文档
DocumentReader reader = new TextReader(new ClassPathResource("docs/java-guide.txt"));
// PDF文档: new PagePdfDocumentReader(resource)
// Word文档: new WordDocumentReader(resource)

// 2. 文档分块
TextSplitter splitter = new TokenTextSplitter(
    800,    // 每块最大Token数
    200,    // 相邻块重叠Token数
    5,      // 最小块大小
    10000,  // 最大块大小
    true    // 是否保留分隔符
);

// 3. 处理并存储
List<Document> documents = splitter.apply(reader.get());
vectorStore.add(documents);

// 完整Pipeline
@Bean
ETLPipeline etlPipeline(DocumentReader reader, TextSplitter splitter, VectorStore store) {
    return new ETLPipeline(reader, splitter, store);
}

20. RAG Advisor的使用?


@Bean
ChatClient ragChatClient(ChatModel model, VectorStore store) {
    return ChatClient.builder(model)
        .defaultSystem("基于以下参考信息回答问题,如果参考信息中没有相关内容,请说明。")
        .defaultAdvisors(new QuestionAnswerAdvisor(store))
        .build();
}

// 调用:自动检索相关文档注入上下文
String answer = chatClient.prompt()
    .user("什么是Java的CAS操作?")
    .call()
    .content();
// QuestionAnswerAdvisor自动:
// 1.将"什么是CAS"向量化
// 2.从VectorStore检索相关文档
// 3.注入到Prompt上下文
// 4.LLM基于上下文生成回答

五、MCP协议

21. MCP(Model Context Protocol)是什么?

22. MCP的核心概念?

概念说明类比
MCP Server提供工具/资源/提示的服务端Web API服务
MCP Client连接MCP Server的客户端HTTP客户端
ToolsServer暴露的可调用函数REST接口
ResourcesServer暴露的数据资源文件/数据源
PromptsServer暴露的Prompt模板模板引擎
Transport通信方式HTTP/TCP

23. Spring AI MCP Server实现?


@Configuration
public class McpServerConfig {

    @Bean
    public McpSyncServer mcpServer() {
        return McpServer.sync()
            .serverInfo("order-tools", "1.0.0")
            .tool(queryOrderTool())
            .tool(createOrderTool())
            .resource(orderSchemaResource())
            .prompt(orderQueryPrompt())
            .build();
    }

    private McpServerFeatures.SyncToolSpecification queryOrderTool() {
        return new McpServerFeatures.SyncToolSpecification(
            new Tool("queryOrder", "根据订单号查询订单详情",
                // JSON Schema定义参数
                """{"type":"object","properties":{
                    "orderId":{"type":"string","description":"订单号"}
                },"required":["orderId"]}"""),
            (exchange, args) -> {
                String orderId = (String) args.get("orderId");
                Order order = orderService.findById(orderId);
                return new CallToolResult(List.of(
                    new TextContent(objectMapper.writeValueAsString(order))
                ));
            }
        );
    }
}

24. MCP Client连接?


@Configuration
public class McpClientConfig {

    @Bean
    public SyncMcpClient mcpClient() {
        return SyncMcpClient.builder()
            .transport(new HttpMcpTransport(
                "http://localhost:3000/mcp"))
            .build();
    }

    // 自动发现Server的工具并注册为Spring AI Tool
    @Bean
    public ToolCallbackProvider mcpToolProvider(SyncMcpClient client) {
        // 连接Server,获取所有工具定义
        var tools = client.listTools();
        // 转换为Spring AI ToolCallback
        return SyncMcpToolCallbackProvider.builder()
            .mcpClient(client)
            .build();
    }
}

关键:MCP Client连接Server后,自动发现其工具,并注册为Spring AI的Tool,无缝集成。

25. MCP vs Function Calling?

维度Function CallingMCP
定义者各模型厂商(OpenAI/Google等)Anthropic提出,开放标准
范围单模型接口规范跨厂商跨应用协议
能力只有函数调用工具+资源+提示
通信API调用stdio/SSE/HTTP
复用性绑定模型一次开发,多AI应用复用
生态各厂商自定义统一标准,生态丰富

结论:Function Calling是单厂商能力,MCP是行业标准。两者互补,不冲突。

26. MCP的Transport方式?

Transport方式适用场景
stdio本地进程标准输入输出IDE插件、CLI工具
SSEHTTP Server-Sent EventsWeb应用(旧版)
Streamable HTTP无状态HTTP请求新版推荐,支持无状态部署

# stdio方式(本地进程)
spring:
  ai:
    mcp:
      client:
        stdio:
          servers-configuration: classpath:mcp-servers.json

# HTTP方式(远程服务)
spring:
  ai:
    mcp:
      client:
        http:
          base-url: http://localhost:3000/mcp

选型:本地工具用stdio,远程服务用Streamable HTTP。

27. 如何将Spring Boot应用变成MCP Server?


<!-- pom.xml添加依赖 -->
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-mcp-server-spring-boot-starter</artifactId>
</dependency>

# application.yml
spring:
  ai:
    mcp:
      server:
        name: my-tools-server
        version: 1.0.0
        type: SYNC
        sse-message-endpoint: /mcp/messages

// 自动将@Tool方法暴露为MCP Tools
@Service
public class MyTools {
    @Tool(description = "获取当前时间")
    public String getCurrentTime() {
        return LocalDateTime.now().toString();
    }
}
// 无需额外配置,Starter自动完成MCP Server注册

28. MCP的实际应用场景?


六、Structured Output

29. 结构化输出的意义?

30. Spring AI的结构化输出?


// 定义输出结构(支持Record/POJO)
record OrderInfo(
    String orderId,
    String status,
    BigDecimal amount,
    LocalDateTime createTime
) {}

// 调用并自动映射
OrderInfo order = chatClient.prompt()
    .user("提取订单信息:订单号12345,已发货,金额99.9元,2025-01-15下单")
    .call()
    .entity(OrderInfo.class);

// order.orderId() == "12345"
// order.status() == "已发货"
// order.amount() == 99.9

// 支持List输出
record MovieReview(String title, int rating, String comment) {}
List<MovieReview> reviews = chatClient.prompt()
    .user("分析这三部电影的评价...")
    .call()
    .entity(new ParameterizedTypeReference<List<MovieReview>>() {});

31. 如何保证输出格式?


// 1. 使用BeanOutputConverter显式控制
BeanOutputConverter<OrderInfo> converter =
    new BeanOutputConverter<>(OrderInfo.class);

String response = chatClient.prompt()
    .user(u -> u.text("提取订单信息:{info}\n{format}")
        .param("info", "订单号12345,已发货,99.9元")
        .param("format", converter.getFormat()))
    .call()
    .content();

OrderInfo order = converter.convert(response);

// 2. 配合重试保证成功率
// 3. Schema约束越严格,成功率越高(必填字段、枚举值)
// 4. Prompt中明确格式要求和示例

32. Enum输出控制?


// 情感分析
enum Sentiment { POSITIVE, NEGATIVE, NEUTRAL }

Sentiment sentiment = chatClient.prompt()
    .user("分析情感:这个产品质量很好,物流也快")
    .call()
    .entity(Sentiment.class);
// → POSITIVE

// 文本分类
enum Category { TECH, FINANCE, SPORTS, ENTERTAINMENT, OTHER }

Category category = chatClient.prompt()
    .user("分类:苹果发布新款MacBook Pro")
    .call()
    .entity(Category.class);
// → TECH

底层原理:Spring AI将Enum转成JSON Schema的enum约束,LLM被限制只能输出合法枚举值。


七、Observability

33. Spring AI的Observability?


监控体系:
  Spring AI → Micrometer → Prometheus → Grafana

核心指标:
  ai.chat.tokens.input     → 输入Token数
  ai.chat.tokens.output    → 输出Token数
  ai.chat.latency          → 调用延迟
  ai.chat.errors           → 错误次数
  ai.tool.call.latency     → 工具调用延迟
  ai.tool.call.errors      → 工具调用错误

34. Token用量监控?


@Component
public class TokenUsageAdvisor implements CallAroundAdvisor {

    private final MeterRegistry meterRegistry;

    @Override
    public AdvisedResponse aroundCall(AdvisedRequest request,
                                       CallAroundAdvisorChain chain) {
        AdvisedResponse response = chain.nextAroundCall(request);
        Usage usage = response.response().getMetadata().getUsage();

        // 记录Token指标
        meterRegistry.counter("ai.tokens.input",
            "model", request.model()).increment(usage.getPromptTokens());
        meterRegistry.counter("ai.tokens.output",
            "model", request.model()).increment(usage.getGenerationTokens());

        // 计算成本(以GPT-4o为例)
        double cost = usage.getPromptTokens() * 0.0000025
                    + usage.getGenerationTokens() * 0.00001;
        meterRegistry.counter("ai.cost.usd",
            "model", request.model()).increment(cost);

        return response;
    }
}

35. AI应用的告警策略?

告警项阈值原因
Token用量突增日用量超均值3倍成本失控/Prompt注入攻击
P99延迟> 5秒用户体验差/模型过载
错误率> 5%模型不可用/配置错误
幻觉率抽检发现率>10%RAG检索质量差/Prompt问题
工具调用失败率> 3%下游服务异常

八、面试高频综合题

36. 如何回答"你们的Spring AI技术栈"?

"我们用Spring AI 2.0搭建AI中台。ChatClient + Advisor架构统一管理对话流程,Advisor链实现记忆/日志/RAG/安全四大增强。VectorStore用Milvus存储文档Embedding,支持千万级向量检索。Tool Calling让Agent调用订单/库存等内部API,实现业务自动化。MCP协议标准化工具注册和发现,各部门服务统一MCP Server化。Observability做Token监控和成本管控,月度成本降低40%。"

37. Spring AI 2.0 GA的核心变更?

38. 如何选择OpenAI兼容的模型?

场景推荐模型理由
通用对话GPT-4o综合能力最强
企业合规Azure OpenAI数据不训练、SLA保障
国内替代智谱GLM-4 / DeepSeek-V3无需翻墙、性价比高
本地部署Ollama + Qwen2.5数据不出内网
性价比DeepSeek-V3效果接近GPT-4,价格1/10
代码场景Claude 3.5 Sonnet代码理解/生成最强

Spring AI统一接口,切换只改配置:spring.ai.openai.chat.options.model=xxx

39. AI应用的测试策略?


测试金字塔:
  ┌──────────────┐
  │  LLM-as-Judge │  ← 自动化质量评估(少量)
  ├──────────────┤
  │  Golden Set   │  ← 回归测试集(中等)
  ├──────────────┤
  │  Mock LLM    │  ← 单元测试(大量)
  └──────────────┘

40. Spring AI + MCP的企业落地?


企业AI中台架构:
  ┌─────────────────────────────────┐
  │          Spring Boot 应用        │
  │  ┌───────────────────────────┐  │
  │  │   Spring AI ChatClient     │  │
  │  │   + Advisor Chain          │  │
  │  └──────────┬────────────────┘  │
  │             │                    │
  │  ┌──────────▼────────────────┐  │
  │  │       MCP Client           │  │
  │  │   (工具发现 + 调用路由)     │  │
  │  └──┬───────┬───────┬───────┘  │
  └─────┼───────┼───────┼──────────┘
        │       │       │
   ┌────▼──┐ ┌─▼───┐ ┌─▼──────┐
   │订单    │ │库存  │ │知识库    │
   │MCP    │ │MCP  │ │MCP     │
   │Server │ │Server│ │Server  │
   └───────┘ └─────┘ └────────┘
   ┌─────────────────────────────┐
   │  Milvus(VectorStore)        │
   │  Prometheus(Observability)  │
   └─────────────────────────────┘

41. Chat Memory的实现方案?

方案存储适用场景特点
InMemoryChatMemory内存开发测试重启丢失
RedisChatMemoryRedis生产环境高性能持久化
JdbcChatMemory数据库需要持久化可查询可审计
WindowedChatMemory装饰器控制Token只保留最近N轮
SummarizingChatMemory装饰器长对话旧消息压缩为摘要

// 组合使用:Redis存储 + 窗口限制 + 摘要压缩
ChatMemory memory = new SummarizingChatMemory(
    new WindowedChatMemory(
        new RedisChatMemory(redisTemplate),
        10  // 最近10轮
    ),
    chatModel  // 用LLM做摘要
);

42. 如何实现AI应用的灰度发布?


// 1. Feature Flag控制新旧Prompt
@Value("${ai.prompt.version:v1}")
private String promptVersion;

// 2. 模型路由(A/B分流)
public ChatModel routeModel(String userId) {
    if (abTestService.inGroup(userId, "experimental")) {
        return gpt4oModel;      // 实验组:新模型
    }
    return deepSeekModel;        // 对照组:稳定模型
}

// 3. 灰度策略
// - 按用户ID哈希分流(5% → 10% → 50% → 100%)
// - 按地域/租户/业务线灰度
// 4. 效果对比Dashboard
// - 对比两组的:回答质量评分 / Token消耗 / 用户满意度

43. Spring AI的多模态支持?


// 图片生成
ImageResponse image = chatClient.prompt()
    .user("画一只JavaLogo风格的猫")
    .call()
    .image();  // ImageModel: DALL-E / Stable Diffusion

// 语音转文字(Whisper)
AudioTranscriptionResponse transcription = audioModel.transcribe(
    new AudioTranscriptionPrompt(new ClassPathResource("meeting.wav"))
);

// 文字转语音(TTS)
byte[] speech = audioModel.synthesize(
    new AudioSynthesisPrompt("欢迎使用AI助手")
);

// 多模态输入(图片理解)
String response = chatClient.prompt()
    .user(u -> u.text("描述这张图片的内容")
        .media(Media.ImageMimeType.PNG, imageResource))
    .call()
    .content();

44. AI应用的错误处理?


@Component
public class FaultToleranceAdvisor implements CallAroundAdvisor {

    @Override
    public AdvisedResponse aroundCall(AdvisedRequest request,
                                       CallAroundAdvisorChain chain) {
        try {
            return chain.nextAroundCall(request);
        } catch (ModelClientException e) {
            // 模型不可用 → 降级到备用模型
            log.warn("主模型不可用,降级到备用模型: {}", e.getMessage());
            return callWithFallback(request);
        } catch (TokenLimitExceededException e) {
            // Token超限 → 截断上下文重试
            log.warn("Token超限,截断上下文重试");
            return callWithTruncatedContext(request);
        }
    }
}

// 工具调用失败 → 重试+默认值
@Retryable(maxAttempts = 3, fallbackMethod = "defaultWeather")
@Tool(description = "查询天气")
public String getWeather(String city) { ... }

public String defaultWeather(String city) {
    return "暂时无法获取天气信息";
}

45. Spring AI的流式输出?


// 流式输出(SSE推送到前端)
@GetMapping(value = "/chat/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
public Flux<String> streamChat(@RequestParam String message) {
    return chatClient.prompt()
        .user(message)
        .stream()
        .content();
}

// 前端接收(JavaScript)
const eventSource = new EventSource("/chat/stream?message=解释Java线程池");
eventSource.onmessage = (event) => {
    document.getElementById("response").textContent += event.data;
};

// 流式结构化输出
Flux<OrderInfo> orderStream = chatClient.prompt()
    .user("提取订单列表")
    .stream()
    .entities(OrderInfo.class);

46. Guardrails安全护栏?


// 输入Guardrail:防止Prompt注入
public class InputGuardrailAdvisor implements CallAroundAdvisor {
    private static final List<String> DANGEROUS_PATTERNS = List.of(
        "ignore previous instructions",
        "system:",
        "你是一个"
    );

    @Override
    public AdvisedResponse aroundCall(AdvisedRequest request,
                                       CallAroundAdvisorChain chain) {
        String userText = request.userText().toLowerCase();
        for (String pattern : DANGEROUS_PATTERNS) {
            if (userText.contains(pattern)) {
                throw new GuardrailException("检测到潜在的Prompt注入: " + pattern);
            }
        }
        return chain.nextAroundCall(request);
    }
}

// 输出Guardrail:过滤PII和有害内容
// 使用正则匹配手机号/身份证号并脱敏
// 使用LLM评估输出安全性(输出有害概率>阈值则拦截)

47. Spring AI的Evaluation框架?


// 1. RelevanceAdvisor - 评估检索相关性
@Bean
ChatClient evalChatClient(ChatModel model, VectorStore store) {
    return ChatClient.builder(model)
        .defaultAdvisors(
            QuestionAnswerAdvisor.builder(store)
                .relevanceThreshold(0.7)  // 相关性阈值
                .build()
        )
        .build();
}

// 2. LLM-as-Judge评分
record EvalResult(double relevance, double accuracy, double safety, String feedback) {}

EvalResult eval = chatClient.prompt()
    .user(u -> u.text("""
        评估以下回答的质量:
        问题:{question}
        回答:{answer}
        参考答案:{reference}
        从相关性(0-1)、准确性(0-1)、安全性(0-1)三个维度评分。
        """)
        .param("question", question)
        .param("answer", answer)
        .param("reference", reference))
    .call()
    .entity(EvalResult.class);

// 3. 自动化评估Pipeline:批量跑Golden Set → 生成评估报告

48. MCP在企业内部的推广?


推广路径:
  1. 工具MCP Server化:各部门将API封装为MCP Server
  2. 统一注册中心:MCP Registry(类似Nacos),管理所有Server
  3. 版本管理:Server版本化,Client按需升级
  4. 权限控制:OAuth2鉴权 + 工具级别授权
  5. 监控Dashboard:工具调用量/延迟/错误率可视化

示例架构:
  MCP Registry (注册中心)
    ├── order-service v2.1 (订单工具)
    ├── inventory-service v1.5 (库存工具)
    ├── knowledge-service v3.0 (知识库工具)
    └── notification-service v1.0 (通知工具)

  AI应用 → MCP Client → Registry发现 → 调用具体Server

49. AI应用的成本控制?


// 1. 模型路由 - 简单问题用小模型
public ChatModel routeByComplexity(String question) {
    if (question.length() < 50 && !question.contains("分析")) {
        return deepSeekModel;  // 便宜模型处理简单问题
    }
    return gpt4oModel;         // 复杂问题用强模型
}

// 2. 语义缓存 - 相似问题不重复调LLM
@Component
public class SemanticCacheAdvisor implements CallAroundAdvisor {
    @Override
    public AdvisedResponse aroundCall(AdvisedRequest request,
                                       CallAroundAdvisorChain chain) {
        // 将问题向量化,在缓存中查找相似问题
        float[] embedding = embeddingModel.embed(request.userText());
        CacheEntry cached = cacheService.findSimilar(embedding, 0.95);
        if (cached != null) {
            return cached.getResponse(); // 缓存命中,省一次LLM调用
        }
        AdvisedResponse response = chain.nextAroundCall(request);
        cacheService.put(embedding, response);
        return response;
    }
}

// 3. Token优化:精简Prompt、压缩历史、限制输出长度
// 4. 批量处理:非实时任务走Batch API,成本降50%
// 5. 监控告警:日Token消耗超预算自动通知

50. Spring AI的未来方向?

方向说明预期
Multi-Agent编排多Agent协作框架(类似CrewAI)2025-2026重点
MCP生态扩展更多工具MCP Server化持续增长
Agent Workflow DSL声明式Agent工作流定义社区提案中
Observability增强更细粒度的Tracing/Metrics持续完善
Java AI标准JSRJDK层面标准化AI接口长期目标
流式Agent流式Tool Calling + 流式推理已在开发
本地模型优化更好的Ollama/ONNX集成持续改进

面试速记口诀

Spring AI三核心:ChatClient(对话)、Advisor(拦截增强)、Tool Calling(工具调用)
MCP三要素:Tools(函数)、Resources(数据)、Prompts(模板)
RAG四步:Reader → Splitter → Embedding → VectorStore
工程化四件套:Observability监控、Guardrails安全、Structured Output格式、Cost Control成本