Spring AI vs LangChain4j:10 年架构师老五的深度对比,看完再选型

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，内网可参考。

Spring AI vs LangChain4j：10 年 架构师老五的深度对比，看完再选型

一、先说结论

二、Spring AI：亲儿子的待遇

核心优势

杀手级特性

真实项目结构

三、LangChain4j：灵活性的代表

核心优势

杀手级特性

真实项目结构

四、深度对比：六大核心场景

场景 1：简单对话

场景 2：RAG 检索增强

场景 3：函数调用

场景 4：流式响应

场景 5：多模型路由

场景 6：测试

五、老五的选型建议

选 Spring AI，如果：

选 LangChain4j，如果：

老五的"都要"方案

六、生产踩坑记录

Spring AI 踩坑

LangChain4j 踩坑

七、总结

最后说两句

Spring AI vs LangChain4j：10 年架构师老五的深度对比，看完再选型