# 责任链模式实战：多 AI 助手的消息路由
在 IM 系统中，需要支持多个 AI 助手（如 @小Q、@小M、@小T、@小V），以及 AI 空间的多轮对话。文本介绍 AQChat 如何使用责任链模式实现多 AI 助手的消息路由。

## 一、业务场景分析
### 需求场景：
1. 明确@某个AI：`@小Q 你好` -> 路由到小Q处理器
2. 明确@其他AI：`@小M 帮我写代码` -> 路由到小M处理器
3. AI 空间多轮对话：在AI空间中发送 `你好`（没有@任何人） -> 路由到多轮对话处理器

### 挑战
如果用 `if-else` 或 `switch`：
```java
// ❌ 传统方式：代码臃肿，难以扩展
if (messageExt.equals("@AQChatHelper")) {
    handleXQ(messageDto);
} else if (messageExt.equals("@xm")) {
    handleXM(messageDto);
} else if (messageExt.equals("@xt")) {
    handleXT(messageDto);
} else if (messageExt.equals("@xv")) {
    handleXV(messageDto);
} else if (roomType == AI && messageExt.isEmpty()) {
    handleMultipleRounds(messageDto);
}
```

**问题**：
1. 代码臃肿：每个AI都要加一个分支
2. 难以扩展：新增AI需要修改核心代码
3. 违反开闭原则：对扩展开放，对修改关闭

### 解决方案：责任链模式

## 二、责任链模式的设计思路
### 责任链模式定义
使多个对象都有机会处理请求，从而避免请求的发送者与接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递请求，直到有对象处理它为止。

### 核心思想
1. 每个处理器独立：每个 Handler 只负责自己的判断逻辑
2. 链式传递：如果当前 Handler 不处理，传递给下一个
3. 统一接口：所有 Handler 实现相同的接口

### 设计结构
```
Handler (抽象类)
    ├── XQHandler (@小Q处理器)
    ├── XMHandler (@小M处理器)
    ├── XTHandler (@小T处理器)
    ├── XVHandler (@小V处理器)
    └── MultipleRoundsHandler (多轮对话处理器)
```

## 三、代码实现细节
1. **抽象 Handler 定义**
```java
public abstract class Handler {
    protected Handler handler;  // 下一个处理器
    
    /**
     * 设置下一个处理器（递归构建链）
     */
    public void setHandler(Handler handler) {
        if (this.handler == null) {
            this.handler = handler;  // 如果当前没有下一个，直接设置
        } else {
            this.handler.setHandler(handler);  // 否则递归调用，找到链尾
        }
    }
    
    /**
     * 处理消息（子类实现）
     */
    public abstract void handleMessage(MessageDto messageDto);
}
```

**关键点**：
* `handler` 字段：指向下一个处理器
* `setHandler()` 方法：递归构建链
* `handleMessage()` 方法：抽象方法，子类实现

2. **具体 Handler 实现**
@小Q处理器（XQHandler）：
```java
@Component
public class XQHandler extends Handler {
    @Resource
    private MqSendingAgent mqSendingAgent;
    
    @Override
    public void handleMessage(MessageDto messageDto) {
        String messageExt = messageDto.getMessageExt();
        
        // 判断是否@了AI助手
        if ((AQBusinessConstant.AT + AQBusinessConstant.AI_HELPER_ID).equals(messageExt)) {
            // 匹配！处理消息
            MessageDto aiMessageDto = new MessageDto();
            BeanUtils.copyProperties(messageDto, aiMessageDto);
            aiMessageDto.setMessageId(IdProvider.nextId() + "");
            // 去掉@AI标记
            aiMessageDto.setMessageContent(
                messageDto.getMessageContent()
                    .replace((AQBusinessConstant.AT + AQBusinessConstant.AI_HELPER_NAME), "")
            );
            
            // 发送到MQ处理
            mqSendingAgent.aiHelper(aiMessageDto);
        } else {
            // 不匹配，传递给下一个处理器
            if (handler != null) {
                handler.handleMessage(messageDto);
            }
        }
    }
}
```
@小M处理器（XMHandler）：
```java
@Component
public class XMHandler extends Handler {
    @Resource
    private MqSendingAgent mqSendingAgent;
    
    @Override
    public void handleMessage(MessageDto messageDto) {
        String messageExt = messageDto.getMessageExt();
        
        // 判断是否@了小M
        if ((AQBusinessConstant.AT + AQBusinessConstant.XM_ID).equals(messageExt)) {
            // 匹配！处理消息
            MessageDto aiMessageDto = new MessageDto();
            BeanUtils.copyProperties(messageDto, aiMessageDto);
            aiMessageDto.setMessageId(IdProvider.nextId() + "");
            aiMessageDto.setMessageContent(
                messageDto.getMessageContent()
                    .replace((AQBusinessConstant.AT + AQBusinessConstant.XM_NAME), "")
            );
            
            mqSendingAgent.xm(aiMessageDto);
        } else {
            // 不匹配，继续传递
            if (handler != null) {
                handler.handleMessage(messageDto);
            }
        }
    }
}
```

多轮对话处理器（MutipleRoundsHandler）：
```java
@Component
public class MultipleRoundsHandler extends Handler {
    @Resource
    private IRoomHolder roomHolder;
    @Resource
    private MqSendingAgent mqSendingAgent;
    
    @Override
    public void handleMessage(MessageDto messageDto) {
        String roomId = messageDto.getRoomId();
        RoomInfoDto roomInfo = roomHolder.getRoomInfoById(roomId);
        
        // 判断：房间类型是AI空间 && messageExt为空（没有@任何人）
        if (RoomType.AI.getCode() == roomInfo.getRoomType() && 
            messageDto.getMessageExt().isEmpty()) {
            
            // 匹配！处理多轮对话
            MessageDto aiMessageDto = new MessageDto();
            BeanUtils.copyProperties(messageDto, aiMessageDto);
            aiMessageDto.setMessageId(IdProvider.nextId() + "");
            
            mqSendingAgent.multiple(aiMessageDto);
        } else {
            // 不匹配，继续传递
            if (handler != null) {
                handler.handleMessage(messageDto);
            }
        }
    }
}
```

3. **责任链的构建**（HandlerFactory）
```java
@Component
public class HandlerFactory implements ApplicationContextAware, InitializingBean {
    private Handler handler;  // 链头
    
    private ApplicationContext applicationContext;
    
    /**
     * 处理消息（从链头开始）
     */
    public void handleMessage(MessageDto messageDto) {
        MessageDto messageDtoCopy = new MessageDto();
        BeanUtils.copyProperties(messageDto, messageDtoCopy);
        
        // 处理AI空间特殊格式：messageExt可能包含 "&" 分隔符
        String messageExt = messageDtoCopy.getMessageExt();
        String[] extArgs = messageExt.split(AQBusinessConstant.AI_SPACE_CONTENT_TAG);
        if (extArgs.length > 1) {
            messageDtoCopy.setMessageExt(extArgs[0]);  // @AI部分
            messageDtoCopy.setMessageContent(extArgs[1]);  // 实际内容
        }
        
        // 从链头开始处理
        handler.handleMessage(messageDtoCopy);
    }
    
    /**
     * 初始化：构建责任链
     */
    private void init() {
        // 1. 从Spring容器获取所有Handler类型的Bean
        Map<String, Handler> handlerMap = applicationContext.getBeansOfType(Handler.class);
        Set<Handler> handlerSet = new HashSet<>(handlerMap.values());
        
        // 2. 构建责任链
        handlerSet.forEach(h -> {
            if (handler == null) {
                handler = h;  // 第一个Handler作为链头
            } else {
                handler.setHandler(h);  // 把新Handler添加到链中
            }
        });
    }
    
    @Override
    public void afterPropertiesSet() throws Exception {
        init();
    }
}
```

### 责任链构建过程（示例）：
假设有 5 个Handler：XQHandler、XMHandler、XTHandler、XVHandler、MutipleRoundsHandler
```
第1次循环：handler = XQHandler (链头)
第2次循环：XQHandler.setHandler(XMHandler) 
           → XQHandler.handler = XMHandler
第3次循环：XQHandler.setHandler(XTHandler)
           → XMHandler.setHandler(XTHandler)
           → XMHandler.handler = XTHandler
第4次循环：XQHandler.setHandler(XVHandler)
           → XMHandler.setHandler(XVHandler)
           → XTHandler.setHandler(XVHandler)
           → XTHandler.handler = XVHandler
第5次循环：XQHandler.setHandler(MultipleRoundsHandler)
           → XMHandler.setHandler(MultipleRoundsHandler)
           → XTHandler.setHandler(MultipleRoundsHandler)
           → XVHandler.setHandler(MultipleRoundsHandler)
           → XVHandler.handler = MultipleRoundsHandler
```
最终形成的链：
```
XQHandler → XMHandler → XTHandler → XVHandler → MultipleRoundsHandler → null
```

## 四、@AI 消息的识别和路由
## 消息格式
**用户发送的消息格式**：
```
消息内容: "@小Q 你好"
messageExt: "@AQChatHelper"  (从消息中提取的@部分)
messageContent: "@小Q 你好"  (原始消息内容)
```

### 识别流程
1. **消息发送入口
```java
// SendMsgCmdHandler.java
public void handle(ChannelHandlerContext ctx, AQChatMsgProtocol.SendMsgCmd cmd) {
    // ... 消息去重、验证等逻辑 ...
    
    // 构建消息对象
    MessageDto messageDto = new MessageDto();
    messageDto.setMessageContent(cmd.getMsg());  // "@小Q 你好"
    messageDto.setMessageExt(cmd.getExt());       // "@AQChatHelper"
    
    // 如果是AI房间或开启了AI功能，使用责任链处理
    if (roomType || SwitchStatusEnum.OPEN.getCode() == roomInfoDto.getAi()) {
        handlerFactory.handleMessage(messageDto);
    }
}
```

2. **HandlerFactory 预处理**
```java
public void handleMessage(MessageDto messageDto) {
    MessageDto messageDtoCopy = new MessageDto();
    BeanUtils.copyProperties(messageDto, messageDtoCopy);
    
    String messageExt = messageDtoCopy.getMessageExt();
    // 处理AI空间特殊格式：messageExt可能包含 "&" 分隔符
    // 例如：messageExt = "@AQChatHelper&实际内容"
    String[] extArgs = messageExt.split(AQBusinessConstant.AI_SPACE_CONTENT_TAG);
    if (extArgs.length > 1) {
        messageDtoCopy.setMessageExt(extArgs[0]);      // "@AQChatHelper"
        messageDtoCopy.setMessageContent(extArgs[1]);  // "实际内容"
    }
    
    // 从链头开始处理
    handler.handleMessage(messageDtoCopy);
}
```

3. **责任链路由**
假设消息是 `"@小M 你好"`，`messageExt = "@xm"`：
```
1. XQHandler.handleMessage(messageDto)
   - 检查：messageExt.equals("@AQChatHelper")? → false
   - 不匹配，调用下一个：handler.handleMessage(messageDto)
   - → XMHandler.handleMessage(messageDto)

2. XMHandler.handleMessage(messageDto)
   - 检查：messageExt.equals("@xm")? → true ✓
   - 匹配！处理消息，发送到MQ
   - 不调用下一个（处理完成）
```

假设消息是 `"你好"`（在AI空间中，没有@任何人），`messageExt = ""`：
```
1. XQHandler.handleMessage(messageDto)
   - 检查：messageExt.equals("@AQChatHelper")? → false
   - 不匹配，传递给下一个

2. XMHandler.handleMessage(messageDto)
   - 检查：messageExt.equals("@xm")? → false
   - 不匹配，传递给下一个

3. XTHandler.handleMessage(messageDto)
   - 检查：messageExt.equals("@xt")? → false
   - 不匹配，传递给下一个

4. XVHandler.handleMessage(messageDto)
   - 检查：messageExt.equals("@xv")? → false
   - 不匹配，传递给下一个

5. MultipleRoundsHandler.handleMessage(messageDto)
   - 检查：房间类型是AI空间 && messageExt为空? → true ✓
   - 匹配！处理多轮对话
```

## 五、多个 AI 助手的处理流程
支持的 AI 助手
| **AI助手** | **ID** |	**名称** | **Handler** |
|-------|------|------|------|
| AI助手 | AQChatHelper | 小Q | XQHandler |
| 小M | xm | 小M | XMHandler |
| 小T | xt | 小T | XTHandler |
| 小V | xv | 小V | XVHandler |
| 多轮对话 | - | - | MultipleRoundsHandler |

处理流程对比
| **消息类型** | **messageExt** | **路由到的Handler** | **说明** |
|----------|----------|----------------|------|
| @小Q 你好	| @AQChatHelper |XQHandler | 第一个匹配 |
| @小M 你好 | @xm | XMHandler | 第二个匹配 |
| @小T 你好 | @xt | XTHandler | 第三个匹配 |
| @小V 你好 | @xv | XVHandler | 第四个匹配 |
| 你好（AI空间） | ``（空） | MultipleRoundsHandler | 最后一个匹配 |

## 六、如何扩展新的 AI 服务
## 扩展步骤
假设要新增一个 `@小A` 助手：

**步骤1**：定义常量
```java
// AQBusinessConstant.java
String XA_ID = "xa";
String XA_NAME = "小A";
String XA_AVATAR = "https://aqchat.oss-cn-shenzhen.aliyuncs.com/avatar/xa.png";
```

**步骤2**：创建 Handler
```java
@Component
public class XAHandler extends Handler {
    @Resource
    private MqSendingAgent mqSendingAgent;
    
    @Override
    public void handleMessage(MessageDto messageDto) {
        String messageExt = messageDto.getMessageExt();
        
        // 判断是否@了小A
        if ((AQBusinessConstant.AT + AQBusinessConstant.XA_ID).equals(messageExt)) {
            // 处理消息
            MessageDto aiMessageDto = new MessageDto();
            BeanUtils.copyProperties(messageDto, aiMessageDto);
            aiMessageDto.setMessageId(IdProvider.nextId() + "");
            aiMessageDto.setMessageContent(
                messageDto.getMessageContent()
                    .replace((AQBusinessConstant.AT + AQBusinessConstant.XA_NAME), "")
            );
            
            mqSendingAgent.xa(aiMessageDto);  // 发送到对应的MQ Topic
        } else {
            // 继续传递
            if (handler != null) {
                handler.handleMessage(messageDto);
            }
        }
    }
}
```

**步骤3**：添加MQ topic 和 Receiver
```java
// AQChatMQConstant.java
String XA_TOPIC = "xa_topic";

// XAReceiver.java
@Component
public class XAReceiver implements InitializingBean {
    // 实现MQ消费者，处理XA消息
}
```

**步骤4**：完成
无需修改 `HandlerFactory`，Spring 会自动发现并加入责任链。

### 扩展优势
1. 零配置：只需添加 `@Component` 注解
2. 无需修改现有代码：符合开闭原则
3. 自动加入链：Spring 容器自动发现并构建链

## 七、责任链模式的优势
1. **解耦**

每个Handler独立：
* 只关注自己的判断逻辑：
* 不需要知道其他 Handler 的存在
* 可以独立测试和维护

2. **灵活扩展**

新增 AI 助手：
* 只需创建新的 Handler 类
* 无需修改现有代码
* 自动加入责任链

3. **统一接口**

所有 Handler 实现相同的接口：
* `handleMessage(MessageDto messageDto)`
* Factory 不需要知道具体判断逻辑
* 代码结构清晰

4. 支持复杂判断
`MutipleRoundsHandler` 的判断逻辑：
* 不是简单的字符串匹配
* 需要查询房间信息
* 判断条件：房间类型 + messageExt 为空

如果用 Map 映射，无法处理这种复杂场景

## 总结
### 关键点
1. 责任链模式：每个 Handler 独立判断，不匹配则传递
2. 零配置扩展：新增 Handler 只需添加 `@Component` 注解
3. 统一接口：所有 Handler 实现 `handleMessage()` 方法
4. 支持复杂判断：每个 Handler 可以有独立的判断逻辑

### 设计优势
| **特性** | **传统if-else** | **责任链模式** |
|------|----------|----------|
| 代码复杂度 | 高（所有判断集中） | 低（每个Handler独立） |
| 扩展性 | 差（需要修改核心代码） | 好（只需新增类） |
| 可维护性 | 差（代码臃肿） | 好（职责清晰） |
| 支持复杂判断 | 困难 | 容易 |

### 经验总结
1. 责任链模式适合：多个处理器、不同判断逻辑、需要灵活扩展的场景
2. 零配置扩展：利用 Spring 的自动发现机制，无需手动注册
3. 统一接口：所有 Handler 实现相同接口，便于管理
4. 递归构建链：`setHandler()` 方法递归调用，自动找到链尾

通过责任链模式，AQChat 实现了多 AI 助手的消息路由，代码结构清晰，易于扩展和维护。

在 IM 系统中，需要支持多个 AI 助手（如 @小Q、@小M、@小T、@小V），以及 AI 空间的多轮对话。文本介绍 AQChat 如何使用责任链模式实现多 AI 助手的消息路由。

责任链模式实战：多 AI 助手的消息路由

人工智能

编程语言

架构设计

本文详解责任链模式在IM系统中的应用，通过Java代码实现多AI助手消息路由。从业务场景分析到代码实现，展示如何避免if-else判断，支持@小Q、@小M等AI助手识别及多轮对话处理。重点讲解Handler抽象类设计、链式构建过程及扩展新AI服务的步骤，体现解耦、灵活扩展等优势。

容器

路由

腾讯云 IM，全球通信，1折起


文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

责任链模式实战：多 AI 助手的消息路由-腾讯云开发者社区-腾讯云

责任链模式实战：多 AI 助手的消息路由

责任链模式实战：多 AI 助手的消息路由

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐