企业官网建设流程全解析

最近在尝试将 AI 能力集成到 Spring Boot 应用中时，发现很多开发者对 SpringAI 的认知还停留在简单的聊天接口调用上。实际上，SpringAI 框架提供了更强大的抽象，特别是其内置的评估器（Evaluator）和优化器（Optimizer）机制，它们是构建稳定、高效、可观测 AI 应用的关键。很多项目在落地时，因为忽略了评估与优化环节，导致模型响应不稳定、成本不可控、效果难以衡量。

本文将深入拆解 SpringAI 中的评估器与优化器，从核心概念、工作原理到实战应用，手把手带你构建一个具备自我评估与优化能力的 AI Agent。无论你是想为现有应用添加智能对话能力，还是正在规划一个全新的 AI 驱动项目，理解并运用这些组件，都能让你的系统更加健壮和智能。

1. 背景与核心概念：为什么需要评估与优化？

在传统的软件开发中，我们通过单元测试、集成测试和性能监控来保证代码质量。但在集成大语言模型（LLM）等 AI 服务时，情况变得复杂：模型的输出是非确定性的、受提示词（Prompt）影响巨大、调用成本（Token 消耗）直接关联费用、且响应质量难以用简单规则量化。

SpringAI 的评估器（Evaluator）和优化器（Optimizer）正是为了解决这些问题而生：

• 评估器（Evaluator）： 扮演“质检员”的角色。它的核心职责是对 AI 模型的输出结果进行质量评估。这不仅仅是检查语法错误，更包括：

  • 相关性评估： 输出是否紧扣用户问题？
  • 事实准确性评估： 输出内容是否存在事实性错误或“幻觉”？
  • 安全性评估： 输出是否包含有害、偏见或不安全的内容？
  • 成本评估： 本次调用消耗了多少 Token？成本是多少？
  • 自定义评估： 是否符合特定的业务规则（例如，生成的 SQL 语句是否能执行）？ 通过评估器，我们可以量化 AI 的表现，为后续的优化和决策提供数据依据。

• 优化器（Optimizer）： 扮演“调优师”的角色。它基于评估结果或其他策略，动态调整 AI 调用的输入参数，以追求更优的输出效果或更低的成本。常见的优化方向包括：

  • 提示词优化： 自动调整 Prompt 的措辞、结构或添加示例（Few-Shot），以获得更准确的回答。
  • 参数优化： 动态调整调用模型的temperature（创造性）、top_p（核采样）等参数，平衡输出的一致性与多样性。
  • 模型选择优化： 根据任务类型（创意写作 vs. 代码生成）或成本预算，自动选择最合适的底层模型（如 GPT-4 vs. GPT-3.5-Turbo）。
  • 链路优化： 在复杂的 Agent 工作流中，决定下一步执行哪个工具（Tool），或是否需要进行多轮思考（Chain-of-Thought）。

核心价值： 将评估与优化环节嵌入 AI 调用链路，使得应用不再是“黑盒”调用，而是形成了一个“调用 -> 评估 -> 优化 -> 再调用”的闭环系统。这极大地提升了 AI 应用的可靠性、可控性和经济性。

2. 环境准备与版本说明

在开始实战之前，我们需要搭建一个基础的 Spring Boot 项目并集成 SpringAI。

1. 基础环境要求：

• JDK: 17 或更高版本（SpringAI 推荐）
• 构建工具: Maven 或 Gradle（本文使用 Maven）
• IDE: IntelliJ IDEA, VS Code 或 Eclipse

2. 创建 Spring Boot 项目：可以通过 Spring Initializr 快速生成。选择以下依赖：

• Spring Web
• Spring AI (如果 Initializr 已集成) 或手动添加依赖

3. 关键依赖配置 (pom.xml):SpringAI 是一个相对较新的项目，其模块和版本迭代较快。请务必根据官方文档或仓库确认最新稳定版本。以下是一个示例配置：

<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <!-- 使用与SpringAI兼容的Spring Boot版本 --> <version>3.2.0</version> <relativePath/> </parent> <groupId>com.example</groupId> <artifactId>spring-ai-demo</artifactId> <version>0.0.1-SNAPSHOT</version> <name>spring-ai-demo</name> <description>Demo project for Spring AI Evaluator and Optimizer</description> <properties> <java.version>17</java.version> <!-- 指定SpringAI版本 --> <spring-ai.version>0.8.1</spring-ai.version> </properties> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <!-- Spring AI Core --> <dependency> <groupId>org.springframework.ai</groupId> <artifactId>spring-ai-core</artifactId> <version>${spring-ai.version}</version> </dependency> <!-- 以OpenAI为例，需要对应的Spring AI Starter --> <dependency> <groupId>org.springframework.ai</groupId> <artifactId>spring-ai-openai-spring-boot-starter</artifactId> <version>${spring-ai.version}</version> </dependency> <!-- 测试依赖 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> </dependencies> <dependencyManagement> <dependencies> <dependency> <groupId>org.springframework.ai</groupId> <artifactId>spring-ai-bom</artifactId> <version>${spring-ai.version}</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build> </project>

4. 配置文件 (application.yml):你需要一个 AI 模型供应商的 API Key。这里以 OpenAI 为例：

spring: application: name: spring-ai-demo ai: openai: api-key: ${OPENAI_API_KEY:your-openai-api-key-here} # 建议使用环境变量 chat: options: model: gpt-3.5-turbo # 默认模型 temperature: 0.7

重要提示： SpringAI 项目及各个供应商的 Starter 处于快速迭代中，上述版本和配置可能在未来发生变化。建议以 SpringAI 官方文档 和 GitHub 仓库为准。如果遇到依赖问题，检查 Spring Boot 与 SpringAI 的版本兼容性通常是第一步。

3. 核心组件拆解：评估器 (Evaluator) 详解

SpringAI 提供了多种评估器，用于从不同维度衡量 AI 输出的质量。理解它们的接口和用途是灵活运用的前提。

3.1 评估器核心接口评估器通常实现Evaluator接口或其变种。其核心方法是evaluate，接收 AI 的输入（Prompt）、输出（Response）以及可能的上下文（Context），返回一个评估结果对象，其中包含评分、原因、元数据等。

3.2 内置评估器示例SpringAI 可能提供一些基础评估器，但更强大的评估器往往需要结合模型本身或外部工具来实现。例如，我们可以用 AI 来评估 AI。

• 基于模型的评估器 (LLM-as-a-Judge)： 这是目前常见且有效的方法。即使用另一个 LLM（或同一个 LLM）作为裁判，根据预定标准评估输出。
• 自定义业务规则评估器： 针对特定场景，编写程序化规则进行评估。

3.3 实战：构建一个相关性评估器假设我们的应用是一个技术问答助手，我们需要确保 AI 的回答与用户的技术问题高度相关。

步骤1：定义评估请求和响应对象

// 文件路径：src/main/java/com/example/demo/evaluator/RelevanceEvaluationRequest.java package com.example.demo.evaluator; import org.springframework.ai.chat.prompt.Prompt; import org.springframework.ai.chat.messages.Message; /** * 相关性评估请求 */ public class RelevanceEvaluationRequest { private final Prompt userPrompt; // 用户的原始提问 private final Message aiResponse; // AI的回复 private String evaluationCriteria; // 评估标准描述 // 构造器、Getter和Setter省略... }

// 文件路径：src/main/java/com/example/demo/evaluator/RelevanceEvaluationResult.java package com.example.demo.evaluator; /** * 相关性评估结果 */ public class RelevanceEvaluationResult { private double score; // 相关性得分，0.0 ~ 1.0 private String reasoning; // 评估理由 private boolean passed; // 是否通过阈值 private String feedback; // 给优化器的反馈建议 // 构造器、Getter和Setter省略... }

步骤2：实现评估器这里我们实现一个简单的基于规则+关键词的评估器作为示例。在实际生产中，你可能会调用另一个 LLM 来进行更复杂的语义评估。

// 文件路径：src/main/java/com/example/demo/evaluator/SimpleRelevanceEvaluator.java package com.example.demo.evaluator; import org.springframework.ai.chat.prompt.Prompt; import org.springframework.ai.chat.messages.AssistantMessage; import org.springframework.stereotype.Component; import java.util.Arrays; import java.util.List; @Component public class SimpleRelevanceEvaluator { // 假设这些是用户问题中的核心关键词 private List<String> extractKeywords(String question) { // 这里简化处理，实际应用中可能需要使用NLP技术进行关键词提取 String[] commonTechWords = {"Spring", "Boot", "API", "数据库", "错误", "配置", "依赖", "Maven", "Gradle"}; return Arrays.stream(commonTechWords) .filter(question::contains) .toList(); } public RelevanceEvaluationResult evaluate(Prompt userPrompt, AssistantMessage aiResponse) { String question = userPrompt.getContents(); String answer = aiResponse.getContent(); List<String> keywords = extractKeywords(question); RelevanceEvaluationResult result = new RelevanceEvaluationResult(); if (keywords.isEmpty()) { result.setScore(0.5); result.setReasoning("问题中未检测到明确技术关键词，相关性评估基于通用性。"); } else { long matchCount = keywords.stream().filter(answer::contains).count(); double score = (double) matchCount / keywords.size(); result.setScore(score); result.setReasoning(String.format("问题包含%d个关键词，回答中匹配了%d个。", keywords.size(), matchCount)); } // 设置阈值，例如得分大于0.3则认为相关 result.setPassed(result.getScore() > 0.3); if (!result.isPassed()) { result.setFeedback("回答未能充分涵盖问题中的关键技术点，建议优化提示词或要求模型更聚焦。"); } else { result.setFeedback("回答相关性良好。"); } return result; } }

这个评估器虽然简单，但演示了核心逻辑：分析输入（问题）、检查输出（回答）、根据规则计算得分、给出结论和建议。在复杂场景中，extractKeywords和评分逻辑可以替换为调用一个评估专用 LLM 的流程。

4. 核心组件拆解：优化器 (Optimizer) 详解

优化器根据评估结果或预设策略，调整下一次 AI 调用的参数。它可以作用于Prompt、ChatOptions等对象。

4.1 优化器的触发时机

1. 前置优化： 在首次调用 AI 前，根据任务类型进行优化（如选择模型、设置基础 Prompt）。
2. 后置优化： 在获得评估结果后，对后续的调用进行优化（如发现回答不相关，则重写 Prompt 再次提问）。

4.2 常见的优化策略

• 提示词工程优化： 这是最常用的优化。根据评估的feedback，在原有 Prompt 前添加指令，如“请确保你的回答紧密围绕以下关键词：...”。
• 参数调优： 动态调整temperature。如果评估发现回答过于天马行空（temperature可能太高），则在下轮调用中降低该值。
• 模型路由： 如果当前模型（如 gpt-3.5-turbo）在复杂逻辑问题上连续得分低，可以自动切换到能力更强的模型（如 gpt-4）。

4.3 实战：构建一个提示词优化器基于上面相关性评估器的反馈，我们来构建一个优化器，当评估不通过时，自动优化 Prompt。

// 文件路径：src/main/java/com/example/demo/optimizer/PromptOptimizer.java package com.example.demo.optimizer; import com.example.demo.evaluator.RelevanceEvaluationResult; import org.springframework.ai.chat.prompt.Prompt; import org.springframework.ai.chat.prompt.SystemPromptTemplate; import org.springframework.stereotype.Component; import java.util.Map; @Component public class PromptOptimizer { /** * 根据相关性评估结果优化原始Prompt * @param originalPrompt 原始用户Prompt * @param evaluationResult 相关性评估结果 * @return 优化后的新Prompt */ public Prompt optimizeForRelevance(Prompt originalPrompt, RelevanceEvaluationResult evaluationResult) { String originalUserMessage = originalPrompt.getContents(); if (evaluationResult.isPassed()) { // 评估通过，返回原Prompt return originalPrompt; } // 评估未通过，构建优化后的System Message String optimizationInstruction = """ 你是一个技术专家助手。请严格遵循以下要求回答问题： 1. 用户的问题是：%s 2. 之前的回答因为未能紧扣问题核心而被评估为相关性不足。 3. **请确保你的回答直接、精准地回应用户问题中的每一个技术点，避免泛泛而谈。** 4. 如果问题涉及代码，请提供准确、可运行的示例。 """.formatted(originalUserMessage); // 创建一个新的Prompt，包含强化的系统指令和原始用户消息 // 注意：这里简化了Prompt的构造，实际可能需要更精细的消息角色管理 SystemPromptTemplate systemPromptTemplate = new SystemPromptTemplate(optimizationInstruction); Prompt optimizedPrompt = new Prompt(systemPromptTemplate.createMessage()); // 通常还需要将原始用户消息作为UserMessage加入，这里为演示简化 // 实际应使用PromptBuilder来构建多角色消息 System.out.println("提示词已优化，新系统指令已添加。"); return optimizedPrompt; } }

这个优化器在评估失败时，会在系统指令中明确要求 AI 聚焦于用户问题的技术点，从而引导模型产生更相关的回答。这是一种典型的“基于反馈的提示词迭代”优化。

5. 完整实战案例：构建一个自评估与优化的 AI Agent

现在，我们将评估器和优化器组合起来，创建一个具备自我改进能力的简单 AI Agent。这个 Agent 的工作流程是：提问 -> 获取回答 -> 评估相关性 -> 如果相关性差则优化提示词 -> 重新提问。

5.1 创建 Agent 服务类

// 文件路径：src/main/java/com/example/demo/service/SelfImprovingAgentService.java package com.example.demo.service; import com.example.demo.evaluator.RelevanceEvaluationResult; import com.example.demo.evaluator.SimpleRelevanceEvaluator; import com.example.demo.optimizer.PromptOptimizer; import org.springframework.ai.chat.client.ChatClient; import org.springframework.ai.chat.messages.AssistantMessage; import org.springframework.ai.chat.prompt.Prompt; import org.springframework.stereotype.Service; @Service public class SelfImprovingAgentService { private final ChatClient chatClient; private final SimpleRelevanceEvaluator relevanceEvaluator; private final PromptOptimizer promptOptimizer; // 通过构造器注入依赖 public SelfImprovingAgentService(ChatClient chatClient, SimpleRelevanceEvaluator relevanceEvaluator, PromptOptimizer promptOptimizer) { this.chatClient = chatClient; this.relevanceEvaluator = relevanceEvaluator; this.promptOptimizer = promptOptimizer; } /** * 执行带评估和优化循环的AI问答 * @param userQuestion 用户问题 * @param maxRetries 最大优化重试次数 * @return 最终的回答 */ public String chatWithSelfImprovement(String userQuestion, int maxRetries) { Prompt currentPrompt = new Prompt(userQuestion); String finalAnswer = null; int retryCount = 0; while (retryCount <= maxRetries) { System.out.printf("\n=== 第 %d 次尝试 ===\n", retryCount + 1); System.out.println("提问: " + currentPrompt.getContents()); // 1. 调用AI AssistantMessage response = chatClient.prompt(currentPrompt) .call() .chatResponse() .getResult() .getOutput(); finalAnswer = response.getContent(); System.out.println("AI回答: " + finalAnswer); // 2. 评估回答 RelevanceEvaluationResult evalResult = relevanceEvaluator.evaluate(currentPrompt, response); System.out.println("评估结果: 得分=" + evalResult.getScore() + ", 通过=" + evalResult.isPassed()); System.out.println("评估理由: " + evalResult.getReasoning()); // 3. 判断是否通过 if (evalResult.isPassed() || retryCount >= maxRetries) { System.out.println("问答结束。最终反馈: " + evalResult.getFeedback()); break; } // 4. 评估未通过，进行优化 System.out.println("评估未通过，尝试优化... 反馈: " + evalResult.getFeedback()); currentPrompt = promptOptimizer.optimizeForRelevance(currentPrompt, evalResult); retryCount++; } return finalAnswer != null ? finalAnswer : "未能生成满意的回答。"; } }

5.2 创建控制器暴露 API

// 文件路径：src/main/java/com/example/demo/controller/AiAgentController.java package com.example.demo.controller; import com.example.demo.service.SelfImprovingAgentService; import org.springframework.web.bind.annotation.*; @RestController @RequestMapping("/api/ai") public class AiAgentController { private final SelfImprovingAgentService agentService; public AiAgentController(SelfImprovingAgentService agentService) { this.agentService = agentService; } @PostMapping("/chat") public String chat(@RequestBody ChatRequest request) { // 可以从前端接收问题，并设置最大重试次数 return agentService.chatWithSelfImprovement(request.getQuestion(), 2); // 最多重试2次 } // 简单的请求体 public static class ChatRequest { private String question; // Getter and Setter public String getQuestion() { return question; } public void setQuestion(String question) { this.question = question; } } }

5.3 运行与验证

1. 启动 Spring Boot 应用。
2. 使用curl、Postman 或任何 HTTP 客户端调用 API。

   curl -X POST http://localhost:8080/api/ai/chat \ -H "Content-Type: application/json" \ -d '{"question":"Spring Boot如何连接数据库？"}'

3. 观察控制台日志，你会看到类似以下的输出，清晰地展示了评估与优化的闭环过程：

   === 第 1 次尝试 === 提问: Spring Boot如何连接数据库？ AI回答: Spring Boot提供了多种便捷的方式来连接数据库，例如通过JPA或者JDBC。你可以轻松地配置数据源。 评估结果: 得分=0.333..., 通过=false 评估理由: 问题包含2个关键词，回答中匹配了1个。 评估未通过，尝试优化... 反馈: 回答未能充分涵盖问题中的关键技术点，建议优化提示词或要求模型更聚焦。 === 第 2 次尝试 === 提问: [优化后的系统指令] + 用户问题 AI回答: 在Spring Boot中连接数据库，主要步骤是：1. 在`pom.xml`中添加对应数据库的驱动依赖（如`spring-boot-starter-data-jdbc`）。2. 在`application.properties`中配置`spring.datasource.url`, `username`, `password`等。3. 使用`JdbcTemplate`或`Spring Data JPA`进行数据操作。核心是自动配置机制简化了传统繁琐的配置。 评估结果: 得分=1.0, 通过=true 评估理由: 问题包含2个关键词，回答中匹配了2个。 问答结束。最终反馈: 回答相关性良好。

5.4 结果说明通过这个简单的案例，我们实现了一个具备初步自我改进能力的 Agent。当第一次回答比较笼统时（只提到了“JPA/JDBC”和“配置数据源”，关键词“Spring Boot”匹配，“数据库”未明确匹配），评估器给出了低分。优化器随即介入，在第二次调用前改写了系统指令，强制要求 AI 聚焦技术点并提供具体步骤，从而得到了一个更具体、相关性更高的回答。

6. 进阶话题：更复杂的评估与优化模式

上面的例子是线性的“评估-优化”循环。在实际复杂的 Agent 工作流（如使用 SpringAI 的Agent或Chain功能）中，评估与优化可以更加灵活。

6.1 多维度评估器组合一个成熟的系统不会只评估相关性。你可以同时部署：

• 事实核查评估器：调用知识库或搜索 API 验证输出事实。
• 安全性评估器：检查输出是否包含暴力、歧视等违规内容。
• 成本评估器：计算本次调用的 Token 消耗和预估费用。 最终的决策（如是否接受该回答、是否触发优化）可以基于这些评估结果的加权组合或一套规则引擎。

6.2 优化器策略模式优化器本身可以抽象为策略模式。针对不同的评估失败类型，采用不同的优化策略：

• RelevancePromptOptimizer: 针对相关性差。
• FactualRetrievalOptimizer: 针对事实错误，在 Prompt 中添加上下文检索到的信息。
• CostOptimizer: 针对成本过高，自动切换到更经济的模型或压缩 Prompt。

6.3 与“链（Chain）”和“工具（Tool）”结合在 SpringAI 的Chain概念中，评估器可以作为链中的一个节点（EvaluatorNode），优化器可以作为决策节点（Router或ConditionalNode）的一部分。例如，在一个“问题分解 -> 多步查询 -> 汇总回答”的链中，可以在汇总后加入评估节点，如果评估不通过，则路由到优化分支重新执行部分步骤。

7. 常见问题与排查思路

8. 最佳实践与工程建议

1. 评估标准先行：在开发 AI 功能前，先和业务方一起定义清晰的、可量化的评估标准（例如，客服回答的满意度得分 > 4/5，代码生成的功能正确率 > 90%）。这是构建有效评估器的基础。
2. 渐进式优化：不要试图一次性构建完美的评估优化系统。先从最简单的规则评估器（如关键词、正则表达式）开始，快速验证流程，再逐步引入更复杂的基于模型的评估。
3. 成本监控与预算：评估和优化本身也可能消耗 Token（尤其是使用 LLM-as-a-Judge 时）。务必为评估环节设置独立的成本预算和监控告警，避免评估开销超过主业务。
4. 人机回环（Human-in-the-loop, HITL）：对于关键业务或高风险场景，不要完全依赖自动评估。当自动评估置信度低或优化多次仍失败时，应将结果交由人工审核，并将人工反馈作为训练数据回流到评估/优化模型，持续改进系统。
5. 可观测性建设：在整个 AI 调用链路上，详细记录每一次的请求、响应、评估结果、优化动作、耗时和成本。这些日志和指标对于分析瓶颈、定位问题、优化策略至关重要。可以考虑使用 Micrometer 集成到你的监控体系。
6. 测试策略：为你的评估器和优化器编写单元测试和集成测试。使用一批精心构造的“问题-标准答案”对作为测试集，确保评估逻辑的稳定性和优化策略的有效性。
7. 策略的版本化管理：将评估规则和优化策略作为配置或代码进行版本管理。这样可以在不同环境（开发、测试、生产）使用不同策略，并且可以方便地回滚到上一个有效版本。

理解和应用 SpringAI 的评估器与优化器，是将 AI 从“玩具”升级为“生产级工具”的关键一步。它迫使开发者以工程化的思维来对待 AI 的不确定性，通过闭环反馈系统来不断提升 AI 应用的可靠性、准确性和成本效益。