夜雨聆风Spring AI vs LangChain4j：10 年 架构师老五的深度对比，看完再选型
老五说：选型不是选网红，是选能陪你走到最后的伙伴。
一、先说结论
别急着站队，听老五把话说完。
| 维度 | Spring AI | LangChain4j |
|---|---|---|
| 背靠生态 | Spring 全家桶 | LangChain 体系 |
| 学习成本 | ⭐⭐（Spring 开发者 0 门槛） | ⭐⭐⭐（需要理解新概念） |
| 功能完整度 | ⭐⭐⭐（核心功能都有） | ⭐⭐⭐⭐（更丰富） |
| 更新频率 | ⭐⭐⭐⭐（官方维护） | ⭐⭐⭐⭐⭐（社区活跃） |
| 生产成熟度 | ⭐⭐⭐⭐（大厂背书） | ⭐⭐⭐（社区项目） |
| 文档质量 | ⭐⭐⭐⭐（官方文档） | ⭐⭐⭐（社区贡献） |
老五锐评： 如果你已经是 Spring 技术栈，选 Spring AI 少走弯路；如果你想玩更多 AI 特性，LangChain4j 更灵活。
二、Spring AI：亲儿子的待遇
核心优势
// 1. 配置简单到离谱
@Configuration
public class AIConfig {
@Bean
public ChatClient chatClient(ChatClient.Builder builder) {
return builder.build(); // 就这么简单
}
}
// 2. 使用体验统一
@RestController
public class AIController {
@Autowired
private ChatClient chatClient; // 跟@Autowired 任何其他 Bean 一样
@PostMapping("/chat")
public String chat(@RequestBody String message) {
return chatClient.prompt()
.user(message)
.call()
.content();
}
}
老五说： 看到没？这就是 Spring 的恐怖之处——把任何新技术都变成"又一个 Bean"。
杀手级特性
// 1. 函数调用（Function Calling）
@Configuration
public class FunctionConfig {
@Bean
public FunctionCallback weatherService() {
return FunctionCallback.builder()
.function("getWeather", new WeatherService()::getWeather)
.description("获取天气信息")
.build();
}
}
// 2. RAG 支持
@Configuration
public class RAGConfig {
@Bean
public VectorStore vectorStore(EmbeddingClient embeddingClient) {
return new Neo4jVectorStore(embeddingClient, neo4jDriver);
}
@Bean
public RAGAdvisor ragAdvisor(VectorStore vectorStore) {
return new RAGAdvisor(vectorStore, 0.8, 5);
}
}
// 3. 响应式支持
public Mono<String> chat Reactive(String message) {
return chatClient.prompt()
.user(message)
.call()
.content()
.publishOn(Schedulers.boundedElastic());
}
老五锐评： Spring AI 最大的优势不是功能多，而是跟 Spring 生态无缝集成。事务、缓存、监控、日志，全是现成的。
真实项目结构
src/main/java
├── config/
│ ├── AIConfig.java # AI 配置
│ └── VectorStoreConfig.java # 向量存储配置
├── controller/
│ └── AIController.java # REST 接口
├── service/
│ ├── AIService.java # AI 业务逻辑
│ └── RAGService.java # RAG 逻辑
├── advisor/
│ ├── LoggingAdvisor.java # 自定义 Advisor
│ └── CacheAdvisor.java # 缓存 Advisor
└── dto/
├── ChatRequest.java
└── ChatResponse.java
老五说： 这结构，Spring 开发者闭着眼都能看懂。
三、LangChain4j：灵活性的代表
核心优势
// 1. Agent 构建更灵活
Assistant assistant = AiServices.builder(Assistant.class)
.chatModel(chatModel)
.tools(new Calculator(), new SearchTool(), new DatabaseTool())
.memory(MessageWindowChatMemory.withMaxMessages(10))
.contentRetriever(vectorStore.contentRetriever())
.build();
// 2. 多模型支持更丰富
ChatModel openai = OpenAiChatModel.builder()
.apiKey(System.getenv("OPENAI_API_KEY"))
.modelName("gpt-4")
.build();
ChatModel anthropic = AnthropicChatModel.builder()
.apiKey(System.getenv("ANTHROPIC_API_KEY"))
.modelName("claude-3")
.build();
ChatModel local = OllamaChatModel.builder()
.baseUrl("http://localhost:11434")
.modelName("qwen2.5")
.build();
老五说： LangChain4j 的灵活性体现在——它不假设你用任何特定框架。
杀手级特性
// 1. 结构化输出
public class AnalysisResult {
String summary;
List<String> keyPoints;
Sentiment sentiment;
double confidence;
}
Assistant assistant = AiServices.builder(Assistant.class)
.chatModel(chatModel)
.responseFormat(AnalysisResult.class) // 直接返回对象
.build();
AnalysisResult result = assistant.analyze(text); // 自动解析 JSON
// 2. 高级 Agent 模式
Agent agent = Agent.builder()
.name("ResearchAgent")
.description("研究助手")
.tools(tools)
.planExecutor(new ReActPlanExecutor()) // ReAct 模式
.build();
// 3. 流式处理
TokenStream stream = assistant.chatAsStream(message);
stream.onNext(token -> System.out.print(token));
老五锐评： LangChain4j 在 AI 原生特性上确实领先，尤其是 Agent 和结构化输出。
真实项目结构
src/main/java
├── agent/
│ ├── Assistant.java # Agent 接口定义
│ ├── ResearchAgent.java # 研究 Agent
│ └── CodeAgent.java # 代码 Agent
├── tool/
│ ├── CalculatorTool.java # 计算工具
│ ├── SearchTool.java # 搜索工具
│ └── DatabaseTool.java # 数据库工具
├── memory/
│ ├── ChatMemoryConfig.java # 记忆配置
│ └── CustomMemoryStore.java # 自定义存储
├── embedding/
│ └── EmbeddingConfig.java # 嵌入配置
└── model/
├── ChatModelConfig.java # 模型配置
└── ModelRouter.java # 模型路由
老五说： LangChain4j 的项目结构更像"AI 原生"，但 Spring 开发者可能需要适应一下。
四、深度对比：六大核心场景
场景 1：简单对话
Spring AI：
@RestController
public class ChatController {
@Autowired
private ChatClient chatClient;
@PostMapping("/chat")
public String chat(@RequestBody String message) {
return chatClient.prompt(message).call().content();
}
}
LangChain4j：
Assistant assistant = AiServices.builder(Assistant.class)
.chatModel(chatModel)
.build();
@PostMapping("/chat")
public String chat(@RequestBody String message) {
return assistant.chat(message);
}
老五评判： 平手。都简单，Spring AI 少写两行配置。
场景 2：RAG 检索增强
Spring AI：
@Configuration
public class RAGConfig {
@Bean
public RAGAdvisor ragAdvisor(VectorStore vectorStore) {
return new RAGAdvisor(vectorStore, 0.75, 5);
}
}
@Service
public class RAGService {
@Autowired
private ChatClient chatClient;
@Autowired
private RAGAdvisor ragAdvisor;
public String query(String question) {
return chatClient.prompt()
.advisors(ragAdvisor)
.user(question)
.call()
.content();
}
}
LangChain4j：
Assistant assistant = AiServices.builder(Assistant.class)
.chatModel(chatModel)
.contentRetriever(vectorStore.contentRetriever(5, 0.75))
.build();
public String query(String question) {
return assistant.chat(question);
}
老五评判： LangChain4j 更简洁，但 Spring AI 的 Advisor 模式更灵活（可以组合多个 Advisor）。
场景 3：函数调用
Spring AI：
@Component
public class ToolConfiguration {
@Bean
@Tool(description = "查询用户信息")
public User getUserInfo(String userId) {
return userService.findById(userId);
}
@Bean
@Tool(description = "发送邮件")
public void sendEmail(String to, String content) {
emailService.send(to, content);
}
}
LangChain4j：
public class Tools {
@Tool("查询用户信息")
public User getUserInfo(String userId) {
return userService.findById(userId);
}
@Tool("发送邮件")
public void sendEmail(String to, String content) {
emailService.send(to, content);
}
}
Assistant assistant = AiServices.builder(Assistant.class)
.chatModel(chatModel)
.tools(new Tools())
.build();
老五评判： Spring AI 的 @Tool 注解更符合 Spring 风格，LangChain4j 需要手动注册 tools。
场景 4：流式响应
Spring AI：
@PostMapping(value = "/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
public Flux<String> stream(@RequestBody String message) {
return chatClient.prompt()
.user(message)
.stream()
.content();
}
LangChain4j：
@PostMapping(value = "/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
public void stream(@RequestBody String message, HttpServletResponse response) {
TokenStream stream = assistant.chatAsStream(message);
stream.onNext(token -> {
response.getWriter().print(token);
response.flushBuffer();
});
}
老五评判： Spring AI 完胜，原生支持 Reactor Flux，跟 Spring WebFlux 无缝集成。
场景 5：多模型路由
Spring AI：
@Configuration
public class ModelRouterConfig {
@Bean
public RouterFunction<ServerResponse> aiRouter(
@Qualifier("openaiClient") ChatClient openaiClient,
@Qualifier("claudeClient") ChatClient claudeClient) {
return RouterFunctions.route()
.POST("/ai/openai/**", req -> openaiClient.handle(req))
.POST("/ai/claude/**", req -> claudeClient.handle(req))
.build();
}
}
LangChain4j：
public class ModelRouter {
private final Map<String, ChatModel> models = new HashMap<>();
public void register(String name, ChatModel model) {
models.put(name, model);
}
public String chat(String modelName, String message) {
ChatModel model = models.get(modelName);
return model.generate(message);
}
}
老五评判： Spring AI 利用 Spring 的路由机制更优雅，LangChain4j 需要自己实现。
场景 6：测试
Spring AI：
@SpringBootTest
class AIServiceTest {
@MockBean
private ChatClient chatClient;
@Autowired
private AIService aiService;
@Test
void testChat() {
when(chatClient.prompt().user(any()).call().content())
.thenReturn("Hello");
String result = aiService.chat("Hi");
assertEquals("Hello", result);
}
}
LangChain4j：
class AIServiceTest {
private ChatModel mockModel = mock(ChatModel.class);
private Assistant assistant;
@BeforeEach
void setup() {
assistant = AiServices.builder(Assistant.class)
.chatModel(mockModel)
.build();
}
@Test
void testChat() {
when(mockModel.generate(any())).thenReturn(Response.from("Hello"));
String result = assistant.chat("Hi");
assertEquals("Hello", result);
}
}
老五评判： Spring AI 的测试更符合 Java 工程师习惯，Mock 框架集成更好。
五、老五的选型建议
选 Spring AI，如果：
✅ 你的项目已经是 Spring Boot
✅ 团队熟悉 Spring 生态
✅ 需要事务、缓存、监控等企业级特性
✅ 追求稳定性和长期支持
✅ 需要与现有 Spring 应用无缝集成
老五说： Spring AI 是"企业级选择"，不是"最酷的"，但是"最稳的"。
选 LangChain4j，如果：
✅ 你想玩更多 AI 原生特性（Agent、结构化输出等）
✅ 项目不依赖 Spring
✅ 需要更灵活的模型切换
✅ 团队愿意学习新概念
✅ 追求功能丰富度
老五说： LangChain4j 是"极客选择"，功能多，但需要自己处理工程化问题。
老五的"都要"方案
// 用 Spring AI 做框架，集成 LangChain4j 的特性
@Configuration
public class HybridConfig {
// Spring AI 作为主框架
@Bean
public ChatClient chatClient(ChatClient.Builder builder) {
return builder.build();
}
// LangChain4j 提供高级特性
@Bean
public Assistant advancedAssistant() {
return AiServices.builder(Assistant.class)
.chatModel(chatModel)
.tools(new AdvancedTools())
.responseFormat(StructuredOutput.class)
.build();
}
}
老五锐评： 小孩子才做选择，成年人可以都要——但要想清楚边界。
六、生产踩坑记录
Spring AI 踩坑
坑 1：版本兼容性问题
- Spring AI 0.8.0 与 Spring Boot 3.2.0 有兼容问题
- 解决：升级到 Spring Boot 3.2.4+
坑 2：向量存储配置复杂
- Neo4j Vector Store 需要手动配置索引
- 解决：写一个自动初始化 Bean
坑 3：流式响应编码问题
- SSE 响应中文乱码
- 解决：显式设置 produces = MediaType.TEXT_EVENT_STREAM_VALUE + UTF-8
LangChain4j 踩坑
坑 1：依赖冲突
- LangChain4j 与某些 JSON 库版本冲突
- 解决：统一 Jackson 版本，排除冲突依赖
坑 2：内存泄漏
- ChatMemory 没有清理机制
- 解决：实现自定义 MemoryStore，定期清理
坑 3：异步支持弱
- 流式处理需要自己处理线程
- 解决：用 CompletableFuture 包装
老五说： 坑都有，但 Spring AI 的坑更容易找到解决方案（社区大）。
七、总结
| 维度 | Spring AI | LangChain4j | 老五推荐 |
|---|---|---|---|
| 企业集成 | ⭐⭐⭐⭐⭐ | ⭐⭐⭐ | Spring AI |
| 功能丰富 | ⭐⭐⭐ | ⭐⭐⭐⭐⭐ | LangChain4j |
| 学习曲线 | ⭐⭐⭐⭐⭐ | ⭐⭐⭐ | Spring AI |
| 社区支持 | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ | Spring AI |
| 更新频率 | ⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | LangChain4j |
| 生产成熟 | ⭐⭐⭐⭐⭐ | ⭐⭐⭐ | Spring AI |
最后说两句
老五用过 Spring AI，也用过 LangChain4j，两个都在生产跑过。
结论：
Spring AI 是"过日子"的选择——稳定、可靠、有后盾 LangChain4j 是"谈恋爱"的选择——刺激、有趣、有惊喜
但工程不是谈恋爱，是要过日子的。
老五的最终建议：
如果你的项目已经在 Spring 生态里，别折腾，选 Spring AI。
如果你想做一个纯 AI 产品，或者团队都是 AI 爱好者，LangChain4j 会让你玩得更开心。
技术选型不是选最好的，是选最合适的。
就这么简单。
本文首发于老五的技术笔记，转载请注明出处。
代码已开源到公司 GitLab，内网可参考。
