# ai-learn
**Repository Path**: jackXUYY/java-ai-learn
## Basic Information
- **Project Name**: ai-learn
- **Description**: java-ai-learn
- **Primary Language**: Java
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No
## Statistics
- **Stars**: 0
- **Forks**: 0
- **Created**: 2026-06-18
- **Last Updated**: 2026-07-21
## Categories & Tags
**Categories**: Uncategorized
**Tags**: None
## README
# ☕ Java 后端开发者转型 Java AI 完整学习计划（高数+机器学习+深度学习+大模型基础原理+神经网络等等都可以先不学）
> **适用对象**：具备 Java 后端开发基础，希望转型 AI 方向，且不离开 Java 技术栈的开发者
> **制定时间**：2026年6月
> **预计周期**：6 ~ 12 个月（视基础和投入时间调整）
---
## 📋 目录
1. [学习路线概览](#一学习路线概览)
2. [AI 基础知识](#二ai-基础知识)
3. [Java AI 生态栈详解](#三java-ai-生态栈详解)
4. [大模型应用开发](#四大模型应用开发)
5. [工程化实践](#五工程化实践)
6. [学习资源推荐](#六学习资源推荐)
7. [时间规划与里程碑](#七时间规划与里程碑)
---
## 一、学习路线概览
### 1.1 总体学习路线图
```mermaid
flowchart TD
A[☕ Java 后端开发者] --> B
subgraph B["🌱 第一阶段：AI 基础（1-2月）"]
B1[数学基础补充] --> B2[机器学习基础概念]
B2 --> B3[深度学习基础概念]
B3 --> B4[大模型基础原理]
end
B --> C
subgraph C["🔧 第二阶段：Java AI 框架（2-3月）"]
C1[LangChain4j 入门] --> C2[Spring AI 集成]
C2 --> C3[Deeplearning4j 基础]
C3 --> C4[ONNX Runtime 推理]
end
C --> D
subgraph D["🤖 第三阶段：大模型应用开发（2-3月）"]
D1[Prompt 工程] --> D2[RAG 系统构建]
D2 --> D3[Agent 开发]
D3 --> D4[向量数据库集成]
end
D --> E
subgraph E["⚙️ 第四阶段：工程化实践（1-2月）"]
E1[微服务集成 AI] --> E2[性能调优]
E2 --> E3[AI 应用部署]
E3 --> E4[监控与可观测性]
end
E --> F[🎯 具备 Java AI 应用独立开发能力]
```
### 1.2 核心学习原则
| 原则 | 说明 |
|------|------|
| ☕ **Java 优先** | 所有框架、工具、示例均以 Java 为主语言 |
| 🎯 **应用导向** | 聚焦工程应用，而非纯学术研究 |
| 🔄 **实践驱动** | 每个阶段配有动手项目，边学边做 |
| 📈 **循序渐进** | 从基础到进阶，知识点相互衔接 |
| 🏢 **产业聚焦** | 结合企业真实场景，学以致用 |
### 1.3 技能树全览
```
Java AI 技能树
├── AI 基础知识
│ ├── 数学基础（线性代数 / 概率统计 / 微积分）
│ ├── 机器学习（监督/无监督/强化学习）
│ ├── 深度学习（CNN / RNN / Transformer）
│ └── 大模型原理（GPT / BERT / Attention）
├── Java AI 生态
│ ├── LangChain4j ★★★★★（大模型应用首选）
│ ├── Spring AI ★★★★☆（企业集成首选）
│ ├── Deeplearning4j ★★★☆☆（自训练场景）
│ ├── ONNX Runtime ★★★☆☆（模型推理）
│ └── Weka ★★☆☆☆（传统机器学习）
├── 大模型应用开发
│ ├── Prompt 工程
│ ├── RAG 检索增强生成
│ ├── AI Agent 开发
│ ├── Function Calling
│ └── 多模态应用
└── 工程化能力
├── 微服务 AI 集成
├── 向量数据库运维
├── AI 应用性能优化
└── 监控与可观测性
```
---
## 二、AI 基础知识
> **说明**：作为工程师，数学不需要达到科研级别，但核心概念必须理解，才能看懂框架文档和调优参数。
### 2.1 数学基础（轻量化版）
#### 线性代数（最重要）
| 概念 | 在 AI 中的用途 | 学习重点 |
|------|--------------|---------|
| 向量 Vector | 文本嵌入、特征表示 | 点积、余弦相似度 |
| 矩阵 Matrix | 权重存储、变换计算 | 矩阵乘法、转置 |
| 张量 Tensor | 多维数据表示 | 维度理解、广播机制 |
| 特征值/向量 | PCA 降维 | 理解即可，无需手算 |
> 💡 推荐 3Blue1Brown「线性代数的本质」系列视频，非常直观。
#### 概率与统计
| 概念 | 在 AI 中的用途 |
|------|--------------|
| 条件概率、贝叶斯定理 | 分类模型基础 |
| 正态分布 | 权重初始化、数据分析 |
| 最大似然估计 MLE | 模型训练目标函数 |
| 交叉熵 Cross-Entropy | 分类任务损失函数 |
#### 微积分（工程向）
- **梯度**：理解反向传播的方向
- **链式法则**：神经网络梯度计算原理
- **梯度下降**：模型参数优化核心算法
> 💡 **工程师重点**：理解概念即可，不需要手推公式，框架会自动完成微分计算。
---
### 2.2 机器学习基础
#### 核心概念速览
```
机器学习
├── 监督学习 Supervised Learning
│ ├── 分类（Classification）— 逻辑回归、决策树、随机森林、SVM
│ └── 回归（Regression）— 线性回归、多项式回归
├── 无监督学习 Unsupervised Learning
│ ├── 聚类（K-Means、DBSCAN）
│ └── 降维（PCA、t-SNE）
└── 强化学习 Reinforcement Learning（了解即可）
└── RLHF：大模型对齐的核心技术
```
#### 必须掌握的 ML 概念
| 概念 | 说明 | 重要程度 |
|------|------|---------|
| 训练集/验证集/测试集 | 数据划分策略 | ★★★★★ |
| 过拟合/欠拟合 | 模型泛化问题 | ★★★★★ |
| 损失函数 | 衡量预测误差 | ★★★★★ |
| 梯度下降 | 参数优化方法 | ★★★★★ |
| 特征工程 | 数据预处理关键步骤 | ★★★★☆ |
| 超参数调优 | 模型性能提升 | ★★★★☆ |
| 交叉验证 | 评估模型可靠性 | ★★★☆☆ |
---
### 2.3 深度学习基础
#### 神经网络基础结构
```
前馈神经网络（Feedforward Neural Network）
输入层 → [隐藏层 1] → [隐藏层 2] → ... → 输出层
核心组件：
- 激活函数：ReLU / Sigmoid / Softmax / GELU
- 权重 & 偏置：可训练参数
- 反向传播：根据损失更新权重
- Batch Normalization：稳定训练过程
- Dropout：正则化防过拟合
```
#### 必了解的网络架构
| 架构 | 用途 | 对 Java AI 开发的意义 |
|------|------|---------------------|
| **CNN** 卷积神经网络 | 图像识别 | 图像分类 API 背后的原理 |
| **RNN/LSTM** 循环网络 | 序列数据、时序 | 理解文本序列处理 |
| **Transformer** | NLP、大模型核心 | ⭐ 必须重点理解，LLM 基础 |
| **BERT** | 文本理解、嵌入 | 向量化文本的基础 |
| **GPT 系列** | 文本生成 | 大模型应用开发核心 |
#### Transformer 架构简要理解
```
Transformer 核心机制：
输入文本
↓ Token Embedding（词向量化）
↓ Positional Encoding（位置编码）
↓ 多头自注意力机制（Multi-Head Self-Attention）
↓ 前馈神经网络（FFN）
↓ 输出：预测下一个 Token
核心创新：Self-Attention 允许模型关注序列中任意位置的关联
```
---
### 2.4 大模型（LLM）基础概念
| 概念 | 说明 |
|------|------|
| **Token** | 模型处理的最小文本单位（不等于字符） |
| **Context Window** | 模型一次能处理的最大 Token 数 |
| **Temperature** | 控制输出随机性（0=确定性，1=创造性） |
| **Top-P / Top-K** | 输出采样策略 |
| **Embedding** | 将文本转换为数值向量的过程 |
| **Fine-tuning** | 在预训练基础上针对特定任务继续训练 |
| **Prompt** | 给模型的输入指令 |
| **System Prompt** | 设定模型角色和行为的系统级提示 |
---
## 三、Java AI 生态栈详解
### 3.1 技术选型全景
```
Java AI 技术栈
┌─────────────────────────────────────────────────────────────┐
│ 应用层 Application Layer │
│ Spring Boot 微服务 / REST API / 业务逻辑 │
├─────────────────────────────────────────────────────────────┤
│ AI 应用框架层 AI Framework Layer │
│ LangChain4j（Agent/Chain/RAG） Spring AI（统一接口） │
├─────────────────────────────────────────────────────────────┤
│ 模型与推理层 Model & Inference Layer │
│ 大模型 API（OpenAI/文心/通义/Claude） ONNX Runtime 本地推理 │
│ Deeplearning4j 自训练模型 │
├─────────────────────────────────────────────────────────────┤
│ 数据层 Data Layer │
│ 向量数据库（Milvus/Chroma/PGVector） 传统 DB + 文档存储 │
└─────────────────────────────────────────────────────────────┘
```
---
### 3.2 LangChain4j ⭐（大模型应用开发首选）
> **定位**：Java 版的 LangChain，用于构建基于 LLM 的应用，是 Java AI 开发最重要的框架
#### Maven 依赖
```xml
dev.langchain4j
langchain4j
0.35.0
dev.langchain4j
langchain4j-open-ai
0.35.0
```
#### 核心功能示例
**1. 基础对话**
```java
ChatLanguageModel model = OpenAiChatModel.builder()
.apiKey("your-api-key")
.modelName("gpt-4o-mini")
.build();
String response = model.generate("请用一句话解释什么是 RAG？");
System.out.println(response);
```
**2. AI Service（声明式 AI 接口）**
```java
interface CustomerSupportAgent {
@SystemMessage("你是一个专业的客服助手，请友好且专业地回答用户问题。")
String answer(String question);
}
CustomerSupportAgent agent = AiServices.create(CustomerSupportAgent.class, model);
String answer = agent.answer("我的订单什么时候到货？");
```
**3. 流式输出**
```java
StreamingChatLanguageModel streamingModel = OpenAiStreamingChatModel.builder()
.apiKey("your-api-key")
.modelName("gpt-4o")
.build();
streamingModel.generate("写一首关于 Java 的诗", new StreamingResponseHandler<>() {
@Override
public void onNext(String token) {
System.out.print(token);
}
@Override
public void onComplete(Response response) {
System.out.println("\n完成！");
}
});
```
#### LangChain4j 学习路径
```
Week 1: 基础
✓ ChatModel 调用（OpenAI / 文心 / 通义）
✓ PromptTemplate 使用
✓ OutputParser 结果解析
✓ MessageHistory 对话历史
Week 2: 进阶
✓ AiServices 声明式 API
✓ EmbeddingModel 向量化
✓ DocumentLoader 文档加载
✓ InMemoryEmbeddingStore 向量存储
Week 3: RAG 系统
✓ EmbeddingStoreIngestor 文档导入
✓ EmbeddingStoreRetriever 相关检索
✓ RetrievalAugmentor 增强检索
Week 4: Agent 开发
✓ Tools/@Tool 工具定义
✓ 工具调用链
✓ 自定义 Agent
```
---
### 3.3 Spring AI ⭐（企业集成首选）
> **定位**：Spring 官方出品的 AI 集成框架，无缝融入 Spring 生态，适合企业级项目
#### Maven 依赖 & 配置
```xml
org.springframework.ai
spring-ai-openai-spring-boot-starter
1.0.0
```
```yaml
spring:
ai:
openai:
api-key: ${OPENAI_API_KEY}
chat:
options:
model: gpt-4o-mini
temperature: 0.7
```
#### 核心功能示例
**1. 自动注入使用**
```java
@RestController
public class ChatController {
@Autowired
private ChatClient chatClient;
@PostMapping("/chat")
public String chat(@RequestBody String message) {
return chatClient.prompt()
.user(message)
.call()
.content();
}
}
```
**2. 结构化输出**
```java
record ProductAnalysis(
String productName,
List pros,
List cons,
double rating
) {}
ProductAnalysis analysis = chatClient.prompt()
.user("分析这款产品：MacBook Pro M3")
.call()
.entity(ProductAnalysis.class); // 自动解析为 Java 对象
```
**3. SSE 流式输出**
```java
@GetMapping(value = "/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
public Flux streamChat(@RequestParam String message) {
return chatClient.prompt()
.user(message)
.stream()
.content();
}
```
#### Spring AI vs LangChain4j 对比
| 维度 | Spring AI | LangChain4j |
|------|-----------|-------------|
| 定位 | Spring 生态集成 | LLM 应用开发框架 |
| 学习曲线 | 低（Spring 用户友好） | 中（专门学习） |
| 适用场景 | 企业级 Spring Boot 项目 | 复杂 AI 应用、Agent |
| Agent 能力 | 基础 | 完整丰富 |
| RAG 支持 | 支持 | 支持且更完整 |
| 多模型统一接口 | ✅ 优秀 | ✅ 支持 |
> 💡 **建议**：两者结合使用，Spring AI 处理企业集成，LangChain4j 处理复杂 AI 逻辑
---
### 3.4 Deeplearning4j（自训练场景）
> **定位**：Java 深度学习框架，适合需要自己训练模型的场景（如企业私有数据建模）
#### 适用场景
- 企业内部分类/预测模型训练
- 自定义文本分类（如情感分析、意图识别）
- 时序数据预测（如异常检测、流量预测）
- 图像识别（在 Java 服务中内嵌）
#### 核心示例
```java
MultiLayerConfiguration config = new NeuralNetConfiguration.Builder()
.updater(new Adam(0.001))
.list()
.layer(new DenseLayer.Builder()
.nIn(784).nOut(256)
.activation(Activation.RELU)
.build())
.layer(new OutputLayer.Builder()
.nIn(256).nOut(10)
.activation(Activation.SOFTMAX)
.lossFunction(LossFunctions.LossFunction.MCXENT)
.build())
.build();
MultiLayerNetwork model = new MultiLayerNetwork(config);
model.init();
model.fit(trainingDataset);
```
---
### 3.5 ONNX Runtime for Java（模型推理）
> **定位**：跨平台模型推理引擎，可以加载 Python 训练的模型在 Java 中推理
#### 典型使用场景
```
Python 训练模型（PyTorch / TensorFlow）
↓ 导出 .onnx 文件
Java 服务使用 ONNX Runtime 加载运行
↓ 高性能推理
直接在 Spring Boot 服务中返回结果
```
#### 快速示例
```java
OrtEnvironment env = OrtEnvironment.getEnvironment();
OrtSession session = env.createSession("model.onnx");
float[] inputData = preprocessText(inputText);
OnnxTensor inputTensor = OnnxTensor.createTensor(env,
FloatBuffer.wrap(inputData),
new long[]{1, inputData.length});
Map inputs = Map.of("input", inputTensor);
OrtSession.Result result = session.run(inputs);
float[][] output = (float[][]) result.get(0).getValue();
```
---
### 3.6 向量数据库选型
| 数据库 | 特点 | Java 支持 | 推荐场景 |
|--------|------|----------|---------|
| **Milvus** | 专业向量数据库，高性能 | Java SDK | 大规模生产环境 |
| **Chroma** | 轻量易用，适合开发 | HTTP API | 开发测试阶段 |
| **PGVector** | PostgreSQL 扩展 | JDBC 支持 | 已有 PG 的项目 |
| **Redis Vector** | 低延迟 | Jedis/Lettuce | 实时检索场景 |
| **Qdrant** | 高性能，功能丰富 | REST API | 中大规模应用 |
---
## 四、大模型应用开发
### 4.1 Prompt 工程
#### Prompt 设计六要素
```
1. 角色设定（Role）
"你是一位经验丰富的 Java 架构师..."
2. 任务描述（Task）
"请帮我审查以下代码并指出潜在问题..."
3. 背景信息（Context）
"这是一个高并发电商系统，QPS 约 10000..."
4. 约束条件（Constraints）
"只使用 Java 17 及以上语法，不使用第三方库..."
5. 输出格式（Format）
"请以 JSON 格式输出，包含字段：问题、严重程度、修改建议"
6. 示例（Examples / Few-Shot）
"例如：{'issue': '空指针风险', 'severity': '高', 'suggestion': '添加 null 检查'}"
```
#### Prompt 模板管理
```java
PromptTemplate template = PromptTemplate.from(
"你是一个 {{role}}。\n" +
"请针对以下需求生成 Java 代码：{{requirement}}\n" +
"要求：{{constraints}}"
);
Prompt prompt = template.apply(Map.of(
"role", "高级 Java 后端工程师",
"requirement", "实现一个线程安全的缓存组件",
"constraints", "使用 Java 17，基于 ConcurrentHashMap"
));
```
---
### 4.2 RAG（检索增强生成）⭐
> **RAG 是当前企业 AI 应用最核心的技术**，解决大模型"幻觉"和知识时效问题
#### RAG 工作流程
```
【索引阶段（离线处理）】
原始文档（PDF / Word / 网页 / 数据库）
↓ 文档加载 Document Loader
↓ 分块处理（Chunk Splitting，每块约 500~1000 Token）
↓ 向量化（Embedding Model）
↓ 存入向量数据库
【检索阶段（在线处理）】
用户提问
↓ 问题向量化
↓ 向量相似度检索（Top-K 最相关文档块）
↓ Context 注入 Prompt
↓ LLM 生成最终回答（基于检索到的上下文）
↓ 返回给用户
```
#### RAG 完整实现（LangChain4j）
```java
@Service
public class RagService {
@Autowired private EmbeddingModel embeddingModel;
@Autowired private EmbeddingStore embeddingStore;
@Autowired private ChatLanguageModel chatModel;
// 文档索引
public void indexDocument(String filePath) {
Document document = FileSystemDocumentLoader.loadDocument(filePath);
DocumentSplitter splitter = DocumentSplitters.recursive(512, 50);
EmbeddingStoreIngestor ingestor = EmbeddingStoreIngestor.builder()
.documentSplitter(splitter)
.embeddingModel(embeddingModel)
.embeddingStore(embeddingStore)
.build();
ingestor.ingest(document);
}
// RAG 查询
public String query(String question) {
EmbeddingStoreContentRetriever retriever =
EmbeddingStoreContentRetriever.builder()
.embeddingStore(embeddingStore)
.embeddingModel(embeddingModel)
.maxResults(5)
.minScore(0.7)
.build();
interface KnowledgeAssistant {
String answer(@UserMessage String question);
}
KnowledgeAssistant assistant = AiServices.builder(KnowledgeAssistant.class)
.chatLanguageModel(chatModel)
.contentRetriever(retriever)
.build();
return assistant.answer(question);
}
}
```
#### RAG 优化策略
| 优化方向 | 方法 | 效果 |
|---------|------|------|
| 分块策略 | 按句子/段落分块 vs 固定长度 | 提升召回质量 |
| 混合检索 | 向量检索 + BM25 关键词检索 | 提升召回率 |
| 重排序 | CrossEncoder Reranker 精排 | 提升精排质量 |
| Query 改写 | 将用户问题改写为更利于检索的形式 | 提升相关性 |
| HyDE | 生成假设文档再检索 | 提升语义匹配 |
---
### 4.3 AI Agent 开发
> **Agent = LLM + 工具调用 + 规划能力 + 记忆**，是当前 AI 最热门的工程方向
#### Agent 工作循环（ReAct 模式）
```
用户请求
↓ LLM 思考（Reasoning）：分析任务，决定下一步
↓ 选择工具（Action）：调用 API / 数据库 / 计算 / 搜索
↓ 获取结果（Observation）：工具执行结果返回 LLM
↓ 循环直到任务完成
↓ 最终回答给用户
```
#### Tool 定义（LangChain4j）
```java
public class OrderTools {
@Tool("根据订单ID查询订单状态")
public OrderStatus getOrderStatus(
@P("订单ID，格式如 ORD-12345") String orderId) {
return orderService.findById(orderId);
}
@Tool("取消订单")
public String cancelOrder(
@P("订单ID") String orderId,
@P("取消原因") String reason) {
return orderService.cancel(orderId, reason);
}
@Tool("查询商品库存")
public int checkInventory(@P("商品SKU编码") String sku) {
return inventoryService.getStock(sku);
}
}
// 创建 Agent
interface CustomerServiceAgent {
@SystemMessage("""
你是一个智能客服 Agent，可以：
1. 查询订单状态
2. 处理取消申请
3. 查看商品库存
请根据用户需求调用相应工具完成任务。
""")
String serve(@UserMessage String userRequest);
}
CustomerServiceAgent agent = AiServices.builder(CustomerServiceAgent.class)
.chatLanguageModel(model)
.tools(new OrderTools())
.chatMemory(MessageWindowChatMemory.withMaxMessages(10))
.build();
```
---
### 4.4 Function Calling（Spring AI）
```java
@Component
public class WeatherFunction implements Function {
@Override
public WeatherResponse apply(WeatherRequest request) {
return weatherApiService.getWeather(request.city());
}
}
@Bean
public FunctionCallback weatherFunctionCallback(WeatherFunction weatherFunction) {
return FunctionCallbackWrapper.builder(weatherFunction)
.withName("getCurrentWeather")
.withDescription("获取指定城市的当前天气信息")
.withInputType(WeatherRequest.class)
.build();
}
```
---
## 五、工程化实践
### 5.1 AI 微服务架构设计
```
企业 AI 微服务架构：
┌──────────────────────────────────────────────────────────────┐
│ API Gateway（鉴权 / 限流 / 路由） │
└──────────────────────┬───────────────────────────────────────┘
│
┌────────────────┼────────────────┐
▼ ▼ ▼
┌───────────┐ ┌───────────┐ ┌───────────────┐
│ 对话服务 │ │ RAG 服务 │ │ Agent 服务 │
│ Chat API │ │ 知识库检索 │ │ 自动化任务 │
└───────────┘ └───────────┘ └───────────────┘
│ │ │
└────────────────┼────────────────┘
▼
┌─────────────────┐
│ 向量数据库 │
│ Milvus/PGVector │
└─────────────────┘
```
### 5.2 限流与成本控制
```java
// 基于 Bucket4j 的 Token 消耗限流
@Component
public class LlmRateLimiter {
private final Bucket bucket;
public LlmRateLimiter() {
// 每分钟最多消耗 100,000 Token
Bandwidth limit = Bandwidth.classic(100000,
Refill.intervally(100000, Duration.ofMinutes(1)));
this.bucket = Bucket.builder().addLimit(limit).build();
}
public void consumeTokens(int tokenCount) {
if (!bucket.tryConsume(tokenCount)) {
throw new RateLimitExceededException("LLM Token 消耗限流，请稍后重试");
}
}
}
```
### 5.3 Prompt 缓存（降低成本）
```java
@Service
public class CachedLlmService {
@Autowired private ChatLanguageModel model;
@Autowired private RedisTemplate redisTemplate;
public String generateWithCache(String prompt) {
String cacheKey = "llm:cache:" + DigestUtils.md5Hex(prompt);
// 命中缓存直接返回
String cached = redisTemplate.opsForValue().get(cacheKey);
if (cached != null) return cached;
// 调用 LLM
String result = model.generate(prompt);
// 缓存 24 小时
redisTemplate.opsForValue().set(cacheKey, result, 24, TimeUnit.HOURS);
return result;
}
}
```
### 5.4 可观测性 & 监控
```java
// 使用 Micrometer 监控 LLM 调用
@Component
public class LlmMetrics {
private final MeterRegistry registry;
private final Counter llmCallCounter;
private final Timer llmResponseTimer;
public LlmMetrics(MeterRegistry registry) {
this.registry = registry;
this.llmCallCounter = Counter.builder("llm.calls.total")
.description("LLM 调用总次数")
.register(registry);
this.llmResponseTimer = Timer.builder("llm.response.time")
.description("LLM 响应时间")
.register(registry);
}
public String callWithMetrics(ChatLanguageModel model, String prompt) {
llmCallCounter.increment();
return llmResponseTimer.record(() -> model.generate(prompt));
}
}
```
### 5.5 AI 应用部署最佳实践
| 部署方向 | 方案 | 说明 |
|---------|------|------|
| **容器化** | Docker + K8s | 标准化部署，弹性伸缩 |
| **API 密钥管理** | Vault / K8s Secret | 绝不硬编码 API Key |
| **模型降级** | 主模型故障切备用模型 | 提高可用性 |
| **日志链路** | Tracing + 请求 ID | 便于问题排查 |
| **本地模型** | Ollama + LangChain4j | 私有化部署场景 |
---
## 六、学习资源推荐
### 6.1 推荐书籍
| 书名 | 语言 | 适合阶段 | 评分 |
|------|------|---------|------|
| 《动手学深度学习》 | 中文 | AI 基础 | ★★★★★ |
| 《机器学习》（周志华·西瓜书） | 中文 | AI 基础进阶 | ★★★★☆ |
| 《大规模语言模型》 | 中文 | LLM 原理 | ★★★★★ |
| Building LLM Apps（英文） | 英文 | LLM 应用开发 | ★★★★☆ |
| 《Spring Boot 实战》 | 中文 | Spring 基础 | ★★★★☆ |
### 6.2 在线课程
| 课程 | 平台 | 适合阶段 |
|------|------|---------|
| 吴恩达《Machine Learning Specialization》 | Coursera | AI 基础 |
| 吴恩达《Deep Learning Specialization》 | Coursera | 深度学习 |
| 《大模型应用开发 LangChain4j》 | B站/慕课 | 框架入门 |
| Spring AI 官方文档 + 示例 | spring.io | Spring AI |
| LangChain4j 官方文档 | langchain4j.dev | LangChain4j |
| 《Prompt Engineering Guide》 | promptingguide.ai | Prompt 工程 |
### 6.3 GitHub 开源项目（重点研究）
| 项目 | 地址 | 价值 |
|------|------|------|
| langchain4j | github.com/langchain4j/langchain4j | Java AI 框架核心 |
| spring-ai | github.com/spring-projects/spring-ai | Spring AI 源码 |
| deeplearning4j | github.com/deeplearning4j | DL4J 框架 |
| spring-ai-alibaba | github.com/alibaba/spring-ai-alibaba | 阿里 AI 集成 |
| langchain4j-examples | github.com/langchain4j/langchain4j-examples | 官方示例 ⭐ |
### 6.4 技术社区 & 博客
- **掘金**：Java AI 实践文章丰富
- **InfoQ**：架构级 AI 工程内容
- **LangChain4j Discord**：官方社区，可提问
- **Spring AI GitHub Issues**：关注最新动态
- **微信公众号**：JavaAI、阿里云开发者、Spring官方博客
---
## 七、时间规划与里程碑
### 7.1 总体时间规划
```
月份 阶段 核心目标
────────────────────────────────────────────────────────
1-2月 🌱 AI 基础阶段 掌握 ML/DL 核心概念
3-4月 🔧 Java AI 框架阶段 熟练使用 LangChain4j + Spring AI
5-6月 🤖 大模型应用开发阶段 能独立构建 RAG 和 Agent 系统
7-8月 ⚙️ 工程化实践阶段 具备生产级 AI 应用开发能力
9-12月 🚀 进阶深化阶段 专项深化 + 求职/晋升准备
```
### 7.2 详细阶段计划
#### 第一阶段：AI 基础（第 1-2 月）
**学习目标**
- [ ] 理解机器学习核心概念（监督/无监督/强化学习）
- [ ] 掌握深度学习基础（神经网络、反向传播、常见架构）
- [ ] 理解 Transformer 和注意力机制原理
- [ ] 了解大模型（LLM）的工作原理和关键概念
**每周计划**
| 周次 | 内容 | 资源 |
|------|------|------|
| Week 1-2 | 线性代数 + 概率统计基础 | 3Blue1Brown 视频 |
| Week 3-4 | 机器学习基础（西瓜书前5章） | 西瓜书 + 吴恩达课程 |
| Week 5-6 | 深度学习基础（动手学DL 1-5章） | 动手学深度学习 |
| Week 7-8 | Transformer / BERT / GPT 原理 | 论文精读 + B站视频 |
**实践项目**：用 Weka/DL4J 实现一个简单文本分类器（如垃圾邮件过滤）
---
#### 第二阶段：Java AI 框架（第 3-4 月）
**学习目标**
- [ ] 熟练使用 LangChain4j 构建对话应用
- [ ] 掌握 Spring AI 企业级集成
- [ ] 了解 ONNX Runtime 模型推理
- [ ] 能接入国内主流大模型 API（文心、通义、智谱）
**每周计划**
| 周次 | 内容 | 资源 |
|------|------|------|
| Week 1-2 | LangChain4j 基础：对话/模板/解析 | 官方文档 + examples |
| Week 3-4 | Spring AI 集成：自动注入/Prompt/输出解析 | Spring AI 官方文档 |
| Week 5-6 | 向量化 + 向量数据库（Chroma/PGVector） | LangChain4j 文档 |
| Week 7-8 | ONNX Runtime 集成 + 国内 API 适配 | ONNX 官方文档 |
**实践项目**：构建一个多轮对话客服机器人（Spring Boot + LangChain4j + 通义千问）
---
#### 第三阶段：大模型应用开发（第 5-6 月）
**学习目标**
- [ ] 掌握 Prompt 工程最佳实践
- [ ] 独立构建完整 RAG 知识库系统
- [ ] 开发基于工具调用的 AI Agent
- [ ] 理解 Function Calling 机制
**每周计划**
| 周次 | 内容 | 资源 |
|------|------|------|
| Week 1-2 | Prompt 工程实战（Few-Shot / CoT / Self-Consistency） | Prompt Engineering Guide |
| Week 3-5 | RAG 系统完整实现（索引+检索+优化） | LangChain4j RAG 文档 |
| Week 6-7 | AI Agent 开发（工具定义 + 调用链） | LangChain4j Agent 文档 |
| Week 8 | Function Calling + 多模态初探 | Spring AI 文档 |
**实践项目**：企业知识库问答系统（RAG + Milvus + Spring Boot）
---
#### 第四阶段：工程化实践（第 7-8 月）
**学习目标**
- [ ] 掌握 AI 微服务架构设计
- [ ] 学会 LLM 调用限流和成本控制
- [ ] 实现 AI 应用的监控和可观测性
- [ ] 完成一个完整的生产级 AI 应用
**实践项目**：完整的企业级 AI 助手系统
- 对话服务（Spring AI + WebSocket）
- 知识库（RAG + Milvus）
- 任务 Agent（LangChain4j + 工具调用）
- 监控面板（Micrometer + Grafana）
---
#### 第五阶段：进阶深化（第 9-12 月）
根据个人方向选择专项深化：
| 方向 | 内容 | 适合人群 |
|------|------|---------|
| **LLM 应用架构师** | 多 Agent 系统、工作流引擎 | 希望做架构设计 |
| **AI 平台工程** | 模型管理、A/B 测试、评估体系 | 希望做平台建设 |
| **垂直领域 AI** | 金融/医疗/法律 AI 应用 | 有行业背景 |
| **本地化部署** | Ollama + 私有化大模型运维 | 对私有化感兴趣 |
---
### 7.3 阶段里程碑 & 能力检验
| 里程碑 | 时间 | 能力标准 |
|--------|------|---------|
| M1: AI 入门 | 第 2 月末 | 能解释 Transformer 架构，能用 DL4J 训练简单模型 |
| M2: 框架掌握 | 第 4 月末 | 独立构建多轮对话应用，熟练使用 LangChain4j |
| M3: RAG 达标 | 第 6 月末 | 独立完成生产可用的企业知识库问答系统 |
| M4: 工程化 | 第 8 月末 | 完成完整 AI 微服务系统，含监控和限流 |
| M5: 专项深化 | 第 12 月末 | 具备某方向的核心竞争力，可参与/主导 AI 项目 |
---
### 7.4 实践项目清单
| 序号 | 项目名称 | 技术栈 | 难度 | 阶段 |
|------|---------|--------|------|------|
| P1 | 文本分类器 | DL4J / Weka | ⭐⭐ | 第一阶段 |
| P2 | 多轮对话客服机器人 | Spring Boot + LangChain4j + 通义 | ⭐⭐⭐ | 第二阶段 |
| P3 | 企业知识库问答系统 | RAG + Milvus + Spring AI | ⭐⭐⭐⭐ | 第三阶段 |
| P4 | 智能工单处理 Agent | LangChain4j Tools + Spring Boot | ⭐⭐⭐⭐ | 第三阶段 |
| P5 | 完整 AI 助手平台 | 全栈（对话+知识库+Agent+监控） | ⭐⭐⭐⭐⭐ | 第四阶段 |
---
## 附录：Java AI 常用 API 速查
### 国内主流大模型 API 接入
| 模型 | 提供商 | LangChain4j 支持 | Spring AI 支持 |
|------|--------|-----------------|---------------|
| 文心一言（ERNIE） | 百度 | ✅ | ✅ |
| 通义千问（Qwen） | 阿里云 | ✅ | ✅（via Alibaba AI） |
| ChatGLM | 智谱 AI | ✅ | ✅ |
| 混元（Hunyuan） | 腾讯 | ✅ | ✅ |
| DeepSeek | 深度求索 | ✅（兼容 OpenAI API） | ✅ |
| Kimi | 月之暗面 | ✅（兼容 OpenAI API） | ✅ |
### 快速接入通义千问（LangChain4j）
```java
// Maven 依赖
// dev.langchain4j:langchain4j-dashscope:0.35.0
ChatLanguageModel qwenModel = QwenChatModel.builder()
.apiKey(System.getenv("DASHSCOPE_API_KEY"))
.modelName(QwenModelName.QWEN_MAX)
.build();
String response = qwenModel.generate("你好，请介绍一下自己");
```
### 快速接入 DeepSeek
```java
// DeepSeek 兼容 OpenAI API，直接用 OpenAI 客户端接入
ChatLanguageModel deepSeekModel = OpenAiChatModel.builder()
.apiKey(System.getenv("DEEPSEEK_API_KEY"))
.baseUrl("https://api.deepseek.com")
.modelName("deepseek-chat")
.build();
```
---
> 📌 **温馨提示**：AI 领域技术迭代极快，学习过程中要关注 LangChain4j、Spring AI 的版本更新。建议在 GitHub 上 Star 这两个项目，及时跟进新特性。
>
> 💪 **坚持就是胜利**：从 Java 后端到 Java AI，你已经具备了最重要的工程化基础，剩下的就是系统性地补充 AI 知识体系，加油！
---
*文档版本：v1.0 | 最后更新：2026年6月*