LangChain4j Java AI 应用开发实战（二十六）：多模型集成策略 —— OpenAI、DeepSeek、阿里百炼混合使用

目录

• 前言
• 一、多模型集成的核心机制
• • 1.1 Spring Boot Starter 的自动配置原理
  • 1.2 关键注解：`@AiService(wiringMode = EXPLICIT)`
  • 1.3 Bean 命名规则
• 二、实战：三模型同时接入
• • 2.1 项目依赖
  • 2.2 配置文件
  • 2.3 定义三个 AiService 接口
  • 2.4 控制器：暴露三个端点
  • 2.5 运行效果
• 三、模型路由策略
• • 3.1 策略一：基于任务类型的静态路由
  • 3.2 策略二：基于用户等级的动态路由
  • 3.3 策略三：故障转移（Failover）路由
  • 3.4 三种策略对比
• 四、DeepSeek 接入：复用 OpenAI 适配器
• • 4.1 单独接入 DeepSeek
  • 4.2 DeepSeek 与 OpenAI 共存
• 五、统一接口抽象：屏蔽厂商差异
• • 5.1 问题：每个模型有自己的 AiService 接口
  • 5.2 解决方案：通用的 ChatModel 注入
• 六、Token 成本分析与优化
• • 6.1 主流模型价格对比（2026 年参考）
  • 6.2 成本优化公式
  • 6.3 成本监控实现
• 七、常见问题与避坑指南
• • 7.1 问题：Bean 名称找不到
  • 7.2 问题：多个 OpenAI 兼容模型冲突
  • 7.3 问题：Ollama 连接失败
  • 7.4 问题速查表
• 八、最佳实践
• • 8.1 "3-2-1"多模型原则
  • 8.2 配置文件管理
  • 8.3 为每个模型定制 SystemMessage
• 结语

前言

在前面的八篇文章中，我们深入学习了 Agentic 工作流编排的完整技术栈。但有一个前提我们一直默认成立：所有 AI 调用都使用同一个模型。

现实生产环境中，这个前提很快就会被打破：

场景 1：成本压力

你的智能客服系统每天处理 10 万次对话：

全部用 GPT-4o：
简单问候（"你好"）→ $0.0025
复杂投诉（2000字分析）→ $0.005
日均成本：~$300 → 月均 $9000

如果简单问题用便宜模型：
简单问候 → DeepSeek（$0.0001）→ 节省 96%
复杂投诉 → GPT-4o（$0.005）→ 能力不妥协
日均成本：~$120 → 月均 $3600（节省 60%）

场景 2：单点故障风险

你的应用只依赖 OpenAI：

某天下午 3 点：
OpenAI API 状态页变红 🔴
→ 你的客服系统全部瘫痪
→ 用户在社交媒体上投诉
→ 老板打电话问你"怎么回事？"

如果你有备用模型：
主模型 OpenAI 不可用
→ 自动切换到 DeepSeek ✅
→ 用户几乎无感知
→ 你从容地喝着咖啡等 OpenAI 恢复

场景 3：能力互补

不同模型的独特优势：

GPT-4o：最强推理 + 多模态（图片理解）
DeepSeek：高性价比 + 中文优秀 + 代码能力强
Qwen（通义千问）：中文理解细腻 + 合规（数据不出境）
Ollama（本地）：数据隐私 + 零网络延迟 + 离线可用

这就是多模型集成的价值所在！

LangChain4j 的 Spring Boot Starter 提供了优雅的多模型共存机制：通过配置文件中声明多个 Bean、@AiService 的 wiringMode = EXPLICIT 精确绑定，你可以在一个项目中同时使用 OpenAI、DeepSeek、阿里百炼、Ollama 等多个模型，并根据任务类型、成本预算或可用性灵活路由。本文将从原理到实战，完整讲解这一企业级能力。

一、多模型集成的核心机制

1.1 Spring Boot Starter 的自动配置原理

在单模型场景中，你只需在 application.properties 中写：

langchain4j.open-ai.chat-model.api-key=${OPENAI_API_KEY}
langchain4j.open-ai.chat-model.model-name=gpt-4o-mini

然后直接使用 @AiService（默认模式），框架会自动发现唯一的 ChatModel Bean 并注入。

但在多模型场景中，你需要显式声明多个模型，并精确指定每个 @AiService 使用哪个模型。

LangChain4j Spring Boot Starter 的关键设计：

application.properties
│
├── langchain4j.open-ai.chat-model.* → 创建 Bean: openAiChatModel
├── langchain4j.community.dashscope.* → 创建 Bean: qwenChatModel
└── langchain4j.ollama.chat-model.* → 创建 Bean: ollamaChatModel

三个 ChatModel Bean 同时存在于 Spring 容器中，每个都有不同的 Bean 名称。@AiService 通过 chatModel 属性精确绑定到指定的 Bean。

1.2 关键注解：@AiService(wiringMode = EXPLICIT)

这是多模型集成的核心注解配置：

// 默认模式：自动发现唯一的 ChatModel Bean（单模型场景）
@AiService
interface MyAssistant {
String chat(String message);
}

// 显式模式：精确指定使用哪个 ChatModel Bean（多模型场景）
@AiService(wiringMode = EXPLICIT, chatModel = "openAiChatModel")
interface OpenAiAssistant {
String chat(String message);
}

@AiService(wiringMode = EXPLICIT, chatModel = "qwenChatModel")
interface QwenAssistant {
String chat(String message);
}

EXPLICIT 模式做了什么？

1.3 Bean 命名规则

⚠️ 注意：DeepSeek API 与 OpenAI API 兼容，因此复用 langchain4j-open-ai 适配器，只需修改 base-url 指向 DeepSeek 即可。

二、实战：三模型同时接入

2.1 项目依赖

<dependencies>
<!– LangChain4j Spring Boot 核心 –>
<dependency>
<groupId>dev.langchain4j</groupId>
<artifactId>langchain4j-spring-boot-starter</artifactId>
</dependency>

<!– OpenAI（GPT-4o、GPT-4o-mini） –>
<dependency>
<groupId>dev.langchain4j</groupId>
<artifactId>langchain4j-open-ai-spring-boot-starter</artifactId>
</dependency>

<!– DashScope / 阿里百炼（通义千问） –>
<dependency>
<groupId>dev.langchain4j</groupId>
<artifactId>langchain4j-community-dashscope-spring-boot-starter</artifactId>
</dependency>

<!– Ollama（本地模型） –>
<dependency>
<groupId>dev.langchain4j</groupId>
<artifactId>langchain4j-ollama-spring-boot-starter</artifactId>
</dependency>

<!– Spring Boot Web –>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>

依赖关系图：

langchain4j-spring-boot-starter ← 核心（统一抽象）
├── langchain4j-open-ai-spring-boot-starter ← OpenAI（GPT 系列）
├── langchain4j-community-dashscope-spring-boot-starter ← 阿里百炼（Qwen）
└── langchain4j-ollama-spring-boot-starter ← Ollama（本地 Llama/Qwen）

2.2 配置文件

# ==========================================
# Spring Boot
# ==========================================
spring.application.name=LangChain4j-Multi-Model
server.port=8082

# ==========================================
# 模型 1：OpenAI（GPT-4o-mini）
# Bean 名称：openAiChatModel
# ==========================================
langchain4j.open-ai.chat-model.api-key=${OPENAI_API_KEY}
langchain4j.open-ai.chat-model.model-name=gpt-4o-mini

# ==========================================
# 模型 2：DashScope / 阿里百炼（通义千问 Turbo）
# Bean 名称：qwenChatModel
# ==========================================
langchain4j.community.dashscope.chat-model.api-key=${DASHSCOPE_API_KEY}
langchain4j.community.dashscope.chat-model.model-name=qwen-turbo

# ==========================================
# 模型 3：Ollama（本地 Llama 3.1）
# Bean 名称：ollamaChatModel
# ==========================================
langchain4j.ollama.chat-model.base-url=http://localhost:11434
langchain4j.ollama.chat-model.model-name=llama3.1

配置解读：

2.3 定义三个 AiService 接口

每个接口通过 wiringMode = EXPLICIT + chatModel 精确绑定到一个模型：

package com.langchain4j;

import dev.langchain4j.service.SystemMessage;
import dev.langchain4j.service.spring.AiService;
import static dev.langchain4j.service.spring.AiServiceWiringMode.EXPLICIT;

// ==========================================
// Assistant 1：绑定到 OpenAI GPT-4o-mini
// ==========================================
@AiService(wiringMode = EXPLICIT, chatModel = "openAiChatModel")
interface OpenAiAssistant {

@SystemMessage("你是一个AI智能助手，擅长深度推理和复杂分析")
String chat(String message);
}

// ==========================================
// Assistant 2：绑定到阿里百炼 Qwen-Turbo
// ==========================================
@AiService(wiringMode = EXPLICIT, chatModel = "qwenChatModel")
interface DashScopeAssistant {

@SystemMessage("你是一个AI智能助手，擅长中文理解和快速响应")
String chat(String message);
}

// ==========================================
// Assistant 3：绑定到 Ollama 本地 Llama3.1
// ==========================================
@AiService(wiringMode = EXPLICIT, chatModel = "ollamaChatModel")
interface OllamaAssistant {

@SystemMessage("你是一个AI智能助手，运行在本地环境中")
String chat(String message);
}

关键对比：

// ❌ 单模型时代：隐式注入
@AiService // 框架自动找到唯一的 ChatModel Bean
interface MyAssistant { ... }

// ✅ 多模型时代：显式绑定
@AiService(wiringMode = EXPLICIT, chatModel = "openAiChatModel")
interface OpenAiAssistant { ... }

@AiService(wiringMode = EXPLICIT, chatModel = "qwenChatModel")
interface QwenAssistant { ... }

2.4 控制器：暴露三个端点

package com.langchain4j;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ChatModelController {

@Autowired
private DashScopeAssistant dashScopeAssistant;

@Autowired
private OllamaAssistant ollamaAssistant;

@Autowired
private OpenAiAssistant openAiAssistant;

// 端点 1：调用通义千问
@GetMapping("/model1")
public String model1(
@RequestParam(value = "message", defaultValue = "Hello")
String message) {
return dashScopeAssistant.chat(message);
}

// 端点 2：调用本地 Ollama
@GetMapping("/model2")
public String model2(
@RequestParam(value = "message", defaultValue = "Hello")
String message) {
return ollamaAssistant.chat(message);
}

// 端点 3：调用 OpenAI
@GetMapping("/model3")
public String model3(
@RequestParam(value = "message", defaultValue = "Hello")
String message) {
return openAiAssistant.chat(message);
}
}

2.5 运行效果

# 启动应用
mvn spring-boot:run

# 测试三个模型
curl "http://localhost:8082/model1?message=你好，请用一句话介绍自己"
# → 我是通义千问，阿里云出品的大语言模型，擅长中文理解与表达。

curl "http://localhost:8082/model2?message=你好，请用一句话介绍自己"
# → 我是 Llama 3.1，Meta 开源的 AI 助手，正在你的本地机器上运行。

curl "http://localhost:8082/model3?message=你好，请用一句话介绍自己"
# → 我是 GPT-4o mini，OpenAI 的多模态 AI 助手，能处理文本和图像。

三、模型路由策略

三个模型同时在线后，下一个自然的问题就是：什么请求应该发给哪个模型？ 这就是模型路由。

3.1 策略一：基于任务类型的静态路由

适用于任务特征明确、模型能力差异显著的场景：

package com.langchain4j;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class ModelRouter {

@Autowired
private OpenAiAssistant openAiAssistant;

@Autowired
private DashScopeAssistant dashScopeAssistant;

@Autowired
private OllamaAssistant ollamaAssistant;

/**
* 根据任务类型路由到不同模型
*/
public String route(String taskType, String message) {
return switch (taskType) {
// 复杂推理 → GPT-4o（能力最强）
case "complex_reasoning", "code_generation", "data_analysis"
-> openAiAssistant.chat(message);

// 中文客服、日常问答 → 通义千问（中文好 + 便宜）
case "customer_service", "chinese_qa", "content_summary"
-> dashScopeAssistant.chat(message);

// 敏感数据、离线场景 → 本地 Ollama（隐私保护）
case "sensitive_data", "offline", "internal_document"
-> ollamaAssistant.chat(message);

// 默认 → 通义千问（综合考虑成本与能力）
default -> dashScopeAssistant.chat(message);
};
}
}

路由决策表：

3.2 策略二：基于用户等级的动态路由

适用于SaaS 多租户场景，不同用户等级使用不同模型：

@Service
public class TieredModelRouter {

@Autowired
private OpenAiAssistant openAiAssistant; // 高级模型

@Autowired
private DashScopeAssistant standardAssistant; // 标准模型

/**
* 根据用户等级路由
*/
public String route(String userTier, String message) {
return switch (userTier) {
case "enterprise" // 企业版：GPT-4o
-> openAiAssistant.chat(message);

case "professional" // 专业版：通义千问 Plus
-> standardAssistant.chat(message);

case "free" // 免费版：通义千问 Turbo + 速率限制
-> standardAssistant.chat("[简短回答] " + message);

default -> standardAssistant.chat(message);
};
}
}

3.3 策略三：故障转移（Failover）路由

适用于高可用场景，主模型不可用时自动切换到备用模型：

@Service
public class FailoverModelRouter {

@Autowired
private OpenAiAssistant primaryAssistant;

@Autowired
private DashScopeAssistant fallbackAssistant;

/**
* 带故障转移的模型调用
*/
public String chatWithFailover(String message) {
try {
// 优先使用主模型（OpenAI）
return primaryAssistant.chat(message);
} catch (Exception e) {
System.err.println("⚠️ 主模型 OpenAI 调用失败：" + e.getMessage());
System.err.println("→ 自动切换到备用模型（通义千问）");

try {
// 切换到备用模型（DashScope）
return fallbackAssistant.chat(message);
} catch (Exception ex) {
return "抱歉，所有 AI 服务暂时不可用，请稍后重试。";
}
}
}
}

故障转移架构图：

用户请求
│
▼
┌──────────────┐
│ 主模型调用 │
│ (OpenAI) │
└──────┬───────┘
│
┌───┴───┐
│ 成功？ │
└───┬───┘
│
┌───┴───┐
│ YES │────→ 返回结果
└───────┘
│ NO
▼
┌──────────────┐
│ 备用模型 │
│ (DashScope) │
└──────┬───────┘
│
┌───┴───┐
│ 成功？ │
└───┬───┘
│
┌───┴───┐
│ YES │────→ 返回结果
└───────┘
│ NO
▼
友好降级提示

3.4 三种策略对比

四、DeepSeek 接入：复用 OpenAI 适配器

DeepSeek 的 API 与 OpenAI 完全兼容，因此无需额外依赖，只需修改配置即可：

4.1 单独接入 DeepSeek

依赖（与 OpenAI 完全相同）：

<dependency>
<groupId>dev.langchain4j</groupId>
<artifactId>langchain4j-open-ai-spring-boot-starter</artifactId>
</dependency>

配置：

# DeepSeek 接入：复用 OpenAI 适配器，修改 base-url 和 model-name
langchain4j.open-ai.chat-model.api-key=${DEEPSEEK_API_KEY}
langchain4j.open-ai.chat-model.base-url=https://api.deepseek.com
langchain4j.open-ai.chat-model.model-name=deepseek-v4-flash
langchain4j.open-ai.chat-model.log-requests=true
langchain4j.open-ai.chat-model.log-responses=true

4.2 DeepSeek 与 OpenAI 共存

但这里有一个挑战：OpenAI 和 DeepSeek 共用同一个配置前缀 langchain4j.open-ai，都是 openAiChatModel Bean 名称。需要手动创建 Bean：

package com.langchain4j.config;

import dev.langchain4j.model.openai.OpenAiChatModel;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class DeepSeekConfig {

/**
* 手动创建 DeepSeek ChatModel Bean
* Bean 名称：deepSeekChatModel
*/
@Bean("deepSeekChatModel")
public OpenAiChatModel deepSeekChatModel() {
return OpenAiChatModel.builder()
.apiKey(System.getenv("DEEPSEEK_API_KEY"))
.baseUrl("https://api.deepseek.com")
.modelName("deepseek-v4-flash")
.build();
}
}

然后通过 @AiService 绑定：

@AiService(wiringMode = EXPLICIT, chatModel = "deepSeekChatModel")
interface DeepSeekAssistant {
String chat(String message);
}

💡 小技巧：如果你不需要同时使用 OpenAI 和 DeepSeek，只需在配置文件中修改 base-url 即可实现"一键切换"。这在后续第27篇会详细展开。

五、统一接口抽象：屏蔽厂商差异

5.1 问题：每个模型有自己的 AiService 接口

在 2.3 节中，我们为三个模型分别定义了三个接口。当模型数量增多时，接口数量也会膨胀。

5.2 解决方案：通用的 ChatModel 注入

除了 @AiService，你还可以直接注入 ChatModel Bean，用编程方式调用：

package com.langchain4j.controller;

import dev.langchain4j.model.chat.ChatModel;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.web.bind.annotation.*;

@RestController
public class UnifiedChatController {

private final ChatModel openAiModel;
private final ChatModel qwenModel;
private final ChatModel ollamaModel;

public UnifiedChatController(
@Qualifier("openAiChatModel") ChatModel openAiModel,
@Qualifier("qwenChatModel") ChatModel qwenModel,
@Qualifier("ollamaChatModel") ChatModel ollamaModel) {
this.openAiModel = openAiModel;
this.qwenModel = qwenModel;
this.ollamaModel = ollamaModel;
}

/**
* 统一聊天端点，通过参数选择模型
*/
@GetMapping("/chat")
public String chat(
@RequestParam String message,
@RequestParam(defaultValue = "qwen") String provider) {

return switch (provider) {
case "openai" -> openAiModel.chat(message);
case "ollama" -> ollamaModel.chat(message);
default -> qwenModel.chat(message);
};
}
}

@AiService vs 直接注入 ChatModel：

六、Token 成本分析与优化

6.1 主流模型价格对比（2026 年参考）

6.2 成本优化公式

智能路由后的日均成本估算：

总成本 = Σ(每个模型的调用量 × 该模型的单价)

优化前（全用 GPT-4o，日 10 万次）：
成本 = 100,000 × (平均 500 tokens × ($2.50+$10.00)/2 / 1,000,000)
≈ $312.5/天

优化后（智能路由）：
70% 简单问题 → Qwen-Turbo（$0.11+$0.22）
20% 中等难度 → GPT-4o-mini（$0.15+$0.60）
10% 复杂推理 → GPT-4o（$2.50+$10.00）

成本 ≈ 70,000 × $0.04 + 20,000 × $0.09 + 10,000 × $0.75
≈ $2,800 + $1,800 + $7,500
≈ $12,100/天 → 实际约 $48/天（包含缓存命中）

节省：(312.5 – 48) / 312.5 ≈ 85%

6.3 成本监控实现

@Component
public class TokenUsageMonitor {

private final Map<String, AtomicLong> usageByModel =
new ConcurrentHashMap<>();

/**
* 记录每次调用的 Token 消耗
*/
public void recordUsage(String modelName, int inputTokens,
int outputTokens) {
usageByModel
.computeIfAbsent(modelName, k -> new AtomicLong())
.addAndGet(inputTokens + outputTokens);
}

/**
* 获取各模型的 Token 用量统计
*/
public Map<String, Long> getUsageStats() {
return usageByModel.entrySet().stream()
.collect(Collectors.toMap(
Map.Entry::getKey,
e -> e.getValue().get()
));
}

/**
* 成本预警：当某个模型的日消耗超过预算时告警
*/
@Scheduled(cron = "0 0 * * * *") // 每小时检查一次
public void checkBudget() {
long dailyTotal = usageByModel.values().stream()
.mapToLong(AtomicLong::get)
.sum();

if (dailyTotal > 1_000_000) { // 日消耗超过 100 万 tokens
System.err.println("⚠️ Token 用量预警：" +
"今日已消耗 " + dailyTotal + " tokens");
}
}
}

七、常见问题与避坑指南

7.1 问题：Bean 名称找不到

症状：

NoSuchBeanDefinitionException: No bean named 'myChatModel' available

原因：chatModel 属性值与实际的 Bean 名称不匹配。

排查：确认 Bean 名称：

// 在 Application 中打印所有 ChatModel Bean
@Bean
public CommandLineRunner listChatModels(
ApplicationContext context) {
return args -> {
String[] beans = context.getBeanNamesForType(ChatModel.class);
System.out.println("可用的 ChatModel Bean：");
for (String bean : beans) {
System.out.println(" – " + bean);
}
};
}

输出：

可用的 ChatModel Bean：
– openAiChatModel
– qwenChatModel
– ollamaChatModel

7.2 问题：多个 OpenAI 兼容模型冲突

症状：配置了 DeepSeek 和 OpenAI，但所有调用都发到了同一个端点。

原因：复用了同一个 openAiChatModel Bean，后加载的配置覆盖了前面的。

解决方案：手动创建 Bean（见 4.2 节），给不同的模型不同的 Bean 名称。

7.3 问题：Ollama 连接失败

症状：

Connection refused: localhost:11434

排查步骤：

# 1. 确认 Ollama 已安装并运行
ollama list

# 2. 确认目标模型已下载
ollama pull llama3.1

# 3. 确认端口正确
curl http://localhost:11434/api/tags

7.4 问题速查表

八、最佳实践

8.1 "3-2-1"多模型原则

3 个模型角色：
– 主力模型（日常任务，性价比优先）
– 增强模型（复杂任务，能力优先）
– 兜底模型（故障转移，可用性优先）

2 个路由维度：
– 任务复杂度（简单 → 主力，复杂 → 增强）
– 模型可用性（正常 → 主力，异常 → 兜底）

1 个监控看板：
– 各模型调用量、延迟、成本
– 故障转移次数
– Token 消耗趋势

8.2 配置文件管理

不同环境使用不同的模型组合：

# application-dev.properties（开发环境：全用本地 Ollama）
langchain4j.ollama.chat-model.model-name=llama3.1
# 不配置云端模型，节省成本

# application-prod.properties（生产环境：多模型混合）
langchain4j.open-ai.chat-model.model-name=gpt-4o-mini
langchain4j.community.dashscope.chat-model.model-name=qwen-plus
langchain4j.ollama.chat-model.model-name=llama3.1

8.3 为每个模型定制 SystemMessage

不同模型对 Prompt 的敏感度不同，建议为每个模型定制 SystemMessage：

// GPT-4o：可以给出复杂指令
@AiService(wiringMode = EXPLICIT, chatModel = "openAiChatModel")
interface OpenAiAssistant {
@SystemMessage("""
你是一个专业的AI助手。请按照以下步骤分析问题：
1. 理解问题的核心
2. 列出可能的解决方案
3. 比较各方案的优劣
4. 给出最终建议
""")
String chat(String message);
}

// Qwen：中文指令更自然
@AiService(wiringMode = EXPLICIT, chatModel = "qwenChatModel")
interface QwenAssistant {
@SystemMessage("""
你是通义千问，一个专业的AI助手。
请用简洁明了的中文回答用户的问题，
适当使用表情符号让回复更友好。
""")
String chat(String message);
}

结语

本文深入讲解了 LangChain4j 在 Spring Boot 中的多模型集成机制——从 @AiService(wiringMode = EXPLICIT) 的显式绑定原理、多 ChatModel Bean 的共存规则、到三种模型路由策略（任务类型、用户等级、故障转移）的完整实战。多模型集成的核心价值在于让合适的模型做合适的事：复杂任务用最强模型保证质量，简单任务用低成本模型控制预算，敏感数据走本地模型保护隐私，主模型故障时自动切换备用模型保障可用性。通过组合 OpenAI、DeepSeek、阿里百炼、Ollama 等多家模型，你可以在能力、成本、隐私和可用性四个维度上找到最优平衡点。

🎯 更多专栏系列文章：LangChain4j Java AI应用开发实战、🔥 其他专栏可以查看博客主页

🔔 关于作者：资深程序老猿，10年+架构经验，现专注 AIGC 探索与实践。 👍 若文章对你有所触动，恳请点赞 ⭐ 关注 ⭐ 收藏！AI 浪潮已至，愿与你同行。