LLM on Zell Blog

Java_Go开发者ai应用开发agent学习路线

Mon, 13 Apr 2026 10:00:00 +0800

前言

AI 时代，Java/后端开发者的机会在哪里？工程化落地。

大模型本身是概率性的"黑盒"，但把它变成稳定、可观测、可扩展的生产级服务，恰恰是 Java/Go 工程师的主场——高并发架构、数据库优化、系统稳定性治理，这些能力可以直接复用。

学习建议：按顺序推进，每个阶段都有对应的详细文章。不要跳过阶段零——思维校准是后面所有技术学习的基础。

一、项目介绍

这是一个基于大语言模型的智能面试辅助平台，旨在帮助求职者提升面试能力。系统提供三大核心功能：

智能简历分析：上传简历后，AI 自动进行多维度评分并给出改进建议
模拟面试系统：基于简历内容生成个性化面试题，支持实时问答和答案评估
RAG 知识库问答：上传技术文档构建私有知识库，支持向量检索增强的智能问答

开源地址：https://github.com/Snailclimb/interview-guide

1.1 系统架构

┌─────────────────────────────────────────────────────────────┐
│                      前端展示层 (React)                      │
├─────────────────────────────────────────────────────────────┤
│                      后端服务层 (Spring Boot)                  │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐        │
│  │ Resume Svc  │  │Interview Svc│  │Knowledge Svc│        │
│  └─────────────┘  └─────────────┘  └─────────────┘        │
│  ┌─────────────────────────────────────────────────┐        │
│  │         AI 集成层 (Spring AI + 通义千问)         │        │
│  └─────────────────────────────────────────────────┘        │
│  ┌─────────────────────────────────────────────────┐        │
│  │      异步处理层 (Redis Stream)                   │        │
│  └─────────────────────────────────────────────────┘        │
├─────────────────────────────────────────────────────────────┤
│                      数据存储层                              │
│  PostgreSQL+pgvector  │  Redis  │  RustFS/MinIO         │
└─────────────────────────────────────────────────────────────┘

1.2 技术栈概览

后端技术：

技术	版本	说明
Spring Boot	4.0	应用框架
Java	21	开发语言
Spring AI	2.0	AI 集成框架
PostgreSQL + pgvector	14+	关系数据库 + 向量存储
Redis	6+	缓存 + 消息队列
Apache Tika	2.9.2	文档解析
MapStruct	1.6.3	对象映射

二、学习路线总览

阶段总览表

阶段	主题	详细文档	核心产出
零	认知校准	大模型核心概念详解	思维从"确定性"转向"概率性"
一	大模型核心概念	大模型核心概念详解	掌握 Token/上下文窗口/Prompt
二	大模型对接	SpringAi实战指南_大模型集成_流式输出	Spring AI / LangChain4j，流式输出
三	Prompt 工程	大模型核心概念详解	结构化 Prompt，CoT思维链
四	RAG + 知识图谱	RAG知识库实战	文档 ETL，向量检索，GraphRAG
五	Agent 核心机制	AI_Agent核心机制_ReAct_MultiAgent_记忆系统	ReAct，Tool Calling，记忆机制
六	工程化框架	工程化与生产落地	异步处理，限流，成本控制
七	项目实战	本项目 InterviewGuide	智能面试平台完整实现

学习时间规划

按每天 3~6 小时投入估算：

阶段	建议时间	说明
阶段零~二	2~3 周	打基础，不要跳过
阶段三~四	3~4 周	核心能力，需动手实践
阶段五~六	2~3 周	工程化，复用后端经验
阶段七	2~4 周	项目实战，巩固所学

三、阶段零：认知校准

3.1 思维校准

认知转变：

认知	说明
确定性 → 概率性	LLM 是概率预测机器，相同输入可能产生不同输出
工程应对	模型输出进入业务逻辑前，必须经过校验、重试或降级兜底
Java 开发者定位	工程化落地，把模型能力变成稳定的生产级服务

3.2 常见踩坑与解决方案

详细内容见：大模型核心概念详解

坑	表现	解决方案
LLM 响应慢卡死 Tomcat	服务雪崩	SseEmitter/WebFlux + 异步线程池
@Transactional 内调 LLM	连接池耗尽	LLM 调用游离事务外
Agent 死循环导致账单爆炸	成本失控	Token 消耗监控 + 阈值告警
LLM 输出不符合事实	幻觉严重	RAG + 知识图谱双引擎校验
JSON 解析失败率高	格式错误	低温 + Strict Mode + Retry 闭环

四、阶段一：大模型核心概念

详细内容：大模型核心概念详解

4.1 Token 与上下文窗口

Token：模型处理文本的基本单位（英文 3~~4 字符/Token，中文 1~~2 汉字/Token）
上下文窗口：LLM 的"工作记忆"，决定模型可以处理的文本量
Token 预算：可用输入 = window × 0.9 - max_output_tokens - 安全边际

4.2 解码参数

参数	工程建议	场景
Temperature	0~~0.3（结构化）/ 0.4~~0.8（分析）	控制输出稳定性
Top-p	低温 + Top-p(0.9)	控制生成多样性
Max Tokens	硬上限	需防截断风险

4.3 Prompt 工程基础

要素	说明
CoT（思维链）	一步一步思考，展示推理过程，对抗幻觉
Few-Shot	提供 1~3 个示例，让模型理解输入输出模式
任务分解	复杂任务拆成子任务逐一完成，再汇总

4.4 结构化输出

方案	特点
JSON Schema 约束	实现简单、跨供应商
Function Calling	结构化更强，供应商差异大
Structured Outputs (Strict)	受限解码，格式错误率趋近 0

五、阶段二：大模型对接

详细内容：SpringAi实战指南_大模型集成_流式输出

5.1 框架选型

框架	特点	适用场景
Spring AI	与 Spring 生态无缝集成	企业内部系统
LangChain4j	RAG 和 Agent 场景功能全面	知识库问答

防腐层设计：AI 框架迭代快，业务代码绝不能直接耦合框架 API，需定义自己的领域接口隔离。

5.2 OpenAI 协议兼容性

主流模型均兼容 OpenAI 格式：

模型	Base URL	特点
DeepSeek	api.deepseek.com	成本低，中文优化
通义千问	dashscope.aliyuncs.com	国内合规，稳定
Ollama	localhost:11434	本地部署，数据安全

5.3 流式输出 SSE

详细内容见：Spring AI实战指南 - 流式输出

@GetMapping(value = "/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
public Flux<ServerSentEvent<String>> streamChat(@RequestParam String question) {
    return chatClient.prompt()
        .system(systemPrompt)
        .user(question)
        .stream()
        .content()
        .map(chunk -> ServerSentEvent.<String>builder()
            .data(chunk.replace("\n", "\\n").replace("\r", "\\r"))
            .build());
}

六、阶段三：Prompt 工程

详细内容：大模型核心概念详解

6.1 CoT 思维链详解

范式	适用场景
普通 CoT	数学推导、逻辑分析
自治 CoT	模型自我验证推理路径
工具增强 CoT	需要调用工具获取中间结果

6.2 Prompt 工程化管理

要点	说明
外置化存储	Prompt 不应硬编码，使用 .st 文件存储
配置中心热更新	接入 Nacos/Apollo
变量注入安全	用户输入需清洗，防 Prompt Injection

6.3 结构化输出与反思闭环

要点	Java 实现
强类型映射	Java 14+ Record
JSR-380 校验	@NotNull、@Size 等注解
Retry Loop	设定最大重试次数（如 3 次）

七、阶段四：RAG + 知识图谱

详细内容：RAG知识库实战

7.1 RAG 核心概念

┌─────────────────────────────────────────────────────────────┐
│                    RAG 系统                                   │
├──────────────────────────┬──────────────────────────────────┤
│     📥 索引阶段           │      🔍 检索阶段                  │
│   文档 → 分块 → 向量化    │   查询 → 检索 → 生成              │
└──────────────────────────┴──────────────────────────────────┘

7.2 技术选型

组件	选型	理由
向量数据库	PostgreSQL + pgvector	一套数据库，运维简单
索引算法	HNSW	毫秒级检索，百万级够用
Embedding	text-embedding-v3	1024 维，中文优化

7.3 关键知识点

概念	说明
混合检索	向量检索 + BM25 关键词检索
Rerank	Cross-Encoder 精排，提升顶部结果准确性
语义缓存	Redis 向量检索命中缓存，降成本 + 降延迟

八、阶段五：Agent 核心机制

详细内容：AI_Agent核心机制_ReAct_MultiAgent_记忆系统

8.1 Agent 调度范式

范式	说明	适用场景
ReAct	Think → Act → Observe 循环，动态纠错	工具调用、复杂推理
Plan-and-Execute	先全局规划再逐步执行	长任务、多步骤
Reflection	自我纠错闭环	代码生成、内容创作

8.2 Tool Calling

`1`	`用户问题 → LLM 判断需要调用工具 → 返回工具名称+参数 → 执行工具 → 返回结果 → LLM 生成回答`

8.3 记忆系统

类型	说明	存储
短期记忆	Redis 缓存对话历史	Redis
长期记忆	用户偏好、历史知识	Neo4j / 向量库

8.4 MCP 协议

协议	说明
MCP	Model Context Protocol，统一工具调用接口
ACP	Agent Communication Protocol，打通 Agent 与 IDE 集成

九、阶段六：工程化框架

详细内容：工程化与生产落地

9.1 Redis Stream 异步处理

上传请求 → 保存文件 → 发送消息到 Stream → 立即返回
                          ↓
                  Consumer 消费消息
                          ↓
                执行分析/向量化任务
                          ↓
                  更新数据库状态

状态流转：PENDING → PROCESSING → COMPLETED / FAILED

9.2 事务安全

要点	说明
事务反模式	禁止在 @Transactional 方法内调用 LLM
事务极小化	LLM 调用游离在事务外，先校验再落盘

9.3 分布式限流

维度	说明
用户维度	限制单个用户
IP 维度	限制单个 IP
接口维度	限制单个接口

9.4 FinOps 成本控制

要点	工具
Token 计量	Micrometer + Prometheus
成本预警	单日 Token 消耗阈值告警
语义缓存	Redis 缓存，降成本 30~50%

十、阶段七：项目实战

10.1 智能面试平台

基于大语言模型的智能面试辅助平台，提供三大核心功能：

智能简历分析：多维度评分 + 改进建议
模拟面试系统：个性化面试题 + 实时问答
RAG 知识库问答：私有知识库 + 向量检索

10.2 核心技术点

功能	技术方案
简历解析	Apache Tika 多格式解析
AI 分析	Spring AI + 结构化输出
向量检索	PostgreSQL + pgvector
流式输出	SSE + 虚拟线程
异步处理	Redis Stream
限流	Redis + Lua

十一、推荐模型选择

场景	推荐模型	说明
开发调试	DeepSeek / 通义千问	成本低，中文友好
生产环境	GPT / Claude / Gemini	稳定性、能力最均衡
数据安全	本地部署 Ollama + Qwen	内网环境，数据不出域

十二、延伸阅读

文档	内容
大模型核心概念详解	Token、上下文窗口、Prompt工程、结构化输出
SpringAi实战指南_大模型集成_流式输出	ChatClient、流式SSE、Function Calling
RAG知识库实战	向量检索、混合检索、语义缓存
AI_Agent核心机制_ReAct_MultiAgent_记忆系统	ReAct、Multi-Agent、记忆系统、MCP
工程化与生产落地	异步处理、限流、FinOps、安全防护

SpringAI实战指南_大模型集成_流式输出

Mon, 13 Apr 2026 10:00:00 +0800

前言

Spring AI 是 Spring 官方打造的 AI 应用开发框架，旨在将 AI 能力无缝集成到 Spring 生态系统中。它侧重于提供构建 AI 应用所需的底层原子能力抽象，让 Java 开发者可以像使用其他 Spring 组件一样，轻松地与大语言模型进行交互。

一、Spring AI 核心能力

能力	说明	应用场景
模型通信 (ChatClient)	统一接口与不同 LLM 对话	简历评分、问答生成
提示词 (Prompt)	结构化管理发送给模型的提示词	.st 模板文件管理
RAG (检索增强生成)	通过 VectorStore 实现 RAG 模式	知识库问答
工具调用 (Function Calling)	模型调用 Java 应用中定义的方法	Agent
记忆 (ChatMemory)	管理多轮对话的上下文历史	会话管理

二、框架对比与选型

2.1 Java AI 框架对比

框架	特点	JDK 基线	适用场景
Spring AI	Spring 官方，原生集成	JDK 17+（建议 JDK 21）	Spring 项目首选
LangChain4j	功能全面，更新快	JDK 8+	老项目，兼容性需求
Solon-AI	轻量化，性能优秀	JDK 8+	Serverless、GraalVM
Agent-Flex	专注于 Agent 编排	JDK 11/17+	Agent 编排需求

2.2 为什么选择 Spring AI

无缝集成：与现有 Spring Boot 技术栈完美融合，学习成本低
高度抽象：统一的、与具体模型无关的 API，轻松切换模型
生态整合：整合向量数据库、ETL 框架等 AI 应用开发工具链
虚拟线程支持：全面拥抱 Java 21 虚拟线程，高并发处理能力强

三、项目依赖配置

3.1 添加依赖

// build.gradle
dependencies {
    // Spring AI 2.0 - OpenAI兼容模式 (阿里云DashScope)
    implementation "org.springframework.ai:spring-ai-starter-model-openai:${spring-ai.version}"
    // Spring AI 2.0 - PostgreSQL Vector Store (pgvector)
    implementation "org.springframework.ai:spring-ai-starter-vector-store-pgvector:${spring-ai.version}"
}

3.2 配置属性

# application.yml
spring:
  ai:
    openai:
      base-url: https://dashscope.aliyuncs.com/compatible-mode
      api-key: ${AI_BAILIAN_API_KEY}
      chat:
        options:
          model: ${AI_MODEL:qwen-plus}
          temperature: 0.2
      # Embedding模型配置
      embedding:
        options:
          model: text-embedding-v3
    # 禁用自动重试机制，让异常立即返回
    retry:
      max-attempts: 1
      on-client-errors: false
    # PostgreSQL Vector Store配置
    vectorstore:
      pgvector:
        index-type: HNSW
        distance-type: COSINE_DISTANCE
        dimensions: 1024
        initialize-schema: true
        remove-existing-vector-store-table: false

3.3 关键配置说明

配置项	说明
`base-url`	阿里云 DashScope 的 OpenAI 兼容端点
`api-key`	通过环境变量注入，严禁硬编码
`temperature`	控制输出随机性（0-1），结构化输出使用 0.2 更稳定
`dimensions`	text-embedding-v3 的向量维度为 1024
`initialize-schema`	开发环境设为 true 自动创建表

四、ChatClient 大模型调用

4.1 服务类设计

@Service
public class ResumeGradingService {

    private final ChatClient chatClient;
    private final PromptTemplate systemPromptTemplate;
    private final PromptTemplate userPromptTemplate;
    private final BeanOutputConverter<ResumeAnalysisResponseDTO> outputConverter;

    public ResumeGradingService(
            ChatClient.Builder chatClientBuilder,
            @Value("classpath:prompts/resume-analysis-system.st") Resource systemPromptResource,
            @Value("classpath:prompts/resume-analysis-user.st") Resource userPromptResource) {
        this.chatClient = chatClientBuilder.build();
        this.systemPromptTemplate = new PromptTemplate(systemPromptResource.getContentAsString(StandardCharsets.UTF_8));
        this.userPromptTemplate = new PromptTemplate(userPromptResource.getContentAsString(StandardCharsets.UTF_8));
        this.outputConverter = new BeanOutputConverter<>(ResumeAnalysisResponseDTO.class);
    }
}

4.2 调用大模型

public ResumeAnalysisResponse analyzeResume(String resumeText) {
    // 1. 加载系统提示词
    String systemPrompt = systemPromptTemplate.render();

    // 2. 加载用户提示词并填充变量
    Map<String, Object> variables = new HashMap<>();
    variables.put("resumeText", resumeText);
    String userPrompt = userPromptTemplate.render(variables);

    // 3. 添加格式指令到系统提示词
    String systemPromptWithFormat = systemPrompt + "\n\n" + outputConverter.getFormat();

    // 4. 调用AI
    ResumeAnalysisResponseDTO dto = chatClient.prompt()
        .system(systemPromptWithFormat)
        .user(userPrompt)
        .call()
        .entity(outputConverter);

    // 5. 转换为业务对象
    return convertToResponse(dto, resumeText);
}

4.3 调用流程图

┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│ 加载提示词   │────▶│ 填充变量    │────▶│ 调用 ChatClient│
└─────────────┘     └─────────────┘     └─────────────┘
                                               │
                                               ▼
┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│ 转换业务对象 │◀────│ 解析响应    │◀────│ 获取 AI 响应 │
└─────────────┘     └─────────────┘     └─────────────┘

五、结构化输出

5.1 Java Record 定义

// 中间DTO用于接收AI响应
private record ResumeAnalysisResponseDTO(
    int overallScore,
    ScoreDetailDTO scoreDetail,
    String summary,
    List<String> strengths,
    List<SuggestionDTO> suggestions
) {}

private record ScoreDetailDTO(
    int contentScore,
    int structureScore,
    int skillMatchScore,
    int expressionScore,
    int projectScore
) {}

private record SuggestionDTO(
    String category,
    String priority,
    String issue,
    String recommendation
) {}

5.2 结构化输出重试策略

public <T> T invokeWithRetry(ChatClient chatClient, String systemPrompt,
                              String userPrompt, BeanOutputConverter<T> converter) {
    int maxAttempts = 2;
    Exception lastError = null;

    for (int i = 0; i < maxAttempts; i++) {
        try {
            return chatClient.prompt()
                .system(systemPrompt + "\n\n" + converter.getFormat())
                .user(userPrompt)
                .call()
                .entity(converter);
        } catch (Exception e) {
            lastError = e;
            // 重试时注入上次错误信息
            userPrompt += "\n\n注意：上次输出解析失败，错误原因：" + e.getMessage();
        }
    }
    throw new BusinessException(ErrorCode.AI_RESPONSE_PARSING_FAILED, lastError);
}

5.3 处理流水线

`1`	`生成 → 解析 → 修复（可选）→ 校验`

阶段	说明	失败处理
生成	LLM 输出 JSON	-
解析	Jackson 反序列化	进入修复阶段
修复	将错误信息发回 LLM 要求修正	达最大次数则返回错误
校验	JSR-380 Bean Validation	进入修复阶段

六、流式输出 SSE

6.1 SSE 简介

SSE（Server-Sent Events） 是一种基于 HTTP 的服务器推送技术，允许服务器向客户端单向发送事件流。

6.2 SSE vs WebSocket

维度	SSE	WebSocket
通信方式	单向（服务端→客户端）	全双工
协议	基于 HTTP	独立协议
实现复杂度	低	高
自动重连	支持	需自己实现
二进制数据	需编码	原生支持
适用场景	AI 流式生成、实时通知	聊天室、协作编辑

6.3 SSE 协议格式

data: 第一行内容
data: 第二行内容
data: 第三行内容

id: 事件ID
event: 自定义事件类型
retry: 3000

字段	说明
`data`	具体的业务数据
`event`	自定义事件类型
`id`	事件 ID，断线重连时使用
`retry`	重连间隔（毫秒）

6.4 Spring Boot SSE 实现

@GetMapping(value = "/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
public Flux<ServerSentEvent<String>> streamData() {
    return Flux.interval(Duration.ofMillis(500))
        .map(seq -> ServerSentEvent.<String>builder()
            .id(String.valueOf(seq))
            .event("message")
            .data("消息 " + seq)
            .retry(3000L)
            .build());
}

6.5 Spring AI 流式调用

@GetMapping(value = "/chat/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
public Flux<ServerSentEvent<String>> streamChat(@RequestParam String question) {
    return chatClient.prompt()
        .system(systemPrompt)
        .user(question)
        .stream()
        .content()
        .map(chunk -> ServerSentEvent.<String>builder()
            .data(chunk.replace("\n", "\\n").replace("\r", "\\r"))
            .build());
}

6.6 SSE 格式转义处理

// 后端转义
.map(chunk -> ServerSentEvent.<String>builder()
    .data(chunk.replace("\n", "\\n").replace("\r", "\\r"))
    .build())

// 前端反向转义
const text = chunk.replace(/\\n/g, '\n').replace(/\\r/g, '\r');

6.7 错误处理与超时控制

return responseFlux
    .timeout(Duration.ofSeconds(30))
    .onErrorResume(TimeoutException.class, e -> {
        log.error("流式输出超时", e);
        return Flux.just("【错误】回答生成超时，请缩短问题或稍后重试。");
    });

6.8 虚拟线程配置

spring:
  threads:
    virtual:
      enabled: true  # 启用虚拟线程

虚拟线程 vs 平台线程：

场景	平台线程	虚拟线程
200 并发 SSE	线程池满，排队	轻松处理
AI 调用等待 3 秒	线程阻塞，占用资源	自动挂起，让出资源
10000 并发请求	拒绝服务	正常处理

七、Function Calling

7.1 Function Calling 原理

Function Calling 允许 LLM 调用我们定义的 Java 方法：

@Bean
public ChatClient chatClient(ChatClient.Builder builder) {
    return builder
        .defaultFunction("getWeather", new GetWeatherFunction())
        .build();
}

public class GetWeatherFunction implements Function<WeatherRequest, WeatherResponse> {
    @Override
    public WeatherResponse apply(WeatherRequest request) {
        // 调用天气 API
        return weatherService.getWeather(request.getCity());
    }
}

7.2 Prompt 模板定义

# System Prompt
你是一个专业的助手。当用户询问天气时，
请调用 getWeather 函数获取实时天气信息。

# User Prompt
{userQuestion}

7.3 处理流程

`1`	`用户输入 → LLM 判断需要调用函数 → 执行函数 → 返回结果 → LLM 生成最终回答`

八、提示词模板管理

8.1 .st 模板文件

# interview-question-system.st
你是一个专业的面试官。请根据候选人的简历内容，
生成针对性的面试问题。

## 要求
1. 问题要基于简历中的具体经历
2. 每个主问题需要生成追问
3. 问题难度要适中，考察真实能力

8.2 变量注入

Map<String, Object> variables = new HashMap<>();
variables.put("resumeText", resumeText);
variables.put("questionCount", 10);
variables.put("followUpCount", 2);

String userPrompt = userPromptTemplate.render(variables);

8.3 安全注入

用户输入注入模板前需清洗特殊符号，防止 Prompt Injection：

public String sanitizeUserInput(String input) {
    // 移除可能破坏 Prompt 结构的符号
    return input.replace("<", "&lt;")
                .replace(">", "&gt;")
                .replace("\"", "&quot;");
}

九、常见问题与解决方案

问题	原因	解决方案
JSON 解析失败	低温导致格式不稳定	升温至 0.3 + Retry 闭环
流式输出中断	网络波动 / 超时	添加超时控制 + 前端重连
响应太慢	上下文太长	减少输入 Token 或分批处理
429 限流	请求频率过高	添加限流器 + 指数退避
线程池耗尽	同步调用阻塞	启用虚拟线程 + 异步处理

十、总结

Spring AI 提供了企业级 AI 应用开发所需的核心能力：

统一抽象：一套代码支持多种 LLM，切换模型只需改配置
结构化输出：BeanOutputConverter 实现 LLM 输出到 Java 对象的自动映射
流式响应：SSE 实现"边生成边展示"的打字机效果
提示词管理：.st 模板文件实现提示词的外置化管理
高并发支持：Java 21 虚拟线程轻松应对高并发场景