2025最新版langchain4j快速上手：Java开发者必备指南-优快云博客

2025最新版langchain4j快速上手：Java开发者必备指南

【免费下载链接】langchain4j langchain4j - 一个Java库，旨在简化将AI/LLM（大型语言模型）能力集成到Java应用程序中。项目地址: https://gitcode.com/GitHub_Trending/la/langchain4j

引言：Java开发者的AI集成痛点与解决方案

你是否还在为Java应用集成AI能力时面临的以下问题而困扰？

不同LLM提供商（如OpenAI、Anthropic、Google Vertex AI）的API差异导致集成复杂
向量存储（Vector Store）选择众多，缺乏统一操作接口
RAG（检索增强生成）流程构建繁琐，需要手动处理文档加载、分割、嵌入和检索
工具调用（Tool Calling）与函数执行集成困难

langchain4j作为Java生态中领先的LLM集成框架，提供了统一API、丰富工具集和完整解决方案，让你无需深入了解各AI服务细节即可快速构建企业级AI应用。本文将带你从零开始，在15分钟内完成第一个AI应用，并逐步深入核心功能，掌握生产级集成技巧。

读完本文后，你将能够：

快速搭建langchain4j开发环境
使用主流LLM模型构建聊天功能
实现基于RAG的文档问答系统
掌握工具调用与函数执行能力
了解高级特性如记忆管理和多模型协作

1. 环境准备与依赖配置

1.1 系统要求

JDK 11+
Maven 3.6+ 或 Gradle 7.0+
网络连接（用于访问LLM API和依赖库）

1.2 依赖引入

Maven配置：

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-bom</artifactId>
            <version>1.5.0-beta11-SNAPSHOT</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<dependencies>
    <!-- 核心依赖 -->
    <dependency>
        <groupId>dev.langchain4j</groupId>
        <artifactId>langchain4j-core</artifactId>
    </dependency>
    
    <!-- OpenAI集成 (根据需要选择) -->
    <dependency>
        <groupId>dev.langchain4j</groupId>
        <artifactId>langchain4j-open-ai</artifactId>
    </dependency>
    
    <!-- 文档加载器 (根据需要选择) -->
    <dependency>
        <groupId>dev.langchain4j</groupId>
        <artifactId>langchain4j-document-loader-github</artifactId>
    </dependency>
    
    <!-- 向量存储 (根据需要选择) -->
    <dependency>
        <groupId>dev.langchain4j</groupId>
        <artifactId>langchain4j-pgvector</artifactId>
    </dependency>
</dependencies>

Gradle配置：

implementation platform("dev.langchain4j:langchain4j-bom:1.5.0-beta11-SNAPSHOT")
implementation "dev.langchain4j:langchain4j-core"
implementation "dev.langchain4j:langchain4j-open-ai"
implementation "dev.langchain4j:langchain4j-document-loader-github"
implementation "dev.langchain4j:langchain4j-pgvector"

1.3 项目初始化

# 克隆仓库
git clone https://gitcode.com/GitHub_Trending/la/langchain4j
cd langchain4j

# 构建项目
./mvnw clean install -DskipTests

2. 快速入门：第一个LLM应用

2.1 基础聊天模型

使用OpenAI模型创建简单的聊天应用：

import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.data.message.UserMessage;

public class BasicChatExample {
    public static void main(String[] args) {
        // 1. 创建模型实例
        OpenAiChatModel model = OpenAiChatModel.builder()
                .apiKey("YOUR_OPENAI_API_KEY")  // 替换为实际API密钥
                .modelName("gpt-4o-mini")      // 模型名称
                .temperature(0.7)              // 创造性控制 (0-1)
                .maxTokens(1000)               // 最大输出令牌数
                .build();
        
        // 2. 发送消息并获取响应
        String response = model.generate(UserMessage.from("请介绍一下Java语言的特点"));
        
        // 3. 输出结果
        System.out.println("AI响应: " + response);
    }
}

2.2 流式响应处理

对于需要实时展示结果的场景，使用流式响应：

import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.data.message.UserMessage;
import dev.langchain4j.model.streaming.StreamingResponseHandler;

public class StreamingChatExample {
    public static void main(String[] args) {
        OpenAiChatModel model = OpenAiChatModel.builder()
                .apiKey("YOUR_OPENAI_API_KEY")
                .modelName("gpt-4o-mini")
                .build();
        
        // 流式处理响应
        model.generateStreaming(
            UserMessage.from("请用500字描述Java的历史发展"),
            new StreamingResponseHandler<String>() {
                @Override
                public void onNext(String partialResponse) {
                    System.out.print(partialResponse);  // 实时打印部分响应
                }
                
                @Override
                public void onComplete() {
                    System.out.println("\n--- 响应完成 ---");
                }
                
                @Override
                public void onError(Throwable error) {
                    System.err.println("发生错误: " + error.getMessage());
                }
            }
        );
        
        // 等待流式响应完成
        try {
            Thread.sleep(30000);  // 30秒超时
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

3. 核心功能详解

3.1 模型配置详解

OpenAiChatModel支持丰富的配置选项，满足不同场景需求：

OpenAiChatModel model = OpenAiChatModel.builder()
        .apiKey("YOUR_OPENAI_API_KEY")
        .modelName("gpt-4o-mini")          // 模型名称
        .temperature(0.7)                  // 创造性: 0(精确)~2(随机)
        .topP(0.9)                         // 核采样: 0~1
        .maxTokens(2048)                   // 最大输出令牌
        .timeout(Duration.ofSeconds(30))   // 超时时间
        .maxRetries(3)                     // 重试次数
        .logRequests(true)                 // 日志请求
        .logResponses(true)                // 日志响应
        .build();

3.2 消息类型与对话管理

支持多种消息类型，构建复杂对话流程：

import dev.langchain4j.data.message.*;
import java.util.Arrays;

public class ConversationExample {
    public static void main(String[] args) {
        OpenAiChatModel model = OpenAiChatModel.builder()
                .apiKey("YOUR_OPENAI_API_KEY")
                .modelName("gpt-4o-mini")
                .build();
        
        // 构建对话历史
        ChatMessage systemMessage = SystemMessage.from(
            "你是一位Java专家，负责解答编程问题。回答要简洁明了，提供代码示例。"
        );
        
        ChatMessage userMessage1 = UserMessage.from(
            "什么是Java中的Stream API？"
        );
        
        // 首次对话
        AiMessage response1 = model.chat(Arrays.asList(systemMessage, userMessage1));
        System.out.println("AI响应1: " + response1.text());
        
        // 继续对话
        ChatMessage userMessage2 = UserMessage.from(
            "如何使用Stream API过滤列表中的偶数？"
        );
        
        AiMessage response2 = model.chat(Arrays.asList(
            systemMessage, userMessage1, response1, userMessage2
        ));
        System.out.println("AI响应2: " + response2.text());
    }
}

3.3 RAG基础实现

检索增强生成（RAG）是提升LLM知识准确性的关键技术：

import dev.langchain4j.rag.DefaultRetrievalAugmentor;
import dev.langchain4j.rag.content.retriever.EmbeddingStoreContentRetriever;
import dev.langchain4j.store.embedding.EmbeddingStore;
import dev.langchain4j.store.embedding.inmemory.InMemoryEmbeddingStore;

public class RagBasicExample {
    public static void main(String[] args) {
        // 1. 创建嵌入模型 (使用OpenAI嵌入)
        OpenAiEmbeddingModel embeddingModel = OpenAiEmbeddingModel.builder()
                .apiKey("YOUR_OPENAI_API_KEY")
                .modelName("text-embedding-3-small")
                .build();
        
        // 2. 创建向量存储
        EmbeddingStore<TextSegment> embeddingStore = new InMemoryEmbeddingStore<>();
        
        // 3. 准备文档并嵌入
        Document document = Document.from("Java是由Sun Microsystems于1995年推出的编程语言...");
        List<TextSegment> segments = TextSplitter.split(document);
        
        embeddingStore.addAll(segments, embeddingModel::embed);
        
        // 4. 创建检索增强器
        RetrievalAugmentor retrievalAugmentor = DefaultRetrievalAugmentor.builder()
                .contentRetriever(EmbeddingStoreContentRetriever.from(embeddingStore, embeddingModel))
                .build();
        
        // 5. 创建增强型聊天模型
        ChatModel ragEnabledChatModel = retrievalAugmentor.enhance(model);
        
        // 6. 提问 (模型将使用提供的文档内容回答)
        AiMessage response = ragEnabledChatModel.chat(
            UserMessage.from("Java是什么时候发布的？")
        );
        
        System.out.println("RAG响应: " + response.text());  // 应回答1995年
    }
}

3.4 文档加载与处理

使用GitHubDocumentLoader加载远程文档：

import dev.langchain4j.data.document.loader.github.GitHubDocumentLoader;
import dev.langchain4j.data.document.parser.TextDocumentParser;

public class DocumentLoadingExample {
    public static void main(String[] args) {
        // 创建GitHub文档加载器
        GitHubDocumentLoader loader = GitHubDocumentLoader.builder()
                .gitHubToken("YOUR_GITHUB_TOKEN")  // 可选，用于访问私有仓库
                .build();
        
        // 加载文档
        Document document = loader.loadDocument(
            "langchain4j",                  // 仓库所有者
            "langchain4j",                  // 仓库名称
            "main",                         // 分支
            "README.md",                    // 文件路径
            new TextDocumentParser()        // 文档解析器
        );
        
        System.out.println("文档标题: " + document.metadata().get("title"));
        System.out.println("文档内容: " + document.content().substring(0, 200) + "...");
    }
}

4. 高级功能应用

4.1 工具调用能力

让LLM根据需求自动调用工具：

import dev.langchain4j.model.tool.ToolSpecification;
import dev.langchain4j.model.tool.ToolExecutor;

public class ToolCallingExample {
    public static void main(String[] args) {
        // 1. 定义工具规范
        ToolSpecification calculatorTool = ToolSpecification.builder()
                .name("calculator")
                .description("用于执行数学计算")
                .parameters(JsonObjectSchema.builder()
                        .addNumberProperty("a", "第一个数字")
                        .addNumberProperty("b", "第二个数字")
                        .addStringProperty("operation", "操作类型: add, subtract, multiply, divide")
                        .build())
                .build();
        
        // 2. 创建工具执行器
        ToolExecutor toolExecutor = toolCall -> {
            if ("calculator".equals(toolCall.name())) {
                double a = toolCall.parameter("a");
                double b = toolCall.parameter("b");
                String operation = toolCall.parameter("operation");
                
                switch (operation) {
                    case "add": return a + b;
                    case "subtract": return a - b;
                    case "multiply": return a * b;
                    case "divide": return a / b;
                    default: return "不支持的操作";
                }
            }
            return "未知工具";
        };
        
        // 3. 创建工具增强型模型
        ToolCallingChatModel toolEnabledChatModel = ToolCallingChatModel.builder()
                .chatModel(model)
                .tools(calculatorTool)
                .toolExecutor(toolExecutor)
                .build();
        
        // 4. 提问需要计算的问题
        AiMessage response = toolEnabledChatModel.chat(
            UserMessage.from("37乘以24等于多少？")
        );
        
        System.out.println("工具调用结果: " + response.text());  // 应返回 888
    }
}

4.2 记忆管理

使用对话记忆增强多轮对话能力：

import dev.langchain4j.memory.ChatMemory;
import dev.langchain4j.memory.chat.MessageWindowChatMemory;

public class ChatMemoryExample {
    public static void main(String[] args) {
        // 创建聊天记忆 (保留最后10条消息)
        ChatMemory chatMemory = MessageWindowChatMemory.withMaxMessages(10);
        
        // 创建带记忆的聊天模型
        ChatModel chatModelWithMemory = ChatModelWithMemory.builder()
                .chatModel(model)
                .chatMemory(chatMemory)
                .build();
        
        // 多轮对话
        AiMessage response1 = chatModelWithMemory.chat(UserMessage.from("我叫张三"));
        AiMessage response2 = chatModelWithMemory.chat(UserMessage.from("记住我的名字了吗？"));
        
        System.out.println(response2.text());  // 应回答记住了，用户名叫张三
    }
}

5. 生产环境注意事项

5.1 性能优化

优化策略	实现方法	预期效果
连接池配置	自定义HttpClientBuilder	减少连接建立开销，提升并发性能
批处理请求	使用批量嵌入API	降低API调用次数，减少延迟
本地缓存	缓存频繁使用的嵌入结果	减少重复计算和API调用
异步处理	使用CompletableFuture	提高应用响应性和吞吐量

// 配置HTTP连接池示例
HttpClient httpClient = HttpClient.newBuilder()
        .connectTimeout(Duration.ofSeconds(10))
        .connectionPool(ConnectionPool.builder()
                .maxConnections(50)
                .maxIdleTime(Duration.ofMinutes(5))
                .build())
        .build();

OpenAiChatModel optimizedModel = OpenAiChatModel.builder()
        .httpClient(httpClient)
        // 其他配置...
        .build();

5.2 错误处理与重试

import dev.langchain4j.model.input.structured.StructuredPrompt;
import dev.langchain4j.model.output.structured.StructuredOutput;

public class RobustExample {
    public static void main(String[] args) {
        ChatModel robustModel = RetryableChatModel.builder()
                .chatModel(model)
                .retryPolicy(RetryPolicy.builder()
                        .maxAttempts(3)
                        .delay(Duration.ofSeconds(2))
                        .exponentialBackoff()
                        .retryOn(IOException.class, TimeoutException.class)
                        .build())
                .build();
                
        try {
            AiMessage response = robustModel.chat(UserMessage.from("需要可靠处理的请求"));
        } catch (Exception e) {
            // 最终错误处理
            System.err.println("所有重试均失败: " + e.getMessage());
        }
    }
}

6. 总结与进阶学习

6.1 核心知识点回顾

统一API：langchain4j提供一致的接口，屏蔽不同LLM和向量存储的实现差异
RAG架构：通过检索增强生成，解决LLM知识时效性和准确性问题
工具调用：扩展LLM能力，使其能与外部系统交互
记忆管理：支持多轮对话上下文保持

6.2 进阶学习路径

深入源码：克隆仓库 https://gitcode.com/GitHub_Trending/la/langchain4j，研究核心模块实现
探索示例：查看 langchain4j-examples 模块中的各类应用场景
参与社区：加入Discord社区交流问题与经验
贡献代码：提交PR参与项目开发，添加新功能或修复bug

6.3 常见问题解决

依赖冲突：使用langchain4j-bom统一管理版本
API密钥安全：生产环境使用环境变量或配置中心管理密钥
模型响应慢：启用流式响应、优化网络或考虑本地模型
内存占用高：使用持久化向量存储替代内存存储

7. 附录：常用集成组件

组件类型	支持实现	Maven依赖
LLM模型	OpenAI、Anthropic、Google Vertex AI、Bedrock	langchain4j-open-ai、langchain4j-anthropic等
向量存储	Pinecone、Milvus、Elasticsearch、PgVector	langchain4j-pinecone、langchain4j-milvus等
文档加载器	GitHub、S3、Azure Blob、本地文件	langchain4j-document-loader-github等
文档解析器	PDF、Word、Markdown、HTML	langchain4j-document-parser-apache-pdfbox等
嵌入模型	OpenAI、BERT、Sentence-BERT	langchain4j-open-ai、langchain4j-onnx-scoring等

希望本文能帮助你快速掌握langchain4j的核心功能。如有任何问题或建议，欢迎在项目仓库提交issue。持续关注项目更新，获取更多高级特性和最佳实践！

提示：点赞收藏本文，关注项目更新，不错过2025年LLM集成最佳实践！下期预告：《langchain4j企业级部署与优化》

创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考