跳至主要內容

第2041篇：LangChain4j入门——Java开发者的AI应用开发框架

老张2026/4/30大约 5 分钟

第2041篇：LangChain4j入门——Java开发者的AI应用开发框架

适读人群：Java工程师，希望快速上手AI应用开发 | 阅读时长：约18分钟 | 核心价值：理解LangChain4j的核心概念和设计哲学，在Java生态中高效构建AI应用

Python版的LangChain在AI社区火了一阵子，然后Java开发者问：Java有没有类似的框架？

LangChain4j就是答案。但它不只是LangChain的Java翻译版——它结合了Java的强类型特性，在某些设计上比原版更优雅。

我在几个项目里都用过，这篇文章是我对LangChain4j核心设计的整体梳理。

LangChain4j的设计哲学

LangChain4j的核心思想是把AI调用变成普通的Java方法调用。

用Python LangChain的感觉是：手工拼装chain，管理prompt template，处理输出。LangChain4j的感觉是：写一个接口，加几个注解，框架帮你处理其他一切。

// Python LangChain风格（伪代码）：
// chain = LLMChain(llm=llm, prompt=prompt_template)
// result = chain.run(user_input=user_message)

// LangChain4j风格：
@AiService
interface CustomerServiceAssistant {
    String chat(String userMessage);
}

// 使用
CustomerServiceAssistant assistant = AiServices.create(CustomerServiceAssistant.class, model);
String response = assistant.chat("我的订单什么时候发货？");

这种声明式风格是LangChain4j最大的特点，也是它最受Java开发者欢迎的原因。

项目搭建

<!-- pom.xml -->
<dependencies>
    <!-- LangChain4j核心 -->
    <dependency>
        <groupId>dev.langchain4j</groupId>
        <artifactId>langchain4j</artifactId>
        <version>0.35.0</version>
    </dependency>
    
    <!-- OpenAI集成 -->
    <dependency>
        <groupId>dev.langchain4j</groupId>
        <artifactId>langchain4j-open-ai</artifactId>
        <version>0.35.0</version>
    </dependency>
    
    <!-- Ollama集成（本地模型） -->
    <dependency>
        <groupId>dev.langchain4j</groupId>
        <artifactId>langchain4j-ollama</artifactId>
        <version>0.35.0</version>
    </dependency>
    
    <!-- Spring Boot集成 -->
    <dependency>
        <groupId>dev.langchain4j</groupId>
        <artifactId>langchain4j-spring-boot-starter</artifactId>
        <version>0.35.0</version>
    </dependency>
    
    <!-- pgvector向量存储 -->
    <dependency>
        <groupId>dev.langchain4j</groupId>
        <artifactId>langchain4j-pgvector</artifactId>
        <version>0.35.0</version>
    </dependency>
</dependencies>

核心概念一：ChatLanguageModel

所有LLM调用的基础：

@Configuration
public class LangChain4jConfig {
    
    // 生产环境：OpenAI API
    @Bean
    @Profile("prod")
    public ChatLanguageModel openAiModel() {
        return OpenAiChatModel.builder()
            .apiKey(System.getenv("OPENAI_API_KEY"))
            .modelName("gpt-4o-mini")
            .temperature(0.3)
            .maxTokens(2048)
            .logRequests(false)     // 生产环境关闭请求日志
            .logResponses(false)
            .build();
    }
    
    // 开发环境：本地Ollama
    @Bean
    @Profile("dev")
    public ChatLanguageModel ollamaModel() {
        return OllamaChatModel.builder()
            .baseUrl("http://dev-gpu-server:11434")
            .modelName("qwen2:7b")
            .temperature(0.3)
            .build();
    }
    
    // 嵌入模型（向量化）
    @Bean
    public EmbeddingModel embeddingModel() {
        return OllamaEmbeddingModel.builder()
            .baseUrl("http://dev-gpu-server:11434")
            .modelName("nomic-embed-text")
            .build();
    }
}

// 最简单的使用方式
@Service
@RequiredArgsConstructor
public class SimpleChatService {
    
    private final ChatLanguageModel chatModel;
    
    public String ask(String question) {
        return chatModel.generate(question);
    }
    
    // 带System Prompt的对话
    public String askWithContext(String systemPrompt, String userMessage) {
        return chatModel.generate(
            SystemMessage.from(systemPrompt),
            UserMessage.from(userMessage)
        ).content().text();
    }
}

核心概念二：AI Service（最重要的特性）

AI Service是LangChain4j最具特色的功能——定义接口，框架自动实现：

/**
 * 声明式AI服务定义
 * 用注解描述行为，框架自动生成实现
 */
@AiService
public interface ContractAnalysisService {
    
    // 简单问答
    String analyze(String contractText);
    
    // 带System Prompt（用@SystemMessage注解）
    @SystemMessage("你是专业合同律师，请识别合同中的风险条款")
    String identifyRisks(String contractText);
    
    // 结构化输出（自动反序列化）
    @SystemMessage("从合同文本中提取关键信息，按JSON格式输出")
    ContractInfo extractInfo(String contractText);
    
    // 多参数输入（自动拼装成Prompt）
    @UserMessage("请分析合同：{{contract}}，重点关注：{{focus}}")
    String analyzeWithFocus(
        @V("contract") String contractText,
        @V("focus") String focusArea
    );
}

// 结构化输出的DTO
@Data
public class ContractInfo {
    private String partyA;
    private String partyB;
    private BigDecimal amount;
    private String currency;
    private LocalDate startDate;
    private LocalDate endDate;
}

// 注入和使用
@RestController
@RequiredArgsConstructor
public class ContractController {
    
    private final ContractAnalysisService contractService;
    
    @PostMapping("/contracts/analyze")
    public ContractInfo analyzeContract(@RequestBody String contractText) {
        // LangChain4j自动调用LLM，自动解析JSON输出到ContractInfo对象
        return contractService.extractInfo(contractText);
    }
}

核心概念三：ConversationChain（有记忆的对话）

@Service
@RequiredArgsConstructor
public class ConversationService {
    
    private final ChatLanguageModel chatModel;
    
    // 每个用户一个对话记忆（存在内存里，重启丢失）
    private final Map<String, ChatMemory> memories = new ConcurrentHashMap<>();
    
    public String chat(String userId, String userMessage) {
        ChatMemory memory = memories.computeIfAbsent(userId, 
            id -> MessageWindowChatMemory.withMaxMessages(20));
        
        ConversationChain chain = ConversationChain.builder()
            .chatLanguageModel(chatModel)
            .chatMemory(memory)
            .build();
        
        return chain.execute(userMessage);
    }
}

// 或者用AI Service + @MemoryId 更优雅
@AiService
public interface ChatAssistant {
    
    @SystemMessage("你是一个友好的AI助手")
    String chat(@MemoryId String userId, @UserMessage String userMessage);
}

@Configuration
public class AssistantConfig {
    
    @Bean
    public ChatAssistant chatAssistant(ChatLanguageModel model) {
        return AiServices.builder(ChatAssistant.class)
            .chatLanguageModel(model)
            // 每个userId有独立的对话记忆，最多保留20条消息
            .chatMemoryProvider(userId -> MessageWindowChatMemory.withMaxMessages(20))
            .build();
    }
}

核心概念四：工具（Tools）

// 定义工具
@Component
public class OrderTools {
    
    private final OrderRepository orderRepo;
    
    @Tool("查询订单状态，根据订单号返回订单的当前状态")
    public OrderStatus queryOrderStatus(
        @P("订单编号") String orderId
    ) {
        return orderRepo.findById(orderId)
            .map(Order::getStatus)
            .orElse(OrderStatus.NOT_FOUND);
    }
    
    @Tool("取消订单，只有未发货的订单才能取消")
    public CancelResult cancelOrder(
        @P("订单编号") String orderId
    ) {
        // 实际取消逻辑
        return orderRepo.cancel(orderId);
    }
}

// 把工具加入AI Service
@Configuration
public class CustomerServiceConfig {
    
    @Bean
    public CustomerServiceAssistant customerServiceAssistant(
            ChatLanguageModel model,
            OrderTools orderTools) {
        
        return AiServices.builder(CustomerServiceAssistant.class)
            .chatLanguageModel(model)
            .tools(orderTools)
            .chatMemoryProvider(userId -> MessageWindowChatMemory.withMaxMessages(30))
            .build();
    }
}

@AiService
interface CustomerServiceAssistant {
    @SystemMessage("""
        你是XX平台的客服助手。
        你可以：查询订单状态、取消未发货的订单。
        始终礼貌、专业。
        """)
    String serve(@MemoryId String userId, @UserMessage String message);
}

框架整体架构

LangChain4j vs Spring AI

两个框架都很好，简单对比：

特性LangChain4jSpring AI
AI Service声明式接口原生支持，非常强大有，但不如前者成熟
Spring生态集成良好（有Spring Boot Starter）原生Spring，无缝集成
模型支持广度非常广泛广泛但稍少
RAG支持完整（EmbeddingStore系列）完整
社区活跃度活跃活跃（背靠Spring官方）

如果你的项目重度依赖Spring生态，Spring AI更合适；如果你希望AI功能有清晰的声明式接口，LangChain4j更优雅。

LangChain4j最核心的价值是让AI调用对Java开发者像调用普通Service一样自然。定义接口、加注解、注入使用——这是Java开发者最熟悉的模式，LangChain4j把它带进了AI开发领域。

编辑此页
最近更新:
贡献者: xiaozhangge