---

前言

在前面的八篇文章中，我们深入学习了 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. 不再自动查找 ChatModel Bean
2. 根据 chatModel 属性值，按名称从 Spring 容器中获取指定的 Bean
3. 将该 Bean 注入到动态代理中

1.3 Bean 命名规则

配置前缀	生成的 Bean 名称
langchain4j.open-ai.chat-model	openAiChatModel
langchain4j.community.dashscope.chat-model	qwenChatModel
langchain4j.ollama.chat-model	ollamaChatModel
langchain4j.open-ai.chat-model（DeepSeek）	openAiChatModel（复用 OpenAI 适配器）

⚠️ 注意：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

配置解读：

模型	配置前缀	Bean 名称	特点
OpenAI GPT-4o-mini	langchain4j.open-ai.chat-model	openAiChatModel	云端，综合能力强
阿里 Qwen-Turbo	langchain4j.community.dashscope.chat-model	qwenChatModel	云端，中文优秀，便宜
Ollama Llama3.1	langchain4j.ollama.chat-model	ollamaChatModel	本地，免费，隐私保护

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);
        };
    }
}

路由决策表：

任务类型	路由目标	原因
复杂推理、代码生成	OpenAI GPT-4o	推理能力最强
中文客服、日常问答	DashScope Qwen	中文好 + 成本低
敏感数据、离线场景	Ollama 本地	数据不出境
其他	DashScope Qwen	性价比最优

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 三种策略对比

策略	路由依据	灵活性	复杂性	适用场景
基于任务类型	任务特征（推理/客服/敏感）	中	低	任务类型明确的系统
基于用户等级	用户 Tier（免费/专业/企业）	高	中	SaaS 多租户系统
故障转移	模型可用性	低	低	所有需要高可用的系统

---

四、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：

	@AiService	直接注入 ChatModel
代码量	需要定义接口	直接调用
功能	SystemMessage、Tools、RAG 等全部支持	只有基础的 chat()
类型安全	✅ 编译时检查	❌ 运行时
适合场景	需要 Prompt 模板化	简单问答、路由/代理
多模型支持	wiringMode=EXPLICIT	@Qualifier 注入

---

六、Token 成本分析与优化

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

模型	输入价格 ($/1M tokens)	输出价格 ($/1M tokens)	特点
GPT-4o	$2.50	$10.00	最强推理+多模态
GPT-4o-mini	$0.15	$0.60	轻量级，性价比高
DeepSeek-V4	~$0.14	~$0.28	极低价，代码强
Qwen-Turbo	~$0.11	~$0.22	中文优秀，便宜
Ollama（本地）	免费	免费	只需电费和硬件

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 问题速查表

现象	原因	解决方案
@AiService 注入失败	有多个 ChatModel Bean，默认模式无法选择	设置 wiringMode=EXPLICIT
Bean 名称不匹配	记错了 Bean 命名规则	用 getBeanNamesForType 列出所有 Bean
模型调用返回乱码	不同模型对 SystemMessage 的处理不同	为每个模型定制 SystemMessage
某模型一直超时	网络问题或 API Key 无效	实现故障转移机制

---

八、最佳实践

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 浪潮已至，愿与你同行。