Java AI 完整学习笔记

日日行不惧千万里2026-07-18 8:51

Java AI 完整学习笔记

版本 ：v1.0 | 更新时间 ：2026年7月 | 适用人群：Java开发者转型AI应用开发

定位：准确、专业、深入的企业级Java AI开发指南，覆盖从入门到生产落地全链路

目录

第一部分：基础认知与前置准备

1.1 Java开发者的AI转型优势

作为Java开发者，你在AI应用开发领域具备天然优势：

优势领域 具体体现
工程化能力 微服务架构、分布式系统、高并发处理经验
企业集成经验 熟悉数据库、消息队列、缓存、监控等中间件
类型安全 强类型系统在AI结构化输出场景下优势明显
性能调优 JVM调优、GC优化、线程池管理经验可直接复用
生态成熟 Spring Boot生态为AI应用提供完善的基础设施

核心认知 ：Java开发者的主战场是AI应用层 和工程化层，而非算法研究层。你不需要从零推导反向传播，但必须理解大模型的工作原理和边界。

1.2 必备前置知识

1.2.1 Java核心强化（必须掌握）
java 复制代码 
// 1. 函数式编程与Stream API - AI响应处理大量使用
List<Document> relevantDocs = documents.stream()
    .filter(doc -> similarityScore(doc, query) > threshold)
    .sorted(Comparator.comparingDouble(this::similarityScore).reversed())
    .limit(5)
    .toList();

// 2. CompletableFuture异步编程 - 流式响应、并行工具调用
CompletableFuture<String> future = CompletableFuture
    .supplyAsync(() -> chatModel.call(prompt), executor)
    .thenApply(this::postProcess);

// 3. 注解处理与反射 - @Tool、@AiService等框架核心机制
// 4. 泛型与类型推断 - 结构化输出的核心基础
// 5. 响应式编程(WebFlux) - SSE流式输出必备
1.2.2 AI基础概念快速入门
概念 通俗解释 Java类比
Token 大模型处理文本的最小单位（约1个汉字=1-2Token） 字节码指令
Prompt 给大模型的指令和上下文 方法入参
Completion 大模型生成的回复 方法返回值
Temperature 控制输出随机性，0=确定性，1=创造性 随机数种子
Embedding 将文本转换为高维向量，用于语义搜索 对象序列化
Context Window 模型能处理的最大Token数（上下文长度） JVM堆内存大小
Hallucination 模型编造不存在的事实 空指针异常（必须防御）
1.2.3 数学基础（按需学习，不用深究）
  • 必知：向量运算（余弦相似度、点积）、概率分布基础
  • 了解：矩阵乘法、梯度下降概念
  • 不用：手推反向传播、证明数学定理

第二部分：Java AI生态全景

2.1 框架选型决策矩阵

框架 定位 核心优势 适用场景 成熟度
Spring AI Spring官方AI框架 无缝Spring生态、企业级特性、可观测性 Spring技术栈团队、企业级应用 ★★★★★
LangChain4j Java版LangChain 功能最全、模块化、社区活跃、Agent能力强 复杂AI工作流、RAG、Agent开发 ★★★★★
Spring AI Alibaba 阿里国产大模型适配 通义千问深度集成、中文优化、国产化支持 国内大模型、阿里云生态 ★★★★☆
Semantic Kernel 微软AI编排框架 Azure生态、多语言支持、规划器强 微软技术栈、Azure OpenAI ★★★★☆
Deeplearning4j Java深度学习框架 分布式训练、支持CNN/RNN 传统机器学习、图像/NLP处理 ★★★☆☆
DJL AWS深度学习库 多引擎支持、Python模型Java部署 本地模型推理、ONNX部署 ★★★★☆

选型建议：

  • 已有Spring Boot项目 → Spring AI
  • 需要复杂RAG/Agent能力 → LangChain4j
  • 使用国产大模型 → Spring AI Alibaba
  • 本地部署模型推理 → DJL + ONNX Runtime

2.2 技术栈全景图

复制代码 
┌─────────────────────────────────────────────────────────┐
│                    应用层 (Application)                  │
│  智能客服 │ 知识库问答 │ AI助手 │ 代码生成 │ 数据分析     │
├─────────────────────────────────────────────────────────┤
│                    编排层 (Orchestration)                │
│  Prompt模板 │ 对话记忆 │ 工具调用 │ RAG流水线 │ Agent    │
├─────────────────────────────────────────────────────────┤
│                    框架层 (Framework)                    │
│     Spring AI    │    LangChain4j    │   Semantic Kernel │
├─────────────────────────────────────────────────────────┤
│                    模型层 (Models)                       │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐   │
│  │  云端大模型  │  │  本地大模型  │  │  Embedding模型│   │
│  │ GPT/通义/文心│  │ Ollama/LLaMA │  │ BGE/Text2Vec │   │
│  └──────────────┘  └──────────────┘  └──────────────┘   │
├─────────────────────────────────────────────────────────┤
│                    存储层 (Storage)                      │
│  ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐   │
│  │ 向量数据库│ │ 关系数据库│ │ 文档存储 │ │ 缓存     │   │
│  │Milvus/PG │ │ MySQL/PG │ │ MinIO/OSS│ │ Redis    │   │
│  └──────────┘ └──────────┘ └──────────┘ └──────────┘   │
└─────────────────────────────────────────────────────────┘

第三部分：核心框架深度解析

3.1 Spring AI 核心架构

3.1.1 设计理念

Spring AI的核心设计原则是**"可移植的AI抽象"**：

  • 一套代码支持20+种AI模型
  • 与Spring Boot/Cloud无缝集成
  • 提供企业级特性（可观测性、安全性、配置管理）
3.1.2 核心API
java 复制代码 
// 1. ChatClient - 对话客户端（推荐使用，Fluent API）
@RestController
public class ChatController {

    private final ChatClient chatClient;

    public ChatController(ChatClient.Builder builder) {
        this.chatClient = builder.build();
    }

    // 简单调用
    @GetMapping("/chat")
    public String chat(@RequestParam String message) {
        return chatClient.prompt()
                .user(message)
                .call()
                .content();
    }

    // 流式响应（SSE）
    @GetMapping(value = "/chat/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
    public Flux<String> chatStream(@RequestParam String message) {
        return chatClient.prompt()
                .user(message)
                .stream()
                .content();
    }

    // 结构化输出（Spring AI 2.0支持自校正）
    @GetMapping("/extract")
    public CustomerInfo extract(@RequestParam String text) {
        return chatClient.prompt()
                .user("从以下文本提取客户信息：" + text)
                .call()
                .entity(CustomerInfo.class);
    }

    public record CustomerInfo(String name, String phone, String email) {}
}
3.1.3 Advisor机制（AOP思想）

Spring AI使用Advisor实现横切关注点，类似Spring AOP：

java 复制代码 
// 内置Advisor：
// 1. MessageChatMemoryAdvisor - 对话记忆
// 2. QuestionAnswerAdvisor - RAG检索增强
// 3. SafeGuardAdvisor - 内容安全防护

chatClient.prompt()
    .user(message)
    .advisors(
        MessageChatMemoryAdvisor.builder(chatMemory).build(),
        QuestionAnswerAdvisor.builder(vectorStore).build(),
        new LoggingAdvisor()  // 自定义Advisor：日志记录
    )
    .call()
    .content();
3.1.4 工具调用（Function Calling）
java 复制代码 
// 1. 定义工具方法
@Component
public class WeatherTools {

    @Tool("获取指定城市的当前天气")
    public String getWeather(@ToolParam(description = "城市名称") String city) {
        // 调用真实天气API
        return city + "：晴，25°C，微风";
    }
}

// 2. 注册并使用
@Bean
public ChatClient weatherChatClient(ChatClient.Builder builder, WeatherTools tools) {
    return builder
            .defaultTools(tools)
            .build();
}

// AI会自动决定是否调用天气工具
String response = chatClient.prompt()
    .user("北京今天天气怎么样？")
    .call()
    .content();
// 输出：北京今天天气晴，温度25°C，适合外出。

3.2 LangChain4j 深度解析

3.2.1 核心理念

LangChain4j是Java生态功能最完整的AI应用开发框架，采用声明式AI服务设计：

java 复制代码 
// 声明式AI服务 - 类似Feign的体验
interface CustomerSupportAgent {

    @SystemMessage("""
        你是专业的电商客服助手。
        回答要礼貌、专业、简洁。
        如果不知道答案，不要编造，转人工处理。
        """)
    String chat(@UserMessage String userMessage);
}

// 构建并使用
CustomerSupportAgent agent = AiServices.builder(CustomerSupportAgent.class)
    .chatModel(chatModel)
    .tools(orderTools, refundTools)
    .chatMemory(MessageWindowChatMemory.withMaxMessages(20))
    .build();

String answer = agent.chat("我的订单什么时候发货？");
3.2.2 核心模块
模块 职责 核心类
Chat Language Model 大模型统一接口 ChatModel, StreamingChatModel
Chat Memory 对话记忆管理 ChatMemory, MessageWindowChatMemory
Documents 文档处理 DocumentLoader, DocumentSplitter
Embeddings 文本向量化 EmbeddingModel, InMemoryEmbeddingStore
RAG 检索增强生成 EmbeddingStoreContentRetriever, DefaultRetrievalAugmentor
Tools 工具调用 @Tool, ToolSpecification
AI Services 声明式服务 AiServices, @SystemMessage
3.2.3 RAG完整流水线
java 复制代码 
// 1. 文档加载
Document document = FileSystemDocumentLoader.loadDocument("manual.pdf");

// 2. 文档分片
DocumentSplitter splitter = DocumentSplitters.recursive(
    300,    // 每个分片最大Token数
    50,     // 重叠Token数（保证上下文连贯）
    new OpenAiTokenizer()
);
List<TextSegment> segments = splitter.split(document);

// 3. 向量化并存储
EmbeddingModel embeddingModel = new BgeSmallZhEmbeddingModel();
List<Embedding> embeddings = embeddingModel.embedAll(segments).content();
EmbeddingStore<TextSegment> embeddingStore = new InMemoryEmbeddingStore<>();
embeddingStore.addAll(embeddings, segments);

// 4. 创建检索器
ContentRetriever retriever = EmbeddingStoreContentRetriever.builder()
    .embeddingStore(embeddingStore)
    .embeddingModel(embeddingModel)
    .maxResults(5)
    .minScore(0.7)
    .build();

// 5. 构建RAG增强的AI服务
Assistant assistant = AiServices.builder(Assistant.class)
    .chatModel(chatModel)
    .contentRetriever(retriever)
    .build();

3.3 Spring AI Alibaba（国产大模型方案）

3.3.1 快速集成
xml 复制代码 
<!-- pom.xml -->
<dependency>
    <groupId>com.alibaba.cloud.ai</groupId>
    <artifactId>spring-ai-alibaba-starter-dashscope</artifactId>
    <version>1.0.0-M6</version>
</dependency>
yaml 复制代码 
# application.yml
spring:
  ai:
    dashscope:
      api-key: ${DASHSCOPE_API_KEY}
      chat:
        options:
          model: qwen-plus  # 通义千问Plus
          temperature: 0.7
java 复制代码 
@RestController
public class QwenController {

    @Autowired
    private ChatClient chatClient;

    @GetMapping("/qwen")
    public String chat(@RequestParam String message) {
        return chatClient.prompt()
                .user(message)
                .call()
                .content();
    }
}
3.3.2 支持的国产模型
模型 能力 适用场景 成本参考
qwen-turbo 快速响应 简单对话、分类、摘要 极低（百万Token≈0.8元）
qwen-plus 平衡性能 通用场景、RAG、工具调用 低（百万Token≈4元）
qwen-max 最强能力 复杂推理、Agent、代码生成 中（百万Token≈20元）
qwen-vl-max 多模态 图片理解、OCR、图表分析 中
text-embedding-v3 向量模型 中文Embedding、RAG 极低

生产建议：简单任务用qwen-turbo，通用场景用qwen-plus，复杂推理才用qwen-max，成本可降低80%以上。

第四部分：核心技术专题

4.1 Prompt Engineering（提示词工程）

4.1.1 结构化Prompt模板
java 复制代码 
// 好的Prompt结构：角色 + 任务 + 约束 + 输出格式 + 示例
@SystemMessage("""
    # 角色
    你是资深Java代码审查专家，有10年阿里巴巴Java开发经验。
    
    # 任务
    审查用户提供的Java代码，找出潜在问题。
    
    # 约束
    1. 严格遵循《阿里巴巴Java开发手册》
    2. 重点关注：NPE风险、并发安全、性能问题、SQL注入
    3. 每个问题必须给出：位置、问题描述、修复建议、严重级别
    4. 不要编造不存在的问题
    
    # 输出格式（JSON）
    {
      "issues": [
        {
          "line": 行号,
          "severity": "BLOCKER/CRITICAL/MAJOR/MINOR",
          "description": "问题描述",
          "suggestion": "修复建议",
          "codeExample": "修复后的代码示例"
        }
      ],
      "summary": "整体评价和改进建议"
    }
    """)
String reviewCode(@UserMessage String code);
4.1.2 高级技巧
技巧 用途 示例
Few-Shot 给模型几个示例，显著提升输出质量 提供2-3个正确的输入输出样例
Chain of Thought 让模型一步步思考，提升推理准确率 "请一步步思考，最后给出答案"
Self-Consistency 多次采样取一致结果，降低幻觉 温度设为0.7，采样3次取多数
ReAct 推理+行动循环，Agent核心模式 Thought → Action → Observation循环

4.2 RAG（检索增强生成）

4.2.1 RAG解决的核心问题
  1. 知识截止：模型训练数据有截止日期，无法获取最新信息
  2. 幻觉问题：模型会编造看似合理但错误的答案
  3. 私有数据：企业内部文档、数据无法用于训练公有模型
  4. 数据安全：敏感数据不能发送给第三方模型训练
4.2.2 RAG完整架构
复制代码 
用户提问 → 查询重写 → 向量检索 → 重排序 → 上下文构建 → LLM生成 → 答案
           ↓           ↓         ↓
        同义词扩展   相似度计算  相关性过滤
        意图识别     关键词匹配  去重压缩
4.2.3 关键优化点

1. 文档分片策略

java 复制代码 
// 推荐配置：
// - 通用文档：chunkSize=500, overlap=100
// - 技术文档：chunkSize=800, overlap=150（保留完整代码块）
// - 法律/合同：chunkSize=1000, overlap=200（保留条款完整性）
DocumentSplitter splitter = DocumentSplitters.recursive(
    500, 100,
    DocumentSplitter.PARAGRAPH_SPLITTERS,
    DocumentSplitter.SENTENCE_SPLITTERS
);

2. 检索优化

  • 混合检索：向量检索 + 关键词检索（BM25）+ RRF融合
  • 重排序（Rerank）：使用BGE-Reranker对初筛结果二次排序
  • 元数据过滤：按部门、文档类型、时间范围提前过滤
  • 多查询扩展：将用户问题重写为多个相似查询，合并结果

3. 高级RAG模式

  • Parent-Child Retrieval：检索小块，返回父文档完整上下文
  • Hypothetical Questions：为每个文档生成可能的问题，提升召回
  • Self-RAG：模型自己判断是否需要检索、检索结果是否相关
  • Agentic RAG：Agent自主决定检索策略、多轮检索、调用工具

4.3 Function Calling（工具调用）

4.3.1 工作原理
复制代码 
用户问题 → LLM判断是否需要调用工具 → 生成工具调用JSON → 执行Java方法 → 结果返回LLM → 生成最终答案
4.3.2 最佳实践
java 复制代码 
public class OrderTools {

    private final OrderService orderService;

    // 1. 工具描述必须清晰准确
    @Tool("根据订单号查询订单详细信息，包含订单状态、物流信息、商品明细、金额")
    public OrderInfo getOrderDetail(
            @P("订单编号，格式为ORD开头加12位数字，例如ORD202607010001") String orderNo) {
        
        // 2. 参数校验在Java层做，不要依赖LLM
        if (!orderNo.matches("^ORD\\d{12}$")) {
            return OrderInfo.error("订单号格式不正确");
        }
        
        // 3. 异常处理必须完善，返回友好信息
        try {
            return orderService.getById(orderNo);
        } catch (Exception e) {
            log.error("查询订单失败", e);
            return OrderInfo.error("查询订单失败，请稍后重试");
        }
    }

    // 4. 工具粒度要适中：太粗LLM不会用，太细调用次数多
    @Tool("查询用户的订单列表，支持按状态筛选")
    public List<OrderInfo> getUserOrders(
            @P("用户ID") String userId,
            @P("订单状态：PENDING_PAYMENT/PAID/SHIPPED/COMPLETED/CANCELLED，可选") String status,
            @P("页码，从1开始") int page,
            @P("每页数量，最大50") int pageSize) {
        // 实现
    }
}
4.3.3 常见陷阱
  • ❌ 工具描述模糊：LLM不知道什么时候用
  • ❌ 参数太复杂：嵌套对象LLM容易传错
  • ❌ 没有返回值：LLM不知道调用结果
  • ❌ 同步阻塞：工具执行太久导致超时
  • ✅ 一个工具只做一件事
  • ✅ 参数都是简单类型（String/Integer/Boolean）
  • ✅ 返回结构化的错误信息
  • ✅ 异步执行+超时控制

4.4 AI Agent（智能体）

4.4.1 Agent核心架构
复制代码 
┌─────────────────────────────────────────┐
│              Agent Core                 │
│  ┌─────────┐  ┌────────┐  ┌─────────┐  │
│  │ Planner │→│Executor│→│Reflector│  │
│  └─────────┘  └────────┘  └─────────┘  │
│        ↓          ↓          ↑         │
│  ┌─────────────────────────────────┐   │
│  │           Memory                │   │
│  │ 短期记忆(对话) │ 长期记忆(知识)  │   │
│  └─────────────────────────────────┘   │
└───────────────────┬─────────────────────┘
                    │
    ┌───────────────┼───────────────┐
    ↓               ↓               ↓
┌───────┐       ┌───────┐       ┌───────┐
│ Tools │       │  RAG  │       │ Human │
└───────┘       └───────┘       └───────┘
4.4.2 ReAct模式实现
java 复制代码 
// LangChain4j内置ReAct Agent
interface ResearchAgent {
    String execute(String task);
}

ResearchAgent agent = AiServices.builder(ResearchAgent.class)
    .chatModel(chatModel)
    .tools(
        new SearchTools(),      // 联网搜索
        new CalculatorTools(),  // 数学计算
        new DatabaseTools(),    // 数据库查询
        new FileTools()         // 文件操作
    )
    .chatMemory(MessageWindowChatMemory.withMaxMessages(50))
    .build();

// Agent会自动：思考→搜索→计算→再思考→总结
String result = agent.execute("分析2026年Q2新能源汽车销量TOP3品牌，对比它们的优缺点，给出投资建议");
4.4.3 多Agent协作
java 复制代码 
// 1. 定义 specialized agents
interface Researcher {
    String research(String topic);
}

interface Writer {
    String write(String outline, String researchData);
}

interface Critic {
    String review(String article);
}

// 2. 主编Agent协调
interface EditorInChief {
    String writeArticle(String topic);
}

EditorInChief editor = AiServices.builder(EditorInChief.class)
    .chatModel(chatModel)
    .tools(
        // 将其他Agent包装为工具
        ToolSpecification.of("research", "调研主题", (String topic) -> researcher.research(topic)),
        ToolSpecification.of("write", "撰写文章", (String outline, String data) -> writer.write(outline, data)),
        ToolSpecification.of("review", "审核文章", (String article) -> critic.review(article))
    )
    .build();

4.5 MCP协议（Model Context Protocol）

4.5.1 MCP是什么

MCP是Anthropic提出的模型上下文协议，解决AI工具的标准化问题：

  • 一次开发，所有支持MCP的模型/框架都能使用
  • 工具可以独立部署、跨语言调用
  • 支持动态发现工具能力
4.5.2 Java集成MCP
xml 复制代码 
<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-mcp</artifactId>
    <version>1.0.0-beta1</version>
</dependency>
java 复制代码 
// 连接MCP服务器
McpTransport transport = new StdioMcpTransport.Builder()
    .command("npx")
    .args("-y", "@modelcontextprotocol/server-filesystem", "/path/to/dir")
    .build();

McpClient mcpClient = new DefaultMcpClient.Builder()
    .transport(transport)
    .build();

// 将MCP工具提供给AI服务
Assistant assistant = AiServices.builder(Assistant.class)
    .chatModel(chatModel)
    .tools(mcpClient.tools())  // 自动发现所有MCP工具
    .build();

第五部分：本地模型部署与推理

5.1 Ollama本地大模型

5.1.1 快速开始
bash 复制代码 
# 1. 安装Ollama
curl -fsSL https://ollama.com/install.sh | sh

# 2. 拉取模型（推荐中文模型）
ollama pull qwen2.5:7b          # 通义千问7B，中文优秀
ollama pull bge-m3              # 中文向量模型
ollama pull nomic-embed-text    # 英文向量模型

# 3. 运行
ollama run qwen2.5:7b
5.1.2 Spring AI集成Ollama
xml 复制代码 
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-starter-model-ollama</artifactId>
</dependency>
yaml 复制代码 
spring:
  ai:
    ollama:
      base-url: http://localhost:11434
      chat:
        options:
          model: qwen2.5:7b
          temperature: 0.7
5.1.3 性能优化
bash 复制代码 
# GPU加速（自动检测，如未生效手动指定）
OLLAMA_LLM_LIBRARY=cuda_v12 ollama serve

# 模型量化选择
# q4_0: 最快，最小，质量损失可接受（推荐）
# q5_0: 平衡
# q8_0: 高质量，内存占用大
# f16: 无损，内存占用最大

# 调整并发数
OLLAMA_NUM_PARALLEL=2 ollama serve

5.2 DJL纯Java模型推理

5.2.1 DJL优势
  • 零Python依赖：纯Java，一个Jar包搞定
  • 多引擎支持：PyTorch、TensorFlow、ONNX Runtime、MXNet
  • 自动GPU加速：自动检测CUDA、ROCm
  • 模型自动下载：从HuggingFace自动拉取模型
5.2.2 本地运行Qwen模型
xml 复制代码 
<dependency>
    <groupId>ai.djl</groupId>
    <artifactId>api</artifactId>
    <version>0.28.0</version>
</dependency>
<dependency>
    <groupId>ai.djl.onnxruntime</groupId>
    <artifactId>onnxruntime-engine</artifactId>
    <version>0.28.0</version>
</dependency>
java 复制代码 
// 纯Java加载Qwen-7B ONNX模型进行推理
Criteria<String, String> criteria = Criteria.builder()
    .setInputTypes(String.class)
    .setOutputTypes(String.class)
    .optModelUrls("djl://ai.djl.huggingface.onnxruntime/Qwen/Qwen2.5-7B-Instruct")
    .optEngine("OnnxRuntime")
    .optOption("quantize", "true")  // 启用量化
    .optOption("gpuCount", "1")     // 使用GPU
    .build();

try (ZooModel<String, String> model = criteria.loadModel();
     Predictor<String, String> predictor = model.newPredictor()) {
    
    String response = predictor.predict("你好，请介绍一下你自己");
    System.out.println(response);
}

5.3 ONNX Runtime Java API

5.3.1 基础使用
java 复制代码 
// 创建ONNX Runtime环境
OrtEnvironment env = OrtEnvironment.getEnvironment();
OrtSession.SessionOptions opts = new OrtSession.SessionOptions();
opts.setIntraOpNumThreads(Runtime.getRuntime().availableProcessors());
opts.setOptimizationLevel(OrtSession.SessionOptions.OptLevel.ALL_OPT);

// GPU加速（如有）
opts.addCUDA(0);

// 加载模型
OrtSession session = env.createSession("model.onnx", opts);

// 准备输入
long[] shape = {1, 128};
long[] inputIds = tokenizer.encode("你好");
OnnxTensor tensor = OnnxTensor.createTensor(env, LongBuffer.wrap(inputIds), shape);

// 推理
Map<String, OnnxTensor> inputs = Map.of("input_ids", tensor);
OrtSession.Result results = session.run(inputs);

// 处理输出
float[][] logits = (float[][]) results.get(0).getValue();
5.3.2 生产环境优化
java 复制代码 
// 1. Session对象池（Session创建昂贵，且线程安全）
private final GenericObjectPool<OrtSession> sessionPool;

// 2. 动态批处理
// 3. 输入输出Tensor复用
// 4. 使用IO Binding减少内存拷贝

第六部分：企业级工程化实践

6.1 从Demo到生产的5道关卡

关卡 常见坑 正确做法
① 模型选型 盲目用GPT-4，成本爆炸 分级路由：简单任务用小模型，复杂任务才用大模型
② 错误处理 网络异常、限流、超时直接崩 重试机制、降级策略、熔断保护
③ 成本控制 Token滥用、无缓存 Token计数、结果缓存、Prompt压缩
④ 可观测性 黑盒调用，出问题无法排查 全链路日志、Token统计、延迟监控
⑤ 安全防护 Prompt注入、数据泄露 输入校验、输出过滤、敏感数据脱敏

6.2 可观测性体系

java 复制代码 
// 1. AI调用拦截器
@Component
public class AiObservabilityInterceptor implements Advisor {

    private final MeterRegistry meterRegistry;
    
    @Override
    public AdvisedResponse advise(AdvisedRequest request, AdvisorChain chain) {
        long start = System.currentTimeMillis();
        Timer.Sample sample = Timer.start(meterRegistry);
        
        try {
            AdvisedResponse response = chain.next(request);
            
            // 记录指标
            sample.stop(Timer.builder("ai.request.duration")
                .tag("model", request.chatModel().toString())
                .tag("status", "success")
                .register(meterRegistry));
            
            // 记录Token使用
            ChatResponseMetadata metadata = response.response().getMetadata();
            meterRegistry.counter("ai.token.usage",
                    "type", "prompt",
                    "model", request.chatModel().toString()
                ).increment(metadata.getUsage().getPromptTokens());
            
            // 记录完整对话日志（脱敏后）
            log.info("AI Request: {} | Response: {} | Tokens: {}",
               脱敏(request.userText()), 
                脱敏(response.content()),
                metadata.getUsage().getTotalTokens());
            
            return response;
        } catch (Exception e) {
            sample.stop(Timer.builder("ai.request.duration")
                .tag("model", request.chatModel().toString())
                .tag("status", "error")
                .tag("error", e.getClass().getSimpleName())
                .register(meterRegistry));
            throw e;
        }
    }
}

6.3 高可用设计

java 复制代码 
// 1. 多模型故障自动切换
@Bean
public ChatModel failoverChatModel(
        @Qualifier("qwenChatModel") ChatModel primary,
        @Qualifier("deepseekChatModel") ChatModel secondary,
        @Qualifier("openAiChatModel") ChatModel tertiary) {
    
    return new FailoverChatModel(primary, secondary, tertiary);
}

// 2. 限流保护
@Bean
public ChatClient rateLimitedChatClient(ChatClient.Builder builder) {
    return builder
            .defaultAdvisors(
                new RateLimiterAdvisor(
                    RateLimiter.create(10),  // QPS限制
                    Duration.ofSeconds(30)   // 超时
                )
            )
            .build();
}

// 3. 结果缓存
@Cacheable(value = "aiResponses", key = "#query", unless = "#result == null")
public String getCachedResponse(String query) {
    return chatClient.prompt().user(query).call().content();
}

// 4. 线程池隔离
@Bean("aiThreadPool")
public ThreadPoolTaskExecutor aiThreadPool() {
    ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
    executor.setCorePoolSize(10);
    executor.setMaxPoolSize(50);
    executor.setQueueCapacity(100);
    executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
    executor.setThreadNamePrefix("ai-exec-");
    return executor;
}

6.4 安全防护

6.4.1 Prompt注入防御
java 复制代码 
@Component
public class PromptInjectionGuard implements Advisor {

    private static final List<String> INJECTION_PATTERNS = List.of(
        "忽略之前的指令",
        "ignore previous instructions",
        "你现在是",
        "忘记你是",
        "system prompt"
    );

    @Override
    public AdvisedResponse advise(AdvisedRequest request, AdvisorChain chain) {
        String userText = request.userText().toLowerCase();
        
        // 1. 简单规则检测
        for (String pattern : INJECTION_PATTERNS) {
            if (userText.contains(pattern.toLowerCase())) {
                throw new SecurityException("检测到潜在的Prompt注入攻击");
            }
        }
        
        // 2. LLM二次检测（高安全场景）
        // 3. 输入长度限制
        if (request.userText().length() > 2000) {
            throw new IllegalArgumentException("输入过长");
        }
        
        return chain.next(request);
    }
}
6.4.2 敏感数据处理
java 复制代码 
// 发送给LLM前脱敏
public String desensitize(String text) {
    // 手机号脱敏
    text = text.replaceAll("(1[3-9]\\d)\\d{4}(\\d{4})", "$1****$2");
    // 身份证号脱敏
    text = text.replaceAll("(\\d{6})\\d{8}(\\d{4})", "$1********$2");
    // 邮箱脱敏
    text = text.replaceAll("(\\w{2})\\w+(@\\w+\\.\\w+)", "$1***$2");
    // 银行卡号脱敏
    return text;
}

第七部分：项目实战路线

7.1 30天入门实战计划

阶段 时间 目标 实战内容
Week 1 Day 1-7 跑通基础对话 Spring AI + 通义千问实现流式对话接口
Week 2 Day 8-14 掌握核心能力 Prompt模板 + 对话记忆 + Function Calling
Week 3 Day 15-21 RAG知识库 文档解析 + 向量数据库 + 知识库问答
Week 4 Day 22-30 Agent实战 多工具调用 + ReAct Agent + 企业系统集成

7.2 实战项目梯度

入门级项目：智能客服助手
  • 技术栈：Spring Boot + Spring AI + 通义千问
  • 核心功能 ：
    • 多轮对话（带记忆）
    • 常见问题自动回答
    • 订单查询（Function Calling）
    • 转人工逻辑
  • 学习点：ChatClient、Prompt模板、工具调用、对话记忆
进阶级项目：企业知识库问答
  • 技术栈：LangChain4j + pgvector + Redis + Ollama
  • 核心功能 ：
    • PDF/Word/Markdown文档上传解析
    • 自动分片、向量化、存储
    • 混合检索 + Rerank重排序
    • 溯源引用（回答标注来源文档）
    • 对话历史持久化
  • 学习点：RAG全流程、向量数据库、文档处理、检索优化
高级项目：AI智能体平台
  • 技术栈：Spring AI Alibaba + MCP + Milvus + vLLM
  • 核心功能 ：
    • 多Agent协作（研究员+程序员+审核员）
    • MCP工具市场（动态加载工具）
    • 工作流编排（可视化拖拽）
    • 多模型路由（自动选择最合适的模型）
    • 私有化模型部署
  • 学习点：Agent架构、MCP协议、工作流编排、多模型管理

7.3 开源项目参考

项目 Stars 特点
spring-ai 20k+ Spring官方，必学
langchain4j 10k+ Java AI事实标准
spring-ai-alibaba 5k+ 国产大模型最佳实践
JChatMind 2k+ Java Agent完整项目
chatgpt-java 10k+ OpenAI Java SDK

第八部分：性能优化与生产部署

8.1 Token成本优化

优化手段 效果 实施难度
模型分级 成本降低50%-80% 低
Prompt压缩 Token减少30%-50% 低
结果缓存 重复请求成本为0 低
上下文精简 Token减少20%-40% 中
RAG精准检索 减少无关上下文 中
模型微调 小模型达到大模型效果 高
java 复制代码 
// Prompt压缩：使用LLM总结历史对话
public List<Message> compressHistory(List<Message> history, int maxTokens) {
    if (tokenCounter.countTokens(history) <= maxTokens) {
        return history;
    }
    
    String summary = chatClient.prompt()
        .user("总结以下对话，保留关键信息，不超过200字：" + history)
        .call()
        .content();
    
    return List.of(new SystemMessage("对话摘要：" + summary));
}

8.2 延迟优化

复制代码 
优化方向：
├── 客户端侧
│   ├── 流式输出（首字节延迟降低90%）
│   ├── HTTP连接池复用
│   ├── 本地缓存热点结果
│   └── 并行调用多个工具
├── 服务端侧
│   ├── 选择更近的API端点
│   ├── 使用更小的模型
│   ├── 减少上下文长度
│   └── 模型推理批处理
└── 网络侧
    ├── API专线/代理
    ├── HTTP/2多路复用
    └── 超时与重试优化

8.3 JVM调优参数

bash 复制代码 
# AI应用推荐JVM参数
java \
  -Xms4g -Xmx4g \
  -XX:+UseZGC \                    # ZGC低延迟
  -XX:MaxGCPauseMillis=50 \
  -XX:+ZGenerational \
  -XX:InitialRAMPercentage=50 \
  -XX:MaxRAMPercentage=75 \
  -Djava.net.preferIPv4Stack=true \
  -Djdk.httpclient.connectionPoolSize=200 \
  -Djdk.httpclient.keepalive.timeout=300 \
  -jar ai-application.jar

8.4 Docker部署

dockerfile 复制代码 
FROM eclipse-temurin:21-jre-jammy

# 安装系统依赖
RUN apt-get update && apt-get install -y --no-install-recommends \
    curl \
    && rm -rf /var/lib/apt/lists/*

WORKDIR /app
COPY target/*.jar app.jar

# JVM参数环境变量
ENV JAVA_OPTS="\
  -XX:+UseZGC \
  -XX:MaxRAMPercentage=75 \
  -Djava.security.egd=file:/dev/./urandom"

EXPOSE 8080

HEALTHCHECK --interval=30s --timeout=3s \
  CMD curl -f http://localhost:8080/actuator/health || exit 1

ENTRYPOINT ["sh", "-c", "java $JAVA_OPTS -jar app.jar"]

第九部分：进阶学习资源

9.1 官方文档

9.2 关键技术深度

领域 学习重点
大模型原理 Transformer架构、注意力机制、Tokenizer原理
RAG进阶 高级分片策略、混合检索、Rerank、Graph RAG
Agent ReAct、Reflexion、Plan-and-Execute、多Agent协作
模型部署 vLLM、TensorRT-LLM、量化技术（GPTQ/AWQ/GGUF）
评估体系 RAGAS、ARES、LLM-as-Judge、自动化评估

9.3 学习建议

  1. 动手为王：不要只看教程，每学一个知识点就写代码验证
  2. 从小做起：先做一个能跑的Demo，再逐步优化，不要一开始就追求完美架构
  3. 关注社区：Java AI发展很快，每周都有新特性，关注GitHub和官方博客
  4. 阅读源码：Spring AI和LangChain4j的源码质量很高，是最好的学习材料
  5. 结合业务：用AI解决你工作中的实际问题，这是最快的学习方式

最后提醒：AI技术迭代极快，但核心思想（抽象、编排、工程化）是通用的。掌握框架设计思想，比死记API更重要。Java在AI工程化领域的优势才刚刚显现，这是Java开发者的新机遇。

本笔记持续更新中，建议收藏并定期回顾。如有疑问或建议，欢迎交流。

相关推荐
听风吹等浪起14 小时前
002：多图合并导出PDF【网页版】
计算机视觉·pdf
蝶恋舞者21 小时前
NMC-G2网络管理卡 资料官网下载流程
pdf
qq_422152571 天前
什么时候需要拆分或合并PDF？几种方案对比
pdf
hu55667981 天前
Adobe Acrobat DC 如何按页数方法拆分2个或多个pdf
pdf·pdf拆分
夏沫琅琊1 天前
Jetpack Compose + 原生 PDF API 从零搭一个 Android 工具应用 (一)
android·pdf·kotlin
慧都小妮子1 天前
Aspose.Words for JasperReports v26.6 发布，底层Java大升级
java·pdf·报表工具·aspose.words·文档转换·报表导出·jasperreports
qq_422152571 天前
PDF页面管理的几种实用方法：拆分、合并、删除指定页面
java·前端·pdf
复园电子2 天前
跨平台PDF签名解析器设计：多方签署与自签名证书（野鸡CA）过滤
pdf·电子合同
马里马里奥-2 天前
PDF 解析超时问题：根因分析与修复方案
pdf
热门推荐
012026年7月AI圈大地震：GPT-5.6被政府限制、Claude入驻Slack、Anthropic自研芯片02GitHub 镜像站点03AI科技热点日报 | 2026年07月01日04幻兽帕鲁 - 服务器管理员权限与 GM 命令完全指南05AI 编程 IDE 全景解析 2026：Agent 全面接管开发链路06国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）072026 国产 AI 大模型横评：DeepSeek、通义千问、Kimi、文心一言、星火、豆包谁更能打？08Codex 下载安装指南：Windows 和 macOS 官方版下载092026年AI技术突破与产业落地全景：从GPT-5到多模态智能体的新纪元102026 年 AI 大模型 & AI 编程工具实战全总结