拒绝复杂理论，带你用最接地气的方式，从零开始掌握Java AI应用开发

写在前面

最近AI应用开发如火如荼，但作为Java开发者，你是不是经常遇到这样的困境：

• Python的AI框架一大堆，但Java能用的却寥寥无几

• 想给自己的Spring Boot项目加上AI能力，却不知道从何下手

• 看了一堆文档，还是不知道怎么写出第一行代码

别急！LangChain4j 就是为你准备的解决方案。它就像是Java世界的"AI万能钥匙"，让你用最熟悉的Java语法，就能轻松构建AI应用。

本文特色：

• 🎯 每个概念都用生活例子解释，零基础也能懂

• 💻 所有代码都能直接复制运行，100%实战

• 📚 从Hello World到企业级应用，循序渐进

• 🚀 囊括对话记忆、工具调用、RAG等核心功能

---

第一部分：先搞懂「是什么」和「为什么」

1.1 什么是LangChain4j？

用一句话说：LangChain4j是专门为Java开发者打造的AI应用开发框架。

它的目标很简单——让你用最少的代码，把大模型能力集成到你的Java项目里。

一个直观对比：

场景	不用框架	用LangChain4j
调用OpenAI	写HTTP请求、处理JSON、解析响应...几十行代码	3行代码搞定
切换模型（OpenAI→阿里云）	重写整个调用逻辑	改一行配置
实现多轮对话	手动管理历史消息	自动记忆，一行配置

1.2 为什么需要它？解决什么痛点？

痛点1：模型差异巨大

OpenAI、通义千问、Claude...每个大模型厂商的API都不一样。如果直接对接，你需要为每个模型写一套适配代码。

LangChain4j的解决方案：提供统一API，切换模型只需改配置，不用改业务代码。

痛点2：AI交互比想象中复杂

你以为的AI开发：发请求 → 收回复

实际的AI开发：

• 多轮对话要管理上下文

• 想让AI基于你的文档回答要做RAG

• 想让AI查天气、查订单要做工具调用

• 想让AI按指定格式返回要做结构化输出

LangChain4j的解决方案：这些复杂功能都已封装成现成组件，拿来就用。

痛点3：Java生态缺少AI工具

Python有LangChain、LlamaIndex，Java却没有好用的AI框架。

LangChain4j的解决方案：专为Java打造，完全遵循Java开发习惯——类型安全、依赖注入、注解支持、与Spring Boot无缝集成。

1.3 核心概念（3个关键词就够了）

不需要记住一堆术语，先理解这3个：

概念	通俗理解	你负责	LangChain4j负责
ChatModel	AI的"电话线"	告诉它连哪个模型、用什么密钥	处理HTTP请求、JSON解析、重试逻辑
Prompt	你对AI说的话	写提示词	管理模板、变量替换
AI Service	AI的"服务接口"	定义一个Java接口	自动生成实现、处理输入输出转换

---

第二部分：极速入门 - 5分钟跑通第一个AI对话

2.1 环境准备

硬件要求：

• JDK 17及以上（LangChain4j最低要求17）

• Maven 3.8+ 或 Gradle 7.0+

• 一个IDE（IDEA、Eclipse或VS Code）

获取API Key：

• 推荐阿里云百炼平台（国内访问快，新用户有免费额度）

• 访问 https://bailian.console.aliyun.com/ 注册并获取API Key

2.2 创建项目

Step 1：创建Spring Boot项目

访问 https://start.spring.io/，选择：

• Project: Maven

• Language: Java

• Spring Boot: 3.2.x

• Dependencies: Spring Web

下载并解压项目。

Step 2：添加依赖

打开 pom.xml，添加LangChain4j相关依赖：

xml

<dependencies>
    <!-- Spring Boot基础 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <!-- LangChain4j核心库 -->
    <dependency>
        <groupId>dev.langchain4j</groupId>
        <artifactId>langchain4j</artifactId>
        <version>1.1.0</version>
    </dependency>
    
    <!-- 阿里云通义千问适配器（选择1：国内用户推荐） -->
    <dependency>
        <groupId>dev.langchain4j</groupId>
        <artifactId>langchain4j-community-dashscope-spring-boot-starter</artifactId>
        <version>1.1.0-beta7</version>
    </dependency>
    
    <!-- 或者用OpenAI（选择2：有OpenAI账号） -->
    <!--
    <dependency>
        <groupId>dev.langchain4j</groupId>
        <artifactId>langchain4j-open-ai</artifactId>
        <version>1.1.0</version>
    </dependency>
    -->
</dependencies>

Step 3：配置文件

创建 src/main/resources/application.yml：

yaml

spring:
  application:
    name: langchain4j-demo

# 阿里云通义千问配置
langchain4j:
  community:
    dashscope:
      chat-model:
        api-key: sk-xxxxxxxxxxxxx  # 替换成你的API Key
        model-name: qwen-max        # 可选：qwen-turbo/qwen-plus/qwen-max
        
logging:
  level:
    dev.langchain4j: DEBUG  # 开启调试日志，方便学习

Step 4：第一个AI服务

创建 AiService.java：

java

package com.example.demo;

import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.dashscope.QwenChatModel;
import org.springframework.stereotype.Service;

@Service
public class AiService {
    
    // 方式1：用构造器创建ChatModel（推荐，灵活）
    private final ChatLanguageModel chatModel = QwenChatModel.builder()
            .apiKey(System.getenv("DASHSCOPE_API_KEY"))  // 从环境变量读取，安全！
            .modelName("qwen-max")
            .temperature(0.7)    // 0-2之间，越高越随机
            .maxTokens(1024)     // 最大回复长度
            .build();
    
    // 方式2：等着Spring Boot自动注入（需要starter）
    // @Resource
    // private ChatModel chatModel;
    
    public String chat(String userMessage) {
        return chatModel.generate(userMessage);
    }
}

Step 5：创建测试接口

创建 AiController.java：

java

package com.example.demo;

import org.springframework.web.bind.annotation.*;
import java.util.HashMap;
import java.util.Map;

@RestController
@RequestMapping("/api/ai")
public class AiController {
    
    private final AiService aiService;
    
    public AiController(AiService aiService) {
        this.aiService = aiService;
    }
    
    @PostMapping("/chat")
    public Map<String, String> chat(@RequestBody Map<String, String> request) {
        String message = request.get("message");
        String reply = aiService.chat(message);
        
        Map<String, String> response = new HashMap<>();
        response.put("reply", reply);
        return response;
    }
    
    @GetMapping("/hello")
    public String hello() {
        return aiService.chat("你好，请简单介绍一下你自己");
    }
}

Step 6：运行测试

启动Spring Boot应用，然后：

bash

# 方式1：访问浏览器
http://localhost:8080/api/ai/hello

# 方式2：用curl测试
curl -X POST http://localhost:8080/api/ai/chat \
  -H "Content-Type: application/json" \
  -d '{"message": "Java程序员如何入门AI开发？"}'

恭喜！你已经跑通了第一个AI应用！ 🎉

---

第三部分：进阶实战 - 构建一个「AI编程小助手」

前面只是热身，现在我们来做一个真正有用的项目：一个能帮程序员解答问题、提供学习建议的AI编程助手。

3.1 需求分析

我们的AI编程助手要实现：

功能	说明	技术点
基础对话	回答编程问题	ChatModel
多轮记忆	记住之前的对话	ChatMemory
系统提示词	设定AI角色和边界	SystemMessage
知识库问答	基于文档回答问题	RAG
工具调用	联网搜索、计算	@Tool注解

3.2 多轮对话记忆

问题：现在的AI每次对话都是独立的，你问完"我叫鱼皮"，再问"我叫什么名字"，它就不记得了。

解决方案：为AI加上"记忆"。

java

@Service
public class AiMemoryService {
    
    private final ChatLanguageModel chatModel;
    
    // 创建带记忆的AI服务
    private final AiServices<CodingAssistant> aiServices;
    
    public AiMemoryService() {
        // 1. 创建模型
        this.chatModel = QwenChatModel.builder()
            .apiKey(System.getenv("DASHSCOPE_API_KEY"))
            .modelName("qwen-max")
            .build();
        
        // 2. 创建记忆组件（存储最近20条消息）
        ChatMemory chatMemory = MessageWindowChatMemory.builder()
            .maxMessages(20)
            .build();
        
        // 3. 定义AI服务接口
        this.aiServices = AiServices.builder(CodingAssistant.class)
            .chatLanguageModel(chatModel)
            .chatMemory(chatMemory)  // 注入记忆
            .build();
    }
    
    // 定义接口：告诉AI它能做什么
    interface CodingAssistant {
        String chat(@UserMessage String userMessage);
    }
    
    public String chat(String message) {
        CodingAssistant assistant = aiServices.build();
        return assistant.chat(message);
    }
}

测试多轮记忆：

java

// 第一轮
aiMemoryService.chat("我叫张三，是个Java程序员");

// 第二轮 - AI会记得你的名字
aiMemoryService.chat("我名字是什么？");  
// 输出：你的名字是张三，你是一位Java程序员

3.3 系统提示词：给AI设定"人设"

系统提示词相当于给AI设定"角色说明书"——你是谁、能做什么、不能做什么。

java

@Service
public class AiAssistantService {
    
    // 系统提示词：定义AI的角色和行为边界
    private static final String SYSTEM_PROMPT = """
        你是「编程小助手」，专门帮助程序员解答学习和求职问题。
        
        ## 你的核心能力
        1. 规划编程学习路线（从零基础到进阶）
        2. 提供项目实战建议
        3. 分享面试技巧和常见问题
        4. 代码审查和优化建议
        
        ## 回答规则
        - 用简洁、易懂的语言
        - 举例说明，不要只讲理论
        - 如果不确定，坦诚说"我不确定"
        - 不要编造不存在的事实
        
        ## 禁止事项
        - 不要讨论政治敏感话题
        - 不要生成恶意代码
        """;
    
    interface CodingTutor {
        @SystemMessage(SYSTEM_PROMPT)  // 系统提示词的声明式写法
        String chat(@UserMessage String question);
    }
    
    public String ask(String question) {
        ChatLanguageModel model = QwenChatModel.builder()
            .apiKey(System.getenv("DASHSCOPE_API_KEY"))
            .build();
            
        CodingTutor tutor = AiServices.create(CodingTutor.class, model);
        return tutor.chat(question);
    }
}

测试效果：

java

// 普通AI：可能会随便回答
assistant.ask("如何学习Java？");

// 加了系统提示词后：会给出结构化建议
// 输出：
// 1. 基础阶段：Java语法 → 面向对象 → 集合框架
// 2. 进阶阶段：多线程 → JVM → 设计模式
// 3. 实战阶段：Spring Boot → 项目练习...

3.4 结构化输出：让AI返回固定格式

很多时候你需要AI返回特定格式的数据（比如JSON），而不是随意的一段文字。

场景：让AI分析代码质量，返回结构化的评分结果。

java

// 1. 定义返回数据的Java类
public class CodeReviewResult {
    private int score;           // 评分 0-100
    private List<String> issues; // 问题列表
    private List<String> suggestions; // 改进建议
    private String summary;      // 总结
    // getter/setter 省略
}

// 2. 定义AI服务接口，指定返回类型
interface CodeReviewer {
    @UserMessage("请分析以下代码的质量：\n{{code}}")
    CodeReviewResult review(@V("code") String code);
}

// 3. 使用
public class CodeReviewDemo {
    public static void main(String[] args) {
        CodeReviewer reviewer = AiServices.create(CodeReviewer.class, model);
        
        String code = """
        public int add(int a, int b) {
            return a + b;
        }
        """;
        
        CodeReviewResult result = reviewer.review(code);
        System.out.println("评分：" + result.getScore());
        System.out.println("建议：" + result.getSuggestions());
    }
}

关键点：LangChain4j会自动把AI的回复解析成你的Java对象。

3.5 工具调用：让AI「动手做事」

这是最强大的功能！让AI不仅能说话，还能主动调用你的Java方法。

场景：让AI可以查询天气、计算数学题、调用公司内部API。

java

@Service
public class ToolCallingService {
    
    // 1. 定义一个工具：用@Tool注解
    @Tool("获取指定城市的天气信息")
    public String getWeather(@P("城市名称，如：北京、上海") String city) {
        // 实际开发中调用天气API
        if ("北京".equals(city)) {
            return "北京：晴，25°C，空气质量良";
        }
        return city + "：多云，22°C";
    }
    
    @Tool("计算数学表达式")
    public double calculate(@P("数学表达式，如：1+2*3") String expression) {
        // 简化实现，实际可用ScriptEngine
        return Double.parseDouble(expression); 
    }
    
    // 2. 定义AI服务接口，声明可用的工具
    interface SmartAssistant {
        @UserMessage("{{userInput}}")
        String chat(@V("userInput") String input);
        
        // 声明这个AI可以使用哪些工具
        default List<Class<?>> tools() {
            return List.of(ToolCallingService.class);
        }
    }
    
    // 3. 使用
    public String ask(String question) {
        SmartAssistant assistant = AiServices.builder(SmartAssistant.class)
            .chatLanguageModel(model)
            .tools(new ToolCallingService())  // 注册工具
            .build();
        
        return assistant.chat(question);
    }
}

测试效果：

java

toolService.ask("北京今天天气怎么样？");
// AI会识别到需要调用getWeather工具，返回天气信息

toolService.ask("计算 123 * 456 等于多少？");
// AI会调用calculate工具，返回计算结果

---

第四部分：RAG知识库 - 让AI回答你的专属文档

这是企业级AI应用的核心能力：让AI基于你自己的文档回答问题，而不是依赖它训练时的通用知识。

4.1 什么是RAG？

RAG（Retrieval-Augmented Generation，检索增强生成） = 先检索 + 再生成

text

用户问："我们公司的年假政策是什么？"
         ↓
    1. 检索：在员工手册中搜索相关段落
         ↓
    2. 增强：把「问题 + 检索到的内容」一起给AI
         ↓
    3. 生成：AI基于员工手册回答，不会乱编

4.2 完整RAG实战

场景：做一个「公司知识库问答系统」，让AI基于公司文档回答。

Step 1：添加依赖

xml

<!-- 文档加载器 -->
<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j</artifactId>
    <version>1.1.0</version>
</dependency>

<!-- 嵌入模型和向量存储 -->
<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-embeddings</artifactId>
    <version>1.1.0</version>
</dependency>

<!-- 内存向量存储（演示用，生产环境用Pinecone/Milvus等） -->
<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-embeddings-in-memory</artifactId>
    <version>1.1.0</version>
</dependency>

Step 2：构建RAG流水线

java

@Service
public class KnowledgeBaseService {
    
    private final EmbeddingStore<TextSegment> embeddingStore;
    private final EmbeddingModel embeddingModel;
    private final ChatLanguageModel chatModel;
    
    public KnowledgeBaseService() {
        // 1. 初始化嵌入模型（将文字转成向量）
        this.embeddingModel = new BgeSmallEnV15QuantizedEmbeddingModel();
        
        // 2. 初始化向量存储（存储文档的向量）
        this.embeddingStore = new InMemoryEmbeddingStore<>();
        
        // 3. 初始化对话模型
        this.chatModel = QwenChatModel.builder()
            .apiKey(System.getenv("DASHSCOPE_API_KEY"))
            .build();
    }
    
    /**
     * 加载文档到知识库
     */
    public void ingestDocument(String filePath) {
        // 1. 加载文档
        Document document = FileSystemDocumentLoader.loadDocument(filePath);
        
        // 2. 分割文档（避免超过模型限制）
        DocumentSplitter splitter = DocumentSplitters.recursive(500, 100);
        List<TextSegment> segments = splitter.split(document);
        
        // 3. 生成嵌入向量并存储
        List<Embedding> embeddings = embeddingModel.embedAll(segments).content();
        embeddingStore.addAll(embeddings, segments);
        
        System.out.println("已加载 " + segments.size() + " 个文档片段");
    }
    
    /**
     * 基于知识库回答问题
     */
    public String ask(String question) {
        // 1. 将问题转为向量
        Embedding questionEmbedding = embeddingModel.embed(question).content();
        
        // 2. 检索最相关的文档片段
        List<EmbeddingMatch<TextSegment>> matches = embeddingStore.findRelevant(
            questionEmbedding, 3  // 返回最相关的3个片段
        );
        
        // 3. 构建上下文
        StringBuilder context = new StringBuilder();
        for (EmbeddingMatch<TextSegment> match : matches) {
            context.append(match.embedded().text()).append("\n\n");
        }
        
        // 4. 构建增强后的提示词
        String prompt = """
            请基于以下【参考文档】回答问题。如果文档中没有相关信息，请坦诚说明。
            
            【参考文档】
            %s
            
            【问题】
            %s
            
            【回答】
            """.formatted(context.toString(), question);
        
        // 5. 生成回答
        return chatModel.generate(prompt);
    }
}

Step 3：使用示例

java

@RestController
public class KnowledgeController {
    
    private final KnowledgeBaseService kbService;
    
    @PostConstruct
    public void init() {
        // 启动时加载公司文档
        kbService.ingestDocument("docs/company_policy.pdf");
        kbService.ingestDocument("docs/employee_handbook.docx");
    }
    
    @PostMapping("/ask")
    public String ask(@RequestBody String question) {
        return kbService.ask(question);
    }
}

---

第五部分：部署和最佳实践

5.1 性能优化建议

优化点	建议	效果
模型选择	简单任务用qwen-turbo，复杂推理用qwen-max	成本降80%
缓存	对常见问题做缓存	响应时间从2秒→50ms
批处理	批量处理多个问题	减少API调用次数
超时设置	设置30秒超时	避免长时间等待

5.2 安全注意事项

java

// 1. API Key保护：使用环境变量，不要写死在代码里
String apiKey = System.getenv("DASHSCOPE_API_KEY");

// 2. 输入过滤
if (userInput.contains("drop table")) {
    return "抱歉，我无法处理这个请求";
}

// 3. 输出限制
model.generate(prompt, new GenerationRequest()
    .maxTokens(2000)  // 限制输出长度
);

5.3 常见问题排查

问题	可能原因	解决方案
API调用超时	网络问题或模型太慢	增加超时时间，改用更快的模型
返回格式乱	没有指定输出格式	在提示词中明确要求JSON格式
中文乱码	编码问题	统一使用UTF-8
上下文太长	超出token限制	压缩提示词，或使用更长的模型

---

总结：你的AI开发路线图

通过本教程，你已经掌握了：

1. ✅ LangChain4j核心概念：ChatModel、AI Service、Prompt

2. ✅ 基础对话：5分钟跑通第一个AI应用

3. ✅ 多轮记忆：让AI记住你说过的话

4. ✅ 系统提示词：给AI设定人设和边界

5. ✅ 工具调用：让AI动手做事情

6. ✅ RAG知识库：基于你的文档回答问题

7. ✅ 结构化输出：让AI返回标准格式

下一步学什么？

阶段	学习内容	时间
入门	掌握本文内容，能写简单AI应用	1-2天
进阶	多Agent协作、MCP协议、流式输出	1周
精通	性能优化、生产部署、成本控制	持续

实战项目推荐：

• AI客服机器人（结合RAG）

• 代码审查助手（结合工具调用）

• 智能PPT生成器（结合多模态）