Spring AI vs LangChain4j：Java AI开发框架完整对比指南

欢迎大家来到IT世界,在知识的湖畔探索吧!

框架概述

Spring AI 1.0 (2025年5月正式发布)

Spring AI是Spring生态系统的官方AI框架，专为Java开发者设计，提供了统一的AI模型访问接口和丰富的企业级功能。

核心理念：

• 模型可移植性：一套代码支持20+种AI模型
• ️ Spring生态集成：无缝融入Spring Boot/Cloud
• ️ 企业级特性：完整的可观测性和安全性
• 结构化输出：类型安全的Java对象映射

LangChain4j (持续更新中)

LangChain4j是LangChain的Java实现，专注于构建LLM驱动的应用程序，提供了丰富的工具链和模块化设计。

核心理念：

• 模块化设计：灵活的组件组合
• 链式编程：直观的工作流构建
• 广泛兼容：支持多种LLM提供商
• ️ 工具丰富：内置大量实用工具

Spring AI 1.0 最新特性

1. ChatClient – 统一对话接口

@RestController public class ChatController { private final ChatClient chatClient; public ChatController(ChatClient.Builder chatClientBuilder) { this.chatClient = chatClientBuilder.build(); } @GetMapping("/chat") public String chat(@RequestParam String message) { return chatClient.prompt() .user(message) .call() .content(); } // 结构化输出 @GetMapping("/analyze") public ProductAnalysis analyzeProduct(@RequestParam String product) { return chatClient.prompt() .user("分析产品: " + product) .call() .entity(ProductAnalysis.class); } } record ProductAnalysis(String name, double price, List<String> features) {}

欢迎大家来到IT世界,在知识的湖畔探索吧!

2. RAG (检索增强生成) 支持

欢迎大家来到IT世界,在知识的湖畔探索吧!@Configuration public class RagConfiguration { @Bean public VectorStore vectorStore() { return new PgVectorStore(jdbcTemplate, embeddingModel); } @Bean public DocumentReader documentReader() { return new PdfDocumentReader(new ClassPathResource("docs/")); } @Bean public QuestionAnswerAdvisor qaAdvisor(VectorStore vectorStore) { return new QuestionAnswerAdvisor(vectorStore, SearchRequest.defaults()); } } @Service public class RagService { private final ChatClient chatClient; public RagService(ChatClient.Builder builder, QuestionAnswerAdvisor qaAdvisor) { this.chatClient = builder .defaultAdvisors(qaAdvisor) .build(); } public String askWithContext(String question) { return chatClient.prompt() .user(question) .call() .content(); } }

3. 工具调用 (Function Calling)

@Component public class WeatherService { @Tool("获取指定城市的天气信息") public String getWeather(String city) { // 调用天气API return "北京今天晴天，温度25°C"; } @Tool("发送邮件通知") public String sendEmail(String to, String subject, String content) { // 发送邮件逻辑 return "邮件已发送"; } } @Service public class AssistantService { private final ChatClient chatClient; public AssistantService(ChatClient.Builder builder, WeatherService weatherService) { this.chatClient = builder .defaultFunctions("getWeather", "sendEmail") .build(); } }

4. 对话记忆管理

欢迎大家来到IT世界,在知识的湖畔探索吧!@Configuration public class MemoryConfiguration { @Bean public ChatMemory chatMemory() { return new InMemoryChatMemory(); } @Bean public MessageChatMemoryAdvisor memoryAdvisor(ChatMemory chatMemory) { return new MessageChatMemoryAdvisor(chatMemory); } } @Service public class ConversationService { private final ChatClient chatClient; public ConversationService(ChatClient.Builder builder, MessageChatMemoryAdvisor memoryAdvisor) { this.chatClient = builder .defaultAdvisors(memoryAdvisor) .build(); } public String chat(String conversationId, String message) { return chatClient.prompt() .user(message) .advisors(advisorSpec -> advisorSpec .param(CHAT_MEMORY_CONVERSATION_ID_KEY, conversationId)) .call() .content(); } }

5. 可观测性集成

@Configuration public class ObservabilityConfiguration { @Bean public ObservationRegistry observationRegistry() { return ObservationRegistry.create(); } @Bean public ChatClientCustomizer observabilityCustomizer( ObservationRegistry observationRegistry) { return builder -> builder .observationRegistry(observationRegistry); } } // 自动监控指标 // - 响应时间 // - Token使用量 // - 错误率 // - 工具调用次数

LangChain4j 核心特性

1. 简洁的AI服务定义

欢迎大家来到IT世界,在知识的湖畔探索吧!public interface Assistant { @SystemMessage("你是一个专业的客服助手") String chat(@UserMessage String message); @SystemMessage("分析以下文本的情感") Sentiment analyzeSentiment(@UserMessage String text); @SystemMessage("总结以下内容") String summarize(@UserMessage String content); } // 使用 Assistant assistant = AiServices.builder(Assistant.class) .chatLanguageModel(openAiModel) .build(); String response = assistant.chat("你好");

2. 工具集成

public class Calculator { @Tool("执行数学计算") public double calculate(@P("数学表达式") String expression) { // 计算逻辑 return result; } } public interface MathAssistant { @SystemMessage("你是一个数学助手，可以使用计算器工具") String solve(@UserMessage String problem); } MathAssistant assistant = AiServices.builder(MathAssistant.class) .chatLanguageModel(model) .tools(new Calculator()) .build();

3. RAG实现

欢迎大家来到IT世界,在知识的湖畔探索吧!// 文档加载和分割 List<Document> documents = FileSystemDocumentLoader .loadDocuments("/path/to/docs", glob("*.pdf")); DocumentSplitter splitter = DocumentSplitters .recursive(300, 30); List<TextSegment> segments = splitter.splitAll(documents); // 向量存储 EmbeddingStore<TextSegment> embeddingStore = new InMemoryEmbeddingStore<>(); EmbeddingStoreIngestor.ingest(documents, embeddingStore); // RAG检索器 ContentRetriever retriever = EmbeddingStoreContentRetriever .builder() .embeddingStore(embeddingStore) .embeddingModel(embeddingModel) .maxResults(3) .build(); // AI服务 public interface RagAssistant { String answer(@UserMessage String question); } RagAssistant assistant = AiServices.builder(RagAssistant.class) .chatLanguageModel(model) .contentRetriever(retriever) .build();

4. 记忆管理

// 对话记忆 ChatMemory chatMemory = MessageWindowChatMemory .withMaxMessages(10); Assistant assistant = AiServices.builder(Assistant.class) .chatLanguageModel(model) .chatMemory(chatMemory) .build(); // 持久化记忆 ChatMemory persistentMemory = MessageWindowChatMemory .builder() .maxMessages(100) .chatMemoryStore(new FileChatMemoryStore()) .build();

⚖️ 详细功能对比

核心功能对比

生态系统对比

性能对比

欢迎大家来到IT世界,在知识的湖畔探索吧!// Spring AI - 批量处理 @Service public class BatchProcessingService { private final ChatClient chatClient; public List<String> processBatch(List<String> inputs) { return inputs.parallelStream() .map(input -> chatClient.prompt() .user(input) .call() .content()) .collect(Collectors.toList()); } } // LangChain4j - 异步处理 public class AsyncProcessingService { private final Assistant assistant; public CompletableFuture<List<String>> processAsync(List<String> inputs) { List<CompletableFuture<String>> futures = inputs.stream() .map(input -> CompletableFuture.supplyAsync(() -> assistant.chat(input))) .collect(Collectors.toList()); return CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])) .thenApply(v -> futures.stream() .map(CompletableFuture::join) .collect(Collectors.toList())); } } 

最佳实践指南

Spring AI 最佳实践

1. 配置管理

# application.yml spring: ai: openai: api-key: ${OPENAI_API_KEY} chat: options: model: gpt-4 temperature: 0.7 max-tokens: 1000 vectorstore: pgvector: url: jdbc:postgresql://localhost:5432/vectordb username: ${DB_USERNAME} password: ${DB_PASSWORD} management: endpoints: web: exposure: include: health,metrics,prometheus metrics: export: prometheus: enabled: true

2. 错误处理和重试

欢迎大家来到IT世界,在知识的湖畔探索吧!@Configuration public class ChatClientConfiguration { @Bean public ChatClient chatClient(ChatModel chatModel) { return ChatClient.builder(chatModel) .defaultSystem("你是一个专业的AI助手") .build(); } @Bean @Retryable(value = {Exception.class}, maxAttempts = 3) public ChatService chatService(ChatClient chatClient) { return new ChatService(chatClient); } } @Service public class RobustChatService { private final ChatClient chatClient; private final CircuitBreaker circuitBreaker; public String chatWithFallback(String message) { return circuitBreaker.executeSupplier(() -> { try { return chatClient.prompt() .user(message) .call() .content(); } catch (Exception e) { log.error("AI调用失败", e); return "抱歉，服务暂时不可用，请稍后重试。"; } }); } }

3. 成本控制

@Component public class TokenUsageMonitor { private final MeterRegistry meterRegistry; private final Counter tokenCounter; public TokenUsageMonitor(MeterRegistry meterRegistry) { this.meterRegistry = meterRegistry; this.tokenCounter = Counter.builder("ai.tokens.used") .description("AI tokens consumed") .register(meterRegistry); } @EventListener public void handleChatResponse(ChatResponseEvent event) { Usage usage = event.getResponse().getMetadata().getUsage(); if (usage != null) { tokenCounter.increment(usage.getTotalTokens()); // 成本告警 if (usage.getTotalTokens() > 10000) { log.warn("高Token使用量: {}", usage.getTotalTokens()); } } } }

LangChain4j 最佳实践

1. 模块化设计

欢迎大家来到IT世界,在知识的湖畔探索吧!// 服务接口分离 public interface DocumentAnalyzer { @SystemMessage("你是文档分析专家") DocumentSummary analyze(@UserMessage String document); } public interface CodeReviewer { @SystemMessage("你是代码审查专家") CodeReview review(@UserMessage String code); } public interface DataAnalyst { @SystemMessage("你是数据分析专家") AnalysisResult analyze(@UserMessage String data); } // 统一服务工厂 @Component public class AiServiceFactory { private final ChatLanguageModel model; public <T> T createService(Class<T> serviceClass) { return AiServices.builder(serviceClass) .chatLanguageModel(model) .chatMemory(createMemory()) .build(); } private ChatMemory createMemory() { return MessageWindowChatMemory.withMaxMessages(10); } }

2. 链式处理

public class DocumentProcessingChain { private final DocumentAnalyzer analyzer; private final ContentSummarizer summarizer; private final QualityChecker checker; public ProcessingResult process(String document) { // 链式处理 DocumentSummary analysis = analyzer.analyze(document); String summary = summarizer.summarize(analysis.getContent()); QualityScore quality = checker.check(summary); return new ProcessingResult(analysis, summary, quality); } }

3. 自定义工具

欢迎大家来到IT世界,在知识的湖畔探索吧!public class DatabaseTool { private final JdbcTemplate jdbcTemplate; @Tool("查询用户信息") public String queryUser(@P("用户ID") String userId) { try { User user = jdbcTemplate.queryForObject( "SELECT * FROM users WHERE id = ?", User.class, userId); return user.toString(); } catch (Exception e) { return "用户不存在"; } } @Tool("更新用户状态") public String updateUserStatus(@P("用户ID") String userId, @P("状态") String status) { int updated = jdbcTemplate.update( "UPDATE users SET status = ? WHERE id = ?", status, userId); return updated > 0 ? "更新成功" : "更新失败"; } }

选择建议

选择 Spring AI 的场景

✅ 推荐使用 Spring AI 当：

1. Spring生态项目：已有Spring Boot/Cloud项目
2. 企业级应用：需要完整的监控和可观测性
3. 团队熟悉Spring：开发团队对Spring生态熟悉
4. 长期维护：需要官方长期支持
5. 多模型切换：需要在不同AI模型间灵活切换

// 典型的Spring AI企业应用 @SpringBootApplication @EnableAiObservability public class EnterpriseAiApplication { @Bean public ChatClient enterpriseChatClient(ChatModel model, ObservationRegistry registry) { return ChatClient.builder(model) .observationRegistry(registry) .defaultSystem("企业级AI助手") .build(); } }

选择 LangChain4j 的场景

✅ 推荐使用 LangChain4j 当：

1. 快速原型：需要快速构建AI应用原型
2. 灵活性优先：需要高度定制化的AI工作流
3. 非Spring项目：不使用Spring框架的项目
4. 丰富工具链：需要大量预构建的AI工具
5. 社区活跃：希望获得活跃的社区支持

欢迎大家来到IT世界,在知识的湖畔探索吧!// 典型的LangChain4j快速应用 public class QuickAiApp { public static void main(String[] args) { Assistant assistant = AiServices.builder(Assistant.class) .chatLanguageModel(OpenAiChatModel.withApiKey(apiKey)) .tools(new WebSearchTool(), new CalculatorTool()) .build(); String response = assistant.chat("帮我搜索最新的AI新闻"); System.out.println(response); } }

混合使用策略

在某些场景下，可以考虑混合使用两个框架：

@Configuration public class HybridAiConfiguration { // Spring AI用于核心业务 @Bean @Primary public ChatClient springAiClient(ChatModel model) { return ChatClient.builder(model).build(); } // LangChain4j用于特定工具 @Bean public DocumentProcessor langChainProcessor() { return AiServices.builder(DocumentProcessor.class) .chatLanguageModel(openAiModel) .tools(new AdvancedDocumentTool()) .build(); } }

迁移指南

从LangChain4j迁移到Spring AI

1. 依赖替换

欢迎大家来到IT世界,在知识的湖畔探索吧!<!-- 移除LangChain4j --> <!-- <dependency> <groupId>dev.langchain4j</groupId> <artifactId>langchain4j-spring-boot-starter</artifactId> <version>0.34.0</version> </dependency> --> <!-- 添加Spring AI --> <dependency> <groupId>org.springframework.ai</groupId> <artifactId>spring-ai-spring-boot-starter</artifactId> <version>1.0.0</version> </dependency>

2. 代码迁移示例

LangChain4j代码：

public interface Assistant { @SystemMessage("你是AI助手") String chat(@UserMessage String message); } Assistant assistant = AiServices.builder(Assistant.class) .chatLanguageModel(model) .build(); 

迁移到Spring AI：

欢迎大家来到IT世界,在知识的湖畔探索吧!@Service public class AssistantService { private final ChatClient chatClient; public AssistantService(ChatClient.Builder builder) { this.chatClient = builder .defaultSystem("你是AI助手") .build(); } public String chat(String message) { return chatClient.prompt() .user(message) .call() .content(); } }

从Spring AI迁移到LangChain4j

代码迁移示例

Spring AI代码：

@Service public class ChatService { private final ChatClient chatClient; public String chat(String message) { return chatClient.prompt() .user(message) .call() .content(); } }

迁移到LangChain4j：

欢迎大家来到IT世界,在知识的湖畔探索吧!public interface ChatService { String chat(@UserMessage String message); } @Component public class ChatServiceImpl { private final ChatService aiService; public ChatServiceImpl(ChatLanguageModel model) { this.aiService = AiServices.builder(ChatService.class) .chatLanguageModel(model) .build(); } public String chat(String message) { return aiService.chat(message); } }

总结

框架特点总结

最终建议

1. 企业级项目：优先选择 Spring AI
2. 快速开发：优先选择 LangChain4j
3. Spring项目：强烈推荐 Spring AI
4. 非Spring项目：推荐 LangChain4j
5. 长期维护：推荐 Spring AI

未来发展趋势

• Spring AI：将继续深化与Spring生态的集成，提供更多企业级特性
• LangChain4j：将保持快速迭代，提供更多创新功能和工具

选择哪个框架最终取决于您的具体需求、团队技能和项目特点。两个框架都是优秀的选择，关键是找到最适合您场景的那一个。