在大模型应用开发中，单纯调用 API 难以实现复杂的上下文管理、工具调用与数据集成需求。LangChain4j 作为专为 Java 生态设计的大模型开发框架，凭借轻量、易用、可扩展的特性，成为 Java 程序员构建企业级大模型应用的首选工具。本文从实战角度出发，结合完整代码示例，详解 LangChain4j 的环境搭建、核心功能实现与实战场景落地，帮助开发者快速上手，轻松构建具备上下文对话、工具调用能力的大模型应用。

环境搭建：LangChain4j 开发基础配置

LangChain4j 基于 Java 开发，需配合 Maven/Gradle 完成依赖管理，同时需根据目标大模型（如 OpenAI、本地化模型）配置 API 密钥或模型连接信息。此环节重点解决依赖引入、环境变量配置与客户端初始化问题，为后续开发打好基础。

依赖引入与项目初始化

以 Maven 项目为例，在pom.xml中引入 LangChain4j 核心依赖及常用大模型适配器，支持快速对接主流大模型：

<!-- pom.xml -->

<project xmlns="http://maven.apache.org/POM/4.0.0"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

<modelVersion>4.0.0</modelVersion>

<groupId>com.example</groupId>

<artifactId>langchain4j-demo</artifactId>

<version>1.0-SNAPSHOT</version>

<properties>

<maven.compiler.source>17</maven.compiler.source>

<maven.compiler.target>17</maven.compiler.target>

<langchain4j.version>0.24.0</langchain4j.version> <!-- 使用最新稳定版 -->

</properties>

<dependencies>

<!-- LangChain4j核心依赖 -->

<dependency>

<groupId>dev.langchain4j</groupId>

<artifactId>langchain4j-core</artifactId>

<version>${langchain4j.version}</version>

</dependency>

<!-- OpenAI大模型适配器（如需对接其他模型，替换对应依赖） -->

<dependency>

<groupId>dev.langchain4j</groupId>

<artifactId>langchain4j-open-ai</artifactId>

<version>${langchain4j.version}</version>

</dependency>

<!-- 工具调用支持（如计算器、HTTP客户端） -->

<dependency>

<groupId>dev.langchain4j</groupId>

<artifactId>langchain4j-tools</artifactId>

<version>${langchain4j.version}</version>

</dependency>

<!-- 日志依赖（方便调试） -->

<dependency>

<groupId>org.slf4j</groupId>

<artifactId>slf4j-simple</artifactId>

<version>2.0.9</version>

</dependency>

</dependencies>

</project>

若需对接本地化模型（如 Llama 2、Qwen），需替换为langchain4j-ollama（Ollama 部署的模型）或langchain4j-local-ai依赖，后续客户端初始化逻辑也需相应调整。

环境变量与客户端初始化

为避免硬编码敏感信息（如 API 密钥），建议通过环境变量或配置文件管理，再初始化 LangChain4j 大模型客户端：

// src/main/java/com/example/langchain4j/demo/OpenAiClientInit.java

package com.example.langchain4j.demo;

import dev.langchain4j.model.openai.OpenAiChatModel;

import dev.langchain4j.model.output.Response;

import java.util.Map;

public class OpenAiClientInit {

public static void main(String[] args) {

// 1. 从环境变量获取API密钥（推荐生产环境使用，避免硬编码）

String openAiApiKey = System.getenv("OPENAI_API_KEY");

// 本地开发可临时设置环境变量（生产环境禁用）

// System.setProperty("OPENAI_API_KEY", "your-api-key");

// 2. 初始化OpenAI聊天模型客户端

OpenAiChatModel chatModel = OpenAiChatModel.builder()

.apiKey(openAiApiKey)

.modelName("gpt-3.5-turbo") // 模型名称，可替换为gpt-4

.temperature(0.7) // 随机性，0-1之间，越低越严谨

.maxTokens(1024) // 最大生成token数

.build();

// 3. 测试客户端连接（发送简单请求）

String prompt = "用Java实现一个简单的单例模式（线程安全），并添加详细注释";

Response<String> response = chatModel.generate(prompt);

// 4. 输出结果

System.out.println("大模型响应：\n" + response.content());

}

}

运行此类前，需在系统环境变量中配置OPENAI_API_KEY（获取自 OpenAI 官网）。若对接本地化模型（如通过 Ollama 部署的 Mistral），客户端初始化代码如下：

// 初始化Ollama客户端（对接本地化模型）

OllamaChatModel ollamaModel = OllamaChatModel.builder()

.baseUrl("http://localhost:11434") // Ollama服务地址

.modelName("mistral:7b") // 本地部署的模型名称

.temperature(0.7)

.build();

核心功能实现：LangChain4j 关键能力落地

LangChain4j 的核心价值在于简化大模型应用的复杂场景开发，如上下文对话、工具调用、数据增强等。以下通过代码示例，详解这三大关键能力的实现方式，覆盖大多数企业级应用需求。

上下文对话管理（多轮对话支持）

传统 API 调用需手动维护对话历史，LangChain4j 通过ChatMemory自动管理上下文，支持多轮对话流畅进行：

// src/main/java/com/example/langchain4j/demo/ContextualChat.java

package com.example.langchain4j.demo;

import dev.langchain4j.model.openai.OpenAiChatModel;

import dev.langchain4j.memory.ChatMemory;

import dev.langchain4j.memory.InMemoryChatMemory;

import dev.langchain4j.model.output.Response;

import dev.langchain4j.data.message.AiMessage;

import dev.langchain4j.data.message.UserMessage;

public class ContextualChat {

public static void main(String[] args) {

// 1. 初始化大模型客户端（同前）

String openAiApiKey = System.getenv("OPENAI_API_KEY");

OpenAiChatModel chatModel = OpenAiChatModel.builder()

.apiKey(openAiApiKey)

.modelName("gpt-3.5-turbo")

.build();

// 2. 创建对话内存（存储多轮对话历史，默认容量10轮）

ChatMemory chatMemory = InMemoryChatMemory.builder()

.maxMessages(20) // 调整最大存储消息数

.build();

// 3. 多轮对话流程

String[] userInputs = {

"什么是工厂模式？",

"它和单例模式的区别是什么？",

"用Java写一个工厂模式的示例，包含汽车制造场景"

};

for (String userInput : userInputs) {

// 3.1 将用户输入添加到内存

chatMemory.add(UserMessage.from(userInput));

// 3.2 获取完整对话历史，发送给大模型

Response<AiMessage> response = chatModel.generate(chatMemory.messages());

// 3.3 将AI响应添加到内存，维护上下文

chatMemory.add(response.content());

// 3.4 输出对话内容

System.out.println("用户：" + userInput);

System.out.println("AI：" + response.content().text() + "\n");

}

}

}

运行后可观察到，AI 能基于前序对话内容回答后续问题（如第二问基于第一问的 “工厂模式” 概念，第三问基于前两问的 Java 场景），无需手动传递历史对话。

工具调用能力（集成外部工具）

LangChain4j 支持大模型自动判断是否调用外部工具（如计算器、API 接口），解决大模型 “不会计算”“数据过时” 等问题。以下以 “计算器工具” 为例，实现自动数学计算：

// src/main/java/com/example/langchain4j/demo/ToolCalling.java

package com.example.langchain4j.demo;

import dev.langchain4j.model.openai.OpenAiChatModel;

import dev.langchain4j.agent.tool.Tool;

import dev.langchain4j.agent.tool.ToolExecutionRequest;

import dev.langchain4j.agent.tool.ToolExecutionResponse;

import dev.langchain4j.model.output.Response;

import java.util.List;

public class ToolCalling {

// 1. 定义计算器工具（需添加@Tool注解，让大模型识别）

public static class CalculatorTool {

@Tool("用于执行数学计算，如加法、乘法、平方等，输入为数学表达式字符串")

public String calculate(String expression) {

// 简化实现：使用Java表达式引擎执行计算

try {

// 实际生产环境需使用更安全的表达式解析库（如Apache Commons JEXL）

javax.script.ScriptEngine engine = new javax.script.ScriptEngineManager()

.getEngineByName("JavaScript");

Object result = engine.eval(expression);

return "计算结果：" + expression + " = " + result;

} catch (Exception e) {

return "计算失败：" + e.getMessage();

}

}

}

public static void main(String[] args) {

// 2. 初始化大模型客户端与工具实例

String openAiApiKey = System.getenv("OPENAI_API_KEY");

OpenAiChatModel chatModel = OpenAiChatModel.builder()

.apiKey(openAiApiKey)

.modelName("gpt-3.5-turbo")

.build();

CalculatorTool calculatorTool = new CalculatorTool();

// 3. 测试工具调用：大模型自动判断是否需要调用计算器

String userInput = "一个长方形的长是15.5厘米，宽是8.2厘米，它的面积和周长分别是多少？";

System.out.println("用户：" + userInput);

// 3.1 让大模型生成工具调用请求（若需要）

Response<List<ToolExecutionRequest>> toolRequestsResponse = chatModel

.generateToolExecutionRequests(userInput);

// 3.2 执行工具调用（若有请求）

if (!toolRequestsResponse.content().isEmpty()) {

ToolExecutionRequest request = toolRequestsResponse.content().get(0);

System.out.println("AI将调用工具：" + request.toolName());

System.out.println("工具参数：" + request.arguments());

// 调用计算器工具

String toolResult = calculatorTool.calculate(request.arguments().get("expression"));

ToolExecutionResponse toolResponse = ToolExecutionResponse.from(toolResult);

// 3.3 将工具结果返回给大模型，生成最终回答

Response<String> finalResponse = chatModel.generate(

userInput,

List.of(toolResponse)

);

System.out.println("AI最终回答：" + finalResponse.content());

} else {

// 无需工具调用，直接生成回答

Response<String> response = chatModel.generate(userInput);

System.out.println("AI回答：" + response.content());

}

}

}

运行后可看到，大模型会自动生成 “面积 = 15.58.2”“周长 = 2(15.5+8.2)” 的表达式，调用计算器工具获取结果后，再整理成自然语言回答，解决了大模型计算精度不足的问题。

实战场景落地：构建企业级大模型应用

结合 LangChain4j 的核心能力，可快速构建企业级大模型应用。以下以 “代码审查助手” 为例，实现代码上传、问题分析、优化建议生成的完整流程，覆盖实际开发中的代码质量管控需求。

代码审查助手实现

// src/main/java/com/example/langchain4j/demo/CodeReviewAssistant.java

package com.example.langchain4j.demo;

import dev.langchain4j.model.openai.OpenAiChatModel;

import dev.langchain4j.model.output.Response;

import dev.langchain4j.data.message.SystemMessage;

import dev.langchain4j.data.message.UserMessage;

import java.nio.file.Files;

import java.nio.file.Paths;

import java.util.stream.Collectors;

public class CodeReviewAssistant {

// 1. 读取本地代码文件（支持Java、Python等多种格式）

private static String readCodeFile(String filePath) {

try {

return Files.lines(Paths.get(filePath))

.collect(Collectors.joining("\n"));

} catch (Exception e) {

return "读取文件失败：" + e.getMessage();

}

}

// 2. 生成代码审查提示（明确审查维度）

private static String buildReviewPrompt(String code, String language) {

return String.format("""

你是专业的代码审查助手，请针对以下%s代码进行审查，重点关注：

1. 语法正确性：是否存在编译错误、语法漏洞；

2. 性能优化：是否存在循环冗余、资源未释放等问题；

3. 安全性：是否存在SQL注入、空指针等风险；

4. 可读性：是否有清晰的注释、规范的命名；

5. 最佳实践：是否符合该语言的编码规范（如Java的阿里巴巴开发手册）。

代码内容：

```%s

%s

请按 "问题列表 + 优化建议 + 优化后代码" 的格式输出审查结果，优化建议需具体可落地。

""", language, language, code);

}

public static void main (String [] args) {

// 3. 配置参数（可从命令行或配置文件读取）

String codeFilePath = "src/main/java/com/example/langchain4j/demo/UnoptimizedCode.java";

String codeLanguage = "Java";

// 4. 读取代码与构建提示

String code = readCodeFile (codeFilePath);

if (code.startsWith ("读取文件失败")) {

System.out.println (code);

return;

}

String prompt = buildReviewPrompt (code, codeLanguage);

// 5. 初始化大模型客户端并执行审查

String openAiApiKey = System.getenv ("OPENAI_API_KEY");

OpenAiChatModel chatModel = OpenAiChatModel.builder ()

.apiKey (openAiApiKey)

.modelName ("gpt-4") // 推荐使用 gpt-4 提升审查精度

.maxTokens (2048)

.build ();

// 添加系统提示，强化助手角色

Response reviewResponse = chatModel.generate (

SystemMessage.from ("你是严格的代码审查专家，审查结果需客观、详细、可落地"),

UserMessage.from (prompt)

);

// 6. 输出审查结果（可保存到文件或展示在前端）

System.out.println ("=== 代码审查结果 ===");

System.out.println (reviewResponse.content ());

// 7. （可选）保存审查结果到文件

try {

Files.write (Paths.get ("code_review_result.md"),

reviewResponse.content ().getBytes ());

System.out.println ("\n 审查结果已保存到 code_review_result.md");

} catch (Exception e) {

System.out.println ("\n 保存审查结果失败：" + e.getMessage ());

}

}

}

// 测试用的未优化代码（UnoptimizedCode.java）

class UnoptimizedCode {

// 无注释，命名不规范，存在资源未释放问题

public void readFile (String path) {

java.io.FileReader fr = null;

try {

fr = new java.io.FileReader (path);

char [] c = new char [1024];

int len;

while ((len = fr.read (c)) != -1) {

System.out.print (new String (c, 0, len));

}

} catch (Exception e) {

e.printStackTrace ();

}

// 未关闭 FileReader，存在资源泄漏

}

// 循环冗余，性能低下

public int sum (int n) {

int result = 0;

for (int i = 0; i <= n; i++) {

result += i;

}

for (int i = 0; i <= n; i++) { // 重复循环，无意义

System.out.println (i);

}

return result;

}

}

运行此类后，大模型会自动识别代码中的问题（如资源未释放、循环冗余、命名不规范），生成详细的审查报告</doubaocanvas>