Java AI开发实战：LangChain4j与Spring AI框架对比与企业级RAG应用

这次我们来看一个2026年最新的Java+AI全栈开发课程，重点聚焦LangChain4j和Spring AI两大框架，以及企业级RAG项目的实战应用。对于想要快速掌握Java AI开发核心技能的开发者来说，这个课程体系提供了从基础到实战的完整路径。

在当前AI技术快速发展的背景下，Java开发者面临着如何将传统开发技能与AI能力结合的现实需求。LangChain4j和Spring AI作为Java生态中最重要的两个AI框架，分别针对不同的应用场景：LangChain4j更适合构建复杂的智能Agent和多步骤推理应用，而Spring AI则提供了快速集成AI服务的简化方案。

本文将从实际开发角度出发，详细分析这两个框架的核心特性、适用场景，并通过企业级RAG项目的实战演示，帮助读者建立完整的Java AI开发能力栈。无论你是想要快速上手基础AI功能，还是需要构建复杂的智能应用系统，都能在这里找到对应的解决方案。

1. 核心能力速览

2. 适用场景与使用边界

Spring AI最适合需要快速集成基础AI功能的场景。比如在现有的Spring Boot项目中添加聊天对话、文本生成等基础AI能力，Spring AI提供了一致的API接口，可以快速对接OpenAI、Azure OpenAI等主流AI服务。它的优势在于与Spring生态的深度集成，开发者可以沿用熟悉的Spring开发模式。

LangChain4j则更适合构建复杂的AI应用系统。当你的项目需要多步骤推理、智能Agent管理、自定义工作流编排时，LangChain4j提供了完整的解决方案。典型应用包括智能客服系统、复杂决策支持工具、多工具协同的AI助手等。

需要注意的是，两个框架都有明确的使用边界。Spring AI不适合需要复杂逻辑编排的场景，而LangChain4j的学习曲线相对较陡，对于简单的AI功能集成可能显得过于重量级。在实际项目中，可以根据具体需求选择合适的框架，甚至组合使用。

3. 环境准备与前置条件

开始Java AI开发前，需要确保开发环境满足以下要求：

基础环境要求：

• JDK 17或更高版本（必须支持模块化）
• Maven 3.6+ 或 Gradle 7.0+
• IDE推荐IntelliJ IDEA或Eclipse with Spring Tools
• 操作系统：Windows 10+/macOS 10.15+/Linux Ubuntu 18.04+

AI服务配置：

• OpenAI API密钥或Azure OpenAI服务端点
• 可选：本地模型部署（Ollama、LocalAI等）
• 网络环境需要能够访问AI服务API

项目依赖管理：对于Maven项目，需要在pom.xml中配置相应的依赖：

<!-- Spring AI 基础依赖 --> <dependency> <groupId>org.springframework.ai</groupId> <artifactId>spring-ai-core</artifactId> <version>2.0.0</version> </dependency> <!-- LangChain4j 核心依赖 --> <dependency> <groupId>dev.langchain4j</groupId> <artifactId>langchain4j-core</artifactId> <version>0.35.0</version> </dependency>

4. Spring AI 快速入门实战

Spring AI的设计理念是降低AI集成门槛，让开发者能够快速在现有Spring项目中添加AI能力。下面通过一个完整的示例演示如何快速集成Spring AI。

项目初始化：首先创建Spring Boot项目，添加Spring AI依赖：

spring init --dependencies=web,ai my-ai-demo

基础配置：在application.properties中配置AI服务连接：

# OpenAI配置 spring.ai.openai.api-key=your-openai-api-key spring.ai.openai.base-url=https://api.openai.com/v1 # 或者Azure OpenAI配置 spring.ai.azure.openai.api-key=your-azure-key spring.ai.azure.openai.endpoint=your-endpoint

核心服务类实现：创建AI服务类处理聊天请求：

@Service public class AIChatService { private final ChatClient chatClient; public AIChatService(ChatClient chatClient) { this.chatClient = chatClient; } public String chat(String message) { ChatResponse response = chatClient.call( new UserMessage(message) ); return response.getResult().getOutput().getContent(); } // 流式响应处理 public Flux<String> chatStream(String message) { return chatClient.stream(new UserMessage(message)) .map(response -> response.getResult().getOutput().getContent()); } }

REST控制器：提供Web接口供前端调用：

@RestController @RequestMapping("/api/ai") public class AIController { private final AIChatService chatService; public AIController(AIChatService chatService) { this.chatService = chatService; } @PostMapping("/chat") public ResponseEntity<String> chat(@RequestBody ChatRequest request) { String response = chatService.chat(request.getMessage()); return ResponseEntity.ok(response); } @GetMapping(value = "/chat/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE) public Flux<String> chatStream(@RequestParam String message) { return chatService.chatStream(message); } }

测试验证：启动应用后，可以使用curl测试接口：

curl -X POST http://localhost:8080/api/ai/chat \ -H "Content-Type: application/json" \ -d '{"message": "用Java写一个快速排序算法"}'

5. LangChain4j 高级功能实战

LangChain4j提供了更强大的AI应用构建能力，特别适合需要复杂逻辑处理的场景。下面通过智能Agent的构建演示LangChain4j的核心功能。

项目依赖配置：在pom.xml中添加LangChain4j完整依赖：

<dependency> <groupId>dev.langchain4j</groupId> <artifactId>langchain4j</artifactId> <version>0.35.0</version> </dependency> <dependency> <groupId>dev.langchain4j</groupId> <artifactId>langchain4j-open-ai</artifactId> <version>0.35.0</version> </dependency>

工具类定义：创建自定义工具供Agent使用：

public class CalculatorTool { @Tool("执行数学计算，支持加减乘除等基本运算") public double calculate(@P("数学表达式") String expression) { // 简化实现，实际项目应使用表达式解析库 if (expression.contains("+")) { String[] parts = expression.split("\\+"); return Double.parseDouble(parts[0]) + Double.parseDouble(parts[1]); } // 其他运算实现... return 0; } } public class WeatherTool { @Tool("获取指定城市的天气信息") public String getWeather(@P("城市名称") String city) { // 模拟天气查询 return city + "今天天气晴朗，温度25°C"; } }

智能Agent构建：创建具备多工具调用能力的智能Agent：

@Service public class SmartAgentService { private final Agent agent; public SmartAgentService() { this.agent = AiServices.builder(Agent.class) .chatLanguageModel(OpenAiChatModel.withApiKey("your-api-key")) .tools(new CalculatorTool(), new WeatherTool()) .build(); } public String executeTask(String taskDescription) { return agent.chat(taskDescription); } // 带记忆的对话 public String chatWithMemory(String message, String sessionId) { ChatMemory chatMemory = MessageWindowChatMemory.withMaxMessages(10); Agent agentWithMemory = AiServices.builder(Agent.class) .chatLanguageModel(OpenAiChatModel.withApiKey("your-api-key")) .tools(new CalculatorTool(), new WeatherTool()) .chatMemory(chatMemory) .build(); return agentWithMemory.chat(sessionId, message); } } interface Agent { String chat(String message); String chat(String sessionId, String message); }

复杂工作流示例：实现多步骤的业务流程：

@Service public class BusinessWorkflowService { public String processCustomerInquiry(String inquiry) { // 步骤1：意图识别 String intent = analyzeIntent(inquiry); // 步骤2：根据意图路由到不同处理流程 switch (intent) { case "WEATHER": return handleWeatherRequest(inquiry); case "CALCULATION": return handleCalculationRequest(inquiry); case "GENERAL": return handleGeneralQuestion(inquiry); default: return "抱歉，我无法处理这个请求"; } } private String analyzeIntent(String text) { // 使用LangChain4j进行意图分析 // 简化实现 if (text.contains("天气")) return "WEATHER"; if (text.contains("计算") || text.contains("加") || text.contains("减")) return "CALCULATION"; return "GENERAL"; } private String handleWeatherRequest(String inquiry) { WeatherTool weatherTool = new WeatherTool(); // 提取城市信息 String city = extractCity(inquiry); return weatherTool.getWeather(city); } private String extractCity(String text) { // 简单的城市提取逻辑 // 实际项目应使用更复杂的NLP技术 if (text.contains("北京")) return "北京"; if (text.contains("上海")) return "上海"; return "北京"; // 默认值 } }

6. 企业级RAG项目实战

检索增强生成（RAG）是企业AI应用的核心场景之一。下面通过一个完整的企业知识库系统演示RAG的实现。

项目架构设计：

企业知识库RAG系统 ├── 文档处理层（文档解析、向量化） ├── 向量存储层（Chroma、Redis等） ├── 检索层（相似度搜索、重排序） ├── 生成层（LLM集成、答案生成） └── API接口层（RESTful接口）

文档处理实现：

@Service public class DocumentProcessor { private final EmbeddingModel embeddingModel; public DocumentProcessor(EmbeddingModel embeddingModel) { this.embeddingModel = embeddingModel; } public List<DocumentChunk> processDocument(String documentPath) { try { // 读取文档内容 String content = Files.readString(Path.of(documentPath)); // 文档分块 List<String> chunks = splitDocument(content); // 生成向量嵌入 List<Embedding> embeddings = embeddingModel.embedAll(chunks); // 构建文档块对象 List<DocumentChunk> documentChunks = new ArrayList<>(); for (int i = 0; i < chunks.size(); i++) { documentChunks.add(new DocumentChunk( chunks.get(i), embeddings.get(i), documentPath, i )); } return documentChunks; } catch (IOException e) { throw new RuntimeException("文档处理失败", e); } } private List<String> splitDocument(String content) { // 简单的按段落分块 return Arrays.stream(content.split("\n\n")) .filter(chunk -> chunk.length() > 50) // 过滤过短的段落 .collect(Collectors.toList()); } }

向量存储与检索：

@Service public class VectorStoreService { private final EmbeddingStore<DocumentChunk> embeddingStore; public VectorStoreService() { this.embeddingStore = new InMemoryEmbeddingStore<>(); } public void storeDocuments(List<DocumentChunk> chunks) { List<Embedding> embeddings = chunks.stream() .map(DocumentChunk::getEmbedding) .collect(Collectors.toList()); embeddingStore.addAll(embeddings, chunks); } public List<DocumentChunk> searchSimilar(String query, int maxResults) { Embedding queryEmbedding = embeddingModel.embed(query); List<EmbeddingMatch<DocumentChunk>> matches = embeddingStore.findRelevant( queryEmbedding, maxResults, 0.7 // 相似度阈值 ); return matches.stream() .map(EmbeddingMatch::embedded) .collect(Collectors.toList()); } }

RAG问答服务：

@Service public class RAGService { private final VectorStoreService vectorStore; private final ChatLanguageModel chatModel; public RAGService(VectorStoreService vectorStore, ChatLanguageModel chatModel) { this.vectorStore = vectorStore; this.chatModel = chatModel; } public String answerQuestion(String question) { // 检索相关文档 List<DocumentChunk> relevantDocs = vectorStore.searchSimilar(question, 3); // 构建上下文 String context = buildContext(relevantDocs); // 构建提示词 String prompt = buildPrompt(question, context); // 调用LLM生成答案 return chatModel.generate(prompt); } private String buildContext(List<DocumentChunk> documents) { return documents.stream() .map(DocumentChunk::getContent) .collect(Collectors.joining("\n\n")); } private String buildPrompt(String question, String context) { return String.format(""" 基于以下上下文信息回答问题。如果上下文不足以回答问题，请说明。 上下文： %s 问题：%s 答案： """, context, question); } }

7. 性能优化与最佳实践

在实际企业应用中，性能优化至关重要。以下是一些关键的优化策略：

批量处理优化：

@Service public class BatchProcessingService { @Async public CompletableFuture<List<String>> processBatch(List<String> inputs) { // 批量嵌入生成 List<Embedding> embeddings = embeddingModel.embedAll(inputs); // 并行处理 return CompletableFuture.completedFuture( inputs.parallelStream() .map(this::processSingle) .collect(Collectors.toList()) ); } // 连接池配置 @Configuration public class HttpClientConfig { @Bean public HttpClient httpClient() { return HttpClient.newBuilder() .connectTimeout(Duration.ofSeconds(30)) .executor(Executors.newFixedThreadPool(10)) .build(); } } }

缓存策略实现：

@Service @CacheConfig(cacheNames = "aiResponses") public class CachedAIService { private final AIChatService aiService; public CachedAIService(AIChatService aiService) { this.aiService = aiService; } @Cacheable(key = "#message") public String getCachedResponse(String message) { return aiService.chat(message); } // 缓存配置 @Configuration @EnableCaching public class CacheConfig { @Bean public CacheManager cacheManager() { return new ConcurrentMapCacheManager("aiResponses"); } } }

8. 监控与可观测性

企业级应用需要完善的监控体系：

日志记录配置：

@Slf4j @Service public class MonitoredAIService { public String chatWithMonitoring(String message) { long startTime = System.currentTimeMillis(); try { String response = aiService.chat(message); long duration = System.currentTimeMillis() - startTime; log.info("AI请求完成 - 消息长度: {}, 响应时间: {}ms", message.length(), duration); return response; } catch (Exception e) { log.error("AI请求失败 - 消息: {}, 错误: {}", message, e.getMessage()); throw e; } } }

性能指标收集：

@Component public class AIPerformanceMetrics { private final MeterRegistry meterRegistry; private final Counter requestCounter; private final Timer responseTimer; public AIPerformanceMetrics(MeterRegistry meterRegistry) { this.meterRegistry = meterRegistry; this.requestCounter = Counter.builder("ai.requests") .description("AI服务请求计数") .register(meterRegistry); this.responseTimer = Timer.builder("ai.response.time") .description("AI服务响应时间") .register(meterRegistry); } public void recordRequest(boolean success, long duration) { requestCounter.increment(); responseTimer.record(duration, TimeUnit.MILLISECONDS); if (!success) { Counter.builder("ai.requests.failed") .register(meterRegistry) .increment(); } } }

9. 安全与合规考虑

在企业环境中，安全性和合规性至关重要：

API密钥管理：

@Configuration public class SecurityConfig { @Bean @ConfigurationProperties(prefix = "ai.security") public AISecurityConfig aiSecurityConfig() { return new AISecurityConfig(); } @Bean public ChatLanguageModel secureChatModel(AISecurityConfig securityConfig) { // 从安全存储获取API密钥 String apiKey = securityConfig.getSecureApiKey(); return OpenAiChatModel.withApiKey(apiKey); } } @Component public class RateLimiter { private final Map<String, RateLimitInfo> userLimits = new ConcurrentHashMap<>(); public boolean allowRequest(String userId) { RateLimitInfo limitInfo = userLimits.computeIfAbsent(userId, k -> new RateLimitInfo()); long currentTime = System.currentTimeMillis(); if (currentTime - limitInfo.getLastReset() > 60000) { // 1分钟重置 limitInfo.reset(); } return limitInfo.tryAcquire(); } }

数据隐私保护：

@Service public class PrivacyAwareAIService { public String processWithPrivacy(String userInput) { // 数据脱敏 String sanitizedInput = sanitizeData(userInput); // 记录审计日志（不记录敏感信息） auditService.logRequest(sanitizedInput); return aiService.chat(sanitizedInput); } private String sanitizeData(String input) { // 移除敏感信息（简化实现） return input.replaceAll("\\d{11}", "***") // 手机号 .replaceAll("\\d{18}", "***"); // 身份证号 } }

10. 部署与运维

Docker容器化部署：

FROM openjdk:17-jdk-slim WORKDIR /app COPY target/my-ai-app.jar app.jar EXPOSE 8080 ENTRYPOINT ["java", "-jar", "app.jar"]

健康检查配置：

@Component public class AIHealthIndicator implements HealthIndicator { private final AIChatService aiService; public AIHealthIndicator(AIChatService aiService) { this.aiService = aiService; } @Override public Health health() { try { // 测试AI服务连通性 String response = aiService.chat("test"); if (response != null && !response.isEmpty()) { return Health.up().withDetail("ai-service", "available").build(); } } catch (Exception e) { return Health.down().withDetail("ai-service", "unavailable") .withException(e).build(); } return Health.unknown().build(); } }

通过以上完整的实战演示，我们可以看到Java AI开发生态的成熟度已经能够支撑企业级应用的需求。Spring AI提供了快速入门路径，而LangChain4j则为复杂AI应用提供了强大的基础设施。

在实际项目选型时，建议从项目复杂度、团队技能栈、性能要求等多个维度综合考虑。对于大多数企业应用，采用渐进式策略：先用Spring AI实现基础功能，随着需求复杂化再引入LangChain4j的特定能力，这种混合架构往往能取得最佳的效果。