1. ChatClient.prompt().user("xxx").call().content() 这行代码背后发生了什么?
2. Advisor Chain的执行顺序是怎样的?before和after分别在什么时候执行?
3. ChatModel的接口设计为什么这样抽象?换模型只改配置的原理是什么?
4. 如何手写一个自定义Advisor?实战中用来做什么?
5. Spring AI的自动装配做了哪些事?
String result = chatClient.prompt()
.system("你是Java专家")
.user("解释HashMap")
.advisors(new SimpleLoggerAdvisor())
.call()
.content();
这行代码的完整执行路径:
1. chatClient.prompt()
└─ 创建 PromptUserSpec 对象(Builder模式的起点)
存入 user文本、system文本、advisors列表、functions列表
2. .system("你是Java专家")
└─ 设置 systemMessage 到 PromptUserSpec
3. .user("解释HashMap")
└─ 设置 userMessage 到 PromptUserSpec
4. .advisors(new SimpleLoggerAdvisor())
└─ 添加到 advisors 列表(注意:合并 defaultAdvisors + 本次传入的)
5. .call()
└─ 关键转折点!进入 CallResponseSpec
│
├─ 5.1 组装 Prompt 对象
│ 包含所有 Message(system + user + history)
│ 包含 ChatOptions(model、temperature等)
│
├─ 5.2 执行 Advisor Chain 的 before 阶段
│ for (advisor : advisors) {
│ request = advisor.adviceRequest(request, ...);
│ }
│ → 这里可以修改 Prompt、添加上下文、做日志记录
│
├─ 5.3 调用 ChatModel.call(prompt)
│ │
│ └─ 实际的HTTP请求发生在这里!
│ 构建 HTTP Body(model/messages/temperature...)
│ POST 到大模型API
│ 解析 Response(content/usage/toolCalls...)
│
├─ 5.4 如果 Response 包含 ToolCalls
│ │
│ ├─ 解析 function name + arguments
│ ├─ 从 FunctionCallbackRegistry 查找对应函数
│ ├─ 执行函数,获取结果
│ ├─ 把函数结果作为 ToolResponseMessage 追加到对话
│ └─ 再次调用 ChatModel(循环直到模型返回纯文本)
│
├─ 5.5 执行 Advisor Chain 的 after 阶段(反序)
│ for (advisor : reversed(advisors)) {
│ response = advisor.adviceResponse(response, ...);
│ }
│
└─ 5.6 返回 ChatResponse
│
└─ .content() 提取纯文本结果
// ChatModel 是最底层的模型调用接口
public interface ChatModel extends Model<Prompt, ChatResponse> {
ChatResponse call(Prompt prompt);
}
// 所有模型提供商实现这个接口
// OpenAiChatModel → 调用OpenAI/GPT/GLM(兼容接口)
// OllamaChatModel → 调用本地Ollama
// ZhiPuAiChatModel → 调用智谱GLM
// Spring AI自动装配做了什么:
@Configuration
@ConditionalOnClass(OpenAiApi.class)
public class OpenAiAutoConfiguration {
@Bean
@ConditionalOnMissingBean
public OpenAiChatModel openAiChatModel(
OpenAiApi openAiApi,
OpenAiChatOptions options) {
return new OpenAiChatModel(openAiApi, options);
}
}
// 所以当你改 application.yml 的 base-url 和 model,
// Spring Boot 创建的就是不同配置的 OpenAiChatModel,
// 但 ChatModel 接口不变,业务代码零修改。
面试追问"让你设计一个多模型切换方案":
// 方案一:Spring Profile(最简单)
// application-glm.yml → base-url: https://open.bigmodel.cn
// application-deepseek.yml → base-url: https://api.deepseek.com
// 启动时:java -jar app.jar --spring.profiles.active=glm
// 方案二:自定义ModelRouter(面试加分)
@Component
public class ModelRouter {
private final Map<String, ChatModel> models;
public ModelRouter(
@Qualifier("glmChatModel") ChatModel glm,
@Qualifier("deepseekChatModel") ChatModel deepseek) {
this.models = Map.of("glm", glm, "deepseek", deepseek);
}
public ChatModel route(String scenario) {
return switch (scenario) {
case "coding" -> models.get("deepseek"); // 代码场景用DeepSeek
case "chat" -> models.get("glm"); // 对话场景用GLM
default -> models.get("glm"); // 默认GLM
};
}
}
// Advisor 接口(简化版)
public interface Advisor {
// 请求阶段:在调用模型之前执行
AdvisedRequest adviseRequest(AdvisedRequest request, Map<String, Object> context);
// 响应阶段:在模型返回之后执行
ChatResponse adviseResponse(ChatResponse response, Map<String, Object> context);
}
// 执行顺序示例:
// advisors = [A, B, C]
//
// 请求阶段(正序):
// A.adviseRequest → B.adviseRequest → C.adviseRequest → 模型调用
//
// 响应阶段(反序):
// 模型返回 → C.adviseResponse → B.adviseResponse → A.adviseResponse
//
// 类比:Servlet Filter 的 doFilter 链
public class TokenCountAdvisor implements Advisor {
private static final Log logger = LogFactory.getLog(TokenCountAdvisor.class);
@Override
public String getName() {
return "TokenCountAdvisor";
}
@Override
public AdvisedRequest adviseRequest(AdvisedRequest request, Map<String, Object> context) {
// 记录请求时间
context.put("startTime", System.currentTimeMillis());
return request;
}
@Override
public ChatResponse adviseResponse(ChatResponse response, Map<String, Object> context) {
long duration = System.currentTimeMillis() - (long) context.get("startTime");
// 从响应中提取Token用量
Usage usage = response.getMetadata().getUsage();
if (usage != null) {
logger.info(String.format(
"Token消耗 — 输入: %d, 输出: %d, 总计: %d, 耗时: %dms",
usage.getPromptTokens(),
usage.getGenerationTokens(),
usage.getTotalTokens(),
duration
));
}
return response;
}
}
// 注册使用:
ChatClient client = ChatClient.builder(chatModel)
.defaultAdvisors(new TokenCountAdvisor())
.build();
public class SensitiveWordAdvisor implements Advisor {
private final Set<String> sensitiveWords;
public SensitiveWordAdvisor(Set<String> words) {
this.sensitiveWords = words;
}
@Override
public AdvisedRequest adviseRequest(AdvisedRequest request, Map<String, Object> context) {
// 检查用户输入
String userText = request.userText();
for (String word : sensitiveWords) {
if (userText.contains(word)) {
// 替换为 ***
userText = userText.replace(word, "***");
}
}
// 返回修改后的请求
return AdvisedRequest.from(request).withUserText(userText).build();
}
@Override
public ChatResponse adviseResponse(ChatResponse response, Map<String, Object> context) {
// 检查模型输出
String content = response.getResult().getOutput().getText();
for (String word : sensitiveWords) {
if (content.contains(word)) {
content = content.replace(word, "***");
}
}
// 注意:实际修改response需要创建新的ChatResponse
// 这里简化处理
return response;
}
}
// 当你调用 .functions("getWeather") 时发生了什么:
// 1. Spring AI从 FunctionCallbackRegistry 查找注册的函数
// 默认从Spring容器中找 @Bean 的 FunctionCallback
// 2. 在请求中添加 tools 声明
// HTTP Body 里会多一个 "tools" 字段:
// {
// "model": "glm-4",
// "messages": [...],
// "tools": [{
// "type": "function",
// "function": {
// "name": "getWeather",
// "description": "获取指定城市的天气",
// "parameters": {
// "type": "object",
// "properties": {"city": {"type": "string"}},
// "required": ["city"]
// }
// }
// }]
// }
// 3. 模型返回 tool_calls 而不是文本
// {
// "choices": [{
// "message": {
// "tool_calls": [{
// "function": {
// "name": "getWeather",
// "arguments": "{\"city\":\"深圳\"}"
// }
// }]
// }
// }]
// }
// 4. Spring AI自动执行函数,把结果追加到对话
// 自动创建 ToolResponseMessage
// 再次调用模型,带上函数结果
// 模型基于函数结果生成最终回复
// 自动循环直到模型不再调用工具(最多N轮,可配置)
// ChatMemory 接口
public interface ChatMemory {
void add(String conversationId, List<Message> messages);
List<Message> get(String conversationId, int lastN);
void clear(String conversationId);
}
// 内置实现:
// InMemoryChatMemory — 内存存储,重启丢失(仅开发用)
// CassandraChatMemory — Cassandra持久化
// Neo4jChatMemory — Neo4j持久化
// 生产环境需要自定义实现(你的AI定价系统就做了这个):
// 关键问题:上下文窗口有限,历史消息怎么处理?
//
// 方案一:保留最近N条(简单但有截断风险)
// 方案二:摘要压缩(旧的对话用LLM压缩成摘要)
// 方案三:滑动窗口 + 摘要混合
@Component
public class MySqlChatMemory implements ChatMemory {
private final JdbcTemplate jdbc;
public MySqlChatMemory(JdbcTemplate jdbc) {
this.jdbc = jdbc;
}
@Override
public void add(String conversationId, List<Message> messages) {
for (Message msg : messages) {
jdbc.update(
"INSERT INTO chat_memory (conversation_id, role, content, created_at) VALUES (?, ?, ?, NOW())",
conversationId,
msg.getMessageType().name(),
msg.getText()
);
}
}
@Override
public List<Message> get(String conversationId, int lastN) {
return jdbc.query(
"SELECT role, content FROM chat_memory WHERE conversation_id = ? ORDER BY created_at DESC LIMIT ?",
(rs, rowNum) -> {
String role = rs.getString("role");
String content = rs.getString("content");
return new UserMessage(content); // 简化,实际需按role创建不同类型
},
conversationId, lastN
).reversed(); // 反转回时间正序
}
@Override
public void clear(String conversationId) {
jdbc.update("DELETE FROM chat_memory WHERE conversation_id = ?", conversationId);
}
}
"设计思想一样,都是拦截器链模式。区别在于:
1. Advisor在应用层,Filter在Web层
2. Advisor操作的是Prompt/ChatResponse对象,Filter操作的是HttpServletRequest/Response
3. Advisor的context是Map<String,Object>,可以跨请求-响应传递数据
4. Spring AI的Advisor能感知模型调用的结果,做基于内容的后处理"
用户: "深圳今天天气怎么样"
│
▼
ChatClient组装Prompt(user message + tools声明)
│
▼
发送给大模型API
│
▼
模型返回: tool_calls=[{name:"getWeather", args:{city:"深圳"}}]
│
▼
Spring AI查找getWeather函数 → 执行 → 得到"深圳32°C,晴"
│
▼
把函数结果作为tool message追加到对话 → 再次调用模型
│
▼
模型返回: "深圳今天天气晴朗,气温32°C。"
│
▼
返回给用户
"上下文窗口溢出。当对话轮次多了以后,所有历史消息拼起来超过了模型的128K Token限制。
>
我的解决方案是滑动窗口+截断:保留最近10轮对话(20条消息),如果Token估算还是超了,就从最早的开始截断。
>
更好的方案是摘要压缩——用LLM把旧对话压缩成摘要,但这样会增加一次额外的模型调用,有成本和延迟的trade-off。"
1. 实现Advisor接口
2. 在adviseRequest记录开始时间
3. 在adviseResponse计算耗时和Token数
4. 注册到ChatClient并测试
1. 开启Spring AI的DEBUG日志:logging.level.org.springframework.ai=DEBUG
2. 调用包含Function Calling的对话
3. 在日志中找到:tools声明 → tool_calls返回 → 函数执行 → 二次调用 → 最终结果
4. 用文字描述完整链路
P3-03将深入RAG管道,从文档切片到向量检索到重排序,每一步都有实战代码和调优经验。