← 返回首页 📚 实战课程
📑 本篇章节导航 (共6章,点击直达)
本节目标核心知识实战代码:手写ChatMemory(MySQL持久化)面试模拟动手练习下一课预告

P3-02 - Spring AI 1.0源码解读

本节目标

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接口设计 — 为什么换模型只改配置


// 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 Chain机制 — 深入到可以手写


// 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 链

手写实战:Token计数Advisor


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();

手写实战:敏感词过滤Advisor


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;
    }
}

四、Function Calling的底层实现


// 当你调用 .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的实现原理


// 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压缩成摘要)
// 方案三:滑动窗口 + 摘要混合

实战代码:手写ChatMemory(MySQL持久化)


@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);
    }
}

面试模拟

Q1: "Spring AI的Advisor Chain和Servlet Filter有什么区别?"

"设计思想一样,都是拦截器链模式。区别在于:
1. Advisor在应用层,Filter在Web层
2. Advisor操作的是Prompt/ChatResponse对象,Filter操作的是HttpServletRequest/Response
3. Advisor的context是Map<String,Object>,可以跨请求-响应传递数据
4. Spring AI的Advisor能感知模型调用的结果,做基于内容的后处理"

Q2: "Function Calling的执行流程画一下"


用户: "深圳今天天气怎么样"
  │
  ▼
ChatClient组装Prompt(user message + tools声明)
  │
  ▼
发送给大模型API
  │
  ▼
模型返回: tool_calls=[{name:"getWeather", args:{city:"深圳"}}]
  │
  ▼
Spring AI查找getWeather函数 → 执行 → 得到"深圳32°C,晴"
  │
  ▼
把函数结果作为tool message追加到对话 → 再次调用模型
  │
  ▼
模型返回: "深圳今天天气晴朗,气温32°C。"
  │
  ▼
返回给用户

Q3: "你自定义ChatMemory的时候遇到了什么问题?"

"上下文窗口溢出。当对话轮次多了以后,所有历史消息拼起来超过了模型的128K Token限制。

>

我的解决方案是滑动窗口+截断:保留最近10轮对话(20条消息),如果Token估算还是超了,就从最早的开始截断。

>

更好的方案是摘要压缩——用LLM把旧对话压缩成摘要,但这样会增加一次额外的模型调用,有成本和延迟的trade-off。"

动手练习

练习1:手写TokenCountAdvisor

1. 实现Advisor接口

2. 在adviseRequest记录开始时间

3. 在adviseResponse计算耗时和Token数

4. 注册到ChatClient并测试

练习2:追踪一次完整的Function Calling

1. 开启Spring AI的DEBUG日志:logging.level.org.springframework.ai=DEBUG

2. 调用包含Function Calling的对话

3. 在日志中找到:tools声明 → tool_calls返回 → 函数执行 → 二次调用 → 最终结果

4. 用文字描述完整链路

下一课预告

P3-03将深入RAG管道,从文档切片到向量检索到重排序,每一步都有实战代码和调优经验。