跳至主要內容

LangChain4J vs Spring AI：Java AI框架深度对比选型指南

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

LangChain4J vs Spring AI：Java AI框架深度对比选型指南

适读人群：有1-5年Java开发经验，想向AI工程师方向转型的开发者 阅读时长：约18分钟 文章价值：

  • 深度对比LangChain4J和Spring AI的核心差异
  • 掌握不同业务场景下的选型决策框架
  • 了解两个框架的真实坑点和最佳实践

技术选型会议上的争吵

去年年底，我一个朋友在一家做企业服务的公司主导AI项目选型，他们技术团队为了"用LangChain4J还是Spring AI"争了整整一个下午，最后不欢而散，两边各自拉了一个支持者，在群里互相发技术博客。

他给我发消息说："老张，你帮我看看，这俩到底差在哪儿，哪个更值得用？"

说实话，这个问题很多团队都纠结过。Java的AI框架生态和Python比起来本来就薄，就这两个能拿出手的，选哪个还真不是一眼能看清楚的事。

我研究了三个月，两个框架都用过，踩了不少坑。今天把我的真实感受和判断写出来，帮你少走弯路。

先搞清楚它们分别是什么

LangChain4J：LangChain的Java移植版，跟随Python LangChain的理念，模块化设计、高度可组合，适合快速构建各种AI应用原型。

Spring AI：Pivotal/VMware官方出品，从一开始就是Spring生态的原生成员，设计理念和Spring Boot完全一致，目标是让AI能力无缝集成到Spring应用。

这个出身差异决定了两者的根本性格：

  • LangChain4J更像"AI优先"，把AI能力放第一位，Spring适配是其次
  • Spring AI更像"Spring优先"，AI能力是Spring Boot应用的一个能力扩展

核心对比

对比维度LangChain4JSpring AI
版本稳定性0.x版本，API变化频繁1.0 GA，API稳定
Spring Boot集成需要手动集成原生支持，starter自动配置
可观测性需要自己集成内置Micrometer支持
Agent支持成熟，功能丰富基础支持，持续完善中
向量数据库支持10+种15+种，含国产数据库
学习曲线中等（需理解Chain/Agent概念）低（Spring开发者秒上手）
中文社区较少较多（Spring中文社区成熟）
生产案例较少阿里/网易等大厂有案例

代码层面的真实差异

同一个功能，两种写法

场景：带历史记录的多轮对话

LangChain4J的写法：

// LangChain4J写法
// pom.xml
// <dependency>
//   <groupId>dev.langchain4j</groupId>
//   <artifactId>langchain4j-open-ai</artifactId>
//   <version>0.36.0</version>
// </dependency>

import dev.langchain4j.memory.chat.MessageWindowChatMemory;
import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.service.AiServices;
import dev.langchain4j.service.MemoryId;
import dev.langchain4j.service.UserMessage;

/**
 * LangChain4J：通过AiServices接口声明式定义AI服务
 * 优点：接口声明清晰，注解驱动
 * 缺点：需要理解一套新的注解体系
 */
@Configuration
public class LangChain4JConfig {

    @Bean
    public OpenAiChatModel chatModel() {
        return OpenAiChatModel.builder()
            .apiKey(System.getenv("OPENAI_API_KEY"))
            .modelName("gpt-4o-mini")
            .build();
    }

    // 声明式AI服务接口
    interface Assistant {
        @UserMessage("{{message}}")
        String chat(@MemoryId String sessionId, 
                    @dev.langchain4j.service.V("message") String message);
    }

    @Bean
    public Assistant assistant(OpenAiChatModel chatModel) {
        return AiServices.builder(Assistant.class)
            .chatLanguageModel(chatModel)
            .chatMemoryProvider(sessionId -> 
                MessageWindowChatMemory.withMaxMessages(20))
            .build();
    }
}

@RestController
@RequiredArgsConstructor
public class LangChain4JChatController {

    private final Assistant assistant;

    @PostMapping("/lc4j/chat")
    public String chat(@RequestParam String sessionId, 
                       @RequestParam String message) {
        // 调用简洁，内存自动管理
        return assistant.chat(sessionId, message);
    }
}

Spring AI的写法：

// Spring AI写法
// application.yml: spring.ai.openai.api-key=${OPENAI_API_KEY}

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.client.advisor.MessageChatMemoryAdvisor;
import org.springframework.ai.chat.memory.InMemoryChatMemory;

/**
 * Spring AI：ChatClient构建器模式
 * 优点：和Spring生态完全一致的编程模型，Advisor链式扩展
 * 缺点：Fluent API稍显冗长
 */
@Configuration
public class SpringAIConfig {

    @Bean
    public ChatClient chatClient(ChatModel chatModel) {
        return ChatClient.builder(chatModel)
            .defaultSystem("你是一个有帮助的AI助手")
            .defaultAdvisors(
                new MessageChatMemoryAdvisor(new InMemoryChatMemory())
            )
            .build();
    }
}

@RestController
@RequiredArgsConstructor
public class SpringAIChatController {

    private final ChatClient chatClient;

    @PostMapping("/spring-ai/chat")
    public String chat(@RequestParam String sessionId,
                       @RequestParam String message) {
        return chatClient.prompt()
            .advisors(advisor -> advisor.param(
                MessageChatMemoryAdvisor.CHAT_MEMORY_CONVERSATION_ID_KEY, 
                sessionId))
            .user(message)
            .call()
            .content();
    }
}

RAG场景对比

LangChain4J的RAG：

/**
 * LangChain4J RAG实现
 * 使用EmbeddingStoreIngestor和EmbeddingStoreRetriever
 */
@Service
@RequiredArgsConstructor
public class LangChain4JRAGService {

    private final EmbeddingModel embeddingModel;
    private final EmbeddingStore<TextSegment> embeddingStore;

    // 文档入库
    public void ingest(String content) {
        EmbeddingStoreIngestor.builder()
            .documentSplitter(DocumentSplitters.recursive(512, 64))
            .embeddingModel(embeddingModel)
            .embeddingStore(embeddingStore)
            .build()
            .ingest(Document.from(content));
    }

    // 构建RAG聊天服务
    @Bean
    public ChatService ragChatService() {
        ContentRetriever retriever = EmbeddingStoreContentRetriever.builder()
            .embeddingStore(embeddingStore)
            .embeddingModel(embeddingModel)
            .maxResults(5)
            .minScore(0.6)
            .build();

        return AiServices.builder(ChatService.class)
            .chatLanguageModel(chatModel)
            .contentRetriever(retriever)
            .build();
    }

    interface ChatService {
        String answer(String question);
    }
}

Spring AI的RAG：

/**
 * Spring AI RAG实现
 * 使用VectorStore + QuestionAnswerAdvisor
 */
@Service
@RequiredArgsConstructor
public class SpringAIRAGService {

    private final VectorStore vectorStore;
    private final ChatClient.Builder chatClientBuilder;

    // 文档入库
    public void ingest(String content) {
        TokenTextSplitter splitter = new TokenTextSplitter(512, 64, 5, 10000, true);
        List<Document> docs = List.of(new Document(content));
        List<Document> splitDocs = splitter.apply(docs);
        vectorStore.add(splitDocs);
    }

    // 构建RAG问答
    public String answer(String question) {
        return chatClientBuilder.build()
            .prompt()
            .advisors(new QuestionAnswerAdvisor(vectorStore, 
                SearchRequest.defaults().withTopK(5)))
            .user(question)
            .call()
            .content();
    }
}

对比感受：Spring AI的RAG实现更简洁，QuestionAnswerAdvisor封装了整个RAG流程，用起来非常自然。LangChain4J的封装更细粒度，自由度更高但需要更多配置。

LangChain4J的坑

坑1：版本升级破坏性变更

我踩过这个坑——0.32到0.35版本升级，AiServices的某些API签名变了，代码直接编译失败，排查了两个小时。

坑2：和Spring Boot集成需要手动搭

没有官方的Spring Boot Starter（有第三方的但不稳定），你需要自己写@Configuration类，自己管理Bean生命周期。

坑3：中文文档极少

出了问题基本只能看英文GitHub Issues，或者去Discord群里问。国内用的人少，搜不到解决方案。

Spring AI的坑

坑1：早期版本（1.0之前）API极不稳定

2024年之前用Spring AI是真的痛苦，Milestone版本几乎每个大版本都有breaking change。好消息是1.0 GA出了之后终于稳了。

坑2：Advisor执行顺序不直观

多个Advisor叠加时，执行顺序需要仔细测试，否则可能出现对话历史没有正确注入进Prompt的问题。

坑3：自定义扩展点比LangChain4J少

如果你的业务需要非常定制化的检索逻辑，Spring AI的抽象层有时候会限制你，需要绕过官方API。

选型决策树

我的最终建议

选Spring AI的情况：

  • 你们是Spring Boot技术栈
  • 项目要长期维护（超过6个月）
  • 团队不大，希望学习成本低
  • 需要成熟的生产监控方案

选LangChain4J的情况：

  • 你们需要复杂的Agent/多Agent系统
  • 对AI原语有深度定制需求
  • 团队有能力跟随框架迭代升级
  • 纯粹的AI应用，而非Spring应用扩展AI能力

我自己怎么用：新项目首选Spring AI，因为和我们的技术栈无缝融合。但是LangChain4J的某些Agent概念我会参考借鉴，在Spring AI之上自己封装。

说到底，框架只是工具，能解决业务问题的才是好框架。别在工具上纠结太久，选一个开始干。

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