一、为什么 Java 开发者需要 LangChain4j？
在大模型应用开发领域，Python 的 LangChain 占据半壁江山，但 Java 生态长期缺乏轻量化、易集成的同类框架 —— 直到 LangChain4j 出现。它专为 Java/Kotlin 开发者设计，解决了 3 个核心痛点：
1.多模型适配成本高：无需针对 OpenAI、通义千问、本地 Llama 3 等不同模型写适配代码，统一 API 调用；
2.重复造轮子：内置对话记忆、工具调用、流式响应等核心能力，避免从零开发；
3.Java 生态融合差：支持 Spring Boot 无缝集成，可直接嵌入现有 Java 项目，无需额外搭建 Python 服务。
如果你的技术栈是 Java，又想快速落地大模型功能（如智能客服、代码助手、知识库问答），LangChain4j 是最优选择。
二、环境搭建：5 分钟起步（Maven + 核心依赖）
LangChain4j 轻量化设计，核心包仅依赖 Jackson 和 OkHttp，无冗余依赖，以下是完整配置：

1. 基础依赖（必选）

<!-- LangChain4j核心包 -->
<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j</artifactId>
    <version>0.32.0</version> <!-- 建议用最新版，功能更全 -->
</dependency>

2. 模型适配器（按需选择）
   根据你使用的模型，引入对应的适配器：

模型类型 依赖配置
OpenAI/GPT-4o dev.langchain4jlangchain4j-open-ai0.32.0
本地 Ollama dev.langchain4jlangchain4j-ollama0.32.0
通义千问 dev.langchain4jlangchain4j-qwen0.32.0
文心一言 dev.langchain4jlangchain4j-ernie-bot0.32.0
3. 辅助依赖（可选）
•Spring Boot 集成：langchain4j-spring-boot-starter
•Redis 记忆持久化：langchain4j-redis
•文档加载（RAG）：langchain4j-document-parser
三、核心实战：从基础对话到工具调用
案例 1：最小化对话（单次问答）
适合不需要上下文的场景（如知识查询、代码生成），3 行代码即可调用大模型：

import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.openai.OpenAiChatModel;
public class BasicChatDemo {
    public static void main(String[] args) {
        // 1. 初始化OpenAI模型（替换为你的API Key）
        ChatLanguageModel model = OpenAiChatModel.builder()
                .apiKey("sk-xxx") // 从环境变量或配置中心注入，避免硬编码
                .modelName("gpt-3.5-turbo") // 可选gpt-4o提升精度
                .temperature(0.7) // 0=严谨，1=灵活
                .build();
        // 2. 发送指令并获取响应
        String prompt = "用Java写一个单例模式，包含懒汉式和饿汉式，带注释";
        String response = model.generate(prompt);
        // 3. 输出结果
        System.out.println("大模型响应：\n" + response);
    }
}

⚠️ 避坑提示：
•API Key 不要硬编码到代码，生产环境用System.getenv(“OPENAI_API_KEY”)读取环境变量；
•若提示 “API Key 无效”，检查是否开启了 OpenAI 账号的付费功能（免费账号有调用限制）。
案例 2：带记忆的多轮对话
解决 “大模型记不住上下文” 的问题，LangChain4j 内置ConversationMemory，支持保留历史对话：

import dev.langchain4j.memory.chat.MessageWindowChatMemory;
import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.service.AiServices;
// 1. 定义对话接口（推荐方式，更易维护）
interface JavaChatBot {
    String chat(String userMessage);
}
public class MemoryChatDemo {
    public static void main(String[] args) {
        // 2. 初始化模型（此处用Ollama本地模型示例，无需API Key）
        ChatLanguageModel model = dev.langchain4j.model.ollama.OllamaChatModel.builder()
                .baseUrl("http://localhost:11434") // Ollama默认端口
                .modelName("llama3") // 本地启动的模型名称
                .build();
        // 3. 创建对话记忆（保留最近10轮对话）
        var memory = MessageWindowChatMemory.withMaxMessages(10);
        // 4. 绑定模型与记忆，创建AI服务
        JavaChatBot bot = AiServices.builder(JavaChatBot.class)
                .chatLanguageModel(model)
                .chatMemory(memory)
                .build();
        // 5. 多轮对话（大模型会记住历史）
        System.out.println(bot.chat("你好，我叫小李，是Java开发"));
        System.out.println(bot.chat("我刚才说我叫什么？")); // 会回答“小李”
        System.out.println(bot.chat("用我的名字编一个Java相关的笑话"));
    }
}

本地模型启动方式：
先安装 Ollama（官网下载），再执行ollama run llama3，等待模型拉取完成即可。
案例 3：工具调用（让大模型 “动手做事”）
大模型默认只能 “说话”，通过工具调用可让它执行实际操作（如计算、查天气、调用 API），核心步骤：定义工具→注册工具→自动调用。
步骤 1：定义工具类
用@Tool注解标记工具方法，描述要清晰（大模型靠描述判断是否调用）：

import dev.langchain4j.agent.tool.Tool;
// 计算器工具
public class CalculatorTool {
    @Tool("计算两个数字的加法，参数a和b为待加的数字")
    public double add(double a, double b) {
        System.out.println("[工具调用] 执行加法：" + a + "+" + b);
        return a + b;
    }
    @Tool("计算两个数字的减法，参数a为被减数，b为减数")
    public double subtract(double a, double b) {
        System.out.println("[工具调用] 执行减法：" + a + "-" + b);
        return a - b;
    }
}
// 天气查询工具（模拟对接天气API）
public class WeatherTool {
    @Tool("查询指定城市的实时天气，参数city为城市名称（如北京、上海）")
    public String getWeather(String city) {
        System.out.println("[工具调用] 查询天气：" + city);
        // 实际场景替换为真实API调用（如高德天气API）
        return city + "当前天气：晴，温度25℃，风力3级";
    }
}

步骤 2：注册工具并测试

import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.service.AiServices;
// 定义带工具能力的接口
interface ToolEnabledBot {
    String answer(String question);
}
public class ToolCallingDemo {
    public static void main(String[] args) {
        // 1. 初始化模型
        var model = OpenAiChatModel.builder()
                .apiKey("sk-xxx")
                .modelName("gpt-3.5-turbo")
                .build();
        // 2. 注册工具（可注册多个）
        var bot = AiServices.builder(ToolEnabledBot.class)
                .chatLanguageModel(model)
                .tools(new CalculatorTool(), new WeatherTool()) // 绑定工具
                .build();
        // 3. 测试工具调用（大模型会自动判断是否需要调用工具）
        System.out.println(bot.answer("100.5加200.3等于多少？"));
        System.out.println(bot.answer("杭州今天天气怎么样？"));
        System.out.println(bot.answer("先算500减120，再告诉我广州的天气"));
    }
}

运行效果：
大模型会先调用对应工具获取结果，再整理成自然语言回答，无需手动判断何时调用工具。
四、Spring Boot 集成：生产级配置
如果你的项目是 Spring Boot，LangChain4j 提供 Starter 简化配置，无需手动构建模型。

1. 引入 Starter 依赖

<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-spring-boot-starter</artifactId>
    <version>0.32.0</version>
</dependency>
<!-- 对接OpenAI需额外引入 -->
<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-open-ai</artifactId>
    <version>0.32.0</version>
</dependency>

2. 配置文件（application.yml）

langchain4j:
  # 模型配置（OpenAI）
  open-ai:
    chat-model:
      api-key: ${OPENAI_API_KEY:sk-xxx} # 支持环境变量占位符
      model-name: gpt-3.5-turbo
      temperature: 0.6
      max-tokens: 2000 # 最大响应长度
  # 对话记忆配置
  chat-memory:
    type: MESSAGE_WINDOW # 内存记忆（生产用REDIS）
    max-messages: 15 # 保留最近15轮对话

3. 业务代码（控制器 + AI 服务）

import dev.langchain4j.service.AiService;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
// 1. 定义AI服务接口（@AiService自动注入）
@AiService
public interface JavaDevBot {
    // 基础对话
    String chat(String input);
    // 带提示词模板的专业问答（避免硬编码提示词）
    @dev.langchain4j.service.Prompt("""
            你是资深Java工程师，回答需满足：
            1. 分点说明核心原理
            2. 附带可运行的代码示例
            3. 指出常见坑点
            问题：{{question}}
            """)
    String answerJavaQuestion(String question);
}

// 2. 控制器（对外提供API）

@RestController
public class ChatController {
    private final JavaDevBot javaDevBot;
    // 构造注入AI服务
    public ChatController(JavaDevBot javaDevBot) {
        this.javaDevBot = javaDevBot;
    }
    @GetMapping("/chat")
    public String chat(@RequestParam String input) {
        return javaDevBot.chat(input);
    }
    @GetMapping("/java/qa")
    public String javaQa(@RequestParam String question) {
        return javaDevBot.answerJavaQuestion(question);
    }
}

测试方式：
启动项目后访问 http://localhost:8080/java/qa?question=什么是线程安全，会返回带代码示例和坑点的专业回答。
五、进阶优化：从 “能用” 到 “好用”

1. 记忆持久化（Redis）
   默认的内存记忆（MessageWindowChatMemory）在多实例部署时不共享，需改用 Redis 存储对话历史：

<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-redis</artifactId>
    <version>0.32.0</version>
</dependency>
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
</dependency>

import dev.langchain4j.memory.chat.RedisChatMemory;
import redis.clients.jedis.JedisPool;
public class RedisMemoryDemo {
    public static void main(String[] args) {
        // 1. 初始化Redis连接池
        JedisPool jedisPool = new JedisPool("localhost", 6379);
        // 2. 创建Redis记忆（每个用户用唯一sessionId区分）
        var memory = RedisChatMemory.builder()
                .jedisPool(jedisPool)
                .sessionId("user_10086") // 从登录态获取用户ID
                .maxMessages(20)
                .build();
        // 3. 绑定到AI服务
        JavaChatBot bot = AiServices.builder(JavaChatBot.class)
                .chatLanguageModel(OpenAiChatModel.builder().apiKey("sk-xxx").build())
                .chatMemory(memory)
                .build();
    }
}

2. 流式响应（实时输出）
   适合聊天界面、实时播报场景，避免用户等待完整响应：

import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.model.output.Response;
import dev.langchain4j.model.output.TokenStream;
public class StreamingDemo {
    public static void main(String[] args) {
        var model = OpenAiChatModel.builder()
                .apiKey("sk-xxx")
                .modelName("gpt-3.5-turbo")
                .build();
        // 流式生成响应
        String prompt = "详细讲解Java Stream API的常用方法，分点说明";
        Response<TokenStream> response = model.generateStreaming(prompt);
        // 实时输出每个Token（逐字打印）
        response.content()
                .onNext(token -> System.out.print(token.text())) // 每收到一个Token就输出
                .onComplete(() -> System.out.println("\n\n响应完成！"))
                .onError(Throwable::printStackTrace) // 异常处理
                .start(); // 启动流式监听
    }
}

3. 自定义提示词模板
   用PromptTemplate实现提示词参数化，避免硬编码，提升可维护性：

import dev.langchain4j.model.input.Prompt;
import dev.langchain4j.model.input.PromptTemplate;
import dev.langchain4j.model.openai.OpenAiChatModel;
public class PromptTemplateDemo {
    public static void main(String[] args) {
        // 1. 定义模板（用{{变量名}}占位）
        String template = """
                角色：你是{role}，专注于{domain}领域。
                任务：解释{concept}的核心原理，要求：
                1. 控制在{wordCount}字以内
                2. 举1个实际项目中的例子
                """;
        PromptTemplate promptTemplate = PromptTemplate.from(template);
        // 2. 填充参数（动态替换占位符）
        Prompt prompt = promptTemplate.apply(
                "role", "Java架构师",
                "domain", "分布式系统",
                "concept", "CAP定理",
                "wordCount", "500"
        );
        // 3. 调用模型
        var model = OpenAiChatModel.builder().apiKey("sk-xxx").build();
        String response = model.generate(prompt.text());
        System.out.println(response);
    }
}

六、常见问题与避坑指南
1.依赖冲突：
LangChain4j 的 OkHttp 版本可能与项目冲突，在dependencyManagement中统一版本：

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>com.squareup.okhttp3</groupId>
            <artifactId>okhttp</artifactId>
            <version>4.11.0</version>
        </dependency>
    </dependencies>
</dependencyManagement>

1.本地模型响应慢：
Ollama 启动时添加–num-gpu 1启用 GPU 加速（需 NVIDIA 显卡 + CUDA），命令：ollama run llama3 --num-gpu 1。
2.工具调用不生效：
检查@Tool注解的描述是否清晰，大模型需要通过描述判断 “是否需要调用该工具”，例如不要只写 “计算加法”，要写 “计算两个数字的加法，参数 a 和 b 为待加的数字”。
3.生产环境 API Key 安全：
不要在配置文件中硬编码 API Key，通过 Spring Cloud Config、Nacos 等配置中心注入，或读取环境变量（System.getenv(“OPENAI_API_KEY”)）。

七、总结与扩展场景
LangChain4j 的核心价值是 “让 Java 开发者用熟悉的技术栈快速落地大模型应用”，目前已覆盖大部分主流场景：
•智能客服：集成对话记忆 + 知识库（RAG），实现精准问答；
•代码助手：结合 Java 语法分析，生成符合项目规范的代码；
•自动化工具：通过工具调用整合内部 API，实现自动化报表、数据查询；
•本地应用：对接 Ollama/Llama 3，实现完全离线的大模型功能。
如果你需要更复杂的能力（如 RAG 知识库、多智能体协作），可以进一步探索 LangChain4j 的DocumentLoader（文档加载）、EmbeddingModel（向量模型）、Agent（智能体）等特性，这些功能可满足企业级大模型应用的开发需求。