Java中三大AI框架

前言

最近缺项目经历想快速提升项目实战能力（包含多个AI项目），或者最近找工作，或者想学习AI的小伙伴，可以看看下面👇🏻的这个链接（或许真的能够帮到你）。

在这么多年的技术生涯中，我一直在思考一个问题：为什么Java在AI浪潮中总是慢半拍？

2022年ChatGPT引爆全球后，Python生态迅速涌现出LangChain、LlamaIndex等优秀框架，而Java开发者只能望洋兴叹，自己封装HTTP调用、手动处理JSON、头疼地管理会话状态。

直到2023年下半年，Java生态终于迎来了自己的AI框架时代。

今天这篇文章就专门跟大家一起聊聊，Java生态中三大AI框架：Spring AI、LangChain4j和JBoltAI。

希望对你会有所帮助。

一、为什么Java需要AI框架？

有些小伙伴可能觉得："不就是调用个API吗，我写个RestTemplate不就搞定了？"让我们看看真实场景下的复杂度：

// 手动集成AI的痛点
public class ManualAIIntegration {
    
    public String chatWithMemory(String userInput, String sessionId) {
        // 1. 手动管理会话上下文
        List<Message> history = sessionStore.get(sessionId);
        
        // 2. 手动构建带上下文的Prompt
        String prompt = buildPromptWithHistory(userInput, history);
        
        // 3. 手动处理HTTP调用和重试
        String response = callLLMWithRetry(prompt, 3);
        
        // 4. 手动解析非结构化输出
        String parsedResponse = extractContentFromJSON(response);
        
        // 5. 手动保存新会话
        history.add(new Message("user", userInput));
        history.add(new Message("assistant", parsedResponse));
        sessionStore.save(sessionId, history);
        
        return parsedResponse;
    }
}

这只是基础对话，如果要实现RAG、Agent、多模型切换，代码量会呈指数级增长。

Java AI框架要解决的正是这些横切关注点：

graph TB
    subgraph AI框架核心能力
        A[统一模型抽象] --> B[Chat/Embedding/Image]
        C[提示词工程] --> D[模板/变量注入]
        E[会话管理] --> F[记忆/持久化]
        G[工具调用] --> H[Function Calling]
        I[RAG支持] --> J[向量检索/文档处理]
        K[输出解析] --> L[结构化映射]
    end
    
    subgraph 业务代码
        M[应用逻辑]
    end
    
    subgraph 底层实现
        N[HTTP客户端]
        O[重试/熔断]
        P[监控/可观测]
        Q[流式处理]
    end
    
    M --> A
    A --> N
    A --> O
    A --> P
    A --> Q

二、Spring AI：Spring生态的官方答案

2.1 项目概况

• 开源地址：https://github.com/spring-projects/spring-ai
• 最新版本：1.0.0-M6 (2025年7月)
• 核心定位：Spring官方出品的AI应用开发框架

2.2 底层架构深度解析

Spring AI的设计哲学是"统一抽象 + 模块化扩展"，让我们通过架构图来理解：

Spring AI最精妙的设计在于它的服务提供者接口(SPI)机制。

每个模型提供商只需要实现核心的接口，就能无缝集成到Spring生态中。

2.3 源码级别的原理分析

让我们深入ChatClient的实现，看看它如何工作：

// ChatClient的核心接口设计
public interface ChatClient {
    
    // 流式API设计，类似WebClient
    ChatClientRequestSpec prompt();
    
    interface ChatClientRequestSpec {
        // 用户消息
        ChatClientRequestSpec user(String text);
        ChatClientRequestSpec user(Resource resource);
        
        // 系统消息
        ChatClientRequestSpec system(String text);
        
        // 函数调用注册
        ChatClientRequestSpec tools(Object... toolInstances);
        
        // 执行调用
        ChatResponse call();
        
        // 流式调用
        Flux<ChatResponse> stream();
    }
}

// 底层调用链路
public class DefaultChatClient implements ChatClient {
    
    private final ChatModel chatModel;
    private final ChatMemory chatMemory;
    
    @Override
    public ChatResponse call(ChatRequest request) {
        // 1. 提示词模板处理
        String prompt = promptTemplate.render(request.getVariables());
        
        // 2. 会话记忆加载
        List<Message> messages = chatMemory.get(request.getSessionId());
        messages.add(new UserMessage(prompt));
        
        // 3. 函数调用注册
        List<ToolDefinition> tools = registerTools(request.getTools());
        
        // 4. 调用模型
        ChatResponse response = chatModel.call(
            new ChatRequest(messages, tools)
        );
        
        // 5. 响应解析（结构化输出）
        Object parsed = outputParser.parse(response.getContent());
        
        // 6. 保存会话
        messages.add(new AssistantMessage(response.getContent()));
        chatMemory.add(request.getSessionId(), messages);
        
        return response;
    }
}

2.4 RAG实现机制

Spring AI的RAG实现采用了ETL管道设计模式：

关键代码实现：

// RAG管道的核心实现
@Component
public class RagPipeline {
    
    private final VectorStore vectorStore;
    private final ChatClient chatClient;
    
    public String query(String question) {
        // 1. 问题向量化
        List<Double> questionVector = embeddingModel.embed(question);
        
        // 2. 相似度检索 (支持SQL风格过滤)
        SearchRequest request = SearchRequest.query(question)
            .withTopK(3)
            .withSimilarityThreshold(0.7)
            .withFilterExpression("category == 'technical'");
        
        List<Document> similarDocs = vectorStore.similaritySearch(request);
        
        // 3. 构建增强提示词
        String context = similarDocs.stream()
            .map(Document::getContent)
            .collect(Collectors.joining("\n\n"));
        
        // 4. 调用模型
        return chatClient.prompt()
            .system("基于以下资料回答问题：" + context)
            .user(question)
            .call()
            .content();
    }
}

2.5 优缺点分析

优点：

• 与Spring生态无缝集成，自动配置、依赖注入一应俱全
• 统一的API抽象，切换模型提供商只需修改配置
• 内置可观测性，支持Micrometer追踪全链路
• AOT编译支持，适合GraalVM原生镜像部署

缺点：

• 需Java 17+，不兼容Java 8
• 对国产模型支持有限，需借助Spring AI Alibaba扩展
• 功能迭代快，API可能变化
• 社区文档相对较少

适用场景：

• 已有Spring Boot技术栈的团队
• 需要快速集成基础AI能力的项目
• 追求"约定优于配置"的开发模式

三、LangChain4j：模块化的AI组装工厂

3.1 项目概况

• 开源地址：https://github.com/langchain4j/langchain4j
• 最新版本：0.30.0
• 核心定位：LangChain的Java实现，模块化AI工具包

3.2 底层架构深度解析

LangChain4j的设计理念是"乐高积木式组装"，每个功能都是独立模块：

graph TB
    subgraph LangChain4j 模块化架构
        A[langchain4j-core] --> B[langchain4j]
        
        subgraph 模型集成模块
            C[langchain4j-open-ai]
            D[langchain4j-ollama]
            E[langchain4j-dashscope]
            F[langchain4j-hugging-face]
        end
        
        subgraph 向量存储模块
            G[langchain4j-pinecone]
            H[langchain4j-milvus]
            I[langchain4j-redis]
            J[langchain4j-pgvector]
        end
        
        subgraph 文档处理模块
            K[langchain4j-document-parser]
            L[langchain4j-document-splitter]
        end
        
        subgraph 高级功能模块
            M[langchain4j-agent]
            N[langchain4j-rag]
            O[langchain4j-memory]
        end
        
        B --> C
        B --> D
        B --> E
        B --> F
        B --> G
        B --> H
        B --> I
        B --> J
        B --> K
        B --> L
        B --> M
        B --> N
        B --> O
    end

3.3 AI Service：声明式编程的魅力

LangChain4j最亮眼的设计是AI Service，它让AI调用变得像接口定义一样简单：

// 声明式AI服务定义
public interface Assistant {
    
    @SystemMessage("你是一个专业的Java架构师")
    @UserMessage("请解释一下{{concept}}，用{{language}}回答")
    String explain(String concept, String language);
    
    // 结构化输出
    @UserMessage("从{{text}}中提取人物信息")
    Person extractPerson(@V("text") String text);
    
    // 带记忆的对话
    @UserMessage("你好，我叫{{name}}")
    String introduce(String name);
    
    @UserMessage("我叫什么名字？") // 能记住上面的介绍
    String askName();
}

// 使用示例
public class AIServiceDemo {
    
    public static void main(String[] args) {
        // 创建模型
        ChatLanguageModel model = OpenAiChatModel.builder()
            .apiKey(System.getenv("OPENAI_API_KEY"))
            .modelName("gpt-3.5-turbo")
            .build();
        
        // 创建记忆
        ChatMemory memory = MessageWindowChatMemory.builder()
            .maxMessages(10)
            .build();
        
        // 组装AI服务
        Assistant assistant = AiServices.builder(Assistant.class)
            .chatLanguageModel(model)
            .chatMemory(memory)
            .build();
        
        // 使用
        String answer = assistant.explain("微服务", "中文");
        Person person = assistant.extractPerson("张三，35岁，程序员");
    }
}

3.4 函数调用（Tool Calling）的实现原理

LangChain4j的函数调用采用了动态代理 + 注解处理的机制：

最近缺项目经历想快速提升项目实战能力（包含多个AI项目），或者最近找工作，或者想学习AI的小伙伴，可以看看下面👇🏻的这个链接（或许真的能够帮到你）。

代码实现：

public class WeatherService {
    
    @Tool("查询指定城市的天气")
    public String getWeather(
        @P("城市名称") String city,
        @P("日期，格式yyyy-MM-dd") String date
    ) {
        // 调用天气API
        return weatherApi.get(city, date);
    }
}

// 注册工具
interface WeatherAssistant {
    String chat(String userMessage);
}

WeatherAssistant assistant = AiServices.builder(WeatherAssistant.class)
    .chatLanguageModel(model)
    .tools(new WeatherService())
    .build();

// 模型会自动判断何时调用getWeather
String response = assistant.chat("北京明天天气怎么样？");

3.5 优缺点分析

优点：

• 模块化设计，按需引入依赖，避免臃肿
• 支持20+模型提供商和30+向量存储
• 声明式AI Service，开发效率高
• Java 8兼容，对老项目友好
• 社区活跃，更新频繁

缺点：

• 学习曲线较陡，概念多
• 配置相对复杂
• 文档以英文为主
• 需自行集成Spring等框架

适用场景：

• 需要深度定制AI行为
• 复杂的Agent工作流
• 学术研究和原型验证
• 多模型、多向量存储混合使用

四、JBoltAI：企业级全栈AI解决方案

4.1 项目概况

• 开源地址：https://gitee.com/jbolt/jboltais （需授权）
• 核心定位：面向企业的全栈AI应用开发平台

4.2 底层架构深度解析

JBoltAI采用三层架构，提供完整的开箱即用能力：

graph TB
    subgraph 业务应用层
        A[智能客服] --> B[智能文档]
        C[智能表单] --> D[智能搜索]
    end
    
    subgraph 核心服务层
        E[IRC接口注册中心]
        F[MQS调用队列服务]
        G[Agent智能体引擎]
        H[RAG检索增强]
        I[知识库管理]
    end
    
    subgraph 模型能力层
        J[OpenAI] --> K[通义千问]
        L[文心一言] --> M[DeepSeek]
        N[私有化模型] --> O[Ollama]
    end
    
    subgraph 基础设施层
        P[多租户隔离]
        Q[权限控制]
        R[数据加密]
        S[审计日志]
    end
    
    A --> E
    B --> F
    E --> G
    F --> H
    G --> J
    H --> N
    I --> P
    P --> Q
    Q --> R
    R --> S

4.3 企业级特性实现

JBoltAI的核心优势在于它的企业级特性：

// 多租户数据隔离
@Service
public class TenantAwareAIService {
    
    @Autowired
    private TenantContext tenantContext;
    
    public String chat(String question) {
        // 1. 获取当前租户
        Tenant tenant = tenantContext.getCurrentTenant();
        
        // 2. 加载租户专属知识库
        KnowledgeBase kb = knowledgeBaseService
            .getByTenant(tenant.getId());
        
        // 3. 租户专属模型配置
        ModelConfig modelConfig = configService
            .getModelConfig(tenant.getModelType());
        
        // 4. 租户专属Prompt模板
        String promptTemplate = promptService
            .getTemplate(tenant.getPromptTemplateId());
        
        // 5. 调用RAG
        return ragService.query(
            question, 
            kb, 
            modelConfig, 
            promptTemplate
        );
    }
}

// 私有化部署支持
@Configuration
public class PrivateDeploymentConfig {
    
    @Bean
    public ModelProvider localModelProvider() {
        // 使用Ollama本地模型
        return OllamaModelProvider.builder()
            .baseUrl("http://localhost:11434")
            .modelName("llama2")
            .build();
    }
    
    @Bean
    public VectorStore localVectorStore() {
        // 使用本地pgvector
        return PgVectorStore.builder()
            .dataSource(localDataSource())
            .build();
    }
}

4.4 优缺点分析

优点：

• 开箱即用，内置36个行业模板
• 多租户、权限控制完善
• 私有化部署，数据安全保障
• 提供商业技术支持
• 支持主流国产模型

缺点：

• 收费框架，有成本门槛
• 社区规模相对较小
• 定制化依赖官方支持
• 开源版本功能受限

适用场景：

• 传统企业系统AI化改造
• 数据安全要求高的场景
• 需要快速交付的项目
• 金融、政务等合规要求严格

五、三大框架综合对比

5.1 功能矩阵对比

维度	Spring AI	LangChain4j	JBoltAI
开源地址	spring-projects/spring-ai	langchain4j/langchain4j	gitee.com/jbolt/jboltais
设计哲学	框架(约定大于配置)	工具包(模块化)	平台(开箱即用)
最低Java版本	17+	8+	8+
模型支持	主流海外模型	20+模型	主流+国产
向量存储	主流	30+	主流
RAG支持	ETL管道	完整组件	内置
Agent能力	基础	强大	企业级
多租户	需自行实现	需自行实现	内置
私有化	不支持	不支持	支持
技术支持	社区	社区	商业
价格	免费	免费	付费
学习曲线	平缓	较陡	平缓

5.2 架构决策树

graph TD
    A[选择Java AI框架] --> B{技术栈}
    B -->|Spring Boot| C{项目类型}
    B -->|非Spring/Java8| D[LangChain4j]
    B -->|企业级/快速交付| E[JBoltAI]
    
    C --> F[轻量AI应用]
    C --> G[复杂AI应用]
    
    F --> H[Spring AI]
    
    G --> I{数据安全}
    I -->|高，需私有化| E
    I -->|一般| J{定制深度}
    
    J -->|深度定制| D
    J -->|常规开发| H
    
    D --> K{社区支持}
    D --> L{多模型需求}
    D --> M{Agent复杂}
    
    H --> N{国产模型}
    H -->|需要| O[Spring AI Alibaba]

六、未来展望与选型建议

6.1 技术演进趋势

从最新的动态来看，Java AI框架正朝着几个方向发展：

1. Agent化：Spring AI Alibaba已开源OpenManus实现，支持多智能体协作
2. MCP协议：模型上下文协议正在成为标准
3. 可观测性：OTel等监控体系不断完善
4. 低代码：可视化编排成为趋势

6.2 选型终极指南

选择Spring AI当：

• 深度拥抱Spring生态
• 需要快速集成基础AI能力
• 团队熟悉Spring Boot

选择LangChain4j当：

• 需要最大灵活性
• 涉及复杂Agent和RAG
• 多模型混合使用
• 保留Java 8兼容性

选择JBoltAI当：

• 企业级项目，数据安全要求高
• 需要快速交付
• 预算充足，需要技术支持

总结

通过本文的深度剖析，我们看到三大Java AI框架各有千秋：

• Spring AI是Spring生态的官方选择，优雅但略显保守
• LangChain4j是模块化的乐高工厂，灵活但学习成本高
• JBoltAI是企业级的交付平台，全面但需要付费

没有最好的框架，只有最适合的框架。建议大家在选型时，综合考虑团队技术栈、项目复杂度、安全要求和预算情况。未来已来，Java开发者终于可以在AI时代喊出那句话："Make Java Great Again!"

希望这篇文章能帮助大家在Java AI应用开发的道路上少走弯路。如果你在实际项目中遇到框架选型的问题，或者有更好的实践经验，欢迎在评论区交流讨论！

最近缺项目经历想快速提升项目实战能力（包含多个AI项目），或者最近找工作，或者想学习AI的小伙伴，可以看看下面👇🏻的这个链接（或许真的能够帮到你）。